Make turn_on work if only brightness is used as well

Author: Breina

custom_components/dmx/entity/light/light_controller.py

@@ -44,27 +44,21 @@ async def _apply_updates(self, updates: Dict[ChannelType, int]):
     def _collect_updates_from_kwargs(self, kwargs: Dict[str, Any]) -> Dict[ChannelType, int]:
         updates = {}
 
-        def set_if_applicable(cond, ct, val):
-            if cond:
-                updates[ct] = val
-
-        if "brightness" in kwargs and self.state.has_channel(ChannelType.DIMMER):
-            set_if_applicable(True, ChannelType.DIMMER, kwargs["brightness"])
+        if "brightness" in kwargs:
+            brightness = kwargs["brightness"]
+            updates.update(self.state.get_scaled_brightness_updates(brightness))
 
         if "rgb_color" in kwargs and self.state.has_rgb():
             r, g, b = kwargs["rgb_color"]
             updates.update({ChannelType.RED: r, ChannelType.GREEN: g, ChannelType.BLUE: b})
 
         if "rgbw_color" in kwargs:
             r, g, b, w = kwargs["rgbw_color"]
-            updates.update({ChannelType.RED: r, ChannelType.GREEN: g, ChannelType.BLUE: b})
-            set_if_applicable(self.state.has_channel(ChannelType.COLD_WHITE), ChannelType.COLD_WHITE, w)
+            updates.update({ChannelType.RED: r, ChannelType.GREEN: g, ChannelType.BLUE: b, ChannelType.WARM_WHITE: w})
 
         if "rgbww_color" in kwargs:
             r, g, b, cw, ww = kwargs["rgbww_color"]
-            updates.update({ChannelType.RED: r, ChannelType.GREEN: g, ChannelType.BLUE: b})
-            set_if_applicable(self.state.has_channel(ChannelType.COLD_WHITE), ChannelType.COLD_WHITE, cw)
-            set_if_applicable(self.state.has_channel(ChannelType.WARM_WHITE), ChannelType.WARM_WHITE, ww)
+            updates.update({ChannelType.RED: r, ChannelType.GREEN: g, ChannelType.BLUE: b,ChannelType.COLD_WHITE: cw, ChannelType.WARM_WHITE: ww})
 
         if "color_temp_kelvin" in kwargs:
             kelvin = kwargs["color_temp_kelvin"]

custom_components/dmx/entity/light/light_state.py

@@ -112,6 +112,42 @@ def _update_on_state_without_dimmer(self):
         else:
             self.is_on = self.brightness > 0
 
+    def get_scaled_brightness_updates(self, new_brightness: int) -> Dict[ChannelType, int]:
+        updates: Dict[ChannelType, int] = {}
+
+        if self._has_dimmer():
+            updates[ChannelType.DIMMER] = new_brightness
+            return updates
+
+        if self.color_mode == ColorMode.COLOR_TEMP:
+            cw, ww = self.converter.temp_to_cw_ww(self.color_temp_kelvin, new_brightness)
+            updates[ChannelType.COLD_WHITE] = cw
+            updates[ChannelType.WARM_WHITE] = ww
+            return updates
+
+        channel_values = {}
+
+        if self.color_mode in [ColorMode.RGB, ColorMode.RGBW, ColorMode.RGBWW]:
+            channel_values[ChannelType.RED] = self.rgb[0]
+            channel_values[ChannelType.GREEN] = self.rgb[1]
+            channel_values[ChannelType.BLUE] = self.rgb[2]
+
+        if self.color_mode == ColorMode.RGBW:
+            channel_values[ChannelType.WARM_WHITE] = self.warm_white
+
+        if self.color_mode == ColorMode.RGBWW:
+            channel_values[ChannelType.COLD_WHITE] = self.cold_white
+            channel_values[ChannelType.WARM_WHITE] = self.warm_white
+
+        max_current = max(channel_values.values(), default=1)
+        scale = new_brightness / max_current if max_current > 0 else 0
+
+        for channel, value in channel_values.items():
+            scaled = round(value * scale)
+            updates[channel] = min(255, scaled)
+
+        return updates
+
     def get_dmx_updates(self, values: Dict[ChannelType, int]) -> Dict[int, int]:
         updates = {}
         for channel_type, val in values.items():

tests/test_color_temperature.py

@@ -90,6 +90,11 @@ def test_8bit_dimmer_color_temp_light_updates(self):
         self.assertEqual(100, dimmer.native_value)
         self.assertAlmostEqual((color_temp.max_value + color_temp.min_value) / 2, color_temp.native_value, None, "", 5)
 
+        asyncio.run(light.async_turn_on(brightness=128))
+        assert_dmx_range(self.universe, 1, [128, 128])
+        self.assertAlmostEqual(50.0, dimmer.native_value, 0)
+        self.assertAlmostEqual((color_temp.max_value + color_temp.min_value) / 2, color_temp.native_value, None, "", 5)
+
         asyncio.run(light.async_turn_on(brightness=255, color_temp_kelvin=light.max_color_temp_kelvin))
         assert_dmx_range(self.universe, 1, [255, 255])
         self.assertEqual(100, dimmer.native_value)

tests/test_cw_ww.py

@@ -85,6 +85,11 @@ def test_8bit_wc_light_updates(self):
         self.assertAlmostEqual(50.0, warm_white.native_value, 0)
         self.assertAlmostEqual(50.0, cold_white.native_value, 0)
 
+        asyncio.run(light.async_turn_on(brightness=64))
+        assert_dmx_range(self.universe, 2, [64, 64])
+        self.assertAlmostEqual(25.0, warm_white.native_value, 0)
+        self.assertAlmostEqual(25.0, cold_white.native_value, 0)
+
         asyncio.run(light.async_turn_on(brightness=255, color_temp_kelvin=light.max_color_temp_kelvin))
         assert_dmx_range(self.universe, 2, [0, 255])
         self.assertEqual(0, warm_white.native_value)

tests/test_rgbw.py

@@ -87,27 +87,27 @@ def test_8bit_rgbw_light_updates(self):
         white: DmxNumberEntity = get_entity_by_name(entities, 'RGBW fader White')
         light: DmxLightEntity = get_entity_by_name(entities, 'RGBW fader Light')
 
-        # Test setting pure red
-        asyncio.run(light.async_turn_on(rgbw_color=(255, 0, 0, 0)))
-        assert_dmx_range(self.universe, 2, [255, 0, 0, 0])
+        asyncio.run(light.async_turn_on(rgbw_color=(255, 128, 64, 0)))
+        assert_dmx_range(self.universe, 2, [255, 128, 64, 0])
         self.assertEqual(100, red.native_value)
-        self.assertEqual(0, green.native_value)
-        self.assertEqual(0, blue.native_value)
+        self.assertAlmostEqual(50.0, green.native_value, 0)
+        self.assertAlmostEqual(25.0, blue.native_value, 0)
+        self.assertEqual(0, white.native_value)
+
+        asyncio.run(light.async_turn_on(brightness=128))
+        assert_dmx_range(self.universe, 2, [128, 64, 32, 0])
+        self.assertAlmostEqual(50.0, red.native_value, 0)
+        self.assertAlmostEqual(25.0, green.native_value, 0)
+        self.assertAlmostEqual(12.5, blue.native_value, 0)
         self.assertEqual(0, white.native_value)
 
-        # Test setting mixed color
         asyncio.run(light.async_turn_on(rgbw_color=(127, 191, 63, 0)))
         assert_dmx_range(self.universe, 2, [127, 191, 63, 0])
         self.assertAlmostEqual(50.0, red.native_value, 0)
         self.assertAlmostEqual(75.0, green.native_value, 0)
         self.assertAlmostEqual(25.0, blue.native_value, 0)
         self.assertEqual(0, white.native_value)
 
-        # Test setting white
-        asyncio.run(light.async_turn_on(rgbw_color=(255, 255, 255, 0)))
-        # White light might be handled differently - adjust expectations based on implementation
-        self.assertTrue(light.is_on)
-
     def test_16bit_rgbw_number_updates(self):
         channels = self.fixture.select_mode('16bit')
         entities = delegator.create_entities('RGBW fader', 3, channels, None, self.universe)
@@ -118,7 +118,6 @@ def test_16bit_rgbw_number_updates(self):
         white: DmxNumberEntity = get_entity_by_name(entities, 'RGBW fader White')
         light: DmxLightEntity = get_entity_by_name(entities, 'RGBW fader Light')
 
-        # Test pure red (16-bit: high byte, low byte for each channel)
         asyncio.run(red.async_set_native_value(100))
         asyncio.run(green.async_set_native_value(0))
         asyncio.run(blue.async_set_native_value(0))
@@ -127,7 +126,6 @@ def test_16bit_rgbw_number_updates(self):
         self.assertEqual(255, light.brightness)
         self.assertEqual((255, 0, 0), light.rgb_color)
 
-        # Test mixed color
         asyncio.run(red.async_set_native_value(50))
         asyncio.run(green.async_set_native_value(75))
         asyncio.run(blue.async_set_native_value(25))
@@ -136,7 +134,6 @@ def test_16bit_rgbw_number_updates(self):
         self.assertEqual(191, light.brightness)
         self.assertEqual((127, 191, 64), light.rgb_color)
 
-        # Test RGBW combination
         asyncio.run(red.async_set_native_value(50))
         asyncio.run(green.async_set_native_value(50))
         asyncio.run(blue.async_set_native_value(50))