lifx-async 4.9.0__tar.gz → 5.0.1__tar.gz

{lifx_async-4.9.0 → lifx_async-5.0.1}/.github/workflows/ci.yml

@@ -40,7 +40,7 @@ jobs:
         python-version: ${{ env.PYTHON_VERSION }}
 
     - name: Install uv
-      uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7
+      uses: astral-sh/setup-uv@61cb8a9741eeb8a550a1b8544337180c0fc8476b # v7
       with:
         version: ${{ env.UV_VERSION }}
         python-version: ${{ env.PYTHON_VERSION }}
@@ -82,7 +82,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
 
     - name: Install uv
-      uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7
+      uses: astral-sh/setup-uv@61cb8a9741eeb8a550a1b8544337180c0fc8476b # v7
       with:
         version: ${{ env.UV_VERSION }}
         python-version: ${{ matrix.python-version }}
@@ -134,7 +134,7 @@ jobs:
         python-version: ${{ env.PYTHON_VERSION }}
 
     - name: Install uv
-      uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867   # v7
+      uses: astral-sh/setup-uv@61cb8a9741eeb8a550a1b8544337180c0fc8476b   # v7
       with:
         version: ${{ env.UV_VERSION }}
         python-version: ${{ env.PYTHON_VERSION }}
@@ -198,7 +198,7 @@ jobs:
         python-version: ${{ env.PYTHON_VERSION }}
 
     - name: Install uv
-      uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7
+      uses: astral-sh/setup-uv@61cb8a9741eeb8a550a1b8544337180c0fc8476b # v7
       with:
         version: ${{ env.UV_VERSION }}
         python-version: ${{ env.PYTHON_VERSION }}

{lifx_async-4.9.0 → lifx_async-5.0.1}/.github/workflows/docs.yml

@@ -35,7 +35,7 @@ jobs:
         python-version: ${{ env.PYTHON_VERSION }}
 
     - name: Install uv
-      uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7
+      uses: astral-sh/setup-uv@61cb8a9741eeb8a550a1b8544337180c0fc8476b # v7
       with:
         version: ${{ env.UV_VERSION }}
         python-version: ${{ env.PYTHON_VERSION }}
@@ -69,7 +69,7 @@ jobs:
         python-version: ${{ env.PYTHON_VERSION }}
 
     - name: Install uv
-      uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7
+      uses: astral-sh/setup-uv@61cb8a9741eeb8a550a1b8544337180c0fc8476b # v7
       with:
         version: ${{ env.UV_VERSION }}
         python-version: ${{ env.PYTHON_VERSION }}
@@ -97,7 +97,7 @@ jobs:
         python-version: ${{ env.PYTHON_VERSION }}
 
     - name: Install uv
-      uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7
+      uses: astral-sh/setup-uv@61cb8a9741eeb8a550a1b8544337180c0fc8476b # v7
       with:
         version: ${{ env.UV_VERSION }}
         python-version: ${{ env.PYTHON_VERSION }}

{lifx_async-4.9.0 → lifx_async-5.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-async
-Version: 4.9.0
+Version: 5.0.1
 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 → lifx_async-5.0.1}/docs/changelog.md

@@ -2,6 +2,27 @@
 
 <!-- version list -->
 
+## v5.0.1 (2026-01-14)
+
+### Bug Fixes
+
+- Handle asyncio.TimeoutError on Python 3.10
+  ([`4438bc4`](https://github.com/Djelibeybi/lifx-async/commit/4438bc45f19f477b585c6af8cf8cbaf5e9341d14))
+
+
+## v5.0.0 (2026-01-12)
+
+### Features
+
+- Add Python 3.10 support
+  ([`7c39131`](https://github.com/Djelibeybi/lifx-async/commit/7c391314305bb856d8bbcd23a5e481b729a5ad04))
+
+### Breaking Changes
+
+- Batch operations now raise first exception immediately (asyncio.gather behavior) instead of
+  collecting all exceptions into an ExceptionGroup (TaskGroup behavior).
+
+
 ## v4.9.0 (2025-12-30)
 
 ### Features

{lifx_async-4.9.0 → lifx_async-5.0.1}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "lifx-async"
-version = "4.9.0"
+version = "5.0.1"
 description = "A modern, type-safe, async Python library for controlling LIFX lights"
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.10"
 dependencies = []
 license = "UPL-1.0"
 license-files = ["LICENSE"]
@@ -19,6 +19,7 @@ classifiers = [
     "Intended Audience :: Developers",
     "Natural Language :: English",
     "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -31,7 +32,7 @@ classifiers = [
 [dependency-groups]
 dev = [
     "hatchling>=1.27.0",
-    "lifx-emulator-core>=3.0.3",
+    "lifx-emulator-core>=3.1.0",
     "mkdocs-git-revision-date-localized-plugin>=1.4.7",
     "mkdocs-llmstxt>=0.4.0",
     "mkdocs-material>=9.6.22",
@@ -44,6 +45,7 @@ dev = [
     "pytest-sugar>=1.1.1",
     "pyyaml>=6.0.3",
     "ruff>=0.14.2",
+    "typing-extensions>=4.15.0",
 ]
 
 [build-system]
@@ -56,7 +58,7 @@ packages = ["src/lifx"]
 [tool.ruff]
 line-length = 88
 indent-width = 4
-target-version = "py311"
+target-version = "py310"
 
 [tool.ruff.format]
 quote-style = "double"
@@ -72,10 +74,11 @@ ignore = []
 "src/lifx/{protocol,products}/generator.py" = ["E501"]
 "src/lifx/protocol/packets.py" = ["E501"]
 "src/lifx/products/registry.py" = ["E501"]
+"benchmarks/*.py" = ["E501"]
 
 [tool.pyright]
 typeCheckingMode = "standard"
-pythonVersion = "3.11"
+pythonVersion = "3.10"
 include = ["src"]
 exclude = [
     "**/__pycache__",

lifx_async-5.0.1/scripts/test_multiversion.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""Multi-version Python test runner.
+
+This script runs the test suite against multiple Python versions to catch
+version-specific issues (like the asyncio.TimeoutError vs TimeoutError
+difference between Python 3.10 and 3.11+) before pushing to GitHub.
+
+Usage:
+    # Run tests on all supported versions (default)
+    uv run scripts/test_multiversion.py
+
+    # Run tests on specific versions only
+    uv run scripts/test_multiversion.py --versions 3.10 3.14
+
+    # Run with verbose pytest output
+    uv run scripts/test_multiversion.py -v
+
+    # Run specific test file/pattern
+    uv run scripts/test_multiversion.py -- tests/test_network/
+
+    # Quick mode: skip coverage
+    uv run scripts/test_multiversion.py --quick
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess  # nosec B404 - subprocess needed for running uv/pytest
+import sys
+import time
+from dataclasses import dataclass
+
+# Python versions supported by this project (from pyproject.toml)
+SUPPORTED_VERSIONS = ["3.10", "3.11", "3.12", "3.13", "3.14"]
+
+# Default: test all supported versions
+DEFAULT_VERSIONS = SUPPORTED_VERSIONS
+
+
+@dataclass
+class TestResult:
+    """Result of running tests on a specific Python version."""
+
+    version: str
+    success: bool
+    duration: float
+    output: str
+
+
+def check_python_available(version: str) -> bool:
+    """Check if a Python version is available via uv."""
+    result = subprocess.run(  # nosec B603 B607 - trusted uv command
+        ["uv", "python", "find", version],
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0
+
+
+def run_tests(
+    version: str,
+    pytest_args: list[str],
+    verbose: bool = False,
+    quick: bool = False,
+) -> TestResult:
+    """Run pytest on a specific Python version using uv."""
+    start_time = time.time()
+
+    cmd = [
+        "uv",
+        "run",
+        "--python",
+        version,
+        "--isolated",  # Use isolated environment to avoid conflicts
+        "pytest",
+    ]
+
+    # Add coverage unless in quick mode
+    if not quick:
+        cmd.extend(["--cov=lifx", "--cov-report=term-missing:skip-covered"])
+
+    # Add verbosity
+    if verbose:
+        cmd.append("-v")
+    else:
+        cmd.append("-q")
+
+    # Add any additional pytest arguments
+    cmd.extend(pytest_args)
+
+    # Ignore animation tests (uncommitted module with known issues)
+    cmd.extend(["--ignore=tests/test_animation"])
+
+    print(f"\n{'=' * 60}")
+    print(f"Running tests on Python {version}")
+    print(f"{'=' * 60}")
+    print(f"Command: {' '.join(cmd)}\n")
+
+    result = subprocess.run(  # nosec B603 - trusted uv/pytest command
+        cmd,
+        capture_output=not verbose,  # Show output in real-time if verbose
+        text=True,
+        cwd=subprocess.run(  # nosec B603 B607 - trusted git command
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+        ).stdout.strip(),
+    )
+
+    duration = time.time() - start_time
+
+    output = ""
+    if not verbose:
+        output = result.stdout + result.stderr
+
+    return TestResult(
+        version=version,
+        success=result.returncode == 0,
+        duration=duration,
+        output=output,
+    )
+
+
+def main() -> int:
+    """Run tests across multiple Python versions."""
+    parser = argparse.ArgumentParser(
+        description="Run tests across multiple Python versions",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument(
+        "--versions",
+        nargs="+",
+        default=None,
+        help=f"Python versions to test (default: all supported: {SUPPORTED_VERSIONS})",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Verbose pytest output",
+    )
+    parser.add_argument(
+        "--quick",
+        action="store_true",
+        help="Quick mode: skip coverage for faster execution",
+    )
+    parser.add_argument(
+        "pytest_args",
+        nargs="*",
+        help="Additional arguments to pass to pytest",
+    )
+
+    args = parser.parse_args()
+
+    # Determine which versions to test
+    if args.versions:
+        versions = args.versions
+    else:
+        versions = DEFAULT_VERSIONS
+
+    # Validate versions
+    for version in versions:
+        if version not in SUPPORTED_VERSIONS:
+            print(
+                f"Warning: {version} is not in supported versions {SUPPORTED_VERSIONS}"
+            )
+
+    # Check availability
+    available_versions = []
+    missing_versions = []
+    for version in versions:
+        if check_python_available(version):
+            available_versions.append(version)
+        else:
+            missing_versions.append(version)
+
+    if missing_versions:
+        print(f"Missing Python versions: {missing_versions}")
+        print("Install with: uv python install " + " ".join(missing_versions))
+        if not available_versions:
+            return 1
+
+    print(f"Testing on Python versions: {available_versions}")
+
+    # Run tests
+    results: list[TestResult] = []
+    for version in available_versions:
+        result = run_tests(
+            version,
+            args.pytest_args,
+            verbose=args.verbose,
+            quick=args.quick,
+        )
+        results.append(result)
+
+        if not args.verbose:
+            # Show last few lines of output for quick feedback
+            lines = result.output.strip().split("\n")
+            for line in lines[-10:]:
+                print(line)
+
+    # Summary
+    print(f"\n{'=' * 60}")
+    print("SUMMARY")
+    print(f"{'=' * 60}")
+
+    all_passed = True
+    for result in results:
+        status = "✓ PASSED" if result.success else "✗ FAILED"
+        print(f"Python {result.version}: {status} ({result.duration:.1f}s)")
+        if not result.success:
+            all_passed = False
+
+    if missing_versions:
+        print(f"\nSkipped (not installed): {missing_versions}")
+
+    if all_passed:
+        print("\n✓ All tests passed across all Python versions!")
+        return 0
+    else:
+        print("\n✗ Some tests failed. Check output above for details.")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{lifx_async-4.9.0 → lifx_async-5.0.1}/src/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_async-4.9.0 → lifx_async-5.0.1}/src/lifx/const.py

@@ -1,5 +1,7 @@
 # lifx-async constants
 
+import asyncio
+import sys
 import uuid
 from typing import Final
 
@@ -109,3 +111,19 @@ PROTOCOL_URL: Final[str] = (
 PRODUCTS_URL: Final[str] = (
     "https://raw.githubusercontent.com/LIFX/products/refs/heads/master/products.json"
 )
+
+# ============================================================================
+# Python Version Compatibility
+# ============================================================================
+
+# On Python 3.10, asyncio.wait_for() raises asyncio.TimeoutError which is NOT
+# a subclass of the built-in TimeoutError. In Python 3.11+, they are unified.
+# Use this tuple with `except TIMEOUT_ERRORS:` to catch timeouts from asyncio
+# operations on all supported Python versions.
+if sys.version_info < (3, 11):
+    TIMEOUT_ERRORS: Final[tuple[type[BaseException], ...]] = (
+        TimeoutError,
+        asyncio.TimeoutError,
+    )
+else:
+    TIMEOUT_ERRORS: Final[tuple[type[BaseException], ...]] = (TimeoutError,)

{lifx_async-4.9.0 → lifx_async-5.0.1}/src/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_async-4.9.0 → lifx_async-5.0.1}/src/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(