lifx-async 4.3.3__tar.gz → 4.3.4__tar.gz

{lifx_async-4.3.3 → lifx_async-4.3.4}/PKG-INFO

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

{lifx_async-4.3.3 → lifx_async-4.3.4}/docs/changelog.md

@@ -2,6 +2,14 @@
 
 <!-- version list -->
 
+## v4.3.4 (2025-11-22)
+
+### Bug Fixes
+
+- **network**: Exclude retry sleep time from timeout budget
+  ([`312d7a7`](https://github.com/Djelibeybi/lifx-async/commit/312d7a7e2561de7d2bbf142c8a521daca31651bb))
+
+
 ## v4.3.3 (2025-11-22)
 
 ### Bug Fixes

{lifx_async-4.3.3 → lifx_async-4.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lifx-async"
-version = "4.3.3"
+version = "4.3.4"
 description = "A modern, type-safe, async Python library for controlling LIFX lights"
 readme = "README.md"
 requires-python = ">=3.11"

{lifx_async-4.3.3 → lifx_async-4.3.4}/src/lifx/devices/base.py

@@ -252,6 +252,8 @@ class Device:
         self.serial = serial_obj.to_string()
         self.ip = ip
         self.port = port
+        self._timeout = timeout
+        self._max_retries = max_retries
 
         # Create lightweight connection handle - connection pooling is internal
         self.connection = DeviceConnection(
@@ -304,10 +306,16 @@ class Device:
             ```
         """
         if serial is None:
-            temp_conn = DeviceConnection(serial="000000000000", ip=ip, port=port)
+            temp_conn = DeviceConnection(
+                serial="000000000000",
+                ip=ip,
+                port=port,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
             try:
                 response = await temp_conn.request(
-                    packets.Device.GetService(), timeout=DISCOVERY_TIMEOUT
+                    packets.Device.GetService(), timeout=timeout
                 )
                 if response and isinstance(response, packets.Device.StateService):
                     if temp_conn.serial and temp_conn.serial != "000000000000":
@@ -890,9 +898,17 @@ class Device:
 
         try:
             # Check each device for the target label
-            async for disc in discover_devices(timeout=discover_timeout):
+            async for disc in discover_devices(
+                timeout=discover_timeout,
+                device_timeout=self._timeout,
+                max_retries=self._max_retries,
+            ):
                 temp_conn = DeviceConnection(
-                    serial=disc.serial, ip=disc.ip, port=disc.port
+                    serial=disc.serial,
+                    ip=disc.ip,
+                    port=disc.port,
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
                 )
 
                 try:
@@ -1063,9 +1079,17 @@ class Device:
 
         try:
             # Check each device for the target label
-            async for disc in discover_devices(timeout=discover_timeout):
+            async for disc in discover_devices(
+                timeout=discover_timeout,
+                device_timeout=self._timeout,
+                max_retries=self._max_retries,
+            ):
                 temp_conn = DeviceConnection(
-                    serial=disc.serial, ip=disc.ip, port=disc.port
+                    serial=disc.serial,
+                    ip=disc.ip,
+                    port=disc.port,
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
                 )
 
                 try:

{lifx_async-4.3.3 → lifx_async-4.3.4}/src/lifx/network/connection.py

@@ -467,13 +467,10 @@ class DeviceConnection:
         correlation_keys: list[tuple[int, int, str]] = []
 
         # Calculate per-attempt timeouts with exponential backoff
-        # Start with a reasonable minimum (100ms) to avoid too-short initial timeouts
-        min_attempt_timeout = 0.1  # 100ms minimum
-        if max_retries > 0:
-            attempt_timeout = max(min_attempt_timeout, timeout / (2 * max_retries))
-        else:
-            # Only one attempt total, use entire timeout
-            attempt_timeout = timeout
+        # Use proper exponential backoff distribution: timeout / (2^(n+1) - 1)
+        # This ensures total of all attempt timeouts equals the overall timeout budget
+        total_weight = (2 ** (max_retries + 1)) - 1
+        base_timeout = timeout / total_weight
 
         # Idle timeout for multi-response protocols
         # Stop streaming if no responses for this long after first response
@@ -482,14 +479,17 @@ class DeviceConnection:
         last_error: Exception | None = None
         has_yielded = False
         overall_start = time.monotonic()
+        total_sleep_time = 0.0  # Track sleep time to exclude from timeout budget
 
         try:
             for attempt in range(max_retries + 1):
                 # Calculate current attempt timeout with exponential backoff
-                current_timeout = min(
-                    attempt_timeout * (2**attempt),
-                    timeout - (time.monotonic() - overall_start),
+                # Exclude sleep time from elapsed time to preserve timeout budget
+                elapsed_response_time = (
+                    time.monotonic() - overall_start - total_sleep_time
                 )
+                ideal_timeout = base_timeout * (2**attempt)
+                current_timeout = min(ideal_timeout, timeout - elapsed_response_time)
 
                 # Check if we've exceeded overall timeout budget
                 if current_timeout <= 0:
@@ -616,6 +616,9 @@ class DeviceConnection:
                         # Sleep with jitter before retry
                         sleep_time = self._calculate_retry_sleep_with_jitter(attempt)
                         await asyncio.sleep(sleep_time)
+                        total_sleep_time += (
+                            sleep_time  # Track sleep to exclude from timeout
+                        )
                         continue
                     else:
                         # All retries exhausted
@@ -673,9 +676,14 @@ class DeviceConnection:
         base_timeout = timeout / total_weight
 
         last_error: Exception | None = None
+        total_sleep_time = 0.0  # Track sleep time to exclude from timeout budget
+        overall_start = time.monotonic()
 
         for attempt in range(max_retries + 1):
-            current_timeout = base_timeout * (2**attempt)
+            # Calculate timeout with budget remaining after excluding sleep time
+            elapsed_response_time = time.monotonic() - overall_start - total_sleep_time
+            ideal_timeout = base_timeout * (2**attempt)
+            current_timeout = min(ideal_timeout, timeout - elapsed_response_time)
             sequence = attempt
 
             # Correlation key: (source, sequence, serial)
@@ -737,6 +745,9 @@ class DeviceConnection:
                     # Sleep with jitter before retry
                     sleep_time = self._calculate_retry_sleep_with_jitter(attempt)
                     await asyncio.sleep(sleep_time)
+                    total_sleep_time += (
+                        sleep_time  # Track sleep to exclude from timeout
+                    )
                     continue
                 else:
                     break

{lifx_async-4.3.3 → lifx_async-4.3.4}/tests/test_devices/test_base.py

@@ -527,7 +527,7 @@ class TestLocationAndGroupManagement:
         mock_discovered_conn.request = AsyncMock(return_value=mock_state_location)
 
         # Create async generator mock for discover_devices
-        async def mock_discover_gen(timeout: float = 5.0):
+        async def mock_discover_gen(timeout: float = 5.0, **kwargs):
             for disc in discovered_devices:
                 yield disc
 
@@ -537,8 +537,10 @@ class TestLocationAndGroupManagement:
             ),
             patch("lifx.devices.base.DeviceConnection") as mock_conn_class,
         ):
-            # First call: discovered device, second call: this device
-            mock_conn_class.side_effect = [mock_discovered_conn, device.connection]
+            # Only one DeviceConnection created for discovered device
+            mock_conn_class.return_value = mock_discovered_conn
+            # Add async close method to mock
+            mock_discovered_conn.close = AsyncMock()
 
             await device.set_location(label)
 
@@ -581,7 +583,7 @@ class TestLocationAndGroupManagement:
         mock_discovered_conn.request = AsyncMock(return_value=mock_state_location)
 
         # Create async generator mock for discover_devices
-        async def mock_discover_gen(timeout: float = 5.0):
+        async def mock_discover_gen(timeout: float = 5.0, **kwargs):
             for disc in discovered_devices:
                 yield disc
 
@@ -591,7 +593,10 @@ class TestLocationAndGroupManagement:
             ),
             patch("lifx.devices.base.DeviceConnection") as mock_conn_class,
         ):
-            mock_conn_class.side_effect = [mock_discovered_conn, device.connection]
+            # Only one DeviceConnection created for discovered device
+            mock_conn_class.return_value = mock_discovered_conn
+            # Add async close method to mock
+            mock_discovered_conn.close = AsyncMock()
 
             await device.set_location(label)
 
@@ -629,7 +634,7 @@ class TestLocationAndGroupManagement:
         mock_discovered_conn.request = AsyncMock(return_value=mock_state_group)
 
         # Create async generator mock for discover_devices
-        async def mock_discover_gen(timeout: float = 5.0):
+        async def mock_discover_gen(timeout: float = 5.0, **kwargs):
             for disc in discovered_devices:
                 yield disc
 
@@ -639,7 +644,10 @@ class TestLocationAndGroupManagement:
             ),
             patch("lifx.devices.base.DeviceConnection") as mock_conn_class,
         ):
-            mock_conn_class.side_effect = [mock_discovered_conn, device.connection]
+            # Only one DeviceConnection created for discovered device
+            mock_conn_class.return_value = mock_discovered_conn
+            # Add async close method to mock
+            mock_discovered_conn.close = AsyncMock()
 
             await device.set_group(label)
 
@@ -682,7 +690,7 @@ class TestLocationAndGroupManagement:
         mock_discovered_conn.request = AsyncMock(return_value=mock_state_group)
 
         # Create async generator mock for discover_devices
-        async def mock_discover_gen(timeout: float = 5.0):
+        async def mock_discover_gen(timeout: float = 5.0, **kwargs):
             for disc in discovered_devices:
                 yield disc
 
@@ -692,7 +700,10 @@ class TestLocationAndGroupManagement:
             ),
             patch("lifx.devices.base.DeviceConnection") as mock_conn_class,
         ):
-            mock_conn_class.side_effect = [mock_discovered_conn, device.connection]
+            # Only one DeviceConnection created for discovered device
+            mock_conn_class.return_value = mock_discovered_conn
+            # Add async close method to mock
+            mock_discovered_conn.close = AsyncMock()
 
             await device.set_group(label)
 

lifx_async-4.3.4/tests/test_network/test_concurrent_requests.py

@@ -0,0 +1,395 @@
+"""Tests for concurrent request handling with DeviceConnection.
+
+This module tests concurrent request/response handling through the
+user-facing DeviceConnection API.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from lifx.exceptions import LifxTimeoutError
+from lifx.protocol.packets import Device
+
+
+class TestConcurrentRequests:
+    """Test concurrent request/response handling with DeviceConnection."""
+
+    async def test_timeout_behavior(self):
+        """Test that timeout raises LifxTimeoutError with no server response."""
+        from lifx.network.connection import DeviceConnection
+
+        conn = DeviceConnection(
+            serial="d073d5000001", ip="192.168.1.100", timeout=0.1, max_retries=0
+        )
+
+        # Request should timeout when no server is available
+        with pytest.raises(LifxTimeoutError):
+            await conn.request(Device.GetPower(), timeout=0.1)
+
+
+class TestErrorHandling:
+    """Test error handling in concurrent scenarios using DeviceConnection."""
+
+    async def test_timeout_when_server_drops_packets(
+        self, emulator_server_with_scenarios
+    ):
+        """Test handling timeout when server drops packets (simulating no response)."""
+        # Create a scenario that drops Device.GetPower packets (pkt_type 20)
+        server, _device = await emulator_server_with_scenarios(
+            device_type="color",
+            serial="d073d5000001",
+            scenarios={
+                "drop_packets": {
+                    "20": 1.0  # Drop 100% of GetPower responses (pkt_type 20)
+                }
+            },
+        )
+
+        from lifx.network.connection import DeviceConnection
+
+        conn = DeviceConnection(
+            serial="d073d5000001",
+            ip="127.0.0.1",
+            port=server.port,
+            timeout=0.5,
+            max_retries=0,  # No retries for faster test
+        )
+
+        # This should timeout since server drops all GetPower packets
+        with pytest.raises(LifxTimeoutError):
+            await conn.request(Device.GetPower(), timeout=0.5)
+
+    async def test_concurrent_requests_with_one_timing_out(
+        self, emulator_server_with_scenarios
+    ):
+        """Test timeout isolation between concurrent requests."""
+        # Create a scenario that drops ONLY GetPower packets
+        server, _device = await emulator_server_with_scenarios(
+            device_type="color",
+            serial="d073d5000001",
+            scenarios={
+                "drop_packets": {
+                    "20": 1.0  # Drop 100% of GetPower responses (pkt_type 20)
+                }
+            },
+        )
+
+        from lifx.network.connection import DeviceConnection
+
+        conn = DeviceConnection(
+            serial="d073d5000001",
+            ip="127.0.0.1",
+            port=server.port,
+            timeout=1.0,
+            max_retries=2,
+        )
+
+        # Create multiple concurrent requests where one will timeout
+        async def get_power():
+            """This will timeout."""
+            try:
+                await conn.request(Device.GetPower(), timeout=0.3)
+                return "power_success"
+            except LifxTimeoutError:
+                return "power_timeout"
+
+        async def get_label():
+            """This should succeed."""
+            try:
+                await conn.request(Device.GetLabel(), timeout=1.0)
+                return "label_success"
+            except LifxTimeoutError:
+                return "label_timeout"
+
+        # Run both concurrently
+        results = await asyncio.gather(get_power(), get_label())
+
+        # Power request should timeout, label should succeed
+        assert results[0] == "power_timeout"
+        assert results[1] == "label_success"
+
+
+class TestAsyncGeneratorRequests:
+    """Test async generator-based request streaming."""
+
+    async def test_request_stream_single_response(self, emulator_server_with_scenarios):
+        """Test request_stream with single response exits immediately after break."""
+        server, _device = await emulator_server_with_scenarios(
+            device_type="color",
+            serial="d073d5000001",
+            scenarios={},
+        )
+
+        from lifx.network.connection import DeviceConnection
+
+        conn = DeviceConnection(
+            serial="d073d5000001",
+            ip="127.0.0.1",
+            port=server.port,
+            timeout=2.0,
+            max_retries=2,
+        )
+
+        # Stream should yield single response
+        received = []
+        async for response in conn.request_stream(Device.GetLabel()):
+            received.append(response)
+            break  # Exit immediately after first response
+
+        assert len(received) == 1
+        assert hasattr(received[0], "label")
+
+    async def test_request_stream_convenience_wrapper(
+        self, emulator_server_with_scenarios
+    ):
+        """Test that request() convenience wrapper works correctly."""
+        server, _device = await emulator_server_with_scenarios(
+            device_type="color",
+            serial="d073d5000001",
+            scenarios={},
+        )
+
+        from lifx.network.connection import DeviceConnection
+
+        conn = DeviceConnection(
+            serial="d073d5000001",
+            ip="127.0.0.1",
+            port=server.port,
+            timeout=2.0,
+            max_retries=2,
+        )
+
+        # request() should return single response directly
+        response = await conn.request(Device.GetLabel())
+        assert hasattr(response, "label")
+
+    async def test_early_exit_no_resource_leak(self, emulator_server_with_scenarios):
+        """Test that breaking early doesn't leak resources."""
+        server, _device = await emulator_server_with_scenarios(
+            device_type="color",
+            serial="d073d5000001",
+            scenarios={},
+        )
+
+        from lifx.network.connection import DeviceConnection
+
+        conn = DeviceConnection(
+            serial="d073d5000001",
+            ip="127.0.0.1",
+            port=server.port,
+            timeout=2.0,
+            max_retries=2,
+        )
+
+        try:
+            # Stream and break early
+            async for _response in conn.request_stream(Device.GetLabel()):
+                break
+
+            # Verify connection is still functional
+            assert conn.is_open
+
+            # Make another request to verify no leak
+            response = await conn.request(Device.GetPower())
+            assert hasattr(response, "level")
+        finally:
+            await conn.close()
+
+
+class TestRetryTimeoutBudget:
+    """Test that retry sleep time doesn't consume the timeout budget.
+
+    This test class verifies the fix for the issue where retry sleep time
+    was being counted against the overall timeout budget, causing later
+    retry attempts to have insufficient time to wait for responses.
+    """
+
+    async def test_retry_sleep_excluded_from_timeout_budget(
+        self, emulator_server_with_scenarios
+    ):
+        """Test that retry sleep time is excluded from timeout budget.
+
+        This test verifies that when retries occur with exponential backoff sleep,
+        the sleep time doesn't consume the overall timeout budget. Each retry
+        attempt should get a fair timeout window.
+
+        Without the fix, this would fail because later attempts would have
+        very short timeouts (e.g., 0.613s on attempt 4) due to accumulated sleep time.
+        """
+        import time
+
+        # Create a scenario that drops all packets to force retries
+        server, _device = await emulator_server_with_scenarios(
+            device_type="color",
+            serial="d073d5000001",
+            scenarios={
+                "drop_packets": {
+                    "20": 1.0  # Drop 100% of GetPower responses (pkt_type 20)
+                }
+            },
+        )
+
+        from lifx.network.connection import DeviceConnection
+
+        # Set up connection with specific timeout and retries
+        timeout = 2.0  # 2 second total timeout budget
+        max_retries = 3  # 4 total attempts (0, 1, 2, 3)
+
+        conn = DeviceConnection(
+            serial="d073d5000001",
+            ip="127.0.0.1",
+            port=server.port,
+            timeout=timeout,
+            max_retries=max_retries,
+        )
+
+        # Calculate expected timeout distribution with exponential backoff
+        # total_weight = (2^(n+1) - 1) = (2^4 - 1) = 15
+        # base_timeout = 2.0 / 15 = 0.133s
+        # Attempt 0: 0.133 * 2^0 = 0.133s
+        # Attempt 1: 0.133 * 2^1 = 0.266s
+        # Attempt 2: 0.133 * 2^2 = 0.533s
+        # Attempt 3: 0.133 * 2^3 = 1.066s
+        # Total: 0.133 + 0.266 + 0.533 + 1.066 = ~2.0s
+
+        start_time = time.monotonic()
+
+        # This should timeout after all retries are exhausted
+        with pytest.raises(LifxTimeoutError) as exc_info:
+            await conn.request(Device.GetPower(), timeout=timeout)
+
+        elapsed = time.monotonic() - start_time
+
+        # Verify the timeout message
+        assert "after 4 attempts" in str(exc_info.value)
+
+        # The total elapsed time should be:
+        # - Timeout budget (2.0s)
+        # - Plus sleep time between retries (3 sleeps with exponential backoff)
+        #   Sleep 0: random(0, 0.1 * 2^0) = random(0, 0.1)
+        #   Sleep 1: random(0, 0.1 * 2^1) = random(0, 0.2)
+        #   Sleep 2: random(0, 0.1 * 2^2) = random(0, 0.4)
+        #   Max total sleep: 0.1 + 0.2 + 0.4 = 0.7s
+        # Total expected: 2.0 + 0.7 = 2.7s maximum
+
+        # Allow some tolerance for timing variations
+        assert elapsed >= timeout, "Should use at least the timeout budget"
+        assert elapsed < timeout + 1.0, (
+            f"Elapsed {elapsed}s should not exceed timeout + max_sleep (3.0s)"
+        )
+
+        # Key assertion: If sleep was counted against timeout budget,
+        # the elapsed time would be close to just the timeout (2.0s)
+        # because later attempts would fail immediately.
+        # With the fix, we should see elapsed > timeout + some sleep time.
+        assert elapsed > timeout + 0.1, (
+            "Sleep time should be added on top of timeout budget"
+        )
+
+    async def test_retry_timeout_calculation_consistency(
+        self, emulator_server_with_scenarios
+    ):
+        """Test that timeout calculation is consistent between GET and SET requests.
+
+        Both _request_stream_impl (GET) and _request_ack_stream_impl (SET)
+        should use the same timeout calculation formula.
+        """
+        import time
+
+        # Create a scenario that drops packets for both GET and SET
+        server, _device = await emulator_server_with_scenarios(
+            device_type="color",
+            serial="d073d5000001",
+            scenarios={
+                "drop_packets": {
+                    "20": 1.0,  # Drop GetPower (GET request)
+                    "21": 1.0,  # Drop SetPower (SET request)
+                }
+            },
+        )
+
+        from lifx.network.connection import DeviceConnection
+
+        timeout = 1.5
+        max_retries = 2  # 3 total attempts
+
+        conn = DeviceConnection(
+            serial="d073d5000001",
+            ip="127.0.0.1",
+            port=server.port,
+            timeout=timeout,
+            max_retries=max_retries,
+        )
+
+        # Test GET request (uses _request_stream_impl)
+        start_get = time.monotonic()
+        with pytest.raises(LifxTimeoutError):
+            await conn.request(Device.GetPower(), timeout=timeout)
+        elapsed_get = time.monotonic() - start_get
+
+        # Test SET request (uses _request_ack_stream_impl)
+        start_set = time.monotonic()
+        with pytest.raises(LifxTimeoutError):
+            await conn.request(Device.SetPower(level=65535), timeout=timeout)
+        elapsed_set = time.monotonic() - start_set
+
+        # Both should take approximately the same time (within tolerance)
+        # since they use the same timeout calculation and retry logic
+        time_diff = abs(elapsed_get - elapsed_set)
+        assert time_diff < 0.5, (
+            f"GET and SET timeout behavior should be consistent (diff: {time_diff}s)"
+        )
+
+        # Both should respect the timeout budget
+        assert elapsed_get >= timeout
+        assert elapsed_set >= timeout
+
+    async def test_retry_all_attempts_get_fair_timeout(
+        self, emulator_server_with_scenarios
+    ):
+        """Test that all retry attempts get adequate timeout windows.
+
+        This verifies that later retry attempts aren't starved of timeout
+        due to accumulated sleep time from earlier attempts.
+        """
+        # Create a scenario that drops packets to force retries
+        server, _device = await emulator_server_with_scenarios(
+            device_type="color",
+            serial="d073d5000001",
+            scenarios={
+                "drop_packets": {
+                    "20": 1.0  # Drop all GetPower responses
+                }
+            },
+        )
+
+        from lifx.network.connection import DeviceConnection
+
+        # Use settings similar to real-world usage
+        timeout = 8.0  # Default timeout
+        max_retries = 4  # 5 total attempts (like in the error log)
+
+        conn = DeviceConnection(
+            serial="d073d5000001",
+            ip="127.0.0.1",
+            port=server.port,
+            timeout=timeout,
+            max_retries=max_retries,
+        )
+
+        # This should timeout after all retries
+        with pytest.raises(LifxTimeoutError) as exc_info:
+            await conn.request(Device.GetPower(), timeout=timeout)
+
+        # Verify all attempts were made
+        assert "after 5 attempts" in str(exc_info.value)
+
+        # The error message should NOT show a very short timeout on later attempts
+        # (like "No response within 0.613s" which would indicate the bug)
+        error_msg = str(exc_info.value)
+
+        # The error should be about exhausting all attempts, not a premature timeout
+        assert "No response from" in error_msg

{lifx_async-4.3.3 → lifx_async-4.3.4}/uv.lock

@@ -432,7 +432,7 @@ wheels = [
 
 [[package]]
 name = "lifx-async"
-version = "4.3.3"
+version = "4.3.4"
 source = { editable = "." }
 
 [package.dev-dependencies]