Add support for WLED presets (#322)

Author: frenck

examples/control.py

@@ -3,7 +3,7 @@
 
 import asyncio
 
-from wled import WLED
+from wled import WLED, Preset
 
 
 async def main():
@@ -12,6 +12,9 @@ async def main():
         device = await led.update()
         print(device.info.version)
 
+        if isinstance(device.state.preset, Preset):
+            print(f"Preset active! Name: {device.state.preset.name}")
+
         # Turn strip on, full brightness
         await led.master(on=True, brightness=255)
 

src/wled/__init__.py

@@ -8,6 +8,7 @@
     Live,
     Nightlight,
     Palette,
+    Preset,
     Segment,
     State,
     Sync,
@@ -28,6 +29,7 @@
     "Live",
     "Nightlight",
     "Palette",
+    "Preset",
     "Segment",
     "State",
     "Sync",

src/wled/models.py

@@ -326,7 +326,7 @@ class State:
     nightlight: Nightlight
     on: bool
     playlist: int
-    preset: int
+    preset: Preset | int | None
     segments: list[Segment]
     sync: Sync
     transition: int
@@ -352,14 +352,18 @@ def preset_active(self) -> bool:
 
     @staticmethod
     def from_dict(
-        data: dict[str, Any], effects: list[Effect], palettes: list[Palette]
+        data: dict[str, Any],
+        effects: list[Effect],
+        palettes: list[Palette],
+        presets: list[Preset],
     ) -> State:
         """Return State object from WLED API response.
 
         Args:
             data: The state response received from the WLED device API.
             effects: A list of effect objects.
-            palettes: A list of palette object.
+            palettes: A list of palette objects.
+            presets: A list of presets objects.
 
         Returns:
             A State object.
@@ -380,25 +384,92 @@ def from_dict(
             for segment_id, segment in enumerate(data.get("seg", []))
         ]
 
+        preset = data.get("ps", -1)
+        if presets:
+            preset = next(
+                (item for item in presets if item.preset_id == data.get("ps")),
+                None,
+            )
+
         return State(
             brightness=brightness,
             nightlight=Nightlight.from_dict(data),
             on=on,
             playlist=data.get("pl", -1),
-            preset=data.get("ps", -1),
+            preset=preset,
             segments=segments,
             sync=Sync.from_dict(data),
             transition=data.get("transition", 0),
             lor=Live(lor),
         )
 
 
+@dataclass
+class Preset:
+    """Object representing a WLED preset."""
+
+    preset_id: int
+    name: str
+    quick_label: str | None
+
+    on: bool
+    transition: int
+    main_segment: Segment | None
+    segments: list[Segment]
+
+    @staticmethod
+    def from_dict(
+        preset_id: int,
+        data: dict[str, Any],
+        effects: list[Effect],
+        palettes: list[Palette],
+    ) -> Preset:
+        """Return Preset object from WLED API response.
+
+        Args:
+            preset_id: The ID of the preset.
+            data: The data from the WLED device API.
+            effects: A list of effect objects.
+            palettes: A list of palette object.
+
+        Returns:
+            A Preset object.
+        """
+        segments = [
+            Segment.from_dict(
+                segment_id=segment_id,
+                data=segment,
+                effects=effects,
+                palettes=palettes,
+                state_on=False,
+                state_brightness=0,
+            )
+            for segment_id, segment in enumerate(data.get("seg", []))
+        ]
+
+        main_segment = next(
+            (item for item in segments if item.segment_id == data.get("mainseg", 0)),
+            None,
+        )
+
+        return Preset(
+            main_segment=main_segment,
+            name=data["n"],
+            on=data.get("on", False),
+            preset_id=preset_id,
+            quick_label=data.get("ql"),
+            segments=segments,
+            transition=data.get("transition", 0),
+        )
+
+
 class Device:
     """Object holding all information of WLED."""
 
     effects: list[Effect] = []
     info: Info
     palettes: list[Palette] = []
+    presets: list[Preset] = []
     state: State
 
     def __init__(self, data: dict) -> None:
@@ -445,11 +516,22 @@ def update_from_dict(self, data: dict) -> Device:
             palettes.sort(key=lambda x: x.name)
             self.palettes = palettes
 
+        if _presets := data.get("presets"):
+            _presets.pop("0")
+            presets = [
+                Preset.from_dict(int(preset_id), preset, self.effects, self.palettes)
+                for preset_id, preset in _presets.items()
+            ]
+            presets.sort(key=lambda x: x.name)
+            self.presets = presets
+
         if _info := data.get("info"):
             self.info = Info.from_dict(_info)
 
         if _state := data.get("state"):
-            self.state = State.from_dict(_state, self.effects, self.palettes)
+            self.state = State.from_dict(
+                _state, self.effects, self.palettes, self.presets
+            )
 
         return self
 

src/wled/wled.py

@@ -35,6 +35,7 @@ class WLED:
     _close_session: bool = False
     _device: Device | None = None
     _supports_si_request: bool | None = None
+    _supports_presets: bool | None = None
 
     @property
     def connected(self) -> bool:
@@ -230,6 +231,15 @@ async def update(self, full_update: bool = False) -> Device:
                     f"WLED device at {self.host} returned an empty API"
                     " response on full update"
                 )
+
+            # Try to get presets, introduced in WLED 0.11
+            try:
+                presets = await self.request("/presets.json")
+                data["presets"] = presets
+                self._supports_presets = True
+            except WLEDError:
+                self._supports_presets = False
+
             self._device = Device(data)
 
             # Try to figure out if this version supports
@@ -249,6 +259,15 @@ async def update(self, full_update: bool = False) -> Device:
 
             return self._device
 
+        if self._supports_presets:
+            presets = await self.request("/presets.json")
+            if not presets:
+                raise WLEDEmptyResponseError(
+                    f"WLED device at {self.host} returned an empty API"
+                    " response on presets update"
+                )
+            self._device.update_from_dict({"presets": presets})
+
         # Handle legacy state and update in separate requests
         if not self._supports_si_request:
             info = await self.request("/json/info")
@@ -274,6 +293,7 @@ async def update(self, full_update: bool = False) -> Device:
                 " response on state & info update"
             )
         self._device.update_from_dict(state_info)
+
         return self._device
 
     async def master(
@@ -454,12 +474,23 @@ async def transition(self, transition: int) -> None:
             "/json/state", method="POST", data={"transition": transition}
         )
 
-    async def preset(self, preset: int) -> None:
+    async def preset(self, preset: int | str) -> None:
         """Set a preset on a WLED device.
 
         Args:
             preset: The preset number to activate on this WLED device.
         """
+        # Find preset if it was based on a name
+        if self._device and self._device.presets and isinstance(preset, str):
+            preset = next(
+                (
+                    item.preset_id
+                    for item in self._device.presets
+                    if item.name.lower() == preset.lower()
+                ),
+                preset,
+            )
+
         await self.request("/json/state", method="POST", data={"ps": preset})
 
     async def live(self, live: Live) -> None: