lifx-async 4.9.0__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/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.9.0.dist-info → lifx_async-5.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-async
-Version: 4.9.0
+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.9.0.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/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.9.0.dist-info/METADATA,sha256=w3SYjZDKKPvXksjmSm0DVfK2KHyFe-EnpgdLaUf27zk,2609
-lifx_async-4.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-lifx_async-4.9.0.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
-lifx_async-4.9.0.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,,