github/ha-core
1
Fork 0
mirror of https://github.com/home-assistant/core synced 2024-09-03 08:14:07 +02:00
Code Releases Activity

Add ColorMode enum to light platform (#69223)

Browse Source
This commit is contained in:
Franck Nijhof 2022-04-11 18:18:29 +02:00 committed by GitHub
parent 3d30a757bf
commit 27bc5e1d74
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 287 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
homeassistant/components/demo/light.py
View File

@ -11,11 +11,7 @@ from homeassistant.components.light import (
ATTR_RGBW_COLOR,
ATTR_RGBWW_COLOR,
ATTR_WHITE,
COLOR_MODE_COLOR_TEMP,
COLOR_MODE_HS,
COLOR_MODE_RGBW,
COLOR_MODE_RGBWW,
COLOR_MODE_WHITE,
ColorMode,
LightEntity,
LightEntityFeature,
)
@ -33,8 +29,8 @@ LIGHT_EFFECT_LIST = ["rainbow", "none"]
LIGHT_TEMPS = [240, 380]
SUPPORT_DEMO = {COLOR_MODE_HS, COLOR_MODE_COLOR_TEMP}
SUPPORT_DEMO_HS_WHITE = {COLOR_MODE_HS, COLOR_MODE_WHITE}
SUPPORT_DEMO = {ColorMode.HS, ColorMode.COLOR_TEMP}
SUPPORT_DEMO_HS_WHITE = {ColorMode.HS, ColorMode.WHITE}
async def async_setup_platform(
@ -74,7 +70,7 @@ async def async_setup_platform(
name="Office RGBW Lights",
rgbw_color=(255, 0, 0, 255),
state=True,
supported_color_modes={COLOR_MODE_RGBW},
supported_color_modes={ColorMode.RGBW},
unique_id="light_4",
),
DemoLight(
@ -82,7 +78,7 @@ async def async_setup_platform(
name="Living Room RGBWW Lights",
rgbww_color=(255, 0, 0, 255, 0),
state=True,
supported_color_modes={COLOR_MODE_RGBWW},
supported_color_modes={ColorMode.RGBWW},
unique_id="light_5",
),
DemoLight(
@ -138,13 +134,13 @@ class DemoLight(LightEntity):
self._state = state
self._unique_id = unique_id
if hs_color:
self._color_mode = COLOR_MODE_HS
self._color_mode = ColorMode.HS
elif rgbw_color:
self._color_mode = COLOR_MODE_RGBW
self._color_mode = ColorMode.RGBW
elif rgbww_color:
self._color_mode = COLOR_MODE_RGBWW
self._color_mode = ColorMode.RGBWW
else:
self._color_mode = COLOR_MODE_COLOR_TEMP
self._color_mode = ColorMode.COLOR_TEMP
if not supported_color_modes:
supported_color_modes = SUPPORT_DEMO
self._color_modes = supported_color_modes
@ -247,26 +243,26 @@ class DemoLight(LightEntity):
self._brightness = kwargs[ATTR_BRIGHTNESS]
if ATTR_COLOR_TEMP in kwargs:
self._color_mode = COLOR_MODE_COLOR_TEMP
self._color_mode = ColorMode.COLOR_TEMP
self._ct = kwargs[ATTR_COLOR_TEMP]
if ATTR_EFFECT in kwargs:
self._effect = kwargs[ATTR_EFFECT]
if ATTR_HS_COLOR in kwargs:
self._color_mode = COLOR_MODE_HS
self._color_mode = ColorMode.HS
self._hs_color = kwargs[ATTR_HS_COLOR]
if ATTR_RGBW_COLOR in kwargs:
self._color_mode = COLOR_MODE_RGBW
self._color_mode = ColorMode.RGBW
self._rgbw_color = kwargs[ATTR_RGBW_COLOR]
if ATTR_RGBWW_COLOR in kwargs:
self._color_mode = COLOR_MODE_RGBWW
self._color_mode = ColorMode.RGBWW
self._rgbww_color = kwargs[ATTR_RGBWW_COLOR]
if ATTR_WHITE in kwargs:
self._color_mode = COLOR_MODE_WHITE
self._color_mode = ColorMode.WHITE
self._brightness = kwargs[ATTR_WHITE]
# As we have disabled polling, we need to inform

217
homeassistant/components/light/__init__.py
View File

@ -12,6 +12,7 @@ from typing import cast, final
import voluptuous as vol
from homeassistant.backports.enum import StrEnum
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
SERVICE_TOGGLE,
@ -64,72 +65,92 @@ SUPPORT_WHITE_VALUE = 128 # Deprecated, replaced by color modes
ATTR_COLOR_MODE = "color_mode"
# List of color modes supported by the light
ATTR_SUPPORTED_COLOR_MODES = "supported_color_modes"
# Possible color modes
COLOR_MODE_UNKNOWN = "unknown" # Ambiguous color mode
COLOR_MODE_ONOFF = "onoff" # Must be the only supported mode
COLOR_MODE_BRIGHTNESS = "brightness" # Must be the only supported mode
class ColorMode(StrEnum):
"""Possible light color modes."""
UNKNOWN = "unknown" # Ambiguous color mode
ONOFF = "onoff" # Must be the only supported mode
BRIGHTNESS = "brightness" # Must be the only supported mode
COLOR_TEMP = "color_temp"
HS = "hs"
XY = "xy"
RGB = "rgb"
RGBW = "rgbw"
RGBWW = "rgbww"
WHITE = "white" # Must *NOT* be the only supported mode
# These COLOR_MODE_* constants are deprecated as of Home Assistant 2022.5.
# Please use the LightEntityFeature enum instead.
COLOR_MODE_UNKNOWN = "unknown"
COLOR_MODE_ONOFF = "onoff"
COLOR_MODE_BRIGHTNESS = "brightness"
COLOR_MODE_COLOR_TEMP = "color_temp"
COLOR_MODE_HS = "hs"
COLOR_MODE_XY = "xy"
COLOR_MODE_RGB = "rgb"
COLOR_MODE_RGBW = "rgbw"
COLOR_MODE_RGBWW = "rgbww"
COLOR_MODE_WHITE = "white" # Must *NOT* be the only supported mode
COLOR_MODE_WHITE = "white"
VALID_COLOR_MODES = {
COLOR_MODE_ONOFF,
COLOR_MODE_BRIGHTNESS,
COLOR_MODE_COLOR_TEMP,
COLOR_MODE_HS,
COLOR_MODE_XY,
COLOR_MODE_RGB,
COLOR_MODE_RGBW,
COLOR_MODE_RGBWW,
COLOR_MODE_WHITE,
ColorMode.ONOFF,
ColorMode.BRIGHTNESS,
ColorMode.COLOR_TEMP,
ColorMode.HS,
ColorMode.XY,
ColorMode.RGB,
ColorMode.RGBW,
ColorMode.RGBWW,
ColorMode.WHITE,
}
COLOR_MODES_BRIGHTNESS = VALID_COLOR_MODES - {COLOR_MODE_ONOFF}
COLOR_MODES_BRIGHTNESS = VALID_COLOR_MODES - {ColorMode.ONOFF}
COLOR_MODES_COLOR = {
COLOR_MODE_HS,
COLOR_MODE_RGB,
COLOR_MODE_RGBW,
COLOR_MODE_RGBWW,
COLOR_MODE_XY,
ColorMode.HS,
ColorMode.RGB,
ColorMode.RGBW,
ColorMode.RGBWW,
ColorMode.XY,
}
def valid_supported_color_modes(color_modes: Iterable[str]) -> set[str]:
def valid_supported_color_modes(
color_modes: Iterable[ColorMode | str],
) -> set[ColorMode | str]:
"""Validate the given color modes."""
color_modes = set(color_modes)
if (
not color_modes
or COLOR_MODE_UNKNOWN in color_modes
or (COLOR_MODE_BRIGHTNESS in color_modes and len(color_modes) > 1)
or (COLOR_MODE_ONOFF in color_modes and len(color_modes) > 1)
or (COLOR_MODE_WHITE in color_modes and not color_supported(color_modes))
or ColorMode.UNKNOWN in color_modes
or (ColorMode.BRIGHTNESS in color_modes and len(color_modes) > 1)
or (ColorMode.ONOFF in color_modes and len(color_modes) > 1)
or (ColorMode.WHITE in color_modes and not color_supported(color_modes))
):
raise vol.Error(f"Invalid supported_color_modes {sorted(color_modes)}")
return color_modes
def brightness_supported(color_modes: Iterable[str] | None) -> bool:
def brightness_supported(color_modes: Iterable[ColorMode | str] | None) -> bool:
"""Test if brightness is supported."""
if not color_modes:
return False
return any(mode in COLOR_MODES_BRIGHTNESS for mode in color_modes)
def color_supported(color_modes: Iterable[str] | None) -> bool:
def color_supported(color_modes: Iterable[ColorMode | str] | None) -> bool:
"""Test if color is supported."""
if not color_modes:
return False
return any(mode in COLOR_MODES_COLOR for mode in color_modes)
def color_temp_supported(color_modes: Iterable[str] | None) -> bool:
def color_temp_supported(color_modes: Iterable[ColorMode | str] | None) -> bool:
"""Test if color temperature is supported."""
if not color_modes:
return False
return COLOR_MODE_COLOR_TEMP in color_modes
return ColorMode.COLOR_TEMP in color_modes
def get_supported_color_modes(hass: HomeAssistant, entity_id: str) -> set | None:
@ -311,19 +332,19 @@ def filter_turn_on_params(light, params):
)
if not brightness_supported(supported_color_modes):
params.pop(ATTR_BRIGHTNESS, None)
if COLOR_MODE_COLOR_TEMP not in supported_color_modes:
if ColorMode.COLOR_TEMP not in supported_color_modes:
params.pop(ATTR_COLOR_TEMP, None)
if COLOR_MODE_HS not in supported_color_modes:
if ColorMode.HS not in supported_color_modes:
params.pop(ATTR_HS_COLOR, None)
if COLOR_MODE_RGB not in supported_color_modes:
if ColorMode.RGB not in supported_color_modes:
params.pop(ATTR_RGB_COLOR, None)
if COLOR_MODE_RGBW not in supported_color_modes:
if ColorMode.RGBW not in supported_color_modes:
params.pop(ATTR_RGBW_COLOR, None)
if COLOR_MODE_RGBWW not in supported_color_modes:
if ColorMode.RGBWW not in supported_color_modes:
params.pop(ATTR_RGBWW_COLOR, None)
if COLOR_MODE_WHITE not in supported_color_modes:
if ColorMode.WHITE not in supported_color_modes:
params.pop(ATTR_WHITE, None)
if COLOR_MODE_XY not in supported_color_modes:
if ColorMode.XY not in supported_color_modes:
params.pop(ATTR_XY_COLOR, None)
return params
@ -387,7 +408,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: # noqa:
# for legacy lights
if ATTR_RGBW_COLOR in params:
if (
COLOR_MODE_RGBW in legacy_supported_color_modes
ColorMode.RGBW in legacy_supported_color_modes
and not supported_color_modes
):
rgbw_color = params.pop(ATTR_RGBW_COLOR)
@ -398,15 +419,15 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: # noqa:
if ATTR_COLOR_TEMP in params:
if (
supported_color_modes
and COLOR_MODE_COLOR_TEMP not in supported_color_modes
and COLOR_MODE_RGBWW in supported_color_modes
and ColorMode.COLOR_TEMP not in supported_color_modes
and ColorMode.RGBWW in supported_color_modes
):
color_temp = params.pop(ATTR_COLOR_TEMP)
brightness = params.get(ATTR_BRIGHTNESS, light.brightness)
params[ATTR_RGBWW_COLOR] = color_util.color_temperature_to_rgbww(
color_temp, brightness, light.min_mireds, light.max_mireds
)
elif COLOR_MODE_COLOR_TEMP not in legacy_supported_color_modes:
elif ColorMode.COLOR_TEMP not in legacy_supported_color_modes:
color_temp = params.pop(ATTR_COLOR_TEMP)
if color_supported(legacy_supported_color_modes):
temp_k = color_util.color_temperature_mired_to_kelvin(color_temp)
@ -428,80 +449,80 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: # noqa:
*rgbww_color, light.min_mireds, light.max_mireds
)
params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
elif ATTR_HS_COLOR in params and COLOR_MODE_HS not in supported_color_modes:
elif ATTR_HS_COLOR in params and ColorMode.HS not in supported_color_modes:
hs_color = params.pop(ATTR_HS_COLOR)
if COLOR_MODE_RGB in supported_color_modes:
if ColorMode.RGB in supported_color_modes:
params[ATTR_RGB_COLOR] = color_util.color_hs_to_RGB(*hs_color)
elif COLOR_MODE_RGBW in supported_color_modes:
elif ColorMode.RGBW in supported_color_modes:
rgb_color = color_util.color_hs_to_RGB(*hs_color)
params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
elif COLOR_MODE_RGBWW in supported_color_modes:
elif ColorMode.RGBWW in supported_color_modes:
rgb_color = color_util.color_hs_to_RGB(*hs_color)
params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
*rgb_color, light.min_mireds, light.max_mireds
)
elif COLOR_MODE_XY in supported_color_modes:
elif ColorMode.XY in supported_color_modes:
params[ATTR_XY_COLOR] = color_util.color_hs_to_xy(*hs_color)
elif ATTR_RGB_COLOR in params and COLOR_MODE_RGB not in supported_color_modes:
elif ATTR_RGB_COLOR in params and ColorMode.RGB not in supported_color_modes:
rgb_color = params.pop(ATTR_RGB_COLOR)
if COLOR_MODE_RGBW in supported_color_modes:
if ColorMode.RGBW in supported_color_modes:
params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
elif COLOR_MODE_RGBWW in supported_color_modes:
elif ColorMode.RGBWW in supported_color_modes:
params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
*rgb_color, light.min_mireds, light.max_mireds
)
elif COLOR_MODE_HS in supported_color_modes:
elif ColorMode.HS in supported_color_modes:
params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
elif COLOR_MODE_XY in supported_color_modes:
elif ColorMode.XY in supported_color_modes:
params[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
elif ATTR_XY_COLOR in params and COLOR_MODE_XY not in supported_color_modes:
elif ATTR_XY_COLOR in params and ColorMode.XY not in supported_color_modes:
xy_color = params.pop(ATTR_XY_COLOR)
if COLOR_MODE_HS in supported_color_modes:
if ColorMode.HS in supported_color_modes:
params[ATTR_HS_COLOR] = color_util.color_xy_to_hs(*xy_color)
elif COLOR_MODE_RGB in supported_color_modes:
elif ColorMode.RGB in supported_color_modes:
params[ATTR_RGB_COLOR] = color_util.color_xy_to_RGB(*xy_color)
elif COLOR_MODE_RGBW in supported_color_modes:
elif ColorMode.RGBW in supported_color_modes:
rgb_color = color_util.color_xy_to_RGB(*xy_color)
params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
elif COLOR_MODE_RGBWW in supported_color_modes:
elif ColorMode.RGBWW in supported_color_modes:
rgb_color = color_util.color_xy_to_RGB(*xy_color)
params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
*rgb_color, light.min_mireds, light.max_mireds
)
elif ATTR_RGBW_COLOR in params and COLOR_MODE_RGBW not in supported_color_modes:
elif ATTR_RGBW_COLOR in params and ColorMode.RGBW not in supported_color_modes:
rgbw_color = params.pop(ATTR_RGBW_COLOR)
rgb_color = color_util.color_rgbw_to_rgb(*rgbw_color)
if COLOR_MODE_RGB in supported_color_modes:
if ColorMode.RGB in supported_color_modes:
params[ATTR_RGB_COLOR] = rgb_color
elif COLOR_MODE_RGBWW in supported_color_modes:
elif ColorMode.RGBWW in supported_color_modes:
params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
*rgb_color, light.min_mireds, light.max_mireds
)
elif COLOR_MODE_HS in supported_color_modes:
elif ColorMode.HS in supported_color_modes:
params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
elif COLOR_MODE_XY in supported_color_modes:
elif ColorMode.XY in supported_color_modes:
params[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
elif (
ATTR_RGBWW_COLOR in params and COLOR_MODE_RGBWW not in supported_color_modes
ATTR_RGBWW_COLOR in params and ColorMode.RGBWW not in supported_color_modes
):
rgbww_color = params.pop(ATTR_RGBWW_COLOR)
rgb_color = color_util.color_rgbww_to_rgb(
*rgbww_color, light.min_mireds, light.max_mireds
)
if COLOR_MODE_RGB in supported_color_modes:
if ColorMode.RGB in supported_color_modes:
params[ATTR_RGB_COLOR] = rgb_color
elif COLOR_MODE_RGBW in supported_color_modes:
elif ColorMode.RGBW in supported_color_modes:
params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
elif COLOR_MODE_HS in supported_color_modes:
elif ColorMode.HS in supported_color_modes:
params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
elif COLOR_MODE_XY in supported_color_modes:
elif ColorMode.XY in supported_color_modes:
params[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
# If both white and brightness are specified, override white
if (
supported_color_modes
and ATTR_WHITE in params
and COLOR_MODE_WHITE in supported_color_modes
and ColorMode.WHITE in supported_color_modes
):
params[ATTR_WHITE] = params.pop(ATTR_BRIGHTNESS, params[ATTR_WHITE])
@ -703,7 +724,7 @@ class LightEntity(ToggleEntity):
entity_description: LightEntityDescription
_attr_brightness: int | None = None
_attr_color_mode: str | None = None
_attr_color_mode: ColorMode | str | None = None
_attr_color_temp: int | None = None
_attr_effect_list: list[str] | None = None
_attr_effect: str | None = None
@ -713,7 +734,7 @@ class LightEntity(ToggleEntity):
_attr_rgb_color: tuple[int, int, int] | None = None
_attr_rgbw_color: tuple[int, int, int, int] | None = None
_attr_rgbww_color: tuple[int, int, int, int, int] | None = None
_attr_supported_color_modes: set[str] | None = None
_attr_supported_color_modes: set[ColorMode | str] | None = None
_attr_supported_features: int = 0
_attr_xy_color: tuple[float, float] | None = None
@ -723,7 +744,7 @@ class LightEntity(ToggleEntity):
return self._attr_brightness
@property
def color_mode(self) -> str | None:
def color_mode(self) -> ColorMode | str | None:
"""Return the color mode of the light."""
return self._attr_color_mode
@ -736,20 +757,20 @@ class LightEntity(ToggleEntity):
supported = self._light_internal_supported_color_modes
if (
COLOR_MODE_RGBW in supported
ColorMode.RGBW in supported
and self.white_value is not None
and self.hs_color is not None
):
return COLOR_MODE_RGBW
if COLOR_MODE_HS in supported and self.hs_color is not None:
return COLOR_MODE_HS
if COLOR_MODE_COLOR_TEMP in supported and self.color_temp is not None:
return COLOR_MODE_COLOR_TEMP
if COLOR_MODE_BRIGHTNESS in supported and self.brightness is not None:
return COLOR_MODE_BRIGHTNESS
if COLOR_MODE_ONOFF in supported:
return COLOR_MODE_ONOFF
return COLOR_MODE_UNKNOWN
return ColorMode.RGBW
if ColorMode.HS in supported and self.hs_color is not None:
return ColorMode.HS
if ColorMode.COLOR_TEMP in supported and self.color_temp is not None:
return ColorMode.COLOR_TEMP
if ColorMode.BRIGHTNESS in supported and self.brightness is not None:
return ColorMode.BRIGHTNESS
if ColorMode.ONOFF in supported:
return ColorMode.ONOFF
return ColorMode.UNKNOWN
return color_mode
@ -838,7 +859,7 @@ class LightEntity(ToggleEntity):
supported_features = self.supported_features
supported_color_modes = self._light_internal_supported_color_modes
if COLOR_MODE_COLOR_TEMP in supported_color_modes:
if ColorMode.COLOR_TEMP in supported_color_modes:
data[ATTR_MIN_MIREDS] = self.min_mireds
data[ATTR_MAX_MIREDS] = self.max_mireds
@ -849,31 +870,31 @@ class LightEntity(ToggleEntity):
return data
def _light_internal_convert_color(self, color_mode: str) -> dict:
def _light_internal_convert_color(self, color_mode: ColorMode | str) -> dict:
data: dict[str, tuple] = {}
if color_mode == COLOR_MODE_HS and self.hs_color:
if color_mode == ColorMode.HS and self.hs_color:
hs_color = self.hs_color
data[ATTR_HS_COLOR] = (round(hs_color[0], 3), round(hs_color[1], 3))
data[ATTR_RGB_COLOR] = color_util.color_hs_to_RGB(*hs_color)
data[ATTR_XY_COLOR] = color_util.color_hs_to_xy(*hs_color)
elif color_mode == COLOR_MODE_XY and self.xy_color:
elif color_mode == ColorMode.XY and self.xy_color:
xy_color = self.xy_color
data[ATTR_HS_COLOR] = color_util.color_xy_to_hs(*xy_color)
data[ATTR_RGB_COLOR] = color_util.color_xy_to_RGB(*xy_color)
data[ATTR_XY_COLOR] = (round(xy_color[0], 6), round(xy_color[1], 6))
elif color_mode == COLOR_MODE_RGB and self.rgb_color:
elif color_mode == ColorMode.RGB and self.rgb_color:
rgb_color = self.rgb_color
data[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
data[ATTR_RGB_COLOR] = tuple(int(x) for x in rgb_color[0:3])
data[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
elif color_mode == COLOR_MODE_RGBW and self._light_internal_rgbw_color:
elif color_mode == ColorMode.RGBW and self._light_internal_rgbw_color:
rgbw_color = self._light_internal_rgbw_color
rgb_color = color_util.color_rgbw_to_rgb(*rgbw_color)
data[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
data[ATTR_RGB_COLOR] = tuple(int(x) for x in rgb_color[0:3])
data[ATTR_RGBW_COLOR] = tuple(int(x) for x in rgbw_color[0:4])
data[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
elif color_mode == COLOR_MODE_RGBWW and self.rgbww_color:
elif color_mode == ColorMode.RGBWW and self.rgbww_color:
rgbww_color = self.rgbww_color
rgb_color = color_util.color_rgbww_to_rgb(
*rgbww_color, self.min_mireds, self.max_mireds
@ -882,7 +903,7 @@ class LightEntity(ToggleEntity):
data[ATTR_RGB_COLOR] = tuple(int(x) for x in rgb_color[0:3])
data[ATTR_RGBWW_COLOR] = tuple(int(x) for x in rgbww_color[0:5])
data[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
elif color_mode == COLOR_MODE_COLOR_TEMP and self.color_temp:
elif color_mode == ColorMode.COLOR_TEMP and self.color_temp:
hs_color = color_util.color_temperature_to_hs(
color_util.color_temperature_mired_to_kelvin(self.color_temp)
)
@ -920,10 +941,10 @@ class LightEntity(ToggleEntity):
# Add warning in 2021.6, remove in 2021.10
data[ATTR_BRIGHTNESS] = self.brightness
if color_mode == COLOR_MODE_COLOR_TEMP:
if color_mode == ColorMode.COLOR_TEMP:
data[ATTR_COLOR_TEMP] = self.color_temp
if color_mode in COLOR_MODES_COLOR or color_mode == COLOR_MODE_COLOR_TEMP:
if color_mode in COLOR_MODES_COLOR or color_mode == ColorMode.COLOR_TEMP:
data.update(self._light_internal_convert_color(color_mode))
if supported_features & SUPPORT_COLOR_TEMP and not self.supported_color_modes:
@ -936,7 +957,7 @@ class LightEntity(ToggleEntity):
# Add warning in 2021.6, remove in 2021.10
data[ATTR_WHITE_VALUE] = self.white_value
if self.hs_color is not None:
data.update(self._light_internal_convert_color(COLOR_MODE_HS))
data.update(self._light_internal_convert_color(ColorMode.HS))
if supported_features & LightEntityFeature.EFFECT:
data[ATTR_EFFECT] = self.effect
@ -955,21 +976,21 @@ class LightEntity(ToggleEntity):
supported_color_modes = set()
if supported_features & SUPPORT_COLOR_TEMP:
supported_color_modes.add(COLOR_MODE_COLOR_TEMP)
supported_color_modes.add(ColorMode.COLOR_TEMP)
if supported_features & SUPPORT_COLOR:
supported_color_modes.add(COLOR_MODE_HS)
supported_color_modes.add(ColorMode.HS)
if supported_features & SUPPORT_WHITE_VALUE:
supported_color_modes.add(COLOR_MODE_RGBW)
supported_color_modes.add(ColorMode.RGBW)
if supported_features & SUPPORT_BRIGHTNESS and not supported_color_modes:
supported_color_modes = {COLOR_MODE_BRIGHTNESS}
supported_color_modes = {ColorMode.BRIGHTNESS}
if not supported_color_modes:
supported_color_modes = {COLOR_MODE_ONOFF}
supported_color_modes = {ColorMode.ONOFF}
return supported_color_modes
@property
def supported_color_modes(self) -> set[str] | None:
def supported_color_modes(self) -> set[ColorMode | str] | None:
"""Flag supported color modes."""
return self._attr_supported_color_modes
@ -990,7 +1011,7 @@ def legacy_supported_features(
supported_features |= SUPPORT_COLOR
if any(mode in supported_color_modes for mode in COLOR_MODES_BRIGHTNESS):
supported_features |= SUPPORT_BRIGHTNESS
if COLOR_MODE_COLOR_TEMP in supported_color_modes:
if ColorMode.COLOR_TEMP in supported_color_modes:
supported_features |= SUPPORT_COLOR_TEMP
return supported_features

33
homeassistant/components/light/reproduce_state.py
View File

@ -33,15 +33,8 @@ from . import (
ATTR_WHITE,
ATTR_WHITE_VALUE,
ATTR_XY_COLOR,
COLOR_MODE_COLOR_TEMP,
COLOR_MODE_HS,
COLOR_MODE_RGB,
COLOR_MODE_RGBW,
COLOR_MODE_RGBWW,
COLOR_MODE_UNKNOWN,
COLOR_MODE_WHITE,
COLOR_MODE_XY,
DOMAIN,
ColorMode,
)
_LOGGER = logging.getLogger(__name__)
@ -79,13 +72,13 @@ class ColorModeAttr(NamedTuple):
COLOR_MODE_TO_ATTRIBUTE = {
COLOR_MODE_COLOR_TEMP: ColorModeAttr(ATTR_COLOR_TEMP, ATTR_COLOR_TEMP),
COLOR_MODE_HS: ColorModeAttr(ATTR_HS_COLOR, ATTR_HS_COLOR),
COLOR_MODE_RGB: ColorModeAttr(ATTR_RGB_COLOR, ATTR_RGB_COLOR),
COLOR_MODE_RGBW: ColorModeAttr(ATTR_RGBW_COLOR, ATTR_RGBW_COLOR),
COLOR_MODE_RGBWW: ColorModeAttr(ATTR_RGBWW_COLOR, ATTR_RGBWW_COLOR),
COLOR_MODE_WHITE: ColorModeAttr(ATTR_WHITE, ATTR_BRIGHTNESS),
COLOR_MODE_XY: ColorModeAttr(ATTR_XY_COLOR, ATTR_XY_COLOR),
ColorMode.COLOR_TEMP: ColorModeAttr(ATTR_COLOR_TEMP, ATTR_COLOR_TEMP),
ColorMode.HS: ColorModeAttr(ATTR_HS_COLOR, ATTR_HS_COLOR),
ColorMode.RGB: ColorModeAttr(ATTR_RGB_COLOR, ATTR_RGB_COLOR),
ColorMode.RGBW: ColorModeAttr(ATTR_RGBW_COLOR, ATTR_RGBW_COLOR),
ColorMode.RGBWW: ColorModeAttr(ATTR_RGBWW_COLOR, ATTR_RGBWW_COLOR),
ColorMode.WHITE: ColorModeAttr(ATTR_WHITE, ATTR_BRIGHTNESS),
ColorMode.XY: ColorModeAttr(ATTR_XY_COLOR, ATTR_XY_COLOR),
}
DEPRECATED_GROUP = [
@ -105,11 +98,11 @@ DEPRECATION_WARNING = (
def _color_mode_same(cur_state: State, state: State) -> bool:
"""Test if color_mode is same."""
cur_color_mode = cur_state.attributes.get(ATTR_COLOR_MODE, COLOR_MODE_UNKNOWN)
saved_color_mode = state.attributes.get(ATTR_COLOR_MODE, COLOR_MODE_UNKNOWN)
cur_color_mode = cur_state.attributes.get(ATTR_COLOR_MODE, ColorMode.UNKNOWN)
saved_color_mode = state.attributes.get(ATTR_COLOR_MODE, ColorMode.UNKNOWN)
# Guard for scenes etc. which where created before color modes were introduced
if saved_color_mode == COLOR_MODE_UNKNOWN:
if saved_color_mode == ColorMode.UNKNOWN:
return True
return cast(bool, cur_color_mode == saved_color_mode)
@ -161,8 +154,8 @@ async def _async_reproduce_state(
service_data[attr] = state.attributes[attr]
if (
state.attributes.get(ATTR_COLOR_MODE, COLOR_MODE_UNKNOWN)
!= COLOR_MODE_UNKNOWN
state.attributes.get(ATTR_COLOR_MODE, ColorMode.UNKNOWN)
!= ColorMode.UNKNOWN
):
# Remove deprecated white value if we got a valid color mode
service_data.pop(ATTR_WHITE_VALUE, None)

6
tests/components/light/test_device_action.py
View File

@ -5,10 +5,10 @@ import homeassistant.components.automation as automation
from homeassistant.components.device_automation import DeviceAutomationType
from homeassistant.components.light import (
ATTR_SUPPORTED_COLOR_MODES,
COLOR_MODE_BRIGHTNESS,
DOMAIN,
FLASH_LONG,
FLASH_SHORT,
ColorMode,
LightEntityFeature,
)
from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON
@ -154,7 +154,7 @@ async def test_get_action_capabilities(hass, device_reg, entity_reg):
},
0,
0,
{ATTR_SUPPORTED_COLOR_MODES: [COLOR_MODE_BRIGHTNESS]},
{ATTR_SUPPORTED_COLOR_MODES: [ColorMode.BRIGHTNESS]},
{},
{
"turn_on": [
@ -180,7 +180,7 @@ async def test_get_action_capabilities(hass, device_reg, entity_reg):
0,
0,
None,
{ATTR_SUPPORTED_COLOR_MODES: [COLOR_MODE_BRIGHTNESS]},
{ATTR_SUPPORTED_COLOR_MODES: [ColorMode.BRIGHTNESS]},
{
"turn_on": [
{

230
tests/components/light/test_init.py
View File

@ -118,8 +118,8 @@ async def test_services(hass, mock_light_profiles, enable_custom_integrations):
await hass.async_block_till_done()
ent1, ent2, ent3 = platform.ENTITIES
ent1.supported_color_modes = [light.COLOR_MODE_HS]
ent3.supported_color_modes = [light.COLOR_MODE_HS]
ent1.supported_color_modes = [light.ColorMode.HS]
ent3.supported_color_modes = [light.ColorMode.HS]
ent1.supported_features = light.LightEntityFeature.TRANSITION
ent2.supported_features = (
light.SUPPORT_COLOR
@ -540,7 +540,7 @@ async def test_light_profiles(
await hass.async_block_till_done()
ent1, _, _ = platform.ENTITIES
ent1.supported_color_modes = [light.COLOR_MODE_HS]
ent1.supported_color_modes = [light.ColorMode.HS]
ent1.supported_features = light.LightEntityFeature.TRANSITION
await hass.services.async_call(
@ -577,7 +577,7 @@ async def test_default_profiles_group(
mock_light_profiles[profile.name] = profile
ent, _, _ = platform.ENTITIES
ent.supported_color_modes = [light.COLOR_MODE_HS]
ent.supported_color_modes = [light.ColorMode.HS]
ent.supported_features = light.LightEntityFeature.TRANSITION
await hass.services.async_call(
light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: ent.entity_id}, blocking=True
@ -684,7 +684,7 @@ async def test_default_profiles_light(
mock_light_profiles[profile.name] = profile
dev = next(filter(lambda x: x.entity_id == "light.ceiling_2", platform.ENTITIES))
dev.supported_color_modes = [light.COLOR_MODE_HS]
dev.supported_color_modes = [light.ColorMode.HS]
dev.supported_features = light.LightEntityFeature.TRANSITION
await hass.services.async_call(
light.DOMAIN,
@ -1038,63 +1038,63 @@ async def test_light_backwards_compatibility_supported_color_modes(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_ONOFF]
assert state.attributes["supported_color_modes"] == [light.ColorMode.ONOFF]
if light_state == STATE_OFF:
assert "color_mode" not in state.attributes
else:
assert state.attributes["color_mode"] == light.COLOR_MODE_ONOFF
assert state.attributes["color_mode"] == light.ColorMode.ONOFF
state = hass.states.get(entity1.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_BRIGHTNESS]
assert state.attributes["supported_color_modes"] == [light.ColorMode.BRIGHTNESS]
if light_state == STATE_OFF:
assert "color_mode" not in state.attributes
else:
assert state.attributes["color_mode"] == light.COLOR_MODE_UNKNOWN
assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
state = hass.states.get(entity2.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_COLOR_TEMP]
assert state.attributes["supported_color_modes"] == [light.ColorMode.COLOR_TEMP]
if light_state == STATE_OFF:
assert "color_mode" not in state.attributes
else:
assert state.attributes["color_mode"] == light.COLOR_MODE_UNKNOWN
assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
state = hass.states.get(entity3.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_HS]
assert state.attributes["supported_color_modes"] == [light.ColorMode.HS]
if light_state == STATE_OFF:
assert "color_mode" not in state.attributes
else:
assert state.attributes["color_mode"] == light.COLOR_MODE_UNKNOWN
assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
state = hass.states.get(entity4.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_HS,
light.COLOR_MODE_RGBW,
light.ColorMode.HS,
light.ColorMode.RGBW,
]
if light_state == STATE_OFF:
assert "color_mode" not in state.attributes
else:
assert state.attributes["color_mode"] == light.COLOR_MODE_UNKNOWN
assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
state = hass.states.get(entity5.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_COLOR_TEMP,
light.COLOR_MODE_HS,
light.ColorMode.COLOR_TEMP,
light.ColorMode.HS,
]
if light_state == STATE_OFF:
assert "color_mode" not in state.attributes
else:
assert state.attributes["color_mode"] == light.COLOR_MODE_UNKNOWN
assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
state = hass.states.get(entity6.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_COLOR_TEMP,
light.COLOR_MODE_HS,
light.COLOR_MODE_RGBW,
light.ColorMode.COLOR_TEMP,
light.ColorMode.HS,
light.ColorMode.RGBW,
]
if light_state == STATE_OFF:
assert "color_mode" not in state.attributes
else:
assert state.attributes["color_mode"] == light.COLOR_MODE_UNKNOWN
assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
async def test_light_backwards_compatibility_color_mode(
@ -1144,38 +1144,38 @@ async def test_light_backwards_compatibility_color_mode(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_ONOFF]
assert state.attributes["color_mode"] == light.COLOR_MODE_ONOFF
assert state.attributes["supported_color_modes"] == [light.ColorMode.ONOFF]
assert state.attributes["color_mode"] == light.ColorMode.ONOFF
state = hass.states.get(entity1.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_BRIGHTNESS]
assert state.attributes["color_mode"] == light.COLOR_MODE_BRIGHTNESS
assert state.attributes["supported_color_modes"] == [light.ColorMode.BRIGHTNESS]
assert state.attributes["color_mode"] == light.ColorMode.BRIGHTNESS
state = hass.states.get(entity2.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_COLOR_TEMP]
assert state.attributes["color_mode"] == light.COLOR_MODE_COLOR_TEMP
assert state.attributes["supported_color_modes"] == [light.ColorMode.COLOR_TEMP]
assert state.attributes["color_mode"] == light.ColorMode.COLOR_TEMP
assert state.attributes["rgb_color"] == (201, 218, 255)
assert state.attributes["hs_color"] == (221.575, 20.9)
assert state.attributes["xy_color"] == (0.277, 0.287)
state = hass.states.get(entity3.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_HS]
assert state.attributes["color_mode"] == light.COLOR_MODE_HS
assert state.attributes["supported_color_modes"] == [light.ColorMode.HS]
assert state.attributes["color_mode"] == light.ColorMode.HS
state = hass.states.get(entity4.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_HS,
light.COLOR_MODE_RGBW,
light.ColorMode.HS,
light.ColorMode.RGBW,
]
assert state.attributes["color_mode"] == light.COLOR_MODE_RGBW
assert state.attributes["color_mode"] == light.ColorMode.RGBW
state = hass.states.get(entity5.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_COLOR_TEMP,
light.COLOR_MODE_HS,
light.ColorMode.COLOR_TEMP,
light.ColorMode.HS,
]
# hs color prioritized over color_temp, light should report mode COLOR_MODE_HS
assert state.attributes["color_mode"] == light.COLOR_MODE_HS
# hs color prioritized over color_temp, light should report mode ColorMode.HS
assert state.attributes["color_mode"] == light.ColorMode.HS
async def test_light_service_call_rgbw(hass, enable_custom_integrations):
@ -1192,19 +1192,19 @@ async def test_light_service_call_rgbw(hass, enable_custom_integrations):
)
entity1 = platform.ENTITIES[1]
entity1.supported_color_modes = {light.COLOR_MODE_RGBW}
entity1.supported_color_modes = {light.ColorMode.RGBW}
assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_HS,
light.COLOR_MODE_RGBW,
light.ColorMode.HS,
light.ColorMode.RGBW,
]
state = hass.states.get(entity1.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_RGBW]
assert state.attributes["supported_color_modes"] == [light.ColorMode.RGBW]
await hass.services.async_call(
"light",
@ -1243,8 +1243,8 @@ async def test_light_state_rgbw(hass, enable_custom_integrations):
entity0.xy_color = "Invalid" # Should be ignored
entity1 = platform.ENTITIES[1]
entity1.supported_color_modes = {light.COLOR_MODE_RGBW}
entity1.color_mode = light.COLOR_MODE_RGBW
entity1.supported_color_modes = {light.ColorMode.RGBW}
entity1.color_mode = light.ColorMode.RGBW
entity1.hs_color = "Invalid" # Should be ignored
entity1.rgb_color = "Invalid" # Should be ignored
entity1.rgbw_color = (1, 2, 3, 4)
@ -1257,9 +1257,9 @@ async def test_light_state_rgbw(hass, enable_custom_integrations):
state = hass.states.get(entity0.entity_id)
assert state.attributes == {
"color_mode": light.COLOR_MODE_RGBW,
"color_mode": light.ColorMode.RGBW,
"friendly_name": "Test_legacy_white_value",
"supported_color_modes": [light.COLOR_MODE_HS, light.COLOR_MODE_RGBW],
"supported_color_modes": [light.ColorMode.HS, light.ColorMode.RGBW],
"supported_features": legacy_supported_features,
"hs_color": (210.0, 66.667),
"rgb_color": (84, 169, 255),
@ -1270,9 +1270,9 @@ async def test_light_state_rgbw(hass, enable_custom_integrations):
state = hass.states.get(entity1.entity_id)
assert state.attributes == {
"color_mode": light.COLOR_MODE_RGBW,
"color_mode": light.ColorMode.RGBW,
"friendly_name": "Test_rgbw",
"supported_color_modes": [light.COLOR_MODE_RGBW],
"supported_color_modes": [light.ColorMode.RGBW],
"supported_features": 0,
"hs_color": (240.0, 25.0),
"rgb_color": (3, 3, 4),
@ -1289,8 +1289,8 @@ async def test_light_state_rgbww(hass, enable_custom_integrations):
platform.ENTITIES.append(platform.MockLight("Test_rgbww", STATE_ON))
entity0 = platform.ENTITIES[0]
entity0.supported_color_modes = {light.COLOR_MODE_RGBWW}
entity0.color_mode = light.COLOR_MODE_RGBWW
entity0.supported_color_modes = {light.ColorMode.RGBWW}
entity0.color_mode = light.ColorMode.RGBWW
entity0.hs_color = "Invalid" # Should be ignored
entity0.rgb_color = "Invalid" # Should be ignored
entity0.rgbw_color = "Invalid" # Should be ignored
@ -1303,9 +1303,9 @@ async def test_light_state_rgbww(hass, enable_custom_integrations):
state = hass.states.get(entity0.entity_id)
assert dict(state.attributes) == {
"color_mode": light.COLOR_MODE_RGBWW,
"color_mode": light.ColorMode.RGBWW,
"friendly_name": "Test_rgbww",
"supported_color_modes": [light.COLOR_MODE_RGBWW],
"supported_color_modes": [light.ColorMode.RGBWW],
"supported_features": 0,
"hs_color": (60.0, 20.0),
"rgb_color": (5, 5, 4),
@ -1328,57 +1328,57 @@ async def test_light_service_call_color_conversion(hass, enable_custom_integrati
platform.ENTITIES.append(platform.MockLight("Test_rgbww", STATE_ON))
entity0 = platform.ENTITIES[0]
entity0.supported_color_modes = {light.COLOR_MODE_HS}
entity0.supported_color_modes = {light.ColorMode.HS}
entity1 = platform.ENTITIES[1]
entity1.supported_color_modes = {light.COLOR_MODE_RGB}
entity1.supported_color_modes = {light.ColorMode.RGB}
entity2 = platform.ENTITIES[2]
entity2.supported_color_modes = {light.COLOR_MODE_XY}
entity2.supported_color_modes = {light.ColorMode.XY}
entity3 = platform.ENTITIES[3]
entity3.supported_color_modes = {
light.COLOR_MODE_HS,
light.COLOR_MODE_RGB,
light.COLOR_MODE_XY,
light.ColorMode.HS,
light.ColorMode.RGB,
light.ColorMode.XY,
}
entity4 = platform.ENTITIES[4]
entity4.supported_features = light.SUPPORT_COLOR
entity5 = platform.ENTITIES[5]
entity5.supported_color_modes = {light.COLOR_MODE_RGBW}
entity5.supported_color_modes = {light.ColorMode.RGBW}
entity6 = platform.ENTITIES[6]
entity6.supported_color_modes = {light.COLOR_MODE_RGBWW}
entity6.supported_color_modes = {light.ColorMode.RGBWW}
assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_HS]
assert state.attributes["supported_color_modes"] == [light.ColorMode.HS]
state = hass.states.get(entity1.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_RGB]
assert state.attributes["supported_color_modes"] == [light.ColorMode.RGB]
state = hass.states.get(entity2.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_XY]
assert state.attributes["supported_color_modes"] == [light.ColorMode.XY]
state = hass.states.get(entity3.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_HS,
light.COLOR_MODE_RGB,
light.COLOR_MODE_XY,
light.ColorMode.HS,
light.ColorMode.RGB,
light.ColorMode.XY,
]
state = hass.states.get(entity4.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_HS]
assert state.attributes["supported_color_modes"] == [light.ColorMode.HS]
state = hass.states.get(entity5.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_RGBW]
assert state.attributes["supported_color_modes"] == [light.ColorMode.RGBW]
state = hass.states.get(entity6.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_RGBWW]
assert state.attributes["supported_color_modes"] == [light.ColorMode.RGBWW]
await hass.services.async_call(
"light",
@ -1733,29 +1733,29 @@ async def test_light_service_call_color_conversion_named_tuple(
platform.ENTITIES.append(platform.MockLight("Test_rgbww", STATE_ON))
entity0 = platform.ENTITIES[0]
entity0.supported_color_modes = {light.COLOR_MODE_HS}
entity0.supported_color_modes = {light.ColorMode.HS}
entity1 = platform.ENTITIES[1]
entity1.supported_color_modes = {light.COLOR_MODE_RGB}
entity1.supported_color_modes = {light.ColorMode.RGB}
entity2 = platform.ENTITIES[2]
entity2.supported_color_modes = {light.COLOR_MODE_XY}
entity2.supported_color_modes = {light.ColorMode.XY}
entity3 = platform.ENTITIES[3]
entity3.supported_color_modes = {
light.COLOR_MODE_HS,
light.COLOR_MODE_RGB,
light.COLOR_MODE_XY,
light.ColorMode.HS,
light.ColorMode.RGB,
light.ColorMode.XY,
}
entity4 = platform.ENTITIES[4]
entity4.supported_features = light.SUPPORT_COLOR
entity5 = platform.ENTITIES[5]
entity5.supported_color_modes = {light.COLOR_MODE_RGBW}
entity5.supported_color_modes = {light.ColorMode.RGBW}
entity6 = platform.ENTITIES[6]
entity6.supported_color_modes = {light.COLOR_MODE_RGBWW}
entity6.supported_color_modes = {light.ColorMode.RGBWW}
assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
await hass.async_block_till_done()
@ -1806,30 +1806,30 @@ async def test_light_service_call_color_temp_emulation(
platform.ENTITIES.append(platform.MockLight("Test_hs_white", STATE_ON))
entity0 = platform.ENTITIES[0]
entity0.supported_color_modes = {light.COLOR_MODE_COLOR_TEMP, light.COLOR_MODE_HS}
entity0.supported_color_modes = {light.ColorMode.COLOR_TEMP, light.ColorMode.HS}
entity1 = platform.ENTITIES[1]
entity1.supported_color_modes = {light.COLOR_MODE_HS}
entity1.supported_color_modes = {light.ColorMode.HS}
entity2 = platform.ENTITIES[2]
entity2.supported_color_modes = {light.COLOR_MODE_HS, light.COLOR_MODE_WHITE}
entity2.supported_color_modes = {light.ColorMode.HS, light.ColorMode.WHITE}
assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_COLOR_TEMP,
light.COLOR_MODE_HS,
light.ColorMode.COLOR_TEMP,
light.ColorMode.HS,
]
state = hass.states.get(entity1.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_HS]
assert state.attributes["supported_color_modes"] == [light.ColorMode.HS]
state = hass.states.get(entity2.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_HS,
light.COLOR_MODE_WHITE,
light.ColorMode.HS,
light.ColorMode.WHITE,
]
await hass.services.async_call(
@ -1866,24 +1866,24 @@ async def test_light_service_call_color_temp_conversion(
entity0 = platform.ENTITIES[0]
entity0.supported_color_modes = {
light.COLOR_MODE_COLOR_TEMP,
light.COLOR_MODE_RGBWW,
light.ColorMode.COLOR_TEMP,
light.ColorMode.RGBWW,
}
entity1 = platform.ENTITIES[1]
entity1.supported_color_modes = {light.COLOR_MODE_RGBWW}
entity1.supported_color_modes = {light.ColorMode.RGBWW}
assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_COLOR_TEMP,
light.COLOR_MODE_RGBWW,
light.ColorMode.COLOR_TEMP,
light.ColorMode.RGBWW,
]
state = hass.states.get(entity1.entity_id)
assert state.attributes["supported_color_modes"] == [light.COLOR_MODE_RGBWW]
assert state.attributes["supported_color_modes"] == [light.ColorMode.RGBWW]
await hass.services.async_call(
"light",
@ -1986,15 +1986,15 @@ async def test_light_service_call_white_mode(hass, enable_custom_integrations):
platform.ENTITIES.append(platform.MockLight("Test_white", STATE_ON))
entity0 = platform.ENTITIES[0]
entity0.supported_color_modes = {light.COLOR_MODE_HS, light.COLOR_MODE_WHITE}
entity0.supported_color_modes = {light.ColorMode.HS, light.ColorMode.WHITE}
assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.attributes["supported_color_modes"] == [
light.COLOR_MODE_HS,
light.COLOR_MODE_WHITE,
light.ColorMode.HS,
light.ColorMode.WHITE,
]
await hass.services.async_call(
@ -2072,22 +2072,22 @@ async def test_light_state_color_conversion(hass, enable_custom_integrations):
platform.ENTITIES.append(platform.MockLight("Test_legacy", STATE_ON))
entity0 = platform.ENTITIES[0]
entity0.supported_color_modes = {light.COLOR_MODE_HS}
entity0.color_mode = light.COLOR_MODE_HS
entity0.supported_color_modes = {light.ColorMode.HS}
entity0.color_mode = light.ColorMode.HS
entity0.hs_color = (240, 100)
entity0.rgb_color = "Invalid" # Should be ignored
entity0.xy_color = "Invalid" # Should be ignored
entity1 = platform.ENTITIES[1]
entity1.supported_color_modes = {light.COLOR_MODE_RGB}
entity1.color_mode = light.COLOR_MODE_RGB
entity1.supported_color_modes = {light.ColorMode.RGB}
entity1.color_mode = light.ColorMode.RGB
entity1.hs_color = "Invalid" # Should be ignored
entity1.rgb_color = (128, 0, 0)
entity1.xy_color = "Invalid" # Should be ignored
entity2 = platform.ENTITIES[2]
entity2.supported_color_modes = {light.COLOR_MODE_XY}
entity2.color_mode = light.COLOR_MODE_XY
entity2.supported_color_modes = {light.ColorMode.XY}
entity2.color_mode = light.ColorMode.XY
entity2.hs_color = "Invalid" # Should be ignored
entity2.rgb_color = "Invalid" # Should be ignored
entity2.xy_color = (0.1, 0.8)
@ -2100,25 +2100,25 @@ async def test_light_state_color_conversion(hass, enable_custom_integrations):
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.attributes["color_mode"] == light.COLOR_MODE_HS
assert state.attributes["color_mode"] == light.ColorMode.HS
assert state.attributes["hs_color"] == (240, 100)
assert state.attributes["rgb_color"] == (0, 0, 255)
assert state.attributes["xy_color"] == (0.136, 0.04)
state = hass.states.get(entity1.entity_id)
assert state.attributes["color_mode"] == light.COLOR_MODE_RGB
assert state.attributes["color_mode"] == light.ColorMode.RGB
assert state.attributes["hs_color"] == (0.0, 100.0)
assert state.attributes["rgb_color"] == (128, 0, 0)
assert state.attributes["xy_color"] == (0.701, 0.299)
state = hass.states.get(entity2.entity_id)
assert state.attributes["color_mode"] == light.COLOR_MODE_XY
assert state.attributes["color_mode"] == light.ColorMode.XY
assert state.attributes["hs_color"] == (125.176, 100.0)
assert state.attributes["rgb_color"] == (0, 255, 22)
assert state.attributes["xy_color"] == (0.1, 0.8)
state = hass.states.get(entity3.entity_id)
assert state.attributes["color_mode"] == light.COLOR_MODE_HS
assert state.attributes["color_mode"] == light.ColorMode.HS
assert state.attributes["hs_color"] == (240, 100)
assert state.attributes["rgb_color"] == (0, 0, 255)
assert state.attributes["xy_color"] == (0.136, 0.04)
@ -2280,7 +2280,7 @@ async def test_services_filter_parameters(
def test_valid_supported_color_modes():
"""Test valid_supported_color_modes."""
supported = {light.COLOR_MODE_HS}
supported = {light.ColorMode.HS}
assert light.valid_supported_color_modes(supported) == supported
# Supported color modes must not be empty
@ -2288,30 +2288,30 @@ def test_valid_supported_color_modes():
with pytest.raises(vol.Error):
light.valid_supported_color_modes(supported)
# COLOR_MODE_WHITE must be combined with a color mode supporting color
supported = {light.COLOR_MODE_WHITE}
# ColorMode.WHITE must be combined with a color mode supporting color
supported = {light.ColorMode.WHITE}
with pytest.raises(vol.Error):
light.valid_supported_color_modes(supported)
supported = {light.COLOR_MODE_WHITE, light.COLOR_MODE_COLOR_TEMP}
supported = {light.ColorMode.WHITE, light.ColorMode.COLOR_TEMP}
with pytest.raises(vol.Error):
light.valid_supported_color_modes(supported)
supported = {light.COLOR_MODE_WHITE, light.COLOR_MODE_HS}
supported = {light.ColorMode.WHITE, light.ColorMode.HS}
assert light.valid_supported_color_modes(supported) == supported
# COLOR_MODE_ONOFF must be the only supported mode
supported = {light.COLOR_MODE_ONOFF}
# ColorMode.ONOFF must be the only supported mode
supported = {light.ColorMode.ONOFF}
assert light.valid_supported_color_modes(supported) == supported
supported = {light.COLOR_MODE_ONOFF, light.COLOR_MODE_COLOR_TEMP}
supported = {light.ColorMode.ONOFF, light.ColorMode.COLOR_TEMP}
with pytest.raises(vol.Error):
light.valid_supported_color_modes(supported)
# COLOR_MODE_BRIGHTNESS must be the only supported mode
supported = {light.COLOR_MODE_BRIGHTNESS}
# ColorMode.BRIGHTNESS must be the only supported mode
supported = {light.ColorMode.BRIGHTNESS}
assert light.valid_supported_color_modes(supported) == supported
supported = {light.COLOR_MODE_BRIGHTNESS, light.COLOR_MODE_COLOR_TEMP}
supported = {light.ColorMode.BRIGHTNESS, light.ColorMode.COLOR_TEMP}
with pytest.raises(vol.Error):
light.valid_supported_color_modes(supported)

10
tests/components/light/test_intent.py
View File

@ -1,10 +1,6 @@
"""Tests for the light intents."""
from homeassistant.components import light
from homeassistant.components.light import (
ATTR_SUPPORTED_COLOR_MODES,
COLOR_MODE_HS,
intent,
)
from homeassistant.components.light import ATTR_SUPPORTED_COLOR_MODES, ColorMode, intent
from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_ON
from homeassistant.helpers.intent import IntentHandleError
@ -14,7 +10,7 @@ from tests.common import async_mock_service
async def test_intent_set_color(hass):
"""Test the set color intent."""
hass.states.async_set(
"light.hello_2", "off", {ATTR_SUPPORTED_COLOR_MODES: [COLOR_MODE_HS]}
"light.hello_2", "off", {ATTR_SUPPORTED_COLOR_MODES: [ColorMode.HS]}
)
hass.states.async_set("switch.hello", "off")
calls = async_mock_service(hass, light.DOMAIN, light.SERVICE_TURN_ON)
@ -59,7 +55,7 @@ async def test_intent_set_color_tests_feature(hass):
async def test_intent_set_color_and_brightness(hass):
"""Test the set color intent."""
hass.states.async_set(
"light.hello_2", "off", {ATTR_SUPPORTED_COLOR_MODES: [COLOR_MODE_HS]}
"light.hello_2", "off", {ATTR_SUPPORTED_COLOR_MODES: [ColorMode.HS]}
)
hass.states.async_set("switch.hello", "off")
calls = async_mock_service(hass, light.DOMAIN, light.SERVICE_TURN_ON)

40
tests/components/light/test_reproduce_state.py
View File

@ -165,16 +165,16 @@ async def test_reproducing_states(hass, caplog):
@pytest.mark.parametrize(
"color_mode",
(
light.COLOR_MODE_COLOR_TEMP,
light.COLOR_MODE_BRIGHTNESS,
light.COLOR_MODE_HS,
light.COLOR_MODE_ONOFF,
light.COLOR_MODE_RGB,
light.COLOR_MODE_RGBW,
light.COLOR_MODE_RGBWW,
light.COLOR_MODE_UNKNOWN,
light.COLOR_MODE_WHITE,
light.COLOR_MODE_XY,
light.ColorMode.COLOR_TEMP,
light.ColorMode.BRIGHTNESS,
light.ColorMode.HS,
light.ColorMode.ONOFF,
light.ColorMode.RGB,
light.ColorMode.RGBW,
light.ColorMode.RGBWW,
light.ColorMode.UNKNOWN,
light.ColorMode.WHITE,
light.ColorMode.XY,
),
)
async def test_filter_color_modes(hass, caplog, color_mode):
@ -200,23 +200,23 @@ async def test_filter_color_modes(hass, caplog, color_mode):
)
expected_map = {
light.COLOR_MODE_COLOR_TEMP: {**VALID_BRIGHTNESS, **VALID_COLOR_TEMP},
light.COLOR_MODE_BRIGHTNESS: VALID_BRIGHTNESS,
light.COLOR_MODE_HS: {**VALID_BRIGHTNESS, **VALID_HS_COLOR},
light.COLOR_MODE_ONOFF: {**VALID_BRIGHTNESS},
light.COLOR_MODE_RGB: {**VALID_BRIGHTNESS, **VALID_RGB_COLOR},
light.COLOR_MODE_RGBW: {**VALID_BRIGHTNESS, **VALID_RGBW_COLOR},
light.COLOR_MODE_RGBWW: {**VALID_BRIGHTNESS, **VALID_RGBWW_COLOR},
light.COLOR_MODE_UNKNOWN: {
light.ColorMode.COLOR_TEMP: {**VALID_BRIGHTNESS, **VALID_COLOR_TEMP},
light.ColorMode.BRIGHTNESS: VALID_BRIGHTNESS,
light.ColorMode.HS: {**VALID_BRIGHTNESS, **VALID_HS_COLOR},
light.ColorMode.ONOFF: {**VALID_BRIGHTNESS},
light.ColorMode.RGB: {**VALID_BRIGHTNESS, **VALID_RGB_COLOR},
light.ColorMode.RGBW: {**VALID_BRIGHTNESS, **VALID_RGBW_COLOR},
light.ColorMode.RGBWW: {**VALID_BRIGHTNESS, **VALID_RGBWW_COLOR},
light.ColorMode.UNKNOWN: {
**VALID_BRIGHTNESS,
**VALID_HS_COLOR,
**VALID_WHITE_VALUE,
},
light.COLOR_MODE_WHITE: {
light.ColorMode.WHITE: {
**VALID_BRIGHTNESS,
light.ATTR_WHITE: VALID_BRIGHTNESS[light.ATTR_BRIGHTNESS],
},
light.COLOR_MODE_XY: {**VALID_BRIGHTNESS, **VALID_XY_COLOR},
light.ColorMode.XY: {**VALID_BRIGHTNESS, **VALID_XY_COLOR},
}
expected = expected_map[color_mode]