lifx-async 4.7.4__py3-none-any.whl → 4.8.0__py3-none-any.whl

lifx/__init__.py

@@ -10,6 +10,7 @@ from importlib.metadata import version as get_version
 from lifx.api import (
     DeviceGroup,
     discover,
+    discover_mdns,
     find_by_ip,
     find_by_label,
     find_by_serial,
@@ -48,6 +49,7 @@ from lifx.exceptions import (
     LifxUnsupportedCommandError,
 )
 from lifx.network.discovery import DiscoveredDevice, discover_devices
+from lifx.network.mdns import LifxServiceRecord, discover_lifx_services
 from lifx.products import ProductCapability, ProductInfo, ProductRegistry
 from lifx.protocol.protocol_types import (
     Direction,
@@ -100,12 +102,16 @@ __all__ = [
     # High-level API
     "DeviceGroup",
     "discover",
+    "discover_mdns",
     "find_by_serial",
     "find_by_label",
     "find_by_ip",
     # Discovery (low-level)
     "discover_devices",
     "DiscoveredDevice",
+    # mDNS Discovery (low-level)
+    "discover_lifx_services",
+    "LifxServiceRecord",
     # Products
     "ProductInfo",
     "ProductRegistry",

lifx/api.py

@@ -803,6 +803,59 @@ async def discover(
             yield device
 
 
+async def discover_mdns(
+    timeout: float = DISCOVERY_TIMEOUT,
+    max_response_time: float = MAX_RESPONSE_TIME,
+    idle_timeout_multiplier: float = IDLE_TIMEOUT_MULTIPLIER,
+    device_timeout: float = DEFAULT_REQUEST_TIMEOUT,
+    max_retries: int = DEFAULT_MAX_RETRIES,
+) -> AsyncGenerator[Light, None]:
+    """Discover LIFX devices via mDNS and yield them as they are found.
+
+    Uses mDNS/DNS-SD discovery with the _lifx._udp.local service type.
+    This method is faster than broadcast discovery as device type information
+    is included in the mDNS TXT records, eliminating the need for additional
+    device queries.
+
+    Note: mDNS discovery requires the mDNS multicast group (224.0.0.251:5353)
+    to be accessible. Some network configurations may block multicast traffic.
+
+    Args:
+        timeout: Discovery timeout in seconds (default 15.0)
+        max_response_time: Max time to wait for responses
+        idle_timeout_multiplier: Idle timeout multiplier
+        device_timeout: request timeout set on discovered devices
+        max_retries: max retries per request set on discovered devices
+
+    Yields:
+        Device instances as they are discovered
+
+    Example:
+        ```python
+        # Process devices as they're discovered
+        async for device in discover_mdns():
+            print(f"Found: {device.serial}")
+            async with device:
+                await device.set_power(True)
+
+        # Or collect all devices first
+        devices = []
+        async for device in discover_mdns():
+            devices.append(device)
+        ```
+    """
+    from lifx.network.mdns.discovery import discover_devices_mdns
+
+    async for device in discover_devices_mdns(
+        timeout=timeout,
+        max_response_time=max_response_time,
+        idle_timeout_multiplier=idle_timeout_multiplier,
+        device_timeout=device_timeout,
+        max_retries=max_retries,
+    ):
+        yield device
+
+
 async def find_by_serial(
     serial: str,
     timeout: float = DISCOVERY_TIMEOUT,
@@ -996,6 +1049,7 @@ __all__ = [
     "LocationGrouping",
     "GroupGrouping",
     "discover",
+    "discover_mdns",
     "find_by_serial",
     "find_by_ip",
     "find_by_label",

lifx/const.py

@@ -38,6 +38,19 @@ STATE_REFRESH_DEBOUNCE_MS: Final[int] = 300
 # Default maximum number of retry attempts for failed requests
 DEFAULT_MAX_RETRIES: Final[int] = 8
 
+# ============================================================================
+# mDNS Constants
+# ============================================================================
+
+# mDNS multicast address (IPv4)
+MDNS_ADDRESS: Final[str] = "224.0.0.251"
+
+# mDNS port
+MDNS_PORT: Final[int] = 5353
+
+# LIFX mDNS service type
+LIFX_MDNS_SERVICE: Final[str] = "_lifx._udp.local"
+
 # ============================================================================
 # HSBK Min/Max Values
 # ============================================================================

lifx/devices/ceiling.py

@@ -347,6 +347,22 @@ class CeilingLight(MatrixLight):
 
         return layout.downlight_zones
 
+    @property
+    def downlight_zone_count(self) -> int:
+        """Number of downlight zones.
+
+        Returns:
+            Zone count (63 for standard 8x8, 127 for Capsule 16x8)
+
+        Raises:
+            LifxError: If device version is not available or not a Ceiling product
+        """
+        # downlight_zones is slice(0, N), so stop equals the count
+        stop = self.downlight_zones.stop
+        if stop is None:
+            raise LifxError("Invalid downlight zones configuration")
+        return stop
+
     @property
     def uplight_is_on(self) -> bool:
         """True if uplight component is currently on.
@@ -496,7 +512,7 @@ class CeilingLight(MatrixLight):
                     "Cannot set downlight color with brightness=0. "
                     "Use turn_downlight_off() instead."
                 )
-            downlight_colors = [colors] * len(range(*self.downlight_zones.indices(256)))
+            downlight_colors = [colors] * self.downlight_zone_count
         else:
             if all(c.brightness == 0 for c in colors):
                 raise ValueError(
@@ -504,10 +520,10 @@ class CeilingLight(MatrixLight):
                     "Use turn_downlight_off() instead."
                 )
 
-            expected_count = len(range(*self.downlight_zones.indices(256)))
-            if len(colors) != expected_count:
+            if len(colors) != self.downlight_zone_count:
                 raise ValueError(
-                    f"Expected {expected_count} colors for downlight, got {len(colors)}"
+                    f"Expected {self.downlight_zone_count} colors for downlight, "
+                    f"got {len(colors)}"
                 )
             downlight_colors = colors
 
@@ -684,10 +700,6 @@ class CeilingLight(MatrixLight):
             ValueError: If list length doesn't match downlight zone count
             LifxTimeoutError: Device did not respond
         """
-        # Number of downlight zones equals the uplight zone index
-        # (downlight is zones 0 to uplight_zone-1)
-        downlight_zone_count = self.uplight_zone
-
         # Validate provided colors early
         if colors is not None:
             if isinstance(colors, HSBK):
@@ -696,9 +708,9 @@ class CeilingLight(MatrixLight):
             else:
                 if all(c.brightness == 0 for c in colors):
                     raise ValueError("Cannot turn on downlight with brightness=0")
-                if len(colors) != downlight_zone_count:
+                if len(colors) != self.downlight_zone_count:
                     raise ValueError(
-                        f"Expected {downlight_zone_count} colors for downlight, "
+                        f"Expected {self.downlight_zone_count} colors for downlight, "
                         f"got {len(colors)}"
                     )
 
@@ -711,7 +723,7 @@ class CeilingLight(MatrixLight):
             # Determine target colors (pass pre-fetched colors to avoid extra fetch)
             if colors is not None:
                 if isinstance(colors, HSBK):
-                    target_colors = [colors] * downlight_zone_count
+                    target_colors = [colors] * self.downlight_zone_count
                 else:
                     target_colors = list(colors)
             else:
@@ -750,7 +762,7 @@ class CeilingLight(MatrixLight):
             # Light is already on - determine target colors first, then set
             if colors is not None:
                 if isinstance(colors, HSBK):
-                    target_colors = [colors] * downlight_zone_count
+                    target_colors = [colors] * self.downlight_zone_count
                 else:
                     target_colors = list(colors)
             else:
@@ -824,6 +836,54 @@ class CeilingLight(MatrixLight):
         if turning_off and self._state_file:
             self._save_state_to_file()
 
+    async def set_color(self, color: HSBK, duration: float = 0.0) -> None:
+        """Set light color, updating component state tracking.
+
+        Overrides Light.set_color() to track the color change in the ceiling
+        light's component state. When set_color() is called, all zones (uplight
+        and downlight) are set to the same color. This override ensures that
+        the cached component colors stay in sync so that subsequent component
+        control methods (like turn_uplight_on or turn_downlight_on) use the
+        correct color values.
+
+        Args:
+            color: HSBK color to set for the entire light
+            duration: Transition duration in seconds (default 0.0)
+
+        Raises:
+            LifxDeviceNotFoundError: If device is not connected
+            LifxTimeoutError: If device does not respond
+            LifxUnsupportedCommandError: If device doesn't support this command
+
+        Example:
+            ```python
+            from lifx.color import HSBK
+
+            # Set entire ceiling light to warm white
+            await ceiling.set_color(
+                HSBK(hue=0, saturation=0, brightness=1.0, kelvin=2700)
+            )
+
+            # Later component control will use this color
+            await ceiling.turn_uplight_off()  # Uplight off
+            await ceiling.turn_uplight_on()  # Restores to warm white
+            ```
+        """
+        # Call parent to perform actual color change
+        await super().set_color(color, duration)
+
+        # Update cached component colors - all zones now have the same color
+        self._last_uplight_color = color
+        self._last_downlight_colors = [color] * self.downlight_zone_count
+
+        # Also update stored state for restoration
+        self._stored_uplight_state = color
+        self._stored_downlight_state = [color] * self.downlight_zone_count
+
+        # Persist if enabled
+        if self._state_file:
+            self._save_state_to_file()
+
     async def turn_downlight_off(
         self, colors: HSBK | list[HSBK] | None = None, duration: float = 0.0
     ) -> None:
@@ -845,8 +905,6 @@ class CeilingLight(MatrixLight):
         Note:
             Sets all downlight zone brightness to 0 on device while preserving H, S, K.
         """
-        expected_count = len(range(*self.downlight_zones.indices(256)))
-
         # Validate provided colors early (before fetching)
         stored_colors: list[HSBK] | None = None
         if colors is not None:
@@ -856,16 +914,16 @@ class CeilingLight(MatrixLight):
                         "Provided color cannot have brightness=0. "
                         "Omit the parameter to use current colors."
                     )
-                stored_colors = [colors] * expected_count
+                stored_colors = [colors] * self.downlight_zone_count
             else:
                 if all(c.brightness == 0 for c in colors):
                     raise ValueError(
                         "Provided colors cannot have brightness=0. "
                         "Omit the parameter to use current colors."
                     )
-                if len(colors) != expected_count:
+                if len(colors) != self.downlight_zone_count:
                     raise ValueError(
-                        f"Expected {expected_count} colors for downlight, "
+                        f"Expected {self.downlight_zone_count} colors for downlight, "
                         f"got {len(colors)}"
                     )
                 stored_colors = list(colors)

lifx/network/mdns/__init__.py

@@ -0,0 +1,58 @@
+"""mDNS/DNS-SD discovery for LIFX devices.
+
+This module provides mDNS-based discovery using the _lifx._udp.local service type.
+It uses only Python stdlib (no external dependencies).
+
+Example:
+    Low-level API (raw mDNS records):
+    ```python
+    async for record in discover_lifx_services():
+        print(f"Found: {record.serial} at {record.ip}:{record.port}")
+    ```
+
+    High-level API (device instances):
+    ```python
+    async for device in discover_devices_mdns():
+        print(f"Found {type(device).__name__}: {device.serial}")
+    ```
+"""
+
+from lifx.network.mdns.discovery import (
+    create_device_from_record,
+    discover_devices_mdns,
+    discover_lifx_services,
+)
+from lifx.network.mdns.dns import (
+    DnsHeader,
+    DnsResourceRecord,
+    ParsedDnsResponse,
+    SrvData,
+    TxtData,
+    build_ptr_query,
+    parse_dns_response,
+    parse_name,
+    parse_txt_record,
+)
+from lifx.network.mdns.transport import MdnsTransport
+from lifx.network.mdns.types import LifxServiceRecord
+
+__all__ = [
+    # Types
+    "LifxServiceRecord",
+    # Discovery functions
+    "discover_lifx_services",
+    "discover_devices_mdns",
+    "create_device_from_record",
+    # DNS parsing
+    "DnsHeader",
+    "DnsResourceRecord",
+    "ParsedDnsResponse",
+    "SrvData",
+    "TxtData",
+    "build_ptr_query",
+    "parse_dns_response",
+    "parse_name",
+    "parse_txt_record",
+    # Transport
+    "MdnsTransport",
+]