lifx-async 4.3.5__py3-none-any.whl → 4.3.7__py3-none-any.whl

lifx/devices/base.py

@@ -19,7 +19,7 @@ from lifx.const import (
     LIFX_LOCATION_NAMESPACE,
     LIFX_UDP_PORT,
 )
-from lifx.exceptions import LifxDeviceNotFoundError
+from lifx.exceptions import LifxDeviceNotFoundError, LifxUnsupportedCommandError
 from lifx.network.connection import DeviceConnection
 from lifx.products.registry import ProductInfo, get_product
 from lifx.protocol import packets
@@ -152,6 +152,23 @@ class Device:
         ```
     """
 
+    @staticmethod
+    def _raise_if_unhandled(response: object) -> None:
+        """Raise LifxUnsupportedCommandError if device doesn't support the command.
+
+        Args:
+            response: The response from connection.request()
+
+        Raises:
+            LifxUnsupportedCommandError: If response is StateUnhandled or False
+        """
+        if isinstance(response, packets.Device.StateUnhandled):
+            raise LifxUnsupportedCommandError(
+                f"Device does not support packet type {response.unhandled_type}"
+            )
+        if response is False:
+            raise LifxUnsupportedCommandError("Device does not support this command")
+
     def __init__(
         self,
         serial: str,
@@ -456,6 +473,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -469,6 +487,7 @@ class Device:
         """
         # Request automatically unpacks and decodes label
         state = await self.connection.request(packets.Device.GetLabel())
+        self._raise_if_unhandled(state)
 
         # Store label
         self._label = state.label
@@ -492,6 +511,7 @@ class Device:
             ValueError: If label is too long
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -508,9 +528,10 @@ class Device:
         label_bytes = label_bytes.ljust(32, b"\x00")
 
         # Request automatically handles acknowledgement
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Device.SetLabel(label=label_bytes),
         )
+        self._raise_if_unhandled(result)
 
         # Update cached state
         self._label = label
@@ -535,6 +556,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -544,6 +566,7 @@ class Device:
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.Device.GetPower())
+        self._raise_if_unhandled(state)
 
         # Power level is uint16 (0 or 65535)
         _LOGGER.debug(
@@ -566,6 +589,7 @@ class Device:
             ValueError: If integer value is not 0 or 65535
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -591,9 +615,10 @@ class Device:
             raise TypeError(f"Expected bool or int, got {type(level).__name__}")
 
         # Request automatically handles acknowledgement
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Device.SetPower(level=power_level),
         )
+        self._raise_if_unhandled(result)
 
         _LOGGER.debug(
             {
@@ -616,6 +641,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -625,6 +651,7 @@ class Device:
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.Device.GetVersion())
+        self._raise_if_unhandled(state)
 
         version = DeviceVersion(
             vendor=state.vendor,
@@ -655,6 +682,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -665,6 +693,7 @@ class Device:
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.Device.GetInfo())  # type: ignore
+        self._raise_if_unhandled(state)
 
         info = DeviceInfo(time=state.time, uptime=state.uptime, downtime=state.downtime)
 
@@ -694,6 +723,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -704,6 +734,7 @@ class Device:
         """
         # Request WiFi info from device
         state = await self.connection.request(packets.Device.GetWifiInfo())
+        self._raise_if_unhandled(state)
 
         # Extract WiFi info from response
         wifi_info = WifiInfo(signal=state.signal)
@@ -730,6 +761,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -739,6 +771,7 @@ class Device:
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.Device.GetHostFirmware())  # type: ignore
+        self._raise_if_unhandled(state)
 
         firmware = FirmwareInfo(
             build=state.build,
@@ -778,6 +811,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -787,6 +821,7 @@ class Device:
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.Device.GetWifiFirmware())  # type: ignore
+        self._raise_if_unhandled(state)
 
         firmware = FirmwareInfo(
             build=state.build,
@@ -822,6 +857,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -832,6 +868,7 @@ class Device:
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.Device.GetLocation())  # type: ignore
+        self._raise_if_unhandled(state)
 
         location = LocationInfo(
             location=state.location,
@@ -873,6 +910,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             ValueError: If label is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -967,11 +1005,12 @@ class Device:
         updated_at = int(time.time() * 1e9)
 
         # Update this device
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Device.SetLocation(
                 location=location_uuid_to_use, label=label_bytes, updated_at=updated_at
             ),
         )
+        self._raise_if_unhandled(result)
 
         # Update cached state
         location_info = LocationInfo(
@@ -1003,6 +1042,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -1013,6 +1053,7 @@ class Device:
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.Device.GetGroup())  # type: ignore
+        self._raise_if_unhandled(state)
 
         group = GroupInfo(
             group=state.group,
@@ -1054,6 +1095,7 @@ class Device:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             ValueError: If label is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -1148,11 +1190,12 @@ class Device:
         updated_at = int(time.time() * 1e9)
 
         # Update this device
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Device.SetGroup(
                 group=group_uuid_to_use, label=label_bytes, updated_at=updated_at
             ),
         )
+        self._raise_if_unhandled(result)
 
         # Update cached state
         group_info = GroupInfo(
@@ -1181,6 +1224,7 @@ class Device:
         Raises:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -1194,9 +1238,10 @@ class Device:
             comes back online and is discoverable again.
         """
         # Send reboot request
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Device.SetReboot(),
         )
+        self._raise_if_unhandled(result)
         _LOGGER.debug(
             {
                 "class": "Device",

lifx/devices/hev.py

@@ -70,6 +70,7 @@ class HevLight(Light):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -82,6 +83,7 @@ class HevLight(Light):
         """
         # Request HEV cycle state
         state = await self.connection.request(packets.Light.GetHevCycle())
+        self._raise_if_unhandled(state)
 
         # Create state object
         cycle_state = HevCycleState(
@@ -116,6 +118,7 @@ class HevLight(Light):
             ValueError: If duration is negative
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -130,12 +133,13 @@ class HevLight(Light):
             raise ValueError(f"Duration must be non-negative, got {duration_seconds}")
 
         # Request automatically handles acknowledgement
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Light.SetHevCycle(
                 enable=enable,
                 duration_s=duration_seconds,
             ),
         )
+        self._raise_if_unhandled(result)
 
         _LOGGER.debug(
             {
@@ -156,6 +160,7 @@ class HevLight(Light):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -166,6 +171,7 @@ class HevLight(Light):
         """
         # Request HEV configuration
         state = await self.connection.request(packets.Light.GetHevCycleConfiguration())
+        self._raise_if_unhandled(state)
 
         # Create config object
         config = HevConfig(
@@ -201,6 +207,7 @@ class HevLight(Light):
             ValueError: If duration is negative
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -212,12 +219,13 @@ class HevLight(Light):
             raise ValueError(f"Duration must be non-negative, got {duration_seconds}")
 
         # Request automatically handles acknowledgement
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Light.SetHevCycleConfiguration(
                 indication=indication,
                 duration_s=duration_seconds,
             ),
         )
+        self._raise_if_unhandled(result)
 
         # Update cached state
         self._hev_config = HevConfig(indication=indication, duration_s=duration_seconds)
@@ -242,6 +250,7 @@ class HevLight(Light):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -254,6 +263,7 @@ class HevLight(Light):
         """
         # Request last HEV result
         state = await self.connection.request(packets.Light.GetLastHevCycleResult())
+        self._raise_if_unhandled(state)
 
         # Store cached state
         self._hev_result = state.result

lifx/devices/infrared.py

@@ -58,6 +58,7 @@ class InfraredLight(Light):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -68,6 +69,7 @@ class InfraredLight(Light):
         """
         # Request infrared state
         state = await self.connection.request(packets.Light.GetInfrared())
+        self._raise_if_unhandled(state)
 
         # Convert from uint16 (0-65535) to float (0.0-1.0)
         brightness = state.brightness / 65535.0
@@ -96,6 +98,7 @@ class InfraredLight(Light):
             ValueError: If brightness is out of range
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -115,9 +118,10 @@ class InfraredLight(Light):
         brightness_u16 = max(0, min(65535, int(round(brightness * 65535))))
 
         # Request automatically handles acknowledgement
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Light.SetInfrared(brightness=brightness_u16),
         )
+        self._raise_if_unhandled(result)
 
         # Update cached state
         self._infrared = brightness

lifx/devices/light.py

@@ -83,6 +83,7 @@ class Light(Device):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -92,6 +93,7 @@ class Light(Device):
         """
         # Request automatically unpacks response and decodes labels
         state = await self.connection.request(packets.Light.GetColor())
+        self._raise_if_unhandled(state)
 
         # Convert from protocol HSBK to user-friendly HSBK
         color = HSBK.from_protocol(state.color)
@@ -133,6 +135,7 @@ class Light(Device):
         Raises:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -150,12 +153,13 @@ class Light(Device):
         duration_ms = int(duration * 1000)
 
         # Request automatically handles acknowledgement
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Light.SetColor(
                 color=protocol_color,
                 duration=duration_ms,
             ),
         )
+        self._raise_if_unhandled(result)
 
         _LOGGER.debug(
             {
@@ -357,6 +361,7 @@ class Light(Device):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -366,6 +371,7 @@ class Light(Device):
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.Light.GetPower())
+        self._raise_if_unhandled(state)
 
         # Power level is uint16 (0 or 65535)
         _LOGGER.debug(
@@ -394,6 +400,7 @@ class Light(Device):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -406,6 +413,7 @@ class Light(Device):
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.Sensor.GetAmbientLight())
+        self._raise_if_unhandled(state)
 
         _LOGGER.debug(
             {
@@ -432,6 +440,7 @@ class Light(Device):
             ValueError: If integer value is not 0 or 65535
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -460,9 +469,10 @@ class Light(Device):
         duration_ms = int(duration * 1000)
 
         # Request automatically handles acknowledgement
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Light.SetPower(level=power_level, duration=duration_ms),
         )
+        self._raise_if_unhandled(result)
 
         _LOGGER.debug(
             {
@@ -499,6 +509,7 @@ class Light(Device):
             ValueError: If parameters are out of range
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -537,7 +548,7 @@ class Light(Device):
         skew_ratio_i16 = int(skew_ratio * 65535) - 32768  # Convert to int16 range
 
         # Send request
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Light.SetWaveform(
                 transient=bool(transient),
                 color=protocol_color,
@@ -547,6 +558,7 @@ class Light(Device):
                 waveform=waveform,
             ),
         )
+        self._raise_if_unhandled(result)
         _LOGGER.debug(
             {
                 "class": "Device",
@@ -602,6 +614,7 @@ class Light(Device):
             ValueError: If parameters are out of range
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -647,7 +660,7 @@ class Light(Device):
         skew_ratio_i16 = int(skew_ratio * 65535) - 32768  # Convert to int16 range
 
         # Send request
-        await self.connection.request(
+        result = await self.connection.request(
             packets.Light.SetWaveformOptional(
                 transient=bool(transient),
                 color=protocol_color,
@@ -661,6 +674,7 @@ class Light(Device):
                 set_kelvin=set_kelvin,
             ),
         )
+        self._raise_if_unhandled(result)
         _LOGGER.debug(
             {
                 "class": "Device",

lifx/devices/matrix.py

@@ -311,6 +311,11 @@ class MatrixLight(Light):
         Returns:
             List of TileInfo objects describing each tile in the chain
 
+        Raises:
+            LifxDeviceNotFoundError: If device is not connected
+            LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
+
         Example:
             >>> chain = await matrix.get_device_chain()
             >>> for tile in chain:
@@ -321,6 +326,7 @@ class MatrixLight(Light):
         response: packets.Tile.StateDeviceChain = await self.connection.request(
             packets.Tile.GetDeviceChain()
         )
+        self._raise_if_unhandled(response)
 
         # Parse tiles from response
         tiles = []
@@ -393,6 +399,11 @@ class MatrixLight(Light):
             returns the actual zone count (e.g., 64 for 8x8, 16 for 4x4). For tiles
             with >64 zones (e.g., 128 for 16x8 Ceiling), returns 64 (protocol limit).
 
+        Raises:
+            LifxDeviceNotFoundError: If device is not connected
+            LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
+
         Example:
             >>> # Get all colors from first tile (no parameters needed)
             >>> colors = await matrix.get64()
@@ -432,6 +443,7 @@ class MatrixLight(Light):
                 rect=TileBufferRect(fb_index=0, x=x, y=y, width=width),
             )
         )
+        self._raise_if_unhandled(response)
 
         max_colors = device_chain[0].width * device_chain[0].height
 
@@ -714,6 +726,11 @@ class MatrixLight(Light):
         Returns:
             MatrixEffect describing the current effect state
 
+        Raises:
+            LifxDeviceNotFoundError: If device is not connected
+            LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
+
         Example:
             >>> effect = await matrix.get_effect()
             >>> print(f"Effect type: {effect.effect_type}")
@@ -723,6 +740,7 @@ class MatrixLight(Light):
         response: packets.Tile.StateEffect = await self.connection.request(
             packets.Tile.GetEffect()
         )
+        self._raise_if_unhandled(response)
 
         # Convert protocol effect to MatrixEffect
         palette = [

lifx/devices/multizone.py

@@ -189,6 +189,7 @@ class MultiZoneLight(Light):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -205,6 +206,7 @@ class MultiZoneLight(Light):
             state = await self.connection.request(
                 packets.MultiZone.GetColorZones(start_index=0, end_index=0)
             )
+        self._raise_if_unhandled(state)
 
         count = state.count
 
@@ -245,6 +247,7 @@ class MultiZoneLight(Light):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -279,6 +282,7 @@ class MultiZoneLight(Light):
                     start_index=current_start, end_index=current_end
                 )
             ):
+                self._raise_if_unhandled(state)
                 # Extract colors from response (up to 8 colors)
                 zones_in_response = min(8, current_end - current_start + 1)
                 for i in range(zones_in_response):
@@ -336,6 +340,7 @@ class MultiZoneLight(Light):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -361,6 +366,7 @@ class MultiZoneLight(Light):
             packets.MultiZone.GetExtendedColorZones(),
             timeout=2.0,  # Allow time for multiple responses
         ):
+            self._raise_if_unhandled(packet)
             # Only process valid colors based on colors_count
             for i in range(packet.colors_count):
                 if i >= len(packet.colors):
@@ -449,6 +455,7 @@ class MultiZoneLight(Light):
             ValueError: If zone indices are invalid
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -477,7 +484,7 @@ class MultiZoneLight(Light):
         duration_ms = int(duration * 1000)
 
         # Send request
-        await self.connection.request(
+        result = await self.connection.request(
             packets.MultiZone.SetColorZones(
                 start_index=start,
                 end_index=end,
@@ -486,6 +493,7 @@ class MultiZoneLight(Light):
                 apply=apply,
             ),
         )
+        self._raise_if_unhandled(result)
 
         _LOGGER.debug(
             {
@@ -529,6 +537,7 @@ class MultiZoneLight(Light):
             ValueError: If colors list is too long or zone index is invalid
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -556,7 +565,7 @@ class MultiZoneLight(Light):
         duration_ms = int(duration * 1000)
 
         # Send request
-        await self.connection.request(
+        result = await self.connection.request(
             packets.MultiZone.SetExtendedColorZones(
                 duration=duration_ms,
                 apply=apply,
@@ -565,6 +574,7 @@ class MultiZoneLight(Light):
                 colors=protocol_colors,
             ),
         )
+        self._raise_if_unhandled(result)
 
         _LOGGER.debug(
             {
@@ -602,6 +612,7 @@ class MultiZoneLight(Light):
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
             LifxProtocolError: If response is invalid
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -616,6 +627,7 @@ class MultiZoneLight(Light):
         """
         # Request automatically unpacks response
         state = await self.connection.request(packets.MultiZone.GetEffect())
+        self._raise_if_unhandled(state)
 
         settings = state.settings
         effect_type = settings.effect_type
@@ -672,6 +684,7 @@ class MultiZoneLight(Light):
         Raises:
             LifxDeviceNotFoundError: If device is not connected
             LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
 
         Example:
             ```python
@@ -701,7 +714,7 @@ class MultiZoneLight(Light):
         parameters = parameters[:8]
 
         # Send request
-        await self.connection.request(
+        result = await self.connection.request(
             packets.MultiZone.SetEffect(
                 settings=MultiZoneEffectSettings(
                     instanceid=0,  # 0 for new effect
@@ -721,10 +734,11 @@ class MultiZoneLight(Light):
                 ),
             ),
         )
+        self._raise_if_unhandled(result)
 
         # Update cached state
-        result = effect if effect.effect_type != FirmwareEffect.OFF else None
-        self._multizone_effect = result
+        cached_effect = effect if effect.effect_type != FirmwareEffect.OFF else None
+        self._multizone_effect = cached_effect
 
         _LOGGER.debug(
             {

lifx/network/connection.py

@@ -22,7 +22,6 @@ from lifx.exceptions import (
     LifxConnectionError,
     LifxProtocolError,
     LifxTimeoutError,
-    LifxUnsupportedCommandError,
 )
 from lifx.network.message import create_message, parse_message
 from lifx.network.transport import UdpTransport
@@ -443,13 +442,12 @@ class DeviceConnection:
             LifxConnectionError: If connection is not open
             LifxProtocolError: If response correlation validation fails
             LifxTimeoutError: If no response after all retries
-            LifxUnsupportedCommandError: If device doesn't support command
         """
         if not self._is_open or self._transport is None:
-            raise LifxConnectionError("Connection not open")
+            raise LifxConnectionError("Connection not open")  # pragma: no cover
 
         if timeout is None:
-            timeout = self.timeout
+            timeout = self.timeout  # pragma: no cover
 
         if max_retries is None:
             max_retries = self.max_retries
@@ -597,12 +595,6 @@ class DeviceConnection:
                                 f"got {header.sequence}, max expected {max_expected}"
                             )
 
-                        # Check for StateUnhandled
-                        if header.pkt_type == _STATE_UNHANDLED_PKT_TYPE:
-                            raise LifxUnsupportedCommandError(
-                                "Request unsupported by device: received StateUnhandled"
-                            )
-
                         # Yield response (can be from any retry attempt)
                         has_yielded = True
                         last_response_time = time.monotonic()
@@ -640,7 +632,7 @@ class DeviceConnection:
         request: Any,
         timeout: float | None = None,
         max_retries: int | None = None,
-    ) -> AsyncGenerator[None, None]:
+    ) -> AsyncGenerator[bool, None]:
         """Internal implementation of request_ack_stream with retry logic.
 
         This is an async generator that sends a request requiring acknowledgement
@@ -652,18 +644,17 @@ class DeviceConnection:
             max_retries: Maximum retries
 
         Yields:
-            None (single yield on successful ack)
+            True for successful ACK, False if device returned StateUnhandled
 
         Raises:
             LifxConnectionError: If connection is not open
             LifxTimeoutError: If no ack after all retries
-            LifxUnsupportedCommandError: If device doesn't support command
         """
         if not self._is_open or self._transport is None:
-            raise LifxConnectionError("Connection not open")
+            raise LifxConnectionError("Connection not open")  # pragma: no cover
 
         if timeout is None:
-            timeout = self.timeout
+            timeout = self.timeout  # pragma: no cover
 
         if max_retries is None:
             max_retries = self.max_retries
@@ -729,14 +720,13 @@ class DeviceConnection:
                         f"{Serial.from_protocol(header.target).to_string()})"
                     )
 
-                # Check for StateUnhandled
+                # Check for StateUnhandled - return False to indicate unsupported
                 if header.pkt_type == _STATE_UNHANDLED_PKT_TYPE:
-                    raise LifxUnsupportedCommandError(
-                        "Request unsupported by device: received StateUnhandled"
-                    )
+                    yield False
+                    return
 
                 # ACK received successfully
-                yield
+                yield True
                 return
 
             except TimeoutError as e:
@@ -791,14 +781,14 @@ class DeviceConnection:
             timeout: Request timeout in seconds
 
         Yields:
-            Unpacked response packet instances
-            For SET packets: yields True once (acknowledgement)
+            Unpacked response packet instances (including StateUnhandled if device
+            doesn't support the command)
+            For SET packets: yields True (acknowledgement) or False (StateUnhandled)
 
         Raises:
             LifxTimeoutError: If request times out
             LifxProtocolError: If response invalid
             LifxConnectionError: If connection fails
-            LifxUnsupportedCommandError: If command not supported
 
         Example:
             ```python
@@ -808,11 +798,16 @@ class DeviceConnection:
                 label = state.label  # Already decoded to string
                 break
 
-            # SET request yields True (acknowledgement)
-            async for _ in conn.request_stream(
+            # SET request yields True (acknowledgement) or False (StateUnhandled)
+            async for result in conn.request_stream(
                 packets.Light.SetColor(color=hsbk, duration=1000)
             ):
-                # Acknowledgement received
+                if result:
+                    # Acknowledgement received
+                    pass
+                else:
+                    # Device doesn't support this command
+                    pass
                 break
 
             # Multi-response GET - stream all responses
@@ -875,9 +870,12 @@ class DeviceConnection:
 
         elif packet_kind == "SET":
             # Request acknowledgement
-            async for _ in self._request_ack_stream_impl(packet, timeout=timeout):
+            async for ack_result in self._request_ack_stream_impl(
+                packet, timeout=timeout
+            ):
                 # Log the request/ack cycle
                 request_values = packet.as_dict
+                reply_packet = "Acknowledgement" if ack_result else "StateUnhandled"
                 _LOGGER.debug(
                     {
                         "class": "DeviceConnection",
@@ -887,7 +885,7 @@ class DeviceConnection:
                             "values": request_values,
                         },
                         "reply": {
-                            "packet": "Acknowledgement",
+                            "packet": reply_packet,
                             "values": {},
                         },
                         "serial": self.serial,
@@ -895,7 +893,7 @@ class DeviceConnection:
                     }
                 )
 
-                yield True
+                yield ack_result
                 return
 
         else:
@@ -934,7 +932,7 @@ class DeviceConnection:
                         yield response_packet
                         return
                 else:
-                    raise LifxUnsupportedCommandError(
+                    raise LifxProtocolError(
                         f"Cannot auto-handle packet kind: {packet_kind}"
                     )
             else:
@@ -961,14 +959,14 @@ class DeviceConnection:
             timeout: Request timeout in seconds
 
         Returns:
-            Single unpacked response packet
-            True for SET acknowledgement
+            Single unpacked response packet (including StateUnhandled if device
+            doesn't support the command)
+            For SET packets: True (acknowledgement) or False (StateUnhandled)
 
         Raises:
             LifxTimeoutError: If no response within timeout
             LifxProtocolError: If response invalid
             LifxConnectionError: If connection fails
-            LifxUnsupportedCommandError: If command not supported
 
         Example:
             ```python
@@ -977,10 +975,13 @@ class DeviceConnection:
             color = HSBK.from_protocol(state.color)
             label = state.label  # Already decoded to string
 
-            # SET request returns True
+            # SET request returns True or False
             success = await conn.request(
                 packets.Light.SetColor(color=hsbk, duration=1000)
             )
+            if not success:
+                # Device doesn't support this command (returned StateUnhandled)
+                pass
             ```
         """
         async for response in self.request_stream(packet, timeout):

{lifx_async-4.3.5.dist-info → lifx_async-4.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-async
-Version: 4.3.5
+Version: 4.3.7
 Summary: A modern, type-safe, async Python library for controlling LIFX lights
 Author-email: Avi Miller <me@dje.li>
 Maintainer-email: Avi Miller <me@dje.li>

{lifx_async-4.3.5.dist-info → lifx_async-4.3.7.dist-info}/RECORD

@@ -5,12 +5,12 @@ lifx/const.py,sha256=dW64lf_jwAD40GSd6hkFkrni5j-w2qkV3pl6YNdCxv4,3426
 lifx/exceptions.py,sha256=pikAMppLn7gXyjiQVWM_tSvXKNh-g366nG_UWyqpHhc,815
 lifx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lifx/devices/__init__.py,sha256=V7hW8sM_RwFgbR4Hv1ByR1JLhYq7Ft1X9pylQjCXYB8,777
-lifx/devices/base.py,sha256=uD3hQe2kjycRZneSptON6psOhoEgPRHVelCoLgdHbFw,41482
-lifx/devices/hev.py,sha256=2zZNYm3TFrL755B4cRPNdYtcDLZEQwGl_22112WsSZc,9504
-lifx/devices/infrared.py,sha256=TrCgJyEioIPlFumMmcSmuGYmRsSGlQ5Rllg6_9Wtg4Y,4248
-lifx/devices/light.py,sha256=9rL24fa44Y7QrRBDSQuG6xpWsaPbQTTm4ExvrDnYWHo,27572
-lifx/devices/matrix.py,sha256=mleYYsXkvvfXxV_pScb_D7VoX0AEJkClpzpNXOzQyGs,32643
-lifx/devices/multizone.py,sha256=c-lXcp8c1Mhs8me6smGkqQFrOOxdoGjWrOO5HnAVooY,27209
+lifx/devices/base.py,sha256=IxwFbKHnmfjhqzlqW66jqHslLUAHq1ocgSTVYXu6yxc,43906
+lifx/devices/hev.py,sha256=ow4AU3eOVAcMK2KKAyQUTB7z6EDoRz7StwVOvwwS4Sk,10124
+lifx/devices/infrared.py,sha256=q8q_cpjdRwojk76jBEdBeIYmqAA4FuTy7ZUquy2yEdg,4498
+lifx/devices/light.py,sha256=EvUeCtjMS23PUoj3cOshFJ8SYT517ksH_3p27J3Sr2o,28452
+lifx/devices/matrix.py,sha256=8VI02LtL_hzIzyXMu1be6QEY8W1e7-jtuitKJ6clFW8,33426
+lifx/devices/multizone.py,sha256=JaKpMvpxz7-RnhkJ1gS6uYrXwEFdJUpyldQsGtXZb_g,28106
 lifx/effects/__init__.py,sha256=4DF31yp7RJic5JoltMlz5dCtF5KQobU6NOUtLUKkVKE,1509
 lifx/effects/base.py,sha256=YO0Hbg2VYHKPtfYnWxmrtzYoPGOi9BUXhn8HVFKv5IM,10283
 lifx/effects/colorloop.py,sha256=kuuyENJS2irAN8vZAFsDa2guQdDbmmc4PJNiyZTfFPE,15840
@@ -20,7 +20,7 @@ lifx/effects/models.py,sha256=MS5D-cxD0Ar8XhqbqKAc9q2sk38IP1vPkYwd8V7jCr8,2446
 lifx/effects/pulse.py,sha256=t5eyjfFWG1xT-RXKghRqHYJ9CG_50tPu4jsDapJZ2mw,8721
 lifx/effects/state_manager.py,sha256=iDfYowiCN5IJqcR1s-pM0mQEJpe-RDsMcOOSMmtPVDE,8983
 lifx/network/__init__.py,sha256=uSyA8r8qISG7qXUHbX8uk9A2E8rvDADgCcf94QIZ9so,499
-lifx/network/connection.py,sha256=K5zzwYWKBvSBMqcP6a5Fp9JkVIiOLXJSAi1XMT4g-Go,38191
+lifx/network/connection.py,sha256=hM7BxpG4udLCMWV18trbgbV_yjPsX5e_V4boCf8eZYs,38278
 lifx/network/discovery.py,sha256=FoFoZcw3dtJs1daESiZiNXytanKQsMTdF9PjOxEgHM0,23804
 lifx/network/message.py,sha256=jCLC9v0tbBi54g5CaHLFM_nP1Izu8kJmo2tt23HHBbA,2600
 lifx/network/transport.py,sha256=8QS0YV32rdP0EDiPEwuvZXbplRWL08pmjKybd87mkZ0,11070
@@ -40,7 +40,7 @@ lifx/theme/canvas.py,sha256=4h7lgN8iu_OdchObGDgbxTqQLCb-FRKC-M-YCWef_i4,8048
 lifx/theme/generators.py,sha256=L0X6_iApLx6XDboGlYunaVsl6nvUCqMfn23VQmRkyCk,6125
 lifx/theme/library.py,sha256=tKlKZNqJp8lRGDnilWyDm_Qr1vCRGGwuvWVS82anNpQ,21326
 lifx/theme/theme.py,sha256=qMEx_8E41C0Cc6f083XHiAXEglTv4YlXW0UFsG1rQKg,5521
-lifx_async-4.3.5.dist-info/METADATA,sha256=S7yNp4EX1b3pNjZUoGGcF7GX5_YpHgpeh0qhKClN0S4,2609
-lifx_async-4.3.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lifx_async-4.3.5.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
-lifx_async-4.3.5.dist-info/RECORD,,
+lifx_async-4.3.7.dist-info/METADATA,sha256=LiDbfeEvXW8ofmnMBzN2OP_4nRa_gSo8Q2RWAqFM6U8,2609
+lifx_async-4.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lifx_async-4.3.7.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
+lifx_async-4.3.7.dist-info/RECORD,,