lifx-async 4.8.1__py3-none-any.whl → 5.0.0__py3-none-any.whl

lifx/api.py

@@ -198,9 +198,7 @@ class DeviceGroup:
             await group.set_power(True, duration=1.0)
             ```
         """
-        async with asyncio.TaskGroup() as tg:
-            for light in self.lights:
-                tg.create_task(light.set_power(on, duration))
+        await asyncio.gather(*(light.set_power(on, duration) for light in self.lights))
 
     async def set_color(self, color: HSBK, duration: float = 0.0) -> None:
         """Set color for all Light devices in the group.
@@ -218,9 +216,9 @@ class DeviceGroup:
             await group.set_color(HSBK.from_rgb(255, 0, 0), duration=2.0)
             ```
         """
-        async with asyncio.TaskGroup() as tg:
-            for light in self.lights:
-                tg.create_task(light.set_color(color, duration))
+        await asyncio.gather(
+            *(light.set_color(color, duration) for light in self.lights)
+        )
 
     async def set_brightness(self, brightness: float, duration: float = 0.0) -> None:
         """Set brightness for all Light devices in the group.
@@ -238,9 +236,9 @@ class DeviceGroup:
             await group.set_brightness(0.5, duration=1.0)
             ```
         """
-        async with asyncio.TaskGroup() as tg:
-            for light in self.lights:
-                tg.create_task(light.set_brightness(brightness, duration))
+        await asyncio.gather(
+            *(light.set_brightness(brightness, duration) for light in self.lights)
+        )
 
     async def pulse(
         self, color: HSBK, period: float = 1.0, cycles: float = 1.0
@@ -261,9 +259,9 @@ class DeviceGroup:
             await group.pulse(Colors.RED, period=1.0, cycles=1.0)
             ```
         """
-        async with asyncio.TaskGroup() as tg:
-            for light in self.lights:
-                tg.create_task(light.pulse(color, period, cycles))
+        await asyncio.gather(
+            *(light.pulse(color, period, cycles) for light in self.lights)
+        )
 
     # Location and Group Organization Methods
 
@@ -280,14 +278,13 @@ class DeviceGroup:
         )
 
         # Fetch all location info concurrently
-        tasks: dict[str, asyncio.Task[CollectionInfo | None]] = {}
-        async with asyncio.TaskGroup() as tg:
-            for device in self._devices:
-                tasks[device.serial] = tg.create_task(device.get_location())
+        location_results = await asyncio.gather(
+            *(device.get_location() for device in self._devices)
+        )
 
-        results: list[tuple[Device, CollectionInfo | None]] = []
-        for device in self._devices:
-            results.append((device, tasks[device.serial].result()))
+        results: list[tuple[Device, CollectionInfo | None]] = list(
+            zip(self._devices, location_results)
+        )
 
         # Group by location UUID
         for device, location_info in results:
@@ -332,15 +329,14 @@ class DeviceGroup:
         # Collect group info from all devices concurrently
         group_data: dict[str, list[tuple[Device, CollectionInfo]]] = defaultdict(list)
 
-        tasks: dict[str, asyncio.Task[CollectionInfo | None]] = {}
-        async with asyncio.TaskGroup() as tg:
-            for device in self._devices:
-                tasks[device.serial] = tg.create_task(device.get_group())
-
         # Fetch all group info concurrently
-        results: list[tuple[Device, CollectionInfo | None]] = []
-        for device in self._devices:
-            results.append((device, tasks[device.serial].result()))
+        group_results = await asyncio.gather(
+            *(device.get_group() for device in self._devices)
+        )
+
+        results: list[tuple[Device, CollectionInfo | None]] = list(
+            zip(self._devices, group_results)
+        )
 
         # Group by group UUID
         for device, group_info in results:
@@ -712,18 +708,20 @@ class DeviceGroup:
             await group.apply_theme(evening, power_on=True, duration=1.0)
             ```
         """
-        async with asyncio.TaskGroup() as tg:
+        await asyncio.gather(
             # Apply theme to all lights
-            for light in self.lights:
-                tg.create_task(light.apply_theme(theme, power_on, duration))
-
+            *(light.apply_theme(theme, power_on, duration) for light in self.lights),
             # Apply theme to all multizone lights
-            for multizone in self.multizone_lights:
-                tg.create_task(multizone.apply_theme(theme, power_on, duration))
-
+            *(
+                multizone.apply_theme(theme, power_on, duration)
+                for multizone in self.multizone_lights
+            ),
             # Apply theme to all matrix light devices
-            for matrix in self.matrix_lights:
-                tg.create_task(matrix.apply_theme(theme, power_on, duration))
+            *(
+                matrix.apply_theme(theme, power_on, duration)
+                for matrix in self.matrix_lights
+            ),
+        )
 
     def invalidate_metadata_cache(self) -> None:
         """Clear all cached location and group metadata.

lifx/color.py

@@ -10,9 +10,23 @@ import colorsys
 import math
 
 from lifx.const import (
+    KELVIN_AMBER,
+    KELVIN_BLUE_DAYLIGHT,
+    KELVIN_BLUE_ICE,
+    KELVIN_BLUE_OVERCAST,
+    KELVIN_BRIGHT_DAYLIGHT,
+    KELVIN_CANDLELIGHT,
+    KELVIN_CLOUDY_DAYLIGHT,
     KELVIN_COOL,
+    KELVIN_COOL_DAYLIGHT,
     KELVIN_DAYLIGHT,
+    KELVIN_INCANDESCENT,
     KELVIN_NEUTRAL,
+    KELVIN_NEUTRAL_WARM,
+    KELVIN_NOON_DAYLIGHT,
+    KELVIN_SOFT_DAYLIGHT,
+    KELVIN_SUNSET,
+    KELVIN_ULTRA_WARM,
     KELVIN_WARM,
     MAX_BRIGHTNESS,
     MAX_HUE,
@@ -520,34 +534,220 @@ class HSBK:
 
 # Common color presets
 class Colors:
-    """Common color presets for convenience."""
-
-    # Primary colors
-    RED = HSBK(hue=0, saturation=1.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    ORANGE = HSBK(hue=30, saturation=1.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    YELLOW = HSBK(hue=60, saturation=1.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    GREEN = HSBK(hue=120, saturation=1.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    CYAN = HSBK(hue=180, saturation=1.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    BLUE = HSBK(hue=240, saturation=1.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    PURPLE = HSBK(hue=270, saturation=1.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    MAGENTA = HSBK(hue=300, saturation=1.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    PINK = HSBK(hue=330, saturation=1.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-
-    # White variants
-    WHITE_WARM = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_WARM)
-    WHITE_NEUTRAL = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    WHITE_COOL = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_COOL)
-    WHITE_DAYLIGHT = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_DAYLIGHT)
-
-    # Pastels
+    """Common color presets for convenience.
+
+    Includes all 140 standard HTML/CSS named colors plus white temperature
+    variants and pastel variations.
+
+    HTML color reference: https://www.w3.org/TR/css-color-3/#svg-color
+    """
+
+    # Off / Black (brightness=0 turns light off or sets zone to black)
+    OFF = HSBK(hue=0, saturation=0.0, brightness=0.0, kelvin=KELVIN_NEUTRAL)
+
+    # HTML Named Colors (alphabetical order)
+    ALICE_BLUE = HSBK.from_rgb(240, 248, 255)
+    ANTIQUE_WHITE = HSBK.from_rgb(250, 235, 215)
+    AQUA = HSBK.from_rgb(0, 255, 255)
+    AQUAMARINE = HSBK.from_rgb(127, 255, 212)
+    AZURE = HSBK.from_rgb(240, 255, 255)
+    BEIGE = HSBK.from_rgb(245, 245, 220)
+    BISQUE = HSBK.from_rgb(255, 228, 196)
+    BLACK = HSBK.from_rgb(0, 0, 0)
+    BLANCHED_ALMOND = HSBK.from_rgb(255, 235, 205)
+    BLUE = HSBK.from_rgb(0, 0, 255)
+    BLUE_VIOLET = HSBK.from_rgb(138, 43, 226)
+    BROWN = HSBK.from_rgb(165, 42, 42)
+    BURLYWOOD = HSBK.from_rgb(222, 184, 135)
+    CADET_BLUE = HSBK.from_rgb(95, 158, 160)
+    CHARTREUSE = HSBK.from_rgb(127, 255, 0)
+    CHOCOLATE = HSBK.from_rgb(210, 105, 30)
+    CORAL = HSBK.from_rgb(255, 127, 80)
+    CORNFLOWER_BLUE = HSBK.from_rgb(100, 149, 237)
+    CORNSILK = HSBK.from_rgb(255, 248, 220)
+    CRIMSON = HSBK.from_rgb(220, 20, 60)
+    CYAN = HSBK.from_rgb(0, 255, 255)
+    DARK_BLUE = HSBK.from_rgb(0, 0, 139)
+    DARK_CYAN = HSBK.from_rgb(0, 139, 139)
+    DARK_GOLDENROD = HSBK.from_rgb(184, 134, 11)
+    DARK_GRAY = HSBK.from_rgb(169, 169, 169)
+    DARK_GREEN = HSBK.from_rgb(0, 100, 0)
+    DARK_GREY = HSBK.from_rgb(169, 169, 169)
+    DARK_KHAKI = HSBK.from_rgb(189, 183, 107)
+    DARK_MAGENTA = HSBK.from_rgb(139, 0, 139)
+    DARK_OLIVE_GREEN = HSBK.from_rgb(85, 107, 47)
+    DARK_ORANGE = HSBK.from_rgb(255, 140, 0)
+    DARK_ORCHID = HSBK.from_rgb(153, 50, 204)
+    DARK_RED = HSBK.from_rgb(139, 0, 0)
+    DARK_SALMON = HSBK.from_rgb(233, 150, 122)
+    DARK_SEA_GREEN = HSBK.from_rgb(143, 188, 143)
+    DARK_SLATE_BLUE = HSBK.from_rgb(72, 61, 139)
+    DARK_SLATE_GRAY = HSBK.from_rgb(47, 79, 79)
+    DARK_SLATE_GREY = HSBK.from_rgb(47, 79, 79)
+    DARK_TURQUOISE = HSBK.from_rgb(0, 206, 209)
+    DARK_VIOLET = HSBK.from_rgb(148, 0, 211)
+    DEEP_PINK = HSBK.from_rgb(255, 20, 147)
+    DEEP_SKY_BLUE = HSBK.from_rgb(0, 191, 255)
+    DIM_GRAY = HSBK.from_rgb(105, 105, 105)
+    DIM_GREY = HSBK.from_rgb(105, 105, 105)
+    DODGER_BLUE = HSBK.from_rgb(30, 144, 255)
+    FIREBRICK = HSBK.from_rgb(178, 34, 34)
+    FLORAL_WHITE = HSBK.from_rgb(255, 250, 240)
+    FOREST_GREEN = HSBK.from_rgb(34, 139, 34)
+    FUCHSIA = HSBK.from_rgb(255, 0, 255)
+    GAINSBORO = HSBK.from_rgb(220, 220, 220)
+    GHOST_WHITE = HSBK.from_rgb(248, 248, 255)
+    GOLD = HSBK.from_rgb(255, 215, 0)
+    GOLDENROD = HSBK.from_rgb(218, 165, 32)
+    GRAY = HSBK.from_rgb(128, 128, 128)
+    GREEN = HSBK.from_rgb(0, 128, 0)
+    GREEN_YELLOW = HSBK.from_rgb(173, 255, 47)
+    GREY = HSBK.from_rgb(128, 128, 128)
+    HONEYDEW = HSBK.from_rgb(240, 255, 240)
+    HOT_PINK = HSBK.from_rgb(255, 105, 180)
+    INDIAN_RED = HSBK.from_rgb(205, 92, 92)
+    INDIGO = HSBK.from_rgb(75, 0, 130)
+    IVORY = HSBK.from_rgb(255, 255, 240)
+    KHAKI = HSBK.from_rgb(240, 230, 140)
+    LAVENDER = HSBK.from_rgb(230, 230, 250)
+    LAVENDER_BLUSH = HSBK.from_rgb(255, 240, 245)
+    LAWN_GREEN = HSBK.from_rgb(124, 252, 0)
+    LEMON_CHIFFON = HSBK.from_rgb(255, 250, 205)
+    LIGHT_BLUE = HSBK.from_rgb(173, 216, 230)
+    LIGHT_CORAL = HSBK.from_rgb(240, 128, 128)
+    LIGHT_CYAN = HSBK.from_rgb(224, 255, 255)
+    LIGHT_GOLDENROD_YELLOW = HSBK.from_rgb(250, 250, 210)
+    LIGHT_GRAY = HSBK.from_rgb(211, 211, 211)
+    LIGHT_GREEN = HSBK.from_rgb(144, 238, 144)
+    LIGHT_GREY = HSBK.from_rgb(211, 211, 211)
+    LIGHT_PINK = HSBK.from_rgb(255, 182, 193)
+    LIGHT_SALMON = HSBK.from_rgb(255, 160, 122)
+    LIGHT_SEA_GREEN = HSBK.from_rgb(32, 178, 170)
+    LIGHT_SKY_BLUE = HSBK.from_rgb(135, 206, 250)
+    LIGHT_SLATE_GRAY = HSBK.from_rgb(119, 136, 153)
+    LIGHT_SLATE_GREY = HSBK.from_rgb(119, 136, 153)
+    LIGHT_STEEL_BLUE = HSBK.from_rgb(176, 196, 222)
+    LIGHT_YELLOW = HSBK.from_rgb(255, 255, 224)
+    LIME = HSBK.from_rgb(0, 255, 0)
+    LIME_GREEN = HSBK.from_rgb(50, 205, 50)
+    LINEN = HSBK.from_rgb(250, 240, 230)
+    MAGENTA = HSBK.from_rgb(255, 0, 255)
+    MAROON = HSBK.from_rgb(128, 0, 0)
+    MEDIUM_AQUAMARINE = HSBK.from_rgb(102, 205, 170)
+    MEDIUM_BLUE = HSBK.from_rgb(0, 0, 205)
+    MEDIUM_ORCHID = HSBK.from_rgb(186, 85, 211)
+    MEDIUM_PURPLE = HSBK.from_rgb(147, 112, 219)
+    MEDIUM_SEA_GREEN = HSBK.from_rgb(60, 179, 113)
+    MEDIUM_SLATE_BLUE = HSBK.from_rgb(123, 104, 238)
+    MEDIUM_SPRING_GREEN = HSBK.from_rgb(0, 250, 154)
+    MEDIUM_TURQUOISE = HSBK.from_rgb(72, 209, 204)
+    MEDIUM_VIOLET_RED = HSBK.from_rgb(199, 21, 133)
+    MIDNIGHT_BLUE = HSBK.from_rgb(25, 25, 112)
+    MINT_CREAM = HSBK.from_rgb(245, 255, 250)
+    MISTY_ROSE = HSBK.from_rgb(255, 228, 225)
+    MOCCASIN = HSBK.from_rgb(255, 228, 181)
+    NAVAJO_WHITE = HSBK.from_rgb(255, 222, 173)
+    NAVY = HSBK.from_rgb(0, 0, 128)
+    OLD_LACE = HSBK.from_rgb(253, 245, 230)
+    OLIVE = HSBK.from_rgb(128, 128, 0)
+    OLIVE_DRAB = HSBK.from_rgb(107, 142, 35)
+    ORANGE = HSBK.from_rgb(255, 165, 0)
+    ORANGE_RED = HSBK.from_rgb(255, 69, 0)
+    ORCHID = HSBK.from_rgb(218, 112, 214)
+    PALE_GOLDENROD = HSBK.from_rgb(238, 232, 170)
+    PALE_GREEN = HSBK.from_rgb(152, 251, 152)
+    PALE_TURQUOISE = HSBK.from_rgb(175, 238, 238)
+    PALE_VIOLET_RED = HSBK.from_rgb(219, 112, 147)
+    PAPAYA_WHIP = HSBK.from_rgb(255, 239, 213)
+    PEACH_PUFF = HSBK.from_rgb(255, 218, 185)
+    PERU = HSBK.from_rgb(205, 133, 63)
+    PINK = HSBK.from_rgb(255, 192, 203)
+    PLUM = HSBK.from_rgb(221, 160, 221)
+    POWDER_BLUE = HSBK.from_rgb(176, 224, 230)
+    PURPLE = HSBK.from_rgb(128, 0, 128)
+    REBECCA_PURPLE = HSBK.from_rgb(102, 51, 153)
+    RED = HSBK.from_rgb(255, 0, 0)
+    ROSY_BROWN = HSBK.from_rgb(188, 143, 143)
+    ROYAL_BLUE = HSBK.from_rgb(65, 105, 225)
+    SADDLE_BROWN = HSBK.from_rgb(139, 69, 19)
+    SALMON = HSBK.from_rgb(250, 128, 114)
+    SANDY_BROWN = HSBK.from_rgb(244, 164, 96)
+    SEA_GREEN = HSBK.from_rgb(46, 139, 87)
+    SEASHELL = HSBK.from_rgb(255, 245, 238)
+    SIENNA = HSBK.from_rgb(160, 82, 45)
+    SILVER = HSBK.from_rgb(192, 192, 192)
+    SKY_BLUE = HSBK.from_rgb(135, 206, 235)
+    SLATE_BLUE = HSBK.from_rgb(106, 90, 205)
+    SLATE_GRAY = HSBK.from_rgb(112, 128, 144)
+    SLATE_GREY = HSBK.from_rgb(112, 128, 144)
+    SNOW = HSBK.from_rgb(255, 250, 250)
+    SPRING_GREEN = HSBK.from_rgb(0, 255, 127)
+    STEEL_BLUE = HSBK.from_rgb(70, 130, 180)
+    TAN = HSBK.from_rgb(210, 180, 140)
+    TEAL = HSBK.from_rgb(0, 128, 128)
+    THISTLE = HSBK.from_rgb(216, 191, 216)
+    TOMATO = HSBK.from_rgb(255, 99, 71)
+    TURQUOISE = HSBK.from_rgb(64, 224, 208)
+    VIOLET = HSBK.from_rgb(238, 130, 238)
+    WHEAT = HSBK.from_rgb(245, 222, 179)
+    WHITE = HSBK.from_rgb(255, 255, 255)
+    WHITE_SMOKE = HSBK.from_rgb(245, 245, 245)
+    YELLOW = HSBK.from_rgb(255, 255, 0)
+    YELLOW_GREEN = HSBK.from_rgb(154, 205, 50)
+
+    # White temperature variants (kelvin-based, warmest to coolest)
+    CANDLELIGHT = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_CANDLELIGHT)
+    SUNSET = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_SUNSET)
+    AMBER = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_AMBER)
+    ULTRA_WARM = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_ULTRA_WARM)
+    INCANDESCENT = HSBK(
+        hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_INCANDESCENT
+    )
+    WARM = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_WARM)
+    NEUTRAL_WARM = HSBK(
+        hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_NEUTRAL_WARM
+    )
+    NEUTRAL = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_NEUTRAL)
+    COOL = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_COOL)
+    COOL_DAYLIGHT = HSBK(
+        hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_COOL_DAYLIGHT
+    )
+    SOFT_DAYLIGHT = HSBK(
+        hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_SOFT_DAYLIGHT
+    )
+    DAYLIGHT = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_DAYLIGHT)
+    NOON_DAYLIGHT = HSBK(
+        hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_NOON_DAYLIGHT
+    )
+    BRIGHT_DAYLIGHT = HSBK(
+        hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_BRIGHT_DAYLIGHT
+    )
+    CLOUDY_DAYLIGHT = HSBK(
+        hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_CLOUDY_DAYLIGHT
+    )
+    BLUE_DAYLIGHT = HSBK(
+        hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_BLUE_DAYLIGHT
+    )
+    BLUE_OVERCAST = HSBK(
+        hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_BLUE_OVERCAST
+    )
+    BLUE_ICE = HSBK(hue=0, saturation=0.0, brightness=1.0, kelvin=KELVIN_BLUE_ICE)
+
+    # Pastel variants (reduced saturation)
     PASTEL_RED = HSBK(hue=0, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    PASTEL_ORANGE = HSBK(hue=30, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
+    PASTEL_ORANGE = HSBK(hue=39, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
     PASTEL_YELLOW = HSBK(hue=60, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
     PASTEL_GREEN = HSBK(hue=120, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
     PASTEL_CYAN = HSBK(hue=180, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
     PASTEL_BLUE = HSBK(hue=240, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
-    PASTEL_PURPLE = HSBK(hue=270, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
+    PASTEL_PURPLE = HSBK(hue=300, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
     PASTEL_MAGENTA = HSBK(
         hue=300, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL
     )
-    PASTEL_PINK = HSBK(hue=330, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
+    PASTEL_PINK = HSBK(hue=350, saturation=0.3, brightness=1.0, kelvin=KELVIN_NEUTRAL)
+
+    # Backwards compatibility aliases
+    WHITE_WARM = WARM
+    WHITE_NEUTRAL = NEUTRAL
+    WHITE_COOL = COOL
+    WHITE_DAYLIGHT = DAYLIGHT

lifx/devices/base.py

@@ -9,7 +9,7 @@ import time
 import uuid
 from dataclasses import dataclass, field
 from math import floor, log10
-from typing import TYPE_CHECKING, Generic, Self, TypeVar, cast
+from typing import TYPE_CHECKING, Generic, TypeVar, cast
 
 from lifx.const import (
     DEFAULT_MAX_RETRIES,
@@ -26,6 +26,8 @@ from lifx.protocol import packets
 from lifx.protocol.models import Serial
 
 if TYPE_CHECKING:
+    from typing_extensions import Self
+
     from lifx.devices import (
         CeilingLight,
         HevLight,
@@ -681,12 +683,13 @@ class Device(Generic[StateT]):
     async def _setup(self) -> None:
         """Populate device capabilities, state and metadata."""
         await self._ensure_capabilities()
-        async with asyncio.TaskGroup() as tg:
-            tg.create_task(self.get_host_firmware())
-            tg.create_task(self.get_wifi_firmware())
-            tg.create_task(self.get_label())
-            tg.create_task(self.get_location())
-            tg.create_task(self.get_group())
+        await asyncio.gather(
+            self.get_host_firmware(),
+            self.get_wifi_firmware(),
+            self.get_label(),
+            self.get_location(),
+            self.get_group(),
+        )
 
     async def get_mac_address(self) -> str:
         """Calculate and return the MAC address for this device."""
@@ -1669,21 +1672,21 @@ class Device(Generic[StateT]):
 
         # Fetch semi-static and volatile state in parallel
         # get_color returns color, power, and label in one request
-        async with asyncio.TaskGroup() as tg:
-            label_task = tg.create_task(self.get_label())
-            power_task = tg.create_task(self.get_power())
-            host_fw_task = tg.create_task(self.get_host_firmware())
-            wifi_fw_task = tg.create_task(self.get_wifi_firmware())
-            location_task = tg.create_task(self.get_location())
-            group_task = tg.create_task(self.get_group())
-
-        # Extract results
-        label = label_task.result()
-        power = power_task.result()
-        host_firmware = host_fw_task.result()
-        wifi_firmware = wifi_fw_task.result()
-        location_info = location_task.result()
-        group_info = group_task.result()
+        (
+            label,
+            power,
+            host_firmware,
+            wifi_firmware,
+            location_info,
+            group_info,
+        ) = await asyncio.gather(
+            self.get_label(),
+            self.get_power(),
+            self.get_host_firmware(),
+            self.get_wifi_firmware(),
+            self.get_location(),
+            self.get_group(),
+        )
 
         # Get MAC address (already calculated in get_host_firmware)
         mac_address = await self.get_mac_address()

lifx/devices/hev.py

@@ -119,10 +119,11 @@ class HevLight(Light):
     async def _setup(self) -> None:
         """Populate HEV light capabilities, state and metadata."""
         await super()._setup()
-        async with asyncio.TaskGroup() as tg:
-            tg.create_task(self.get_hev_config())
-            tg.create_task(self.get_hev_cycle())
-            tg.create_task(self.get_last_hev_result())
+        await asyncio.gather(
+            self.get_hev_config(),
+            self.get_hev_cycle(),
+            self.get_last_hev_result(),
+        )
 
     async def get_hev_cycle(self) -> HevCycleState:
         """Get current HEV cycle state.
@@ -413,12 +414,10 @@ class HevLight(Light):
         await super().refresh_state()
 
         # Fetch all HEV light state
-        async with asyncio.TaskGroup() as tg:
-            hev_cycle_task = tg.create_task(self.get_hev_cycle())
-            hev_result_task = tg.create_task(self.get_last_hev_result())
-
-        hev_cycle = hev_cycle_task.result()
-        hev_result = hev_result_task.result()
+        hev_cycle, hev_result = await asyncio.gather(
+            self.get_hev_cycle(),
+            self.get_last_hev_result(),
+        )
 
         self._state.hev_cycle = hev_cycle
         self._state.hev_result = hev_result
@@ -440,14 +439,11 @@ class HevLight(Light):
 
         # Fetch semi-static and volatile state in parallel
         # get_color returns color, power, and label in one request
-        async with asyncio.TaskGroup() as tg:
-            hev_cycle_task = tg.create_task(self.get_hev_cycle())
-            hev_config_task = tg.create_task(self.get_hev_config())
-            hev_result_task = tg.create_task(self.get_last_hev_result())
-
-        hev_cycle = hev_cycle_task.result()
-        hev_config = hev_config_task.result()
-        hev_result = hev_result_task.result()
+        hev_cycle, hev_config, hev_result = await asyncio.gather(
+            self.get_hev_cycle(),
+            self.get_hev_config(),
+            self.get_last_hev_result(),
+        )
 
         # Create state instance with HEV fields
         self._state = HevLightState.from_light_state(

lifx/devices/light.py

@@ -964,19 +964,19 @@ class Light(Device[LightState]):
         # Fetch semi-static and volatile state in parallel
         # get_color returns color, power, and label in one request
         try:
-            async with asyncio.TaskGroup() as tg:
-                color_task = tg.create_task(self.get_color())
-                host_fw_task = tg.create_task(self.get_host_firmware())
-                wifi_fw_task = tg.create_task(self.get_wifi_firmware())
-                location_task = tg.create_task(self.get_location())
-                group_task = tg.create_task(self.get_group())
-
-            # Extract results
-            color, power, label = color_task.result()
-            host_firmware = host_fw_task.result()
-            wifi_firmware = wifi_fw_task.result()
-            location_info = location_task.result()
-            group_info = group_task.result()
+            (
+                (color, power, label),
+                host_firmware,
+                wifi_firmware,
+                location_info,
+                group_info,
+            ) = await asyncio.gather(
+                self.get_color(),
+                self.get_host_firmware(),
+                self.get_wifi_firmware(),
+                self.get_location(),
+                self.get_group(),
+            )
 
             # Get MAC address (already calculated in get_host_firmware)
             mac_address = await self.get_mac_address()
@@ -1003,7 +1003,7 @@ class Light(Device[LightState]):
 
             return self._state
 
-        except* LifxTimeoutError:
+        except LifxTimeoutError:
             raise LifxTimeoutError(f"Error initializing state for {self.serial}")
-        except* LifxError:
+        except LifxError:
             raise LifxError(f"Error initializing state for {self.serial}")

lifx/devices/multizone.py

@@ -969,12 +969,10 @@ class MultiZoneLight(Light):
         """
         await super().refresh_state()
 
-        async with asyncio.TaskGroup() as tg:
-            zones_task = tg.create_task(self.get_all_color_zones())
-            effect_task = tg.create_task(self.get_effect())
-
-        zones = zones_task.result()
-        effect = effect_task.result()
+        zones, effect = await asyncio.gather(
+            self.get_all_color_zones(),
+            self.get_effect(),
+        )
 
         self._state.zones = zones
         self._state.effect = effect.effect_type
@@ -994,12 +992,10 @@ class MultiZoneLight(Light):
         """
         light_state = await super()._initialize_state()
 
-        async with asyncio.TaskGroup() as tg:
-            zones_task = tg.create_task(self.get_all_color_zones())
-            effect_task = tg.create_task(self.get_effect())
-
-        zones = zones_task.result()
-        effect = effect_task.result()
+        zones, effect = await asyncio.gather(
+            self.get_all_color_zones(),
+            self.get_effect(),
+        )
 
         self._state = MultiZoneLightState.from_light_state(
             light_state=light_state, zones=zones, effect=effect.effect_type

lifx/effects/base.py

@@ -85,22 +85,26 @@ class LIFXEffect(ABC):
         if self.power_on:
             needs_power_on = False
 
-            async def power_on_if_needed(light: Light) -> None:
-                """Power on a single light if it's currently off."""
-                nonlocal needs_power_on
+            async def power_on_if_needed(light: Light) -> bool:
+                """Power on a single light if it's currently off.
+
+                Returns True if the light was powered on.
+                """
                 is_on = await light.get_power()
                 if not is_on:
-                    needs_power_on = True
                     # Get startup color for this light
                     startup_color = await self.from_poweroff_hsbk(light)
                     # Set color immediately, then power on
                     await light.set_color(startup_color, duration=0)
                     await light.set_power(True, duration=POWER_ON_TRANSITION_DURATION)
+                    return True
+                return False
 
             # Power on all lights concurrently
-            async with asyncio.TaskGroup() as tg:
-                for light in self.participants:
-                    tg.create_task(power_on_if_needed(light))
+            results = await asyncio.gather(
+                *(power_on_if_needed(light) for light in self.participants)
+            )
+            needs_power_on = any(results)
 
             # Wait for power transition to complete if any lights were powered on
             if needs_power_on:

lifx/effects/colorloop.py

@@ -353,17 +353,11 @@ class EffectColorloop(LIFXEffect):
             )
 
         # Fetch colors for all lights concurrently
-        colors: list[HSBK] = [None] * len(self.participants)  # type: ignore
-
-        async with asyncio.TaskGroup() as tg:
-            for idx, light in enumerate(self.participants):
-
-                async def fetch_and_store(index: int, device: Light) -> None:
-                    colors[index] = await get_color_for_light(device)
-
-                tg.create_task(fetch_and_store(idx, light))
+        colors = await asyncio.gather(
+            *(get_color_for_light(light) for light in self.participants)
+        )
 
-        return colors
+        return list(colors)
 
     async def from_poweroff_hsbk(self, _light: Light) -> HSBK:
         """Return startup color when light is powered off.

lifx/effects/conductor.py

@@ -154,36 +154,32 @@ class Conductor:
 
             # Capture prestates in parallel for all lights that need it
             if lights_needing_capture:
-                captured: list[tuple[str, PreState]] = [None] * len(  # type: ignore
-                    lights_needing_capture
-                )
 
-                async with asyncio.TaskGroup() as tg:
-                    for capture_idx, (_, light) in enumerate(lights_needing_capture):
-
-                        async def capture_and_store(cidx: int, device: Light) -> None:
-                            prestate = await self._state_manager.capture_state(device)
-                            captured[cidx] = (device.serial, prestate)
-                            _LOGGER.debug(
-                                {
-                                    "class": self.__class__.__name__,
-                                    "method": "start",
-                                    "action": "capture",
-                                    "values": {
-                                        "serial": device.serial,
-                                        "power": prestate.power,
-                                        "color": {
-                                            "hue": prestate.color.hue,
-                                            "saturation": prestate.color.saturation,
-                                            "brightness": prestate.color.brightness,
-                                            "kelvin": prestate.color.kelvin,
-                                        },
-                                        "has_zones": prestate.zone_colors is not None,
-                                    },
-                                }
-                            )
-
-                        tg.create_task(capture_and_store(capture_idx, light))
+                async def capture_and_log(device: Light) -> tuple[str, PreState]:
+                    prestate = await self._state_manager.capture_state(device)
+                    _LOGGER.debug(
+                        {
+                            "class": self.__class__.__name__,
+                            "method": "start",
+                            "action": "capture",
+                            "values": {
+                                "serial": device.serial,
+                                "power": prestate.power,
+                                "color": {
+                                    "hue": prestate.color.hue,
+                                    "saturation": prestate.color.saturation,
+                                    "brightness": prestate.color.brightness,
+                                    "kelvin": prestate.color.kelvin,
+                                },
+                                "has_zones": prestate.zone_colors is not None,
+                            },
+                        }
+                    )
+                    return (device.serial, prestate)
+
+                captured = await asyncio.gather(
+                    *(capture_and_log(light) for _, light in lights_needing_capture)
+                )
 
                 # Store captured prestates
                 for serial, prestate in captured:
@@ -257,11 +253,12 @@ class Conductor:
         async with self._lock:
             # Restore all lights in parallel
             if lights_to_restore:
-                async with asyncio.TaskGroup() as tg:
-                    for light, prestate in lights_to_restore:
-                        tg.create_task(
-                            self._state_manager.restore_state(light, prestate)
-                        )
+                await asyncio.gather(
+                    *(
+                        self._state_manager.restore_state(light, prestate)
+                        for light, prestate in lights_to_restore
+                    )
+                )
 
             # Remove from running registry after restoration
             for light in lights:
@@ -304,11 +301,12 @@ class Conductor:
 
                 # Restore all lights in parallel
                 if lights_to_restore:
-                    async with asyncio.TaskGroup() as tg:
-                        for light, prestate in lights_to_restore:
-                            tg.create_task(
-                                self._state_manager.restore_state(light, prestate)
-                            )
+                    await asyncio.gather(
+                        *(
+                            self._state_manager.restore_state(light, prestate)
+                            for light, prestate in lights_to_restore
+                        )
+                    )
 
                 # Remove from running registry after restoration
                 for light in participants:
@@ -367,10 +365,9 @@ class Conductor:
         Returns:
             List of lights compatible with the effect
         """
-        # Check all lights in parallel using effect's compatibility check
-        results: list[tuple[Light, bool]] = []
 
-        async def check_and_store(light: Light) -> None:
+        # Check all lights in parallel using effect's compatibility check
+        async def check_compatibility(light: Light) -> tuple[Light, bool]:
             """Check if a single light is compatible with the effect."""
             is_compatible = await effect.is_light_compatible(light)
 
@@ -388,11 +385,11 @@ class Conductor:
                     }
                 )
 
-            results.append((light, is_compatible))
+            return (light, is_compatible)
 
-        async with asyncio.TaskGroup() as tg:
-            for light in participants:
-                tg.create_task(check_and_store(light))
+        results = await asyncio.gather(
+            *(check_compatibility(light) for light in participants)
+        )
 
         # Filter to only compatible lights
         compatible = [light for light, is_compatible in results if is_compatible]

lifx/effects/pulse.py

@@ -184,17 +184,11 @@ class EffectPulse(LIFXEffect):
                 return await self.fetch_light_color(light)
 
         # Fetch colors for all lights concurrently
-        colors: list[HSBK] = [None] * len(self.participants)  # type: ignore
-
-        async with asyncio.TaskGroup() as tg:
-            for idx, light in enumerate(self.participants):
-
-                async def fetch_and_store(index: int, device: Light) -> None:
-                    colors[index] = await get_color_for_light(device)
-
-                tg.create_task(fetch_and_store(idx, light))
+        colors = await asyncio.gather(
+            *(get_color_for_light(light) for light in self.participants)
+        )
 
-        return colors
+        return list(colors)
 
     async def _apply_waveform(self, light: Light, color: HSBK) -> None:
         """Apply waveform to a single light.

lifx/network/connection.py

@@ -11,7 +11,7 @@ from collections.abc import AsyncGenerator
 from typing import TYPE_CHECKING, Any, TypeVar
 
 if TYPE_CHECKING:
-    from typing import Self
+    from typing_extensions import Self
 
 from lifx.const import (
     DEFAULT_MAX_RETRIES,

lifx/network/mdns/transport.py

@@ -255,9 +255,10 @@ class MdnsTransport:
             raise LifxNetworkError("Socket not open")
 
         try:
-            async with asyncio.timeout(timeout):
-                data, addr = await self._protocol.queue.get()
-                return data, addr
+            data, addr = await asyncio.wait_for(
+                self._protocol.queue.get(), timeout=timeout
+            )
+            return data, addr
         except TimeoutError as e:
             raise LifxTimeoutError(f"No mDNS data received within {timeout}s") from e
         except OSError as e:

lifx/network/transport.py

@@ -205,43 +205,9 @@ class UdpTransport:
             raise LifxNetworkError("Socket not open")
 
         try:
-            async with asyncio.timeout(timeout):
-                data, addr = await self._protocol.queue.get()
-
-                # Validate packet size
-                if len(data) > MAX_PACKET_SIZE:
-                    from lifx.exceptions import LifxProtocolError
-
-                    _LOGGER.error(
-                        {
-                            "class": "UdpTransport",
-                            "method": "receive",
-                            "action": "packet_too_large",
-                            "packet_size": len(data),
-                            "max_size": MAX_PACKET_SIZE,
-                        }
-                    )
-                    raise LifxProtocolError(
-                        f"Packet too big: {len(data)} bytes > {MAX_PACKET_SIZE} bytes"
-                    )
-
-                if len(data) < MIN_PACKET_SIZE:
-                    from lifx.exceptions import LifxProtocolError
-
-                    _LOGGER.error(
-                        {
-                            "class": "UdpTransport",
-                            "method": "receive",
-                            "action": "packet_too_small",
-                            "packet_size": len(data),
-                            "min_size": MIN_PACKET_SIZE,
-                        }
-                    )
-                    raise LifxProtocolError(
-                        f"Packet too small: {len(data)} bytes < {MIN_PACKET_SIZE} bytes"
-                    )
-
-                return data, addr
+            data, addr = await asyncio.wait_for(
+                self._protocol.queue.get(), timeout=timeout
+            )
         except TimeoutError as e:
             raise LifxTimeoutError(f"No data received within {timeout}s") from e
         except OSError as e:
@@ -255,6 +221,41 @@ class UdpTransport:
             )
             raise LifxNetworkError(f"Failed to receive data: {e}") from e
 
+        # Validate packet size
+        if len(data) > MAX_PACKET_SIZE:
+            from lifx.exceptions import LifxProtocolError
+
+            _LOGGER.error(
+                {
+                    "class": "UdpTransport",
+                    "method": "receive",
+                    "action": "packet_too_large",
+                    "packet_size": len(data),
+                    "max_size": MAX_PACKET_SIZE,
+                }
+            )
+            raise LifxProtocolError(
+                f"Packet too big: {len(data)} bytes > {MAX_PACKET_SIZE} bytes"
+            )
+
+        if len(data) < MIN_PACKET_SIZE:
+            from lifx.exceptions import LifxProtocolError
+
+            _LOGGER.error(
+                {
+                    "class": "UdpTransport",
+                    "method": "receive",
+                    "action": "packet_too_small",
+                    "packet_size": len(data),
+                    "min_size": MIN_PACKET_SIZE,
+                }
+            )
+            raise LifxProtocolError(
+                f"Packet too small: {len(data)} bytes < {MIN_PACKET_SIZE} bytes"
+            )
+
+        return data, addr
+
     async def receive_many(
         self, timeout: float = 5.0, max_packets: int | None = None
     ) -> list[tuple[bytes, tuple[str, int]]]:
@@ -273,34 +274,40 @@ class UdpTransport:
         if self._protocol is None:
             raise LifxNetworkError("Socket not open")
 
+        import time
+
         packets: list[tuple[bytes, tuple[str, int]]] = []
+        deadline = time.monotonic() + timeout
 
-        try:
-            async with asyncio.timeout(timeout):
-                while True:
-                    if max_packets is not None and len(packets) >= max_packets:
-                        break
-
-                    try:
-                        data, addr = await self._protocol.queue.get()
-
-                        # Validate packet size
-                        if len(data) > MAX_PACKET_SIZE:
-                            # Drop oversized packet to prevent memory exhaustion DoS
-                            continue
-
-                        if len(data) < MIN_PACKET_SIZE:
-                            # Drop undersized packet (header is 36 bytes)
-                            continue
-
-                        packets.append((data, addr))
-                    except OSError:
-                        # Ignore individual receive errors
-                        break
-
-        except TimeoutError:
-            # Timeout is expected - return what we collected
-            pass
+        while True:
+            if max_packets is not None and len(packets) >= max_packets:
+                break
+
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                break
+
+            try:
+                data, addr = await asyncio.wait_for(
+                    self._protocol.queue.get(), timeout=remaining
+                )
+
+                # Validate packet size
+                if len(data) > MAX_PACKET_SIZE:
+                    # Drop oversized packet to prevent memory exhaustion DoS
+                    continue
+
+                if len(data) < MIN_PACKET_SIZE:
+                    # Drop undersized packet (header is 36 bytes)
+                    continue
+
+                packets.append((data, addr))
+            except TimeoutError:
+                # Timeout is expected - return what we collected
+                break
+            except OSError:
+                # Ignore individual receive errors
+                break
 
         return packets
 

{lifx_async-4.8.1.dist-info → lifx_async-5.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-async
-Version: 4.8.1
+Version: 5.0.0
 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>
@@ -11,6 +11,7 @@ Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -18,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.11
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 # lifx-async

{lifx_async-4.8.1.dist-info → lifx_async-5.0.0.dist-info}/RECORD

@@ -1,34 +1,34 @@
 lifx/__init__.py,sha256=DKHG1vFJvPw_LpMkQgZN85gyOSD8dnceq6LnEGgR9vs,2810
-lifx/api.py,sha256=xHUM6NDgv8V8tLpDtpnPVJNGcVU5y_8da9wI3pnm06Y,35903
-lifx/color.py,sha256=wcmeeiBmOAjunInERNd6rslKvBEpV4vfjwwiZ8v7H8A,17877
+lifx/api.py,sha256=tTE9H8eSVrFIr6rEGxedWoR4ChnqvTz2EUgEQk60fgU,35428
+lifx/color.py,sha256=UfeoOiFgFih5edl2Ei-0wSzvZXRTI47yUm9GlNJZeTw,26041
 lifx/const.py,sha256=5LEh4h0-bEJlOfpG8fgyht0LkAEV9jkkpuCiuatBhEI,3840
 lifx/exceptions.py,sha256=pikAMppLn7gXyjiQVWM_tSvXKNh-g366nG_UWyqpHhc,815
 lifx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lifx/devices/__init__.py,sha256=4b5QtO0EFWxIqN2lUYgM8uLjWyHI5hUcReiF9QCjCGw,1061
-lifx/devices/base.py,sha256=0G2PCJRNeIPkMCIw68x0ijn6gUIwh2jFlex8SN4Hs1Y,63530
+lifx/devices/base.py,sha256=mhNLX6FoLBaZtYo9InleneYdb0dk3B2Ze8Z2eqXCNHo,63180
 lifx/devices/ceiling.py,sha256=bLAurvqTNmhKMFUUJmLqn1vDFawapYju2i4G0pHOH_4,45790
-lifx/devices/hev.py,sha256=T5hvt2q_vdgPBvThx_-M7n5pZu9pL0y9Fs3Zz_KL0NM,15588
+lifx/devices/hev.py,sha256=kTRJRYnWyIY8Pkg_jOn978N-_1YXy9fRmBiGgEWscXw,15194
 lifx/devices/infrared.py,sha256=ePk9qxX_s-hv5gQMvio1Vv8FYiCd68HF0ySbWgSrvuU,8130
-lifx/devices/light.py,sha256=gk92lhViUWINGaxDWbs4qn8Stnn2fGCfRkC5Kk0Q-hI,34087
+lifx/devices/light.py,sha256=ZhC7zuruZ9nzmnAR_st2KMUH8UNQAcNK-eQUYnKXm-8,33833
 lifx/devices/matrix.py,sha256=TcfVvqFCIhGXjOtaQEARQCXe9XqSFDZ4wEQdRZBiQpA,42301
-lifx/devices/multizone.py,sha256=zQj0qKxWccHAmkIpqIcGzZsKjCQL-_bAquz78o0Izng,33570
+lifx/devices/multizone.py,sha256=7Te5Z_X9hDvdypjMqPGGM2TG0P9QltzFVi7UUxRdbGI,33326
 lifx/effects/__init__.py,sha256=4DF31yp7RJic5JoltMlz5dCtF5KQobU6NOUtLUKkVKE,1509
-lifx/effects/base.py,sha256=YO0Hbg2VYHKPtfYnWxmrtzYoPGOi9BUXhn8HVFKv5IM,10283
-lifx/effects/colorloop.py,sha256=kuuyENJS2irAN8vZAFsDa2guQdDbmmc4PJNiyZTfFPE,15840
-lifx/effects/conductor.py,sha256=0Aizn2gpo2kTqwSF4p9Qat8S4F53xwHJwVjOJONduKc,15036
+lifx/effects/base.py,sha256=tKgX5PsV6hipffD2B236rOzudkMwWq59-eQGnfvNKdU,10354
+lifx/effects/colorloop.py,sha256=Yz9XcQ_VhTPSnJn1s4WnkoXTRh2_qFJrPhQkIiTF6Tk,15574
+lifx/effects/conductor.py,sha256=Oaq-6m1kdUF6bma_U9GcA9onZzh6YRjpExBr-OGHQJI,14552
 lifx/effects/const.py,sha256=03LfL8v9PtoUs6-2IR3aa6nkyA4Otdno51SFJtntC-U,795
 lifx/effects/models.py,sha256=MS5D-cxD0Ar8XhqbqKAc9q2sk38IP1vPkYwd8V7jCr8,2446
-lifx/effects/pulse.py,sha256=t5eyjfFWG1xT-RXKghRqHYJ9CG_50tPu4jsDapJZ2mw,8721
+lifx/effects/pulse.py,sha256=k4dtBhhgVHyuwzqzx89jYVKbSRUVQdZj91cklyKarbE,8455
 lifx/effects/state_manager.py,sha256=iDfYowiCN5IJqcR1s-pM0mQEJpe-RDsMcOOSMmtPVDE,8983
 lifx/network/__init__.py,sha256=uSyA8r8qISG7qXUHbX8uk9A2E8rvDADgCcf94QIZ9so,499
-lifx/network/connection.py,sha256=aerPiYWf096lq8oBiS7JfE4k-P18GS50mNEC4TYa2g8,38401
+lifx/network/connection.py,sha256=qPKEkhr9DvoL2cCJoIlDi8rowNS-gUn_F3mesnzyFjs,38412
 lifx/network/discovery.py,sha256=syFfkDYWo0AEoBdEBjWqBm4K7UJwZW5x2K0FBMiA2I0,24186
 lifx/network/message.py,sha256=jCLC9v0tbBi54g5CaHLFM_nP1Izu8kJmo2tt23HHBbA,2600
-lifx/network/transport.py,sha256=8QS0YV32rdP0EDiPEwuvZXbplRWL08pmjKybd87mkZ0,11070
+lifx/network/transport.py,sha256=io_3SFYQliNa_upHcKRzrLUkDVsDmNsxa2gQMlxj7Zk,10912
 lifx/network/mdns/__init__.py,sha256=LlZgsFe6q5_SIXvXqtuZ_O9tJbcJZ-nsFkD2_wD8_TM,1412
 lifx/network/mdns/discovery.py,sha256=EZ2zlJmy96rMDmu5J-68ystXJ2gYa18zTYP3iqmTGgU,13200
 lifx/network/mdns/dns.py,sha256=OsvNSxLepIG3Nhw-kkQF3JrBYI-ikod5SHD2HO5_yGE,9363
-lifx/network/mdns/transport.py,sha256=k8gVZCvU-gksV2dV-jm2YG-_kuKWx0whtP3Va0EjCd8,10242
+lifx/network/mdns/transport.py,sha256=41E_yX9Jx42ffElTcF-73A4ma48b3xkkHnG3DTcO8u8,10250
 lifx/network/mdns/types.py,sha256=9fhH5iuMQxLkFPhmFTf2-kOcUNoWEu7LrN15Qr9tFE0,990
 lifx/products/__init__.py,sha256=pf2O-fzt6nOrQd-wmzhiog91tMiGa-dDbaSNtU2ZQfE,764
 lifx/products/generator.py,sha256=DsTCJcEVPmn9sfXSbXYdFZjqMfIbodnIQL46DRASs0g,15731
@@ -47,7 +47,7 @@ lifx/theme/canvas.py,sha256=4h7lgN8iu_OdchObGDgbxTqQLCb-FRKC-M-YCWef_i4,8048
 lifx/theme/generators.py,sha256=nq3Yvntq_h-eFHbmmow3LcAdA_hEbRRaP5mv9Bydrjk,6435
 lifx/theme/library.py,sha256=tKlKZNqJp8lRGDnilWyDm_Qr1vCRGGwuvWVS82anNpQ,21326
 lifx/theme/theme.py,sha256=qMEx_8E41C0Cc6f083XHiAXEglTv4YlXW0UFsG1rQKg,5521
-lifx_async-4.8.1.dist-info/METADATA,sha256=Euz_zOCJMdS0w1GJ4D1nBKJJMdEMEdNFzTqB3mcZOAM,2609
-lifx_async-4.8.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-lifx_async-4.8.1.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
-lifx_async-4.8.1.dist-info/RECORD,,
+lifx_async-5.0.0.dist-info/METADATA,sha256=Ozi93MbWMkhFydTJ_nuyQUxRLLH_iGYOxtlr0iBXe2U,2660
+lifx_async-5.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+lifx_async-5.0.0.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
+lifx_async-5.0.0.dist-info/RECORD,,