Refactor color handling architecture across all devices

- Moved color property from ColorableMixin to abstract Light base class
- Updated ColorableMixin to use property descriptors for better performance
- Modified all vendor implementations to properly implement color property
- Updated test files to reflect new inheritance patterns
- Renamed test_vendor_muteme.py to test_vendor_muteme_muteme.py for clarity

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: JnyJny

src/busylight_core/light.py

@@ -38,10 +38,10 @@
     NoLightsFoundError,
 )
 from .hardware import Hardware
-from .mixins import ColorableMixin, TaskableMixin
+from .mixins import TaskableMixin
 
 
-class Light(abc.ABC, ColorableMixin, TaskableMixin):
+class Light(abc.ABC, TaskableMixin):
     """Base class for USB connected lights.
 
     This base class provides a common interface for USB connected lights.
@@ -478,3 +478,23 @@ def reset(self) -> None:
     def __bytes__(self) -> bytes:
         """Return the light's state suitable for writing to the device."""
         raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def color(self) -> tuple[int, int, int]:
+        """Get the current RGB color of the light."""
+        raise NotImplementedError
+
+    @color.setter
+    @abc.abstractmethod
+    def color(self, value: tuple[int, int, int]) -> None:
+        """Set the RGB color of the light.
+
+        :param: value: tuple[int, int, int] - RGB color tuple
+        """
+        raise NotImplementedError
+
+    @property
+    def is_lit(self) -> bool:
+        """Check if the light is currently lit."""
+        return any(self.color)

src/busylight_core/mixins/colorable.py

@@ -2,45 +2,32 @@
 
 
 class ColorableMixin:
-    """Mixin providing color manipulation properties for Light classes."""
-
-    @property
-    def red(self) -> int:
-        """Red color value."""
-        return getattr(self, "_red", 0)
-
-    @red.setter
-    def red(self, value: int) -> None:
-        self._red = value
-
-    @property
-    def green(self) -> int:
-        """Green color value."""
-        return getattr(self, "_green", 0)
-
-    @green.setter
-    def green(self, value: int) -> None:
-        self._green = value
-
-    @property
-    def blue(self) -> int:
-        """Blue color value."""
-        return getattr(self, "_blue", 0)
-
-    @blue.setter
-    def blue(self, value: int) -> None:
-        self._blue = value
+    """Mixin providing color properties."""
+
+    red = property(
+        lambda self: getattr(self, "_red", 0),
+        lambda self, value: setattr(self, "_red", value),
+        doc="Red color value.",
+    )
+
+    green = property(
+        lambda self: getattr(self, "_green", 0),
+        lambda self, value: setattr(self, "_green", value),
+        doc="Green color value.",
+    )
+
+    blue = property(
+        lambda self: getattr(self, "_blue", 0),
+        lambda self, value: setattr(self, "_blue", value),
+        doc="Blue color value.",
+    )
 
     @property
     def color(self) -> tuple[int, int, int]:
-        """A tuple of red, green, and blue color values."""
-        return self.red, self.green, self.blue
+        """Tuple of RGB color values."""
+        return (self.red, self.green, self.blue)
 
     @color.setter
     def color(self, value: tuple[int, int, int]) -> None:
+        """Tuple of RGB color values."""
         self.red, self.green, self.blue = value
-
-    @property
-    def is_lit(self) -> bool:
-        """True if any color value is greater than 0."""
-        return any(self.color)

src/busylight_core/vendors/compulab/fit_statusb.py

@@ -3,9 +3,10 @@
 from typing import ClassVar
 
 from busylight_core.light import Light
+from busylight_core.mixins import ColorableMixin
 
 
-class Fit_StatUSB(Light):
+class Fit_StatUSB(ColorableMixin, Light):
     """CompuLab fit-statUSB status light controller.
 
     The fit-statUSB is a USB-connected RGB LED device that communicates

src/busylight_core/vendors/epos/_busylight.py

@@ -46,25 +46,9 @@ def __init__(self) -> None:
 
     on = OnField(0, 8)
 
-    def set_color(
-        self,
-        color: tuple[int, int, int],
-        led: int = 0,
-    ) -> None:
-        """Set color for the specified LED."""
-        self.report = Report.ONE
-        self.action = Action.SetColor
-        match led:
-            case 0:
-                self.color = color
-            case 1:
-                self.color0 = color
-            case 2:
-                self.color1 = color
-
     @property
     def color0(self) -> tuple[int, int, int]:
-        """Return the first color as a tuple of RGB values."""
+        """Return the first LED color as a tuple of RGB values."""
         return (self.red0, self.green0, self.blue0)
 
     @color0.setter
@@ -73,7 +57,7 @@ def color0(self, color: tuple[int, int, int]) -> None:
 
     @property
     def color1(self) -> tuple[int, int, int]:
-        """Return the second color as a tuple of RGB values."""
+        """Return the second LED color as a tuple of RGB values."""
         return (self.red1, self.green1, self.blue1)
 
     @color1.setter
@@ -82,21 +66,13 @@ def color1(self, color: tuple[int, int, int]) -> None:
 
     @property
     def color(self) -> tuple[int, int, int]:
-        return self.color0
+        """The first non-black LED color as a tuple of RGB values."""
+        for color in (self.color0, self.color1):
+            if any(color):
+                return color
+        return (0, 0, 0)
 
     @color.setter
     def color(self, color: tuple[int, int, int]) -> None:
         self.color0 = color
         self.color1 = color
-
-    def reset(self) -> None:
-        """Reset state to default value."""
-        self.report = 0
-        self.action = 0
-        self.red0 = 0
-        self.green0 = 0
-        self.blue0 = 0
-        self.red1 = 0
-        self.green1 = 0
-        self.blue1 = 0
-        self.on = 0

src/busylight_core/vendors/epos/busylight.py

@@ -5,7 +5,7 @@
 
 from busylight_core.light import Light
 
-from ._busylight import State
+from ._busylight import Action, Report, State
 
 
 class Busylight(Light):
@@ -21,12 +21,12 @@ class Busylight(Light):
 
     @staticmethod
     def vendor() -> str:
-        """Return the vendor name for this device."""
+        """The vendor name for this device."""
         return "EPOS"
 
     @cached_property
     def state(self) -> State:
-        """Get the device state manager for controlling LED patterns."""
+        """The device state manager for controlling LED patterns."""
         return State()
 
     def __bytes__(self) -> bytes:
@@ -35,16 +35,31 @@ def __bytes__(self) -> bytes:
     def on(self, color: tuple[int, int, int], led: int = 0) -> None:
         """Turn on the EPOS Busylight with the specified color.
 
-        Args:
-            color: RGB color tuple (red, green, blue) with values 0-255
-            led: LED index for targeting specific LEDs
-
+        :param color: RGB color tuple (red, green, blue) with values 0-255
+        :param led: LED index (0 for both LEDs, 1 for first LED, 2 for second LED)
         """
-        self.color = color
         with self.batch_update():
-            self.state.set_color(color, led)
+            match led:
+                case 1:
+                    self.state.color0 = color
+                case 2:
+                    self.state.color1 = color
+                case _:
+                    self.state.color = color
+
+            self.state.report = Report.ONE
+            self.state.action = Action.SetColor
+
+    @property
+    def color(self) -> tuple[int, int, int]:
+        """The device color as a tuple of RGB values."""
+        return self.state.color
+
+    @color.setter
+    def color(self, color: tuple[int, int, int]) -> None:
+        self.state.color = color
 
     def reset(self) -> None:
         """Reset the device to its default state."""
-        self.state.reset()
+        self.state.clear()
         super().reset()

src/busylight_core/vendors/kuando/busylight_alpha.py

@@ -5,11 +5,12 @@
 from typing import ClassVar
 
 from busylight_core.light import Light
+from busylight_core.mixins import ColorableMixin
 
 from ._busylight import State
 
 
-class Busylight_Alpha(Light):
+class Busylight_Alpha(ColorableMixin, Light):
     """Kuando Busylight Alpha status light controller.
 
     The Busylight Alpha is a USB-connected RGB LED device that requires
@@ -34,10 +35,8 @@ def __bytes__(self) -> bytes:
     def on(self, color: tuple[int, int, int], led: int = 0) -> None:
         """Turn on the Busylight Alpha with the specified color.
 
-        Args:
-            color: RGB color tuple (red, green, blue) with values 0-255
-            led: LED index (unused for Busylight Alpha)
-
+        :param color: RGB color tuple (red, green, blue) with values 0-255
+        :param led: LED index (unused for Busylight Alpha)
         """
         self.color = color
         with self.batch_update():
@@ -47,9 +46,7 @@ def on(self, color: tuple[int, int, int], led: int = 0) -> None:
     def off(self, led: int = 0) -> None:
         """Turn off the Busylight Alpha.
 
-        Args:
-            led: LED index (unused for Busylight Alpha)
-
+        :param led: LED index (unused for Busylight Alpha)
         """
         self.color = (0, 0, 0)
         with self.batch_update():

src/busylight_core/vendors/luxafor/busytag.py

@@ -3,11 +3,12 @@
 from typing import ClassVar
 
 from busylight_core.light import Light
+from busylight_core.mixins import ColorableMixin
 
 from ._busytag import Command
 
 
-class BusyTag(Light):
+class BusyTag(ColorableMixin, Light):
     """BusyTag status light controller.
 
     The BusyTag is a wireless status light that uses command strings
@@ -38,10 +39,8 @@ def __bytes__(self) -> bytes:
     def on(self, color: tuple[int, int, int], led: int = 0) -> None:
         """Turn on the BusyTag with the specified color.
 
-        Args:
-            color: RGB color tuple (red, green, blue) with values 0-255
-            led: LED index for specific LED targeting
-
+        :param color: RGB color tuple (red, green, blue)
+        :param led: LED index (default is 0, for the first LED)
         """
         with self.batch_update():
             self.color = color

src/busylight_core/vendors/luxafor/flag.py

@@ -24,14 +24,9 @@ class Flag(Light):
 
     @classmethod
     def claims(cls, hardware: Hardware) -> bool:
-        """Check if this class can handle the given hardware device.
-
-        Args:
-            hardware: Hardware device to check
-
-        Returns:
-            True if this class can handle the hardware
+        """Check if this class claims the given hardware device.
 
+        :param hardware: A hardware instance
         """
         if not super().claims(hardware):
             return False
@@ -48,24 +43,29 @@ def claims(cls, hardware: Hardware) -> bool:
 
     @cached_property
     def state(self) -> State:
-        """Get the device state manager for controlling LED patterns."""
+        """The device state manager for controlling a Luxfor device."""
         return State()
 
     def __bytes__(self) -> bytes:
-        self.state.color = self.color
         return bytes(self.state)
 
     def on(self, color: tuple[int, int, int], led: int = 0) -> None:
-        """Turn on the Luxafor Flag with the specified color.
-
-        Args:
-            color: RGB color tuple (red, green, blue) with values 0-255
-            led: LED index (0 for all LEDs, or specific LED number)
+        """Turn on a Luxafor device with the specified color tuple.
 
+        :param color: RGB color tuple (red, green, blue)
         """
         with self.batch_update():
+            self.color = color
             try:
                 self.state.leds = LEDS(led)
             except ValueError:
                 self.state.leds = LEDS.All
-            self.color = color
+
+    @property
+    def color(self) -> tuple[int, int, int]:
+        """The current RGB color of a Luxafor device."""
+        return self.state.color
+
+    @color.setter
+    def color(self, value: tuple[int, int, int]) -> None:
+        self.state.color = value

src/busylight_core/vendors/luxafor/mute.py

@@ -18,22 +18,12 @@ class Mute(Flag):
 
     @property
     def is_button(self) -> bool:
-        """Check if this device has button functionality.
-
-        Returns:
-            True, as the Mute device has a button
-
-        """
+        """Return True if this device has button functionality."""
         return True
 
     @property
     def button_on(self) -> bool:
-        """Check if the mute button is currently pressed.
-
-        Returns:
-            True if the button is pressed, False otherwise
-
-        """
+        """Return True if the mute button is currently pressed."""
         results = self.read_strategy(8, 200)
 
         try: