Bump github/codeql-action from 4.32.1 to 4.32.2

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.32.1 to 4.32.2.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](6bc82e05fd...45cbd0c69e)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-version: 4.32.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/builder.yml

@@ -235,6 +235,7 @@ jobs:
           build-args: |
             BUILD_FROM=${{ steps.vars.outputs.base_image }}
           tags: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
+          outputs: type=image,push=true,compression=zstd,compression-level=9,force-compression=true,oci-mediatypes=true
           labels: |
             io.hass.arch=${{ matrix.arch }}
             io.hass.version=${{ needs.init.outputs.version }}

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@6bc82e05fd0ea64601dd4b465378bbcf57de0314 # v4.32.1
+        uses: github/codeql-action/init@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v4.32.2
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@6bc82e05fd0ea64601dd4b465378bbcf57de0314 # v4.32.1
+        uses: github/codeql-action/analyze@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v4.32.2
         with:
           category: "/language:python"

.strict-typing

@@ -282,7 +282,6 @@ homeassistant.components.imgw_pib.*
 homeassistant.components.immich.*
 homeassistant.components.incomfort.*
 homeassistant.components.inels.*
-homeassistant.components.infrared.*
 homeassistant.components.input_button.*
 homeassistant.components.input_select.*
 homeassistant.components.input_text.*
@@ -436,6 +435,7 @@ homeassistant.components.raspberry_pi.*
 homeassistant.components.rdw.*
 homeassistant.components.recollect_waste.*
 homeassistant.components.recorder.*
+homeassistant.components.redgtech.*
 homeassistant.components.remember_the_milk.*
 homeassistant.components.remote.*
 homeassistant.components.remote_calendar.*

CODEOWNERS

@@ -782,8 +782,6 @@ build.json @home-assistant/supervisor
 /tests/components/inels/ @epdevlab
 /homeassistant/components/influxdb/ @mdegat01
 /tests/components/influxdb/ @mdegat01
-/homeassistant/components/infrared/ @home-assistant/core
-/tests/components/infrared/ @home-assistant/core
 /homeassistant/components/inkbird/ @bdraco
 /tests/components/inkbird/ @bdraco
 /homeassistant/components/input_boolean/ @home-assistant/core
@@ -1357,6 +1355,8 @@ build.json @home-assistant/supervisor
 /tests/components/recorder/ @home-assistant/core
 /homeassistant/components/recovery_mode/ @home-assistant/core
 /tests/components/recovery_mode/ @home-assistant/core
+/homeassistant/components/redgtech/ @jonhsady @luan-nvg
+/tests/components/redgtech/ @jonhsady @luan-nvg
 /homeassistant/components/refoss/ @ashionky
 /tests/components/refoss/ @ashionky
 /homeassistant/components/rehlko/ @bdraco @peterager

homeassistant/components/abode/light.py

@@ -99,7 +99,7 @@ class AbodeLight(AbodeDevice, LightEntity):
         return _hs
 
     @property
-    def color_mode(self) -> ColorMode | None:
+    def color_mode(self) -> ColorMode:
         """Return the color mode of the light."""
         if self._device.is_dimmable and self._device.is_color_capable:
             if self.hs_color is not None:
@@ -110,7 +110,7 @@ class AbodeLight(AbodeDevice, LightEntity):
         return ColorMode.ONOFF
 
     @property
-    def supported_color_modes(self) -> set[ColorMode] | None:
+    def supported_color_modes(self) -> set[ColorMode]:
         """Flag supported color modes."""
         if self._device.is_dimmable and self._device.is_color_capable:
             return {ColorMode.COLOR_TEMP, ColorMode.HS}

homeassistant/components/alexa_devices/strings.json

@@ -90,6 +90,9 @@
     "cannot_retrieve_data_with_error": {
       "message": "Error retrieving data: {error}"
     },
+    "config_entry_not_found": {
+      "message": "Config entry not found: {device_id}"
+    },
     "device_serial_number_missing": {
       "message": "Device serial number missing: {device_id}"
     },

homeassistant/components/alexa_devices/switch.py

@@ -59,13 +59,15 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
-    # Replace unique id for "DND" switch and remove from Speaker Group
-    await async_update_unique_id(
-        hass, coordinator, SWITCH_DOMAIN, "do_not_disturb", "dnd"
-    )
+    # DND keys
+    old_key = "do_not_disturb"
+    new_key = "dnd"
 
-    # Remove DND switch from virtual groups
-    await async_remove_dnd_from_virtual_group(hass, coordinator)
+    # Remove old DND switch from virtual groups
+    await async_remove_dnd_from_virtual_group(hass, coordinator, old_key)
+
+    # Replace unique id for DND switch
+    await async_update_unique_id(hass, coordinator, SWITCH_DOMAIN, old_key, new_key)
 
     known_devices: set[str] = set()
 

homeassistant/components/alexa_devices/utils.py

@@ -54,7 +54,7 @@ def alexa_api_call[_T: AmazonEntity, **_P](
 async def async_update_unique_id(
     hass: HomeAssistant,
     coordinator: AmazonDevicesCoordinator,
-    domain: str,
+    platform: str,
     old_key: str,
     new_key: str,
 ) -> None:
@@ -63,7 +63,9 @@ async def async_update_unique_id(
 
     for serial_num in coordinator.data:
         unique_id = f"{serial_num}-{old_key}"
-        if entity_id := entity_registry.async_get_entity_id(domain, DOMAIN, unique_id):
+        if entity_id := entity_registry.async_get_entity_id(
+            DOMAIN, platform, unique_id
+        ):
             _LOGGER.debug("Updating unique_id for %s", entity_id)
             new_unique_id = unique_id.replace(old_key, new_key)
 
@@ -74,12 +76,13 @@ async def async_update_unique_id(
 async def async_remove_dnd_from_virtual_group(
     hass: HomeAssistant,
     coordinator: AmazonDevicesCoordinator,
+    key: str,
 ) -> None:
     """Remove entity DND from virtual group."""
     entity_registry = er.async_get(hass)
 
     for serial_num in coordinator.data:
-        unique_id = f"{serial_num}-do_not_disturb"
+        unique_id = f"{serial_num}-{key}"
         entity_id = entity_registry.async_get_entity_id(
             DOMAIN, SWITCH_DOMAIN, unique_id
         )
@@ -104,7 +107,7 @@ async def async_remove_unsupported_notification_sensors(
         ):
             unique_id = f"{serial_num}-{notification_key}"
             entity_id = entity_registry.async_get_entity_id(
-                domain=SENSOR_DOMAIN, platform=DOMAIN, unique_id=unique_id
+                DOMAIN, SENSOR_DOMAIN, unique_id=unique_id
             )
             is_unsupported = not coordinator.data[serial_num].notifications_supported
 

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.75.0"]
+  "requirements": ["anthropic==0.78.0"]
 }

homeassistant/components/apple_tv/binary_sensor.py

@@ -2,15 +2,16 @@
 
 from __future__ import annotations
 
-from pyatv.const import KeyboardFocusState
+from pyatv.const import FeatureName, FeatureState, KeyboardFocusState
 from pyatv.interface import AppleTV, KeyboardListener
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
 from homeassistant.const import CONF_NAME
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AppleTvConfigEntry
+from . import SIGNAL_CONNECTED, AppleTvConfigEntry
 from .entity import AppleTVEntity
 
 
@@ -21,10 +22,22 @@ async def async_setup_entry(
 ) -> None:
     """Load Apple TV binary sensor based on a config entry."""
     # apple_tv config entries always have a unique id
-    assert config_entry.unique_id is not None
-    name: str = config_entry.data[CONF_NAME]
     manager = config_entry.runtime_data
-    async_add_entities([AppleTVKeyboardFocused(name, config_entry.unique_id, manager)])
+    cb: CALLBACK_TYPE
+
+    def setup_entities(atv: AppleTV) -> None:
+        if atv.features.in_state(FeatureState.Available, FeatureName.TextFocusState):
+            assert config_entry.unique_id is not None
+            name: str = config_entry.data[CONF_NAME]
+            async_add_entities(
+                [AppleTVKeyboardFocused(name, config_entry.unique_id, manager)]
+            )
+            cb()
+
+    cb = async_dispatcher_connect(
+        hass, f"{SIGNAL_CONNECTED}_{config_entry.unique_id}", setup_entities
+    )
+    config_entry.async_on_unload(cb)
 
 
 class AppleTVKeyboardFocused(AppleTVEntity, BinarySensorEntity, KeyboardListener):

homeassistant/components/camera/strings.json

@@ -58,14 +58,14 @@
       "name": "Enable motion detection"
     },
     "play_stream": {
-      "description": "Plays the camera stream on a supported media player.",
+      "description": "Plays a camera stream on a supported media player.",
       "fields": {
         "format": {
           "description": "Stream format supported by the media player.",
           "name": "Format"
         },
         "media_player": {
-          "description": "Media players to stream to.",
+          "description": "Media player to stream to.",
           "name": "Media player"
         }
       },

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==1.12.0", "openai==2.15.0"],
+  "requirements": ["hass-nabucasa==1.13.0", "openai==2.15.0"],
   "single_config_entry": true
 }

homeassistant/components/cloudflare_r2/backup.py

@@ -196,44 +196,46 @@ class R2BackupAgent(BackupAgent):
         )
         upload_id = multipart_upload["UploadId"]
         try:
-            parts = []
+            parts: list[dict[str, Any]] = []
             part_number = 1
-            buffer_size = 0  # bytes
-            buffer: list[bytes] = []
+            buffer = bytearray()  # bytes buffer to store the data
 
             stream = await open_stream()
             async for chunk in stream:
-                buffer_size += len(chunk)
-                buffer.append(chunk)
+                buffer.extend(chunk)
+
+                # upload parts of exactly MULTIPART_MIN_PART_SIZE_BYTES to ensure
+                # all non-trailing parts have the same size (required by S3/R2)
+                while len(buffer) >= MULTIPART_MIN_PART_SIZE_BYTES:
+                    part_data = bytes(buffer[:MULTIPART_MIN_PART_SIZE_BYTES])
+                    del buffer[:MULTIPART_MIN_PART_SIZE_BYTES]
 
-                # If buffer size meets minimum part size, upload it as a part
-                if buffer_size >= MULTIPART_MIN_PART_SIZE_BYTES:
                     _LOGGER.debug(
-                        "Uploading part number %d, size %d", part_number, buffer_size
+                        "Uploading part number %d, size %d",
+                        part_number,
+                        len(part_data),
                     )
                     part = await self._client.upload_part(
                         Bucket=self._bucket,
                         Key=self._with_prefix(tar_filename),
                         PartNumber=part_number,
                         UploadId=upload_id,
-                        Body=b"".join(buffer),
+                        Body=part_data,
                     )
                     parts.append({"PartNumber": part_number, "ETag": part["ETag"]})
                     part_number += 1
-                    buffer_size = 0
-                    buffer = []
 
             # Upload the final buffer as the last part (no minimum size requirement)
             if buffer:
                 _LOGGER.debug(
-                    "Uploading final part number %d, size %d", part_number, buffer_size
+                    "Uploading final part number %d, size %d", part_number, len(buffer)
                 )
                 part = await self._client.upload_part(
                     Bucket=self._bucket,
                     Key=self._with_prefix(tar_filename),
                     PartNumber=part_number,
                     UploadId=upload_id,
-                    Body=b"".join(buffer),
+                    Body=bytes(buffer),
                 )
                 parts.append({"PartNumber": part_number, "ETag": part["ETag"]})
 

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.2.3"]
+  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.1.28"]
 }

homeassistant/components/demo/light.py

@@ -46,7 +46,6 @@ async def async_setup_entry(
     async_add_entities(
         [
             DemoLight(
-                available=True,
                 effect_list=LIGHT_EFFECT_LIST,
                 effect=LIGHT_EFFECT_LIST[0],
                 translation_key="bed_light",
@@ -55,21 +54,18 @@ async def async_setup_entry(
                 unique_id="light_1",
             ),
             DemoLight(
-                available=True,
                 ct=LIGHT_TEMPS[1],
                 device_name="Ceiling Lights",
                 state=True,
                 unique_id="light_2",
             ),
             DemoLight(
-                available=True,
                 hs_color=LIGHT_COLORS[1],
                 device_name="Kitchen Lights",
                 state=True,
                 unique_id="light_3",
             ),
             DemoLight(
-                available=True,
                 ct=LIGHT_TEMPS[1],
                 device_name="Office RGBW Lights",
                 rgbw_color=(255, 0, 0, 255),
@@ -78,7 +74,6 @@ async def async_setup_entry(
                 unique_id="light_4",
             ),
             DemoLight(
-                available=True,
                 device_name="Living Room RGBWW Lights",
                 rgbww_color=(255, 0, 0, 255, 0),
                 state=True,
@@ -86,7 +81,6 @@ async def async_setup_entry(
                 unique_id="light_5",
             ),
             DemoLight(
-                available=True,
                 device_name="Entrance Color + White Lights",
                 hs_color=LIGHT_COLORS[1],
                 state=True,
@@ -112,7 +106,6 @@ class DemoLight(LightEntity):
         unique_id: str,
         device_name: str,
         state: bool,
-        available: bool = False,
         brightness: int = 180,
         ct: int | None = None,
         effect_list: list[str] | None = None,
@@ -125,128 +118,72 @@ class DemoLight(LightEntity):
     ) -> None:
         """Initialize the light."""
         self._attr_translation_key = translation_key
-        self._available = True
-        self._brightness = brightness
-        self._ct = ct or random.choice(LIGHT_TEMPS)
-        self._effect = effect
-        self._effect_list = effect_list
-        self._hs_color = hs_color
-        self._rgbw_color = rgbw_color
-        self._rgbww_color = rgbww_color
-        self._state = state
-        self._unique_id = unique_id
+        self._attr_brightness = brightness
+        self._attr_color_temp_kelvin = ct or random.choice(LIGHT_TEMPS)
+        self._attr_effect = effect
+        self._attr_effect_list = effect_list
+        self._attr_hs_color = hs_color
+        self._attr_rgbw_color = rgbw_color
+        self._attr_rgbww_color = rgbww_color
+        self._attr_is_on = state
+        self._attr_unique_id = unique_id
         if hs_color:
-            self._color_mode = ColorMode.HS
+            self._attr_color_mode = ColorMode.HS
         elif rgbw_color:
-            self._color_mode = ColorMode.RGBW
+            self._attr_color_mode = ColorMode.RGBW
         elif rgbww_color:
-            self._color_mode = ColorMode.RGBWW
+            self._attr_color_mode = ColorMode.RGBWW
         else:
-            self._color_mode = ColorMode.COLOR_TEMP
+            self._attr_color_mode = ColorMode.COLOR_TEMP
         if not supported_color_modes:
             supported_color_modes = SUPPORT_DEMO
-        self._color_modes = supported_color_modes
-        if self._effect_list is not None:
+        self._attr_supported_color_modes = supported_color_modes
+        if self._attr_effect_list is not None:
             self._attr_supported_features |= LightEntityFeature.EFFECT
         self._attr_device_info = DeviceInfo(
             identifiers={
                 # Serial numbers are unique identifiers within a specific domain
-                (DOMAIN, self.unique_id)
+                (DOMAIN, unique_id)
             },
             name=device_name,
         )
 
-    @property
-    def unique_id(self) -> str:
-        """Return unique ID for light."""
-        return self._unique_id
-
     @property
     def available(self) -> bool:
         """Return availability."""
         # This demo light is always available, but well-behaving components
         # should implement this to inform Home Assistant accordingly.
-        return self._available
-
-    @property
-    def brightness(self) -> int:
-        """Return the brightness of this light between 0..255."""
-        return self._brightness
-
-    @property
-    def color_mode(self) -> ColorMode | None:
-        """Return the color mode of the light."""
-        return self._color_mode
-
-    @property
-    def hs_color(self) -> tuple[int, int] | None:
-        """Return the hs color value."""
-        return self._hs_color
-
-    @property
-    def rgbw_color(self) -> tuple[int, int, int, int] | None:
-        """Return the rgbw color value."""
-        return self._rgbw_color
-
-    @property
-    def rgbww_color(self) -> tuple[int, int, int, int, int] | None:
-        """Return the rgbww color value."""
-        return self._rgbww_color
-
-    @property
-    def color_temp_kelvin(self) -> int | None:
-        """Return the color temperature value in Kelvin."""
-        return self._ct
-
-    @property
-    def effect_list(self) -> list[str] | None:
-        """Return the list of supported effects."""
-        return self._effect_list
-
-    @property
-    def effect(self) -> str | None:
-        """Return the current effect."""
-        return self._effect
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if light is on."""
-        return self._state
-
-    @property
-    def supported_color_modes(self) -> set[ColorMode]:
-        """Flag supported color modes."""
-        return self._color_modes
+        return True
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the light on."""
-        self._state = True
+        self._attr_is_on = True
 
         if ATTR_BRIGHTNESS in kwargs:
-            self._brightness = kwargs[ATTR_BRIGHTNESS]
+            self._attr_brightness = kwargs[ATTR_BRIGHTNESS]
 
         if ATTR_COLOR_TEMP_KELVIN in kwargs:
-            self._color_mode = ColorMode.COLOR_TEMP
-            self._ct = kwargs[ATTR_COLOR_TEMP_KELVIN]
+            self._attr_color_mode = ColorMode.COLOR_TEMP
+            self._attr_color_temp_kelvin = kwargs[ATTR_COLOR_TEMP_KELVIN]
 
         if ATTR_EFFECT in kwargs:
-            self._effect = kwargs[ATTR_EFFECT]
+            self._attr_effect = kwargs[ATTR_EFFECT]
 
         if ATTR_HS_COLOR in kwargs:
-            self._color_mode = ColorMode.HS
-            self._hs_color = kwargs[ATTR_HS_COLOR]
+            self._attr_color_mode = ColorMode.HS
+            self._attr_hs_color = kwargs[ATTR_HS_COLOR]
 
         if ATTR_RGBW_COLOR in kwargs:
-            self._color_mode = ColorMode.RGBW
-            self._rgbw_color = kwargs[ATTR_RGBW_COLOR]
+            self._attr_color_mode = ColorMode.RGBW
+            self._attr_rgbw_color = kwargs[ATTR_RGBW_COLOR]
 
         if ATTR_RGBWW_COLOR in kwargs:
-            self._color_mode = ColorMode.RGBWW
-            self._rgbww_color = kwargs[ATTR_RGBWW_COLOR]
+            self._attr_color_mode = ColorMode.RGBWW
+            self._attr_rgbww_color = kwargs[ATTR_RGBWW_COLOR]
 
         if ATTR_WHITE in kwargs:
-            self._color_mode = ColorMode.WHITE
-            self._brightness = kwargs[ATTR_WHITE]
+            self._attr_color_mode = ColorMode.WHITE
+            self._attr_brightness = kwargs[ATTR_WHITE]
 
         # As we have disabled polling, we need to inform
         # Home Assistant about updates in our state ourselves.
@@ -254,7 +191,7 @@ class DemoLight(LightEntity):
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the light off."""
-        self._state = False
+        self._attr_is_on = False
 
         # As we have disabled polling, we need to inform
         # Home Assistant about updates in our state ourselves.

homeassistant/components/denonavr/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["denonavr"],
-  "requirements": ["denonavr==1.3.1"],
+  "requirements": ["denonavr==1.3.2"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/denonavr/media_player.py

@@ -17,6 +17,7 @@ from denonavr.const import (
     STATE_ON,
     STATE_PAUSED,
     STATE_PLAYING,
+    STATE_STOPPED,
 )
 from denonavr.exceptions import (
     AvrCommandError,
@@ -69,6 +70,7 @@ SUPPORT_MEDIA_MODES = (
     | MediaPlayerEntityFeature.NEXT_TRACK
     | MediaPlayerEntityFeature.VOLUME_SET
     | MediaPlayerEntityFeature.PLAY
+    | MediaPlayerEntityFeature.STOP
 )
 
 SCAN_INTERVAL = timedelta(seconds=10)
@@ -96,6 +98,7 @@ DENON_STATE_MAPPING = {
     STATE_OFF: MediaPlayerState.OFF,
     STATE_PLAYING: MediaPlayerState.PLAYING,
     STATE_PAUSED: MediaPlayerState.PAUSED,
+    STATE_STOPPED: MediaPlayerState.IDLE,
 }
 
 
@@ -404,6 +407,11 @@ class DenonDevice(MediaPlayerEntity):
         """Send pause command."""
         await self._receiver.async_pause()
 
+    @async_log_errors
+    async def async_media_stop(self) -> None:
+        """Send stop command."""
+        await self._receiver.async_stop()
+
     @async_log_errors
     async def async_media_previous_track(self) -> None:
         """Send previous track command."""

homeassistant/components/enphase_envoy/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["pyenphase"],
   "quality_scale": "platinum",
-  "requirements": ["pyenphase==2.4.3"],
+  "requirements": ["pyenphase==2.4.5"],
   "zeroconf": [
     {
       "type": "_enphase-envoy._tcp.local."

homeassistant/components/esphome/entry_data.py

@@ -29,7 +29,6 @@ from aioesphomeapi import (
     Event,
     EventInfo,
     FanInfo,
-    InfraredInfo,
     LightInfo,
     LockInfo,
     MediaPlayerInfo,
@@ -86,7 +85,6 @@ INFO_TYPE_TO_PLATFORM: dict[type[EntityInfo], Platform] = {
     DateTimeInfo: Platform.DATETIME,
     EventInfo: Platform.EVENT,
     FanInfo: Platform.FAN,
-    InfraredInfo: Platform.INFRARED,
     LightInfo: Platform.LIGHT,
     LockInfo: Platform.LOCK,
     MediaPlayerInfo: Platform.MEDIA_PLAYER,
@@ -522,27 +520,6 @@ class RuntimeEntryData:
             ),
         )
 
-    @callback
-    def async_on_infrared_proxy_receive(
-        self, hass: HomeAssistant, receive_event: Any
-    ) -> None:
-        """Handle an infrared proxy receive event."""
-        # Fire a Home Assistant event with the infrared data
-        device_info = self.device_info
-        if not device_info:
-            return
-
-        hass.bus.async_fire(
-            f"{DOMAIN}_infrared_proxy_received",
-            {
-                "device_name": device_info.name,
-                "device_mac": device_info.mac_address,
-                "entry_id": self.entry_id,
-                "key": receive_event.key,
-                "timings": receive_event.timings,
-            },
-        )
-
     @callback
     def async_register_assist_satellite_config_updated_callback(
         self,

homeassistant/components/esphome/infrared.py

@@ -1,100 +0,0 @@
-"""Infrared platform for ESPHome."""
-
-from __future__ import annotations
-
-import logging
-
-from aioesphomeapi import EntityInfo, EntityState, InfraredCapability, InfraredInfo
-
-from homeassistant.components.infrared import InfraredCommand, InfraredEntity
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import entity_platform
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import DOMAIN
-from .entity import EsphomeEntity, async_static_info_updated
-from .entry_data import ESPHomeConfigEntry
-
-_LOGGER = logging.getLogger(__name__)
-
-PARALLEL_UPDATES = 0
-
-
-class EsphomeInfraredEntity(EsphomeEntity[InfraredInfo, EntityState], InfraredEntity):
-    """ESPHome infrared entity using native API."""
-
-    _attr_has_entity_name = True
-    _attr_name = "Infrared Transmitter"
-
-    @callback
-    def _on_device_update(self) -> None:
-        """Call when device updates or entry data changes."""
-        super()._on_device_update()
-        if self._entry_data.available:
-            # Infrared entities should go available as soon as the device comes online
-            self.async_write_ha_state()
-
-    async def async_send_command(self, command: InfraredCommand) -> None:
-        """Send an IR command.
-
-        Raises:
-            HomeAssistantError: If transmission fails.
-        """
-        timings = [
-            interval
-            for timing in command.get_raw_timings()
-            for interval in (timing.high_us, -timing.low_us)
-        ]
-        _LOGGER.debug("Sending command: %s", timings)
-
-        try:
-            self._client.infrared_rf_transmit_raw_timings(
-                self._static_info.key,
-                carrier_frequency=command.modulation,
-                timings=timings,
-            )
-        except Exception as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="error_sending_ir_command",
-                translation_placeholders={
-                    "device_name": self._device_info.name,
-                    "error": str(err),
-                },
-            ) from err
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ESPHomeConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up ESPHome infrared entities, filtering out receiver-only devices."""
-    entry_data = entry.runtime_data
-    entry_data.info[InfraredInfo] = {}
-    platform = entity_platform.async_get_current_platform()
-
-    def filtered_static_info_update(infos: list[EntityInfo]) -> None:
-        transmitter_infos: list[EntityInfo] = [
-            info
-            for info in infos
-            if isinstance(info, InfraredInfo)
-            and info.capabilities & InfraredCapability.TRANSMITTER
-        ]
-        async_static_info_updated(
-            hass,
-            entry_data,
-            platform,
-            async_add_entities,
-            InfraredInfo,
-            EsphomeInfraredEntity,
-            EntityState,
-            transmitter_infos,
-        )
-
-    entry_data.cleanup_callbacks.append(
-        entry_data.async_register_static_info_callback(
-            InfraredInfo, filtered_static_info_update
-        )
-    )

homeassistant/components/esphome/light.py

@@ -299,7 +299,6 @@ class EsphomeLight(EsphomeEntity[LightInfo, LightState], LightEntity):
         return round(self._state.brightness * 255)
 
     @property
-    @esphome_state_property
     def color_mode(self) -> ColorMode:
         """Return the color mode of the light."""
         if not self._supports_color_mode:

homeassistant/components/esphome/manager.py

@@ -17,8 +17,6 @@ from aioesphomeapi import (
     EncryptionPlaintextAPIError,
     ExecuteServiceResponse,
     HomeassistantServiceCall,
-    InfraredCapability,
-    InfraredInfo,
     InvalidAuthAPIError,
     InvalidEncryptionKeyAPIError,
     LogLevel,
@@ -694,15 +692,6 @@ class ESPHomeManager:
                 cli.subscribe_zwave_proxy_request(self._async_zwave_proxy_request)
             )
 
-        if any(
-            isinstance(info, InfraredInfo)
-            and info.capabilities & InfraredCapability.RECEIVER
-            for info in entity_infos
-        ):
-            entry_data.disconnect_callbacks.add(
-                cli.subscribe_infrared_rf_receive(self._async_infrared_proxy_receive)
-            )
-
         cli.subscribe_home_assistant_states_and_services(
             on_state=entry_data.async_update_state,
             on_service_call=self.async_on_service_call,
@@ -733,10 +722,6 @@ class ESPHomeManager:
             self.hass, self.entry_data.device_info, zwave_home_id
         )
 
-    def _async_infrared_proxy_receive(self, receive_event: Any) -> None:
-        """Handle an infrared proxy receive event."""
-        self.entry_data.async_on_infrared_proxy_receive(self.hass, receive_event)
-
     async def on_disconnect(self, expected_disconnect: bool) -> None:
         """Run disconnect callbacks on API disconnect."""
         entry_data = self.entry_data

homeassistant/components/esphome/strings.json

@@ -137,9 +137,6 @@
     "error_compiling": {
       "message": "Error compiling {configuration}. Try again in ESPHome dashboard for more information."
     },
-    "error_sending_ir_command": {
-      "message": "Error sending IR command to {device_name}: {error}"
-    },
     "error_uploading": {
       "message": "Error during OTA (Over-The-Air) update of {configuration}. Try again in ESPHome dashboard for more information."
     },

homeassistant/components/evohome/entity.py

@@ -181,7 +181,7 @@ class EvoChild(EvoEntity):
 
         self._device_state_attrs = {
             "activeFaults": self._evo_device.active_faults,
-            "setpoints": self._setpoints,
+            "setpoints": self.setpoints,
         }
 
         super()._handle_coordinator_update()

homeassistant/components/evohome/manifest.json

@@ -4,7 +4,7 @@
   "codeowners": ["@zxdavb"],
   "documentation": "https://www.home-assistant.io/integrations/evohome",
   "iot_class": "cloud_polling",
-  "loggers": ["evohome", "evohomeasync", "evohomeasync2"],
+  "loggers": ["evohomeasync", "evohomeasync2"],
   "quality_scale": "legacy",
-  "requirements": ["evohome-async==1.0.6"]
+  "requirements": ["evohome-async==1.1.3"]
 }

homeassistant/components/fressnapf_tracker/__init__.py

@@ -1,11 +1,22 @@
 """The Fressnapf Tracker integration."""
 
-from fressnapftracker import AuthClient, FressnapfTrackerAuthenticationError
+import logging
+
+from fressnapftracker import (
+    ApiClient,
+    AuthClient,
+    Device,
+    FressnapfTrackerAuthenticationError,
+    FressnapfTrackerError,
+    FressnapfTrackerInvalidTrackerResponseError,
+    Tracker,
+)
 
 from homeassistant.const import CONF_ACCESS_TOKEN, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.httpx_client import get_async_client
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 
 from .const import CONF_USER_ID, DOMAIN
 from .coordinator import (
@@ -21,6 +32,43 @@ PLATFORMS: list[Platform] = [
     Platform.SWITCH,
 ]
 
+_LOGGER = logging.getLogger(__name__)
+
+
+async def _get_valid_tracker(hass: HomeAssistant, device: Device) -> Tracker | None:
+    """Test if the tracker returns valid data and return it.
+
+    Malformed data might indicate the tracker is broken or hasn't been properly registered with the app.
+    """
+    client = ApiClient(
+        serial_number=device.serialnumber,
+        device_token=device.token,
+        client=get_async_client(hass),
+    )
+    try:
+        return await client.get_tracker()
+    except FressnapfTrackerInvalidTrackerResponseError:
+        _LOGGER.warning(
+            "Tracker with serialnumber %s is invalid. Consider removing it via the App",
+            device.serialnumber,
+        )
+        async_create_issue(
+            hass,
+            DOMAIN,
+            f"invalid_fressnapf_tracker_{device.serialnumber}",
+            issue_domain=DOMAIN,
+            learn_more_url="https://www.home-assistant.io/integrations/fressnapf_tracker/",
+            is_fixable=False,
+            severity=IssueSeverity.WARNING,
+            translation_key="invalid_fressnapf_tracker",
+            translation_placeholders={
+                "tracker_id": device.serialnumber,
+            },
+        )
+        return None
+    except FressnapfTrackerError as err:
+        raise ConfigEntryNotReady(err) from err
+
 
 async def async_setup_entry(
     hass: HomeAssistant, entry: FressnapfTrackerConfigEntry
@@ -40,12 +88,15 @@ async def async_setup_entry(
 
     coordinators: list[FressnapfTrackerDataUpdateCoordinator] = []
     for device in devices:
+        tracker = await _get_valid_tracker(hass, device)
+        if tracker is None:
+            continue
         coordinator = FressnapfTrackerDataUpdateCoordinator(
             hass,
             entry,
             device,
+            initial_data=tracker,
         )
-        await coordinator.async_config_entry_first_refresh()
         coordinators.append(coordinator)
 
     entry.runtime_data = coordinators

homeassistant/components/fressnapf_tracker/coordinator.py

@@ -34,6 +34,7 @@ class FressnapfTrackerDataUpdateCoordinator(DataUpdateCoordinator[Tracker]):
         hass: HomeAssistant,
         config_entry: FressnapfTrackerConfigEntry,
         device: Device,
+        initial_data: Tracker,
     ) -> None:
         """Initialize."""
         super().__init__(
@@ -49,6 +50,7 @@ class FressnapfTrackerDataUpdateCoordinator(DataUpdateCoordinator[Tracker]):
             device_token=device.token,
             client=get_async_client(hass),
         )
+        self.data = initial_data
 
     async def _async_update_data(self) -> Tracker:
         try:

homeassistant/components/fressnapf_tracker/strings.json

@@ -92,5 +92,11 @@
     "not_seen_recently": {
       "message": "The flashlight cannot be activated when the tracker has not moved recently."
     }
+  },
+  "issues": {
+    "invalid_fressnapf_tracker": {
+      "description": "The Fressnapf GPS tracker with the serial number `{tracker_id}` is sending invalid data. This most likely indicates the tracker is broken or hasn't been properly registered with the app. Please remove the tracker via the Fressnapf app. You can then close this issue.",
+      "title": "Invalid Fressnapf GPS tracker detected"
+    }
   }
 }

homeassistant/components/google_air_quality/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["google_air_quality_api"],
   "quality_scale": "bronze",
-  "requirements": ["google_air_quality_api==3.0.0"]
+  "requirements": ["google_air_quality_api==3.0.1"]
 }

homeassistant/components/group/config_flow.py

@@ -39,6 +39,7 @@ from .valve import async_create_preview_valve
 
 _STATISTIC_MEASURES = [
     "last",
+    "first_available",
     "max",
     "mean",
     "median",

homeassistant/components/group/sensor.py

@@ -68,6 +68,8 @@ ATTR_MEAN = "mean"
 ATTR_MEDIAN = "median"
 ATTR_LAST = "last"
 ATTR_LAST_ENTITY_ID = "last_entity_id"
+ATTR_FIRST_AVAILABLE = "first_available"
+ATTR_FIRST_AVAILABLE_ENTITY_ID = "first_available_entity_id"
 ATTR_RANGE = "range"
 ATTR_STDEV = "stdev"
 ATTR_SUM = "sum"
@@ -78,6 +80,7 @@ SENSOR_TYPES = {
     ATTR_MEAN: "mean",
     ATTR_MEDIAN: "median",
     ATTR_LAST: "last",
+    ATTR_FIRST_AVAILABLE: "first_available",
     ATTR_RANGE: "range",
     ATTR_STDEV: "stdev",
     ATTR_SUM: "sum",
@@ -255,6 +258,19 @@ def calc_last(
     return attributes, last
 
 
+def calc_first_available(
+    sensor_values: list[tuple[str, float, State]],
+) -> tuple[dict[str, str | None], float | None]:
+    """Calculate first available value."""
+    first_available_entity_id: str | None = None
+    first_available: float | None = None
+    if sensor_values:
+        first_available_entity_id, first_available, _ = sensor_values[0]
+
+    attributes = {ATTR_FIRST_AVAILABLE_ENTITY_ID: first_available_entity_id}
+    return attributes, first_available
+
+
 def calc_range(
     sensor_values: list[tuple[str, float, State]],
 ) -> tuple[dict[str, str | None], float]:
@@ -309,6 +325,7 @@ CALC_TYPES: dict[
     "mean": calc_mean,
     "median": calc_median,
     "last": calc_last,
+    "first_available": calc_first_available,
     "range": calc_range,
     "stdev": calc_stdev,
     "sum": calc_sum,

homeassistant/components/group/strings.json

@@ -280,6 +280,7 @@
   "selector": {
     "type": {
       "options": {
+        "first_available": "First available",
         "last": "Most recently updated",
         "max": "Maximum",
         "mean": "Arithmetic mean",

homeassistant/components/infrared/__init__.py

@@ -1,156 +0,0 @@
-"""Provides functionality to interact with infrared devices."""
-
-from __future__ import annotations
-
-from abc import abstractmethod
-from datetime import datetime, timedelta
-import logging
-from typing import final
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import Context, HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv, entity_registry as er
-from homeassistant.helpers.entity import EntityDescription
-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.restore_state import RestoreEntity
-from homeassistant.helpers.typing import ConfigType
-from homeassistant.util import dt as dt_util
-from homeassistant.util.hass_dict import HassKey
-
-from .const import DOMAIN
-from .protocols import InfraredCommand, NECInfraredCommand, Timing
-
-__all__ = [
-    "DOMAIN",
-    "InfraredCommand",
-    "InfraredEntity",
-    "InfraredEntityDescription",
-    "NECInfraredCommand",
-    "Timing",
-    "async_get_emitters",
-    "async_send_command",
-]
-
-_LOGGER = logging.getLogger(__name__)
-
-DATA_COMPONENT: HassKey[EntityComponent[InfraredEntity]] = HassKey(DOMAIN)
-ENTITY_ID_FORMAT = DOMAIN + ".{}"
-PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA
-PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE
-SCAN_INTERVAL = timedelta(seconds=30)
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the infrared domain."""
-    component = hass.data[DATA_COMPONENT] = EntityComponent[InfraredEntity](
-        _LOGGER, DOMAIN, hass, SCAN_INTERVAL
-    )
-    await component.async_setup(config)
-
-    return True
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up a config entry."""
-    return await hass.data[DATA_COMPONENT].async_setup_entry(entry)
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
-
-
-@callback
-def async_get_emitters(hass: HomeAssistant) -> list[InfraredEntity]:
-    """Get all infrared emitters."""
-    component = hass.data.get(DATA_COMPONENT)
-    if component is None:
-        return []
-
-    return list(component.entities)
-
-
-async def async_send_command(
-    hass: HomeAssistant,
-    entity_uuid: str,
-    command: InfraredCommand,
-    context: Context | None = None,
-) -> None:
-    """Send an IR command to the specified infrared entity.
-
-    Raises:
-        HomeAssistantError: If the infrared entity is not found.
-    """
-    component = hass.data.get(DATA_COMPONENT)
-    if component is None:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="component_not_loaded",
-        )
-
-    ent_reg = er.async_get(hass)
-    entity_id = er.async_validate_entity_id(ent_reg, entity_uuid)
-    entity = component.get_entity(entity_id)
-    if entity is None:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="entity_not_found",
-            translation_placeholders={"entity_id": entity_id},
-        )
-
-    if context is not None:
-        entity.async_set_context(context)
-
-    await entity.async_send_command_internal(command)
-
-
-class InfraredEntityDescription(EntityDescription, frozen_or_thawed=True):
-    """Describes infrared entities."""
-
-
-class InfraredEntity(RestoreEntity):
-    """Base class for infrared transmitter entities."""
-
-    entity_description: InfraredEntityDescription
-    _attr_should_poll = False
-    _attr_state: None
-
-    __last_command_sent: datetime | None = None
-
-    @property
-    @final
-    def state(self) -> str | None:
-        """Return the entity state."""
-        if (last_command := self.__last_command_sent) is None:
-            return None
-        return last_command.isoformat(timespec="milliseconds")
-
-    @final
-    async def async_send_command_internal(self, command: InfraredCommand) -> None:
-        """Send an IR command and update state.
-
-        Should not be overridden, handles setting last sent timestamp.
-        """
-        await self.async_send_command(command)
-        self.__last_command_sent = dt_util.utcnow()
-        self.async_write_ha_state()
-
-    @final
-    async def async_internal_added_to_hass(self) -> None:
-        """Call when the infrared entity is added to hass."""
-        await super().async_internal_added_to_hass()
-        state = await self.async_get_last_state()
-        if state is not None and state.state is not None:
-            self.__last_command_sent = dt_util.parse_datetime(state.state)
-
-    @abstractmethod
-    async def async_send_command(self, command: InfraredCommand) -> None:
-        """Send an IR command.
-
-        Args:
-            command: The IR command to send.
-
-        Raises:
-            HomeAssistantError: If transmission fails.
-        """

homeassistant/components/infrared/const.py

@@ -1,5 +0,0 @@
-"""Constants for the Infrared integration."""
-
-from typing import Final
-
-DOMAIN: Final = "infrared"

homeassistant/components/infrared/icons.json

@@ -1,7 +0,0 @@
-{
-  "entity_component": {
-    "_": {
-      "default": "mdi:led-on"
-    }
-  }
-}

homeassistant/components/infrared/manifest.json

@@ -1,8 +0,0 @@
-{
-  "domain": "infrared",
-  "name": "Infrared",
-  "codeowners": ["@home-assistant/core"],
-  "documentation": "https://www.home-assistant.io/integrations/infrared",
-  "integration_type": "entity",
-  "quality_scale": "internal"
-}

homeassistant/components/infrared/protocols.py

@@ -1,119 +0,0 @@
-"""IR protocol definitions for the Infrared integration."""
-
-import abc
-from dataclasses import dataclass
-from typing import override
-
-
-@dataclass(frozen=True, slots=True)
-class Timing:
-    """High/low signal timing."""
-
-    high_us: int
-    low_us: int
-
-
-class InfraredCommand(abc.ABC):
-    """Base class for IR commands."""
-
-    repeat_count: int
-    modulation: int
-
-    def __init__(self, *, modulation: int, repeat_count: int = 0) -> None:
-        """Initialize the IR command."""
-        self.modulation = modulation
-        self.repeat_count = repeat_count
-
-    @abc.abstractmethod
-    def get_raw_timings(self) -> list[Timing]:
-        """Get raw timings for the command."""
-
-
-class NECInfraredCommand(InfraredCommand):
-    """NEC IR command."""
-
-    address: int
-    command: int
-
-    def __init__(
-        self, *, address: int, command: int, modulation: int, repeat_count: int = 0
-    ) -> None:
-        """Initialize the NEC IR command."""
-        super().__init__(modulation=modulation, repeat_count=repeat_count)
-        self.address = address
-        self.command = command
-
-    @override
-    def get_raw_timings(self) -> list[Timing]:
-        """Get raw timings for the NEC command.
-
-        NEC protocol timing (in microseconds):
-        - Leader pulse: 9000µs high, 4500µs low
-        - Logical '0': 562µs high, 562µs low
-        - Logical '1': 562µs high, 1687µs low
-        - End pulse: 562µs high
-        - Repeat code: 9000µs high, 2250µs low, 562µs end pulse
-        - Frame gap: ~96ms between end pulse and next frame (total frame ~108ms)
-
-        Data format (32 bits, LSB first):
-        - Standard NEC: address (8-bit) + ~address (8-bit) + command (8-bit) + ~command (8-bit)
-        - Extended NEC: address_low (8-bit) + address_high (8-bit) + command (8-bit) + ~command (8-bit)
-        """
-        # NEC timing constants (microseconds)
-        leader_high = 9000
-        leader_low = 4500
-        bit_high = 562
-        zero_low = 562
-        one_low = 1687
-        repeat_low = 2250
-        frame_gap = 96000  # Gap to make total frame ~108ms
-
-        timings: list[Timing] = [Timing(high_us=leader_high, low_us=leader_low)]
-
-        # Determine if standard (8-bit) or extended (16-bit) address
-        if self.address <= 0xFF:
-            # Standard NEC: address + inverted address
-            address_low = self.address & 0xFF
-            address_high = (~self.address) & 0xFF
-        else:
-            # Extended NEC: 16-bit address (no inversion)
-            address_low = self.address & 0xFF
-            address_high = (self.address >> 8) & 0xFF
-
-        command_byte = self.command & 0xFF
-        command_inverted = (~self.command) & 0xFF
-
-        # Build 32-bit command data (LSB first in transmission)
-        data = (
-            address_low
-            | (address_high << 8)
-            | (command_byte << 16)
-            | (command_inverted << 24)
-        )
-
-        for _ in range(32):
-            bit = data & 1
-            if bit:
-                timings.append(Timing(high_us=bit_high, low_us=one_low))
-            else:
-                timings.append(Timing(high_us=bit_high, low_us=zero_low))
-            data >>= 1
-
-        # End pulse
-        timings.append(Timing(high_us=bit_high, low_us=0))
-
-        # Add repeat codes if requested
-        for _ in range(self.repeat_count):
-            # Replace the last timing's low_us with the frame gap
-            last_timing = timings[-1]
-            timings[-1] = Timing(high_us=last_timing.high_us, low_us=frame_gap)
-
-            # Repeat code: leader burst + shorter space + end pulse
-            timings.extend(
-                [
-                    Timing(high_us=leader_high, low_us=repeat_low),
-                    Timing(high_us=bit_high, low_us=0),
-                ]
-            )
-
-        return timings

homeassistant/components/infrared/strings.json

@@ -1,10 +0,0 @@
-{
-  "exceptions": {
-    "component_not_loaded": {
-      "message": "Infrared component not loaded"
-    },
-    "entity_not_found": {
-      "message": "Infrared entity `{entity_id}` not found"
-    }
-  }
-}

homeassistant/components/lcn/manifest.json

@@ -10,5 +10,5 @@
   "iot_class": "local_polling",
   "loggers": ["pypck"],
   "quality_scale": "silver",
-  "requirements": ["pypck==0.9.9", "lcn-frontend==0.2.7"]
+  "requirements": ["pypck==0.9.10", "lcn-frontend==0.2.7"]
 }

homeassistant/components/liebherr/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["pyliebherrhomeapi"],
-  "quality_scale": "bronze",
+  "quality_scale": "silver",
   "requirements": ["pyliebherrhomeapi==0.2.1"],
   "zeroconf": [
     {

homeassistant/components/liebherr/quality_scale.yaml

@@ -34,7 +34,7 @@ rules:
   docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
-  log-when-unavailable: todo
+  log-when-unavailable: done
   parallel-updates: done
   reauthentication-flow: done
   test-coverage: done

homeassistant/components/light/__init__.py

@@ -5,10 +5,9 @@ from __future__ import annotations
 from collections.abc import Iterable
 import csv
 import dataclasses
-from functools import partial
 import logging
 import os
-from typing import TYPE_CHECKING, Any, Final, Self, cast, final
+from typing import TYPE_CHECKING, Any, Self, cast, final
 
 from propcache.api import cached_property
 import voluptuous as vol
@@ -23,13 +22,6 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, entity_registry as er
-from homeassistant.helpers.deprecation import (
-    DeprecatedConstant,
-    DeprecatedConstantEnum,
-    all_with_deprecated_constants,
-    check_if_deprecated_constant,
-    dir_with_deprecated_constants,
-)
 from homeassistant.helpers.entity import ToggleEntity, ToggleEntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.frame import ReportBehavior, report_usage
@@ -56,27 +48,6 @@ PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA
 PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE
 
 
-# These SUPPORT_* constants are deprecated as of Home Assistant 2022.5.
-# Please use the LightEntityFeature enum instead.
-_DEPRECATED_SUPPORT_BRIGHTNESS: Final = DeprecatedConstant(
-    1, "supported_color_modes", "2026.1"
-)  # Deprecated, replaced by color modes
-_DEPRECATED_SUPPORT_COLOR_TEMP: Final = DeprecatedConstant(
-    2, "supported_color_modes", "2026.1"
-)  # Deprecated, replaced by color modes
-_DEPRECATED_SUPPORT_EFFECT: Final = DeprecatedConstantEnum(
-    LightEntityFeature.EFFECT, "2026.1"
-)
-_DEPRECATED_SUPPORT_FLASH: Final = DeprecatedConstantEnum(
-    LightEntityFeature.FLASH, "2026.1"
-)
-_DEPRECATED_SUPPORT_COLOR: Final = DeprecatedConstant(
-    16, "supported_color_modes", "2026.1"
-)  # Deprecated, replaced by color modes
-_DEPRECATED_SUPPORT_TRANSITION: Final = DeprecatedConstantEnum(
-    LightEntityFeature.TRANSITION, "2026.1"
-)
-
 # Color mode of the light
 ATTR_COLOR_MODE = "color_mode"
 # List of color modes supported by the light
@@ -291,7 +262,7 @@ def filter_turn_off_params(
     if not params:
         return params
 
-    supported_features = light.supported_features_compat
+    supported_features = light.supported_features
 
     if LightEntityFeature.FLASH not in supported_features:
         params.pop(ATTR_FLASH, None)
@@ -303,7 +274,7 @@ def filter_turn_off_params(
 
 def filter_turn_on_params(light: LightEntity, params: dict[str, Any]) -> dict[str, Any]:
     """Filter out params not supported by the light."""
-    supported_features = light.supported_features_compat
+    supported_features = light.supported_features
 
     if LightEntityFeature.EFFECT not in supported_features:
         params.pop(ATTR_EFFECT, None)
@@ -956,7 +927,7 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     def capability_attributes(self) -> dict[str, Any]:
         """Return capability attributes."""
         data: dict[str, Any] = {}
-        supported_features = self.supported_features_compat
+        supported_features = self.supported_features
         supported_color_modes = self._light_internal_supported_color_modes
 
         if ColorMode.COLOR_TEMP in supported_color_modes:
@@ -1106,12 +1077,12 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     def state_attributes(self) -> dict[str, Any] | None:
         """Return state attributes."""
         data: dict[str, Any] = {}
-        supported_features = self.supported_features_compat
+        supported_features = self.supported_features
         supported_color_modes = self.supported_color_modes
         legacy_supported_color_modes = (
             supported_color_modes or self._light_internal_supported_color_modes
         )
-        supported_features_value = supported_features.value
+
         _is_on = self.is_on
         color_mode = self._light_internal_color_mode if _is_on else None
 
@@ -1130,26 +1101,12 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
                 data[ATTR_BRIGHTNESS] = self.brightness
             else:
                 data[ATTR_BRIGHTNESS] = None
-        elif supported_features_value & _DEPRECATED_SUPPORT_BRIGHTNESS.value:
-            # Backwards compatibility for ambiguous / incomplete states
-            # Warning is printed by supported_features_compat, remove in 2025.1
-            if _is_on:
-                data[ATTR_BRIGHTNESS] = self.brightness
-            else:
-                data[ATTR_BRIGHTNESS] = None
 
         if color_temp_supported(supported_color_modes):
             if color_mode == ColorMode.COLOR_TEMP:
                 data[ATTR_COLOR_TEMP_KELVIN] = self.color_temp_kelvin
             else:
                 data[ATTR_COLOR_TEMP_KELVIN] = None
-        elif supported_features_value & _DEPRECATED_SUPPORT_COLOR_TEMP.value:
-            # Backwards compatibility
-            # Warning is printed by supported_features_compat, remove in 2025.1
-            if _is_on:
-                data[ATTR_COLOR_TEMP_KELVIN] = self.color_temp_kelvin
-            else:
-                data[ATTR_COLOR_TEMP_KELVIN] = None
 
         if color_supported(legacy_supported_color_modes) or color_temp_supported(
             legacy_supported_color_modes
@@ -1187,24 +1144,8 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
                 type(self),
                 report_issue,
             )
-        supported_features = self.supported_features_compat
-        supported_features_value = supported_features.value
-        supported_color_modes: set[ColorMode] = set()
 
-        if supported_features_value & _DEPRECATED_SUPPORT_COLOR_TEMP.value:
-            supported_color_modes.add(ColorMode.COLOR_TEMP)
-        if supported_features_value & _DEPRECATED_SUPPORT_COLOR.value:
-            supported_color_modes.add(ColorMode.HS)
-        if (
-            not supported_color_modes
-            and supported_features_value & _DEPRECATED_SUPPORT_BRIGHTNESS.value
-        ):
-            supported_color_modes = {ColorMode.BRIGHTNESS}
-
-        if not supported_color_modes:
-            supported_color_modes = {ColorMode.ONOFF}
-
-        return supported_color_modes
+        return {ColorMode.ONOFF}
 
     @cached_property
     def supported_color_modes(self) -> set[ColorMode] | None:
@@ -1216,48 +1157,9 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         """Flag supported features."""
         return self._attr_supported_features
 
-    @property
-    def supported_features_compat(self) -> LightEntityFeature:
-        """Return the supported features as LightEntityFeature.
-
-        Remove this compatibility shim in 2025.1 or later.
-        """
-        features = self.supported_features
-        if type(features) is not int:
-            return features
-        new_features = LightEntityFeature(features)
-        if self._deprecated_supported_features_reported is True:
-            return new_features
-        self._deprecated_supported_features_reported = True
-        report_issue = self._suggest_report_issue()
-        report_issue += (
-            " and reference "
-            "https://developers.home-assistant.io/blog/2023/12/28/support-feature-magic-numbers-deprecation"
-        )
-        _LOGGER.warning(
-            (
-                "Entity %s (%s) is using deprecated supported features"
-                " values which will be removed in HA Core 2025.1. Instead it should use"
-                " %s and color modes, please %s"
-            ),
-            self.entity_id,
-            type(self),
-            repr(new_features),
-            report_issue,
-        )
-        return new_features
-
     def __should_report_light_issue(self) -> bool:
         """Return if light color mode issues should be reported."""
         if not self.platform:
             return True
         # philips_js has known issues, we don't need users to open issues
         return self.platform.platform_name not in {"philips_js"}
-
-
-# These can be removed if no deprecated constant are in this module anymore
-__getattr__ = partial(check_if_deprecated_constant, module_globals=globals())
-__dir__ = partial(
-    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
-)
-__all__ = all_with_deprecated_constants(globals())

homeassistant/components/mqtt/light/schema_json.py

@@ -221,8 +221,10 @@ class MqttLightJson(MqttEntity, LightEntity, RestoreEntity):
             # Brightness is supported and no supported_color_modes are set,
             # so set brightness as the supported color mode.
             self._attr_supported_color_modes = {ColorMode.BRIGHTNESS}
+            self._attr_color_mode = ColorMode.BRIGHTNESS
         else:
             self._attr_supported_color_modes = {ColorMode.ONOFF}
+            self._attr_color_mode = ColorMode.ONOFF
 
     def _update_color(self, values: dict[str, Any]) -> None:
         color_mode: str = values["color_mode"]

homeassistant/components/mqtt/light/schema_template.py

@@ -274,6 +274,7 @@ class MqttLightTemplate(MqttEntity, LightEntity, RestoreEntity):
                         if color_temp_value != "None"
                         else None
                     )
+                    self._update_color_mode()
                 except ValueError:
                     _LOGGER.warning(
                         "Invalid color temperature value '%s' received from %s",

homeassistant/components/nanoleaf/light.py

@@ -85,7 +85,7 @@ class NanoleafLight(NanoleafEntity, LightEntity):
         return self._nanoleaf.hue, self._nanoleaf.saturation
 
     @property
-    def color_mode(self) -> ColorMode | None:
+    def color_mode(self) -> ColorMode:
         """Return the color mode of the light."""
         # According to API docs, color mode is "ct", "effect" or "hs"
         # https://forum.nanoleaf.me/docs/openapi#_4qgqrz96f44d

homeassistant/components/redgtech/__init__.py

@@ -0,0 +1,35 @@
+"""Initialize the Redgtech integration for Home Assistant."""
+
+from __future__ import annotations
+
+import logging
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import RedgtechConfigEntry, RedgtechDataUpdateCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+
+
+PLATFORMS = [Platform.SWITCH]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: RedgtechConfigEntry) -> bool:
+    """Set up Redgtech from a config entry."""
+    _LOGGER.debug("Setting up Redgtech entry: %s", entry.entry_id)
+    coordinator = RedgtechDataUpdateCoordinator(hass, entry)
+
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    _LOGGER.debug("Successfully set up Redgtech entry: %s", entry.entry_id)
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: RedgtechConfigEntry) -> bool:
+    """Unload a config entry."""
+    _LOGGER.debug("Unloading Redgtech entry: %s", entry.entry_id)
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/redgtech/config_flow.py

@@ -0,0 +1,67 @@
+"""Config flow for the Redgtech integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from redgtech_api.api import RedgtechAPI, RedgtechAuthError, RedgtechConnectionError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
+
+from .const import DOMAIN, INTEGRATION_NAME
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class RedgtechConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Config Flow for Redgtech integration."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial user step for login."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            email = user_input[CONF_EMAIL]
+            password = user_input[CONF_PASSWORD]
+
+            self._async_abort_entries_match({CONF_EMAIL: user_input[CONF_EMAIL]})
+
+            api = RedgtechAPI()
+            try:
+                await api.login(email, password)
+            except RedgtechAuthError:
+                errors["base"] = "invalid_auth"
+            except RedgtechConnectionError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected error during login")
+                errors["base"] = "unknown"
+            else:
+                _LOGGER.debug("Login successful, token received")
+                return self.async_create_entry(
+                    title=email,
+                    data={
+                        CONF_EMAIL: email,
+                        CONF_PASSWORD: password,
+                    },
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                vol.Schema(
+                    {
+                        vol.Required(CONF_EMAIL): str,
+                        vol.Required(CONF_PASSWORD): str,
+                    }
+                ),
+                user_input,
+            ),
+            errors=errors,
+            description_placeholders={"integration_name": INTEGRATION_NAME},
+        )

homeassistant/components/redgtech/const.py

@@ -0,0 +1,4 @@
+"""Constants for the Redgtech integration."""
+
+DOMAIN = "redgtech"
+INTEGRATION_NAME = "Redgtech"

homeassistant/components/redgtech/coordinator.py

@@ -0,0 +1,130 @@
+"""Coordinator for Redgtech integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+from typing import Any
+
+from redgtech_api.api import RedgtechAPI, RedgtechAuthError, RedgtechConnectionError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+UPDATE_INTERVAL = timedelta(seconds=15)
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class RedgtechDevice:
+    """Representation of a Redgtech device."""
+
+    unique_id: str
+    name: str
+    state: bool
+
+
+type RedgtechConfigEntry = ConfigEntry[RedgtechDataUpdateCoordinator]
+
+
+class RedgtechDataUpdateCoordinator(DataUpdateCoordinator[dict[str, RedgtechDevice]]):
+    """Coordinator to manage fetching data from the Redgtech API.
+
+    Uses a dictionary keyed by unique_id for O(1) device lookup instead of O(n) list iteration.
+    """
+
+    config_entry: RedgtechConfigEntry
+
+    def __init__(self, hass: HomeAssistant, config_entry: RedgtechConfigEntry) -> None:
+        """Initialize the coordinator."""
+        self.api = RedgtechAPI()
+        self.access_token: str | None = None
+        self.email = config_entry.data[CONF_EMAIL]
+        self.password = config_entry.data[CONF_PASSWORD]
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_interval=UPDATE_INTERVAL,
+            config_entry=config_entry,
+        )
+
+    async def login(self, email: str, password: str) -> str | None:
+        """Login to the Redgtech API and return the access token."""
+        try:
+            self.access_token = await self.api.login(email, password)
+        except RedgtechAuthError as e:
+            raise ConfigEntryError("Authentication error during login") from e
+        except RedgtechConnectionError as e:
+            raise UpdateFailed("Connection error during login") from e
+        else:
+            _LOGGER.debug("Access token obtained successfully")
+            return self.access_token
+
+    async def renew_token(self, email: str, password: str) -> None:
+        """Renew the access token."""
+        self.access_token = await self.api.login(email, password)
+        _LOGGER.debug("Access token renewed successfully")
+
+    async def call_api_with_valid_token[_R, *_Ts](
+        self, api_call: Callable[[*_Ts], Coroutine[Any, Any, _R]], *args: *_Ts
+    ) -> _R:
+        """Make an API call with a valid token.
+
+        Ensure we have a valid access token, renewing it if necessary.
+        """
+        if not self.access_token:
+            _LOGGER.debug("No access token, logging in")
+            self.access_token = await self.login(self.email, self.password)
+        else:
+            _LOGGER.debug("Using existing access token")
+        try:
+            return await api_call(*args)
+        except RedgtechAuthError:
+            _LOGGER.debug("Auth failed, trying to renew token")
+            await self.renew_token(
+                self.config_entry.data[CONF_EMAIL],
+                self.config_entry.data[CONF_PASSWORD],
+            )
+            return await api_call(*args)
+
+    async def _async_update_data(self) -> dict[str, RedgtechDevice]:
+        """Fetch data from the API on demand.
+
+        Returns a dictionary keyed by unique_id for efficient device lookup.
+        """
+        _LOGGER.debug("Fetching data from Redgtech API on demand")
+        try:
+            data = await self.call_api_with_valid_token(
+                self.api.get_data, self.access_token
+            )
+        except RedgtechAuthError as e:
+            raise ConfigEntryError("Authentication failed") from e
+        except RedgtechConnectionError as e:
+            raise UpdateFailed("Failed to connect to Redgtech API") from e
+
+        devices: dict[str, RedgtechDevice] = {}
+
+        for item in data["boards"]:
+            display_categories = {cat.lower() for cat in item["displayCategories"]}
+
+            if "light" in display_categories or "switch" not in display_categories:
+                continue
+
+            device = RedgtechDevice(
+                unique_id=item["endpointId"],
+                name=item["friendlyName"],
+                state=item["value"],
+            )
+            _LOGGER.debug("Processing device: %s", device)
+            devices[device.unique_id] = device
+
+        return devices

homeassistant/components/redgtech/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "redgtech",
+  "name": "Redgtech",
+  "codeowners": ["@jonhsady", "@luan-nvg"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/redgtech",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["redgtech-api==0.1.38"]
+}

homeassistant/components/redgtech/quality_scale.yaml

@@ -0,0 +1,72 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: No custom actions
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: No custom actions
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: No explicit signature for events
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: done
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No options flow
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default:
+    status: exempt
+    comment: Only essential entities
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: No repair issues
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: todo
+  strict-typing: done

homeassistant/components/redgtech/strings.json

@@ -0,0 +1,40 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "email": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "email": "Enter the email address associated with your {integration_name} account.",
+          "password": "Enter the password for your {integration_name} account."
+        },
+        "description": "Please enter your credentials to connect to the {integration_name} API.",
+        "title": "Set up {integration_name}"
+      }
+    }
+  },
+  "exceptions": {
+    "api_error": {
+      "message": "Error while communicating with the {integration_name} API"
+    },
+    "authentication_failed": {
+      "message": "Authentication failed. Please check your credentials."
+    },
+    "connection_error": {
+      "message": "Connection error with {integration_name} API"
+    },
+    "switch_auth_error": {
+      "message": "Authentication failed when controlling {integration_name} switch"
+    }
+  }
+}

homeassistant/components/redgtech/switch.py

@@ -0,0 +1,95 @@
+"""Integration for Redgtech switches."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from redgtech_api.api import RedgtechAuthError, RedgtechConnectionError
+
+from homeassistant.components.switch import SwitchEntity
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN, INTEGRATION_NAME
+from .coordinator import (
+    RedgtechConfigEntry,
+    RedgtechDataUpdateCoordinator,
+    RedgtechDevice,
+)
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: RedgtechConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the switch platform."""
+    coordinator = config_entry.runtime_data
+    async_add_entities(
+        RedgtechSwitch(coordinator, device) for device in coordinator.data.values()
+    )
+
+
+class RedgtechSwitch(CoordinatorEntity[RedgtechDataUpdateCoordinator], SwitchEntity):
+    """Representation of a Redgtech switch."""
+
+    _attr_has_entity_name = True
+    _attr_name = None
+
+    def __init__(
+        self, coordinator: RedgtechDataUpdateCoordinator, device: RedgtechDevice
+    ) -> None:
+        """Initialize the switch."""
+        super().__init__(coordinator)
+        self.coordinator = coordinator
+        self.device = device
+        self._attr_unique_id = device.unique_id
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, device.unique_id)},
+            name=device.name,
+            manufacturer=INTEGRATION_NAME,
+        )
+
+    @property
+    def is_on(self) -> bool:
+        """Return true if the switch is on."""
+        if device := self.coordinator.data.get(self.device.unique_id):
+            return bool(device.state)
+        return False
+
+    async def _set_state(self, new_state: bool) -> None:
+        """Set state of the switch."""
+        try:
+            await self.coordinator.call_api_with_valid_token(
+                self.coordinator.api.set_switch_state,
+                self.device.unique_id,
+                new_state,
+                self.coordinator.access_token,
+            )
+        except RedgtechAuthError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="switch_auth_error",
+                translation_placeholders={"integration_name": INTEGRATION_NAME},
+            ) from err
+        except RedgtechConnectionError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="connection_error",
+                translation_placeholders={"integration_name": INTEGRATION_NAME},
+            ) from err
+
+        await self.coordinator.async_refresh()
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the switch on."""
+        await self._set_state(True)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the switch off."""
+        await self._set_state(False)

homeassistant/components/shelly/climate.py

@@ -104,7 +104,6 @@ class RpcLinkedgoThermostatClimate(ShellyRpcAttributeEntity, ClimateEntity):
         )
 
         config = coordinator.device.config
-        self._status = coordinator.device.status
 
         self._attr_min_temp = config[key]["min"]
         self._attr_max_temp = config[key]["max"]
@@ -142,6 +141,11 @@ class RpcLinkedgoThermostatClimate(ShellyRpcAttributeEntity, ClimateEntity):
                 THERMOSTAT_TO_HA_MODE[mode] for mode in modes
             ]
 
+    @property
+    def _status(self) -> dict[str, Any]:
+        """Return the full device status."""
+        return self.coordinator.device.status
+
     @property
     def current_humidity(self) -> float | None:
         """Return the current humidity."""

homeassistant/components/smarla/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pysmarlaapi", "pysignalr"],
   "quality_scale": "bronze",
-  "requirements": ["pysmarlaapi==0.9.3"]
+  "requirements": ["pysmarlaapi==0.13.0"]
 }

homeassistant/components/switchbot/light.py

@@ -74,7 +74,7 @@ class SwitchbotLightEntity(SwitchbotEntity, LightEntity):
         return max(0, min(255, round(self._device.brightness * 2.55)))
 
     @property
-    def color_mode(self) -> ColorMode | None:
+    def color_mode(self) -> ColorMode:
         """Return the color mode of the light."""
         return SWITCHBOT_COLOR_MODE_TO_HASS.get(
             self._device.color_mode, ColorMode.UNKNOWN

homeassistant/components/syncthing/__init__.py

@@ -1,6 +1,7 @@
 """The syncthing integration."""
 
 import asyncio
+from asyncio import Task
 import logging
 
 import aiosyncthing
@@ -13,7 +14,7 @@ from homeassistant.const import (
     EVENT_HOMEASSISTANT_STOP,
     Platform,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import Event, HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
@@ -57,7 +58,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-    async def cancel_listen_task(_):
+    async def cancel_listen_task(event: Event) -> None:
+        """Cancel the listen task on Home Assistant stop."""
         await syncthing.unsubscribe()
 
     entry.async_on_unload(
@@ -80,44 +82,46 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 class SyncthingClient:
     """A Syncthing client."""
 
-    def __init__(self, hass, client, server_id):
+    def __init__(
+        self, hass: HomeAssistant, client: aiosyncthing.Syncthing, server_id: str
+    ) -> None:
         """Initialize the client."""
         self._hass = hass
         self._client = client
         self._server_id = server_id
-        self._listen_task = None
+        self._listen_task: Task[None] | None = None
 
     @property
-    def server_id(self):
+    def server_id(self) -> str:
         """Get server id."""
         return self._server_id
 
     @property
-    def url(self):
+    def url(self) -> str:
         """Get server URL."""
         return self._client.url
 
     @property
-    def database(self):
+    def database(self) -> aiosyncthing.Database:
         """Get database namespace client."""
         return self._client.database
 
     @property
-    def system(self):
+    def system(self) -> aiosyncthing.System:
         """Get system namespace client."""
         return self._client.system
 
-    def subscribe(self):
+    def subscribe(self) -> None:
         """Start event listener coroutine."""
         self._listen_task = asyncio.create_task(self._listen())
 
-    async def unsubscribe(self):
+    async def unsubscribe(self) -> None:
         """Stop event listener coroutine."""
         if self._listen_task:
             self._listen_task.cancel()
         await self._client.close()
 
-    async def _listen(self):
+    async def _listen(self) -> None:
         """Listen to Syncthing events."""
         events = self._client.events
         server_was_unavailable = False
@@ -142,11 +146,7 @@ class SyncthingClient:
                         continue
 
                     signal_name = EVENTS[event["type"]]
-                    folder = None
-                    if "folder" in event["data"]:
-                        folder = event["data"]["folder"]
-                    else:  # A workaround, some events store folder id under `id` key
-                        folder = event["data"]["id"]
+                    folder = event["data"].get("folder") or event["data"]["id"]
                     async_dispatcher_send(
                         self._hass,
                         f"{signal_name}-{self._server_id}-{folder}",
@@ -168,7 +168,8 @@ class SyncthingClient:
                 server_was_unavailable = True
                 continue
 
-    async def _server_available(self):
+    async def _server_available(self) -> bool:
+        """Check if the Syncthing server is available."""
         try:
             await self._client.system.ping()
         except aiosyncthing.exceptions.SyncthingError:

homeassistant/components/syncthing/config_flow.py

@@ -21,7 +21,7 @@ DATA_SCHEMA = vol.Schema(
 )
 
 
-async def validate_input(hass: HomeAssistant, data):
+async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, str]:
     """Validate the user input allows us to connect."""
 
     try:

homeassistant/components/syncthing/sensor.py

@@ -1,16 +1,20 @@
-"""Support for monitoring the Syncthing instance."""
+"""Support for Syncthing sensors."""
+
+from collections.abc import Mapping
+from typing import Any
 
 import aiosyncthing
 
 from homeassistant.components.sensor import SensorEntity
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_track_time_interval
 
+from . import SyncthingClient
 from .const import (
     DOMAIN,
     FOLDER_PAUSED_RECEIVED,
@@ -86,14 +90,21 @@ class FolderSensor(SensorEntity):
         "stateChanged": "state_changed",
     }
 
-    def __init__(self, syncthing, server_id, folder_id, folder_label, version):
+    def __init__(
+        self,
+        syncthing: SyncthingClient,
+        server_id: str,
+        folder_id: str,
+        folder_label: str,
+        version: str,
+    ) -> None:
         """Initialize the sensor."""
         self._syncthing = syncthing
         self._server_id = server_id
         self._folder_id = folder_id
         self._folder_label = folder_label
-        self._state = None
-        self._unsub_timer = None
+        self._state: dict[str, Any] | None = None
+        self._unsub_timer: CALLBACK_TYPE | None = None
 
         self._short_server_id = server_id.split("-")[0]
         self._attr_name = f"{self._short_server_id} {folder_id} {folder_label}"
@@ -107,9 +118,9 @@ class FolderSensor(SensorEntity):
         )
 
     @property
-    def native_value(self):
+    def native_value(self) -> str | None:
         """Return the state of the sensor."""
-        return self._state["state"]
+        return self._state["state"] if self._state else None
 
     @property
     def available(self) -> bool:
@@ -117,11 +128,11 @@ class FolderSensor(SensorEntity):
         return self._state is not None
 
     @property
-    def extra_state_attributes(self):
+    def extra_state_attributes(self) -> Mapping[str, Any] | None:
         """Return the state attributes."""
         return self._state
 
-    async def async_update_status(self):
+    async def async_update_status(self) -> None:
         """Request folder status and update state."""
         try:
             state = await self._syncthing.database.status(self._folder_id)
@@ -131,11 +142,11 @@ class FolderSensor(SensorEntity):
             self._state = self._filter_state(state)
         self.async_write_ha_state()
 
-    def subscribe(self):
+    def subscribe(self) -> None:
         """Start polling syncthing folder status."""
         if self._unsub_timer is None:
 
-            async def refresh(event_time):
+            async def refresh(event_time) -> None:
                 """Get the latest data from Syncthing."""
                 await self.async_update_status()
 
@@ -144,7 +155,7 @@ class FolderSensor(SensorEntity):
             )
 
     @callback
-    def unsubscribe(self):
+    def unsubscribe(self) -> None:
         """Stop polling syncthing folder status."""
         if self._unsub_timer is not None:
             self._unsub_timer()
@@ -154,8 +165,9 @@ class FolderSensor(SensorEntity):
         """Handle entity which will be added."""
 
         @callback
-        def handle_folder_summary(event):
-            if self._state is not None:
+        def handle_folder_summary(event: dict[str, Any]) -> None:
+            """Handle folder summary event."""
+            if self._state:
                 self._state = self._filter_state(event["data"]["summary"])
                 self.async_write_ha_state()
 
@@ -168,8 +180,9 @@ class FolderSensor(SensorEntity):
         )
 
         @callback
-        def handle_state_changed(event):
-            if self._state is not None:
+        def handle_state_changed(event: dict[str, Any]) -> None:
+            """Handle folder state changed event."""
+            if self._state:
                 self._state["state"] = event["data"]["to"]
                 self.async_write_ha_state()
 
@@ -182,8 +195,9 @@ class FolderSensor(SensorEntity):
         )
 
         @callback
-        def handle_folder_paused(event):
-            if self._state is not None:
+        def handle_folder_paused(event: dict[str, Any]) -> None:
+            """Handle folder paused event."""
+            if self._state:
                 self._state["state"] = "paused"
                 self.async_write_ha_state()
 
@@ -196,7 +210,8 @@ class FolderSensor(SensorEntity):
         )
 
         @callback
-        def handle_server_unavailable():
+        def handle_server_unavailable() -> None:
+            """Handle server becoming unavailable."""
             self._state = None
             self.unsubscribe()
             self.async_write_ha_state()
@@ -209,7 +224,8 @@ class FolderSensor(SensorEntity):
             )
         )
 
-        async def handle_server_available():
+        async def handle_server_available() -> None:
+            """Handle server becoming available."""
             self.subscribe()
             await self.async_update_status()
 
@@ -226,20 +242,20 @@ class FolderSensor(SensorEntity):
 
         await self.async_update_status()
 
-    def _filter_state(self, state):
-        # Select only needed state attributes and map their names
-        state = {
+    def _filter_state(self, state: dict[str, Any]) -> dict[str, Any]:
+        """Filter and map state attributes."""
+        filtered_state: dict[str, Any] = {
             self.STATE_ATTRIBUTES[key]: value
             for key, value in state.items()
             if key in self.STATE_ATTRIBUTES
         }
 
         # A workaround, for some reason, state of paused folders is an empty string
-        if state["state"] == "":
-            state["state"] = "paused"
+        if filtered_state["state"] == "":
+            filtered_state["state"] = "paused"
 
         # Add some useful attributes
-        state["id"] = self._folder_id
-        state["label"] = self._folder_label
+        filtered_state["id"] = self._folder_id
+        filtered_state["label"] = self._folder_label
 
-        return state
+        return filtered_state

homeassistant/components/template/cover.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import logging
 from typing import TYPE_CHECKING, Any
 
 import voluptuous as vol
@@ -54,23 +53,11 @@ from .schemas import (
 from .template_entity import TemplateEntity
 from .trigger_entity import TriggerEntity
 
-_LOGGER = logging.getLogger(__name__)
-
 OPEN_STATE = "open"
 OPENING_STATE = "opening"
 CLOSED_STATE = "closed"
 CLOSING_STATE = "closing"
 
-_VALID_STATES = [
-    OPEN_STATE,
-    OPENING_STATE,
-    CLOSED_STATE,
-    CLOSING_STATE,
-    "true",
-    "false",
-    "none",
-]
-
 CONF_POSITION = "position"
 CONF_POSITION_TEMPLATE = "position_template"
 CONF_TILT = "tilt"

homeassistant/components/template/light.py

@@ -293,7 +293,6 @@ class AbstractTemplateLight(AbstractTemplateEntity, LightEntity):
         # Stored values for template attributes
         self._attr_is_on = initial_state
         self._supports_transition = False
-        self._attr_color_mode: ColorMode | None = None
 
     def _setup_light_features(self, config: ConfigType, name: str) -> None:
         """Setup light scripts, supported color modes, and supported features."""

homeassistant/components/tradfri/light.py

@@ -110,7 +110,7 @@ class TradfriLight(TradfriBaseEntity, LightEntity):
         return cast(bool, self._device_data.state)
 
     @property
-    def color_mode(self) -> ColorMode | None:
+    def color_mode(self) -> ColorMode:
         """Return the color mode of the light."""
         if self._fixed_color_mode:
             return self._fixed_color_mode

homeassistant/components/vesync/manifest.json

@@ -14,5 +14,6 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["pyvesync"],
+  "quality_scale": "bronze",
   "requirements": ["pyvesync==3.4.1"]
 }

homeassistant/components/waterfurnace/icons.json

@@ -0,0 +1,15 @@
+{
+  "entity": {
+    "sensor": {
+      "actual_compressor_speed": {
+        "default": "mdi:speedometer"
+      },
+      "airflow_current_speed": {
+        "default": "mdi:fan"
+      },
+      "mode": {
+        "default": "mdi:gauge"
+      }
+    }
+  }
+}

homeassistant/components/waterfurnace/sensor.py

@@ -18,89 +18,93 @@ from homeassistant.util import slugify
 from . import UPDATE_TOPIC, WaterFurnaceConfigEntry, WaterFurnaceData
 
 SENSORS = [
-    SensorEntityDescription(name="Furnace Mode", key="mode", icon="mdi:gauge"),
     SensorEntityDescription(
-        name="Total Power",
+        key="mode",
+        translation_key="mode",
+    ),
+    SensorEntityDescription(
         key="totalunitpower",
+        translation_key="total_unit_power",
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Active Setpoint",
         key="tstatactivesetpoint",
+        translation_key="tstat_active_setpoint",
         native_unit_of_measurement=UnitOfTemperature.FAHRENHEIT,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Leaving Air",
         key="leavingairtemp",
+        translation_key="leaving_air_temp",
         native_unit_of_measurement=UnitOfTemperature.FAHRENHEIT,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Room Temp",
         key="tstatroomtemp",
+        translation_key="room_temp",
         native_unit_of_measurement=UnitOfTemperature.FAHRENHEIT,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Loop Temp",
         key="enteringwatertemp",
+        translation_key="entering_water_temp",
         native_unit_of_measurement=UnitOfTemperature.FAHRENHEIT,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Humidity Set Point",
         key="tstathumidsetpoint",
-        icon="mdi:water-percent",
+        translation_key="tstat_humid_setpoint",
         native_unit_of_measurement=PERCENTAGE,
+        device_class=SensorDeviceClass.HUMIDITY,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Humidity",
         key="tstatrelativehumidity",
-        icon="mdi:water-percent",
         native_unit_of_measurement=PERCENTAGE,
+        device_class=SensorDeviceClass.HUMIDITY,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Compressor Power",
         key="compressorpower",
+        translation_key="compressor_power",
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Fan Power",
         key="fanpower",
+        translation_key="fan_power",
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Aux Power",
         key="auxpower",
+        translation_key="aux_power",
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Loop Pump Power",
         key="looppumppower",
+        translation_key="loop_pump_power",
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(
-        name="Compressor Speed", key="actualcompressorspeed", icon="mdi:speedometer"
+        key="actualcompressorspeed",
+        translation_key="actual_compressor_speed",
     ),
     SensorEntityDescription(
-        name="Fan Speed", key="airflowcurrentspeed", icon="mdi:fan"
+        key="airflowcurrentspeed",
+        translation_key="airflow_current_speed",
     ),
 ]
 
@@ -124,6 +128,7 @@ class WaterFurnaceSensor(SensorEntity):
     """Implementing the Waterfurnace sensor."""
 
     _attr_should_poll = False
+    _attr_has_entity_name = True
 
     def __init__(
         self, client: WaterFurnaceData, description: SensorEntityDescription

homeassistant/components/waterfurnace/strings.json

@@ -26,6 +26,49 @@
       }
     }
   },
+  "entity": {
+    "sensor": {
+      "actual_compressor_speed": {
+        "name": "Compressor speed"
+      },
+      "airflow_current_speed": {
+        "name": "Fan speed"
+      },
+      "aux_power": {
+        "name": "Aux power"
+      },
+      "compressor_power": {
+        "name": "Compressor power"
+      },
+      "entering_water_temp": {
+        "name": "Loop temperature"
+      },
+      "fan_power": {
+        "name": "Fan power"
+      },
+      "leaving_air_temp": {
+        "name": "Leaving air temperature"
+      },
+      "loop_pump_power": {
+        "name": "Loop pump power"
+      },
+      "mode": {
+        "name": "Furnace mode"
+      },
+      "room_temp": {
+        "name": "Room temperature"
+      },
+      "total_unit_power": {
+        "name": "Total power"
+      },
+      "tstat_active_setpoint": {
+        "name": "Active setpoint"
+      },
+      "tstat_humid_setpoint": {
+        "name": "Humidity setpoint"
+      }
+    }
+  },
   "issues": {
     "deprecated_yaml_import_issue_cannot_connect": {
       "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, we could not connect to {integration_title}. Please check your YAML configuration and restart Home Assistant, or remove the {domain} key from your configuration and configure the integration via the UI.",

homeassistant/components/zha/light.py

@@ -157,10 +157,10 @@ class Light(LightEntity, ZHAEntity):
         )
 
     @property
-    def color_mode(self) -> ColorMode | None:
+    def color_mode(self) -> ColorMode:
         """Return the color mode."""
         if self.entity_data.entity.color_mode is None:
-            return None
+            return ColorMode.UNKNOWN
         return ZHA_TO_HA_COLOR_MODE[self.entity_data.entity.color_mode]
 
     @property

homeassistant/components/zwave_js/light.py

@@ -120,10 +120,6 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
         self._supports_rgbw = False
         self._supports_color_temp = False
         self._supports_dimming = False
-        self._color_mode: ColorMode | None = None
-        self._hs_color: tuple[float, float] | None = None
-        self._rgbw_color: tuple[int, int, int, int] | None = None
-        self._color_temp: int | None = None
         self._warm_white = self.get_zwave_value(
             TARGET_COLOR_PROPERTY,
             CommandClass.SWITCH_COLOR,
@@ -134,7 +130,6 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
             CommandClass.SWITCH_COLOR,
             value_property_key=ColorComponent.COLD_WHITE,
         )
-        self._supported_color_modes: set[ColorMode] = set()
 
         self._target_brightness: Value | None = None
 
@@ -180,17 +175,18 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
         )
 
         self._calculate_color_support()
+        self._attr_supported_color_modes = set()
         if self._supports_rgbw:
-            self._supported_color_modes.add(ColorMode.RGBW)
+            self._attr_supported_color_modes.add(ColorMode.RGBW)
         elif self._supports_color:
-            self._supported_color_modes.add(ColorMode.HS)
+            self._attr_supported_color_modes.add(ColorMode.HS)
         if self._supports_color_temp:
-            self._supported_color_modes.add(ColorMode.COLOR_TEMP)
-        if not self._supported_color_modes:
+            self._attr_supported_color_modes.add(ColorMode.COLOR_TEMP)
+        if not self._attr_supported_color_modes:
             if self.info.primary_value.command_class == CommandClass.SWITCH_BINARY:
-                self._supported_color_modes.add(ColorMode.ONOFF)
+                self._attr_supported_color_modes.add(ColorMode.ONOFF)
             else:
-                self._supported_color_modes.add(ColorMode.BRIGHTNESS)
+                self._attr_supported_color_modes.add(ColorMode.BRIGHTNESS)
         self._calculate_color_values()
 
         # Entity class attributes
@@ -225,11 +221,6 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
             return None
         return round((cast(int, self.info.primary_value.value) / 99) * 255)
 
-    @property
-    def color_mode(self) -> ColorMode | None:
-        """Return the color mode of the light."""
-        return self._color_mode
-
     @property
     def is_on(self) -> bool | None:
         """Return true if device is on (brightness above 0)."""
@@ -239,26 +230,6 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
         brightness = self.brightness
         return brightness > 0 if brightness is not None else None
 
-    @property
-    def hs_color(self) -> tuple[float, float] | None:
-        """Return the hs color."""
-        return self._hs_color
-
-    @property
-    def rgbw_color(self) -> tuple[int, int, int, int] | None:
-        """Return the RGBW color."""
-        return self._rgbw_color
-
-    @property
-    def color_temp_kelvin(self) -> int | None:
-        """Return the color temperature value in Kelvin."""
-        return self._color_temp
-
-    @property
-    def supported_color_modes(self) -> set[ColorMode] | None:
-        """Flag supported features."""
-        return self._supported_color_modes
-
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the device on."""
 
@@ -479,9 +450,9 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
 
         # Default: Brightness (no color) or Unknown
         if self.supported_color_modes == {ColorMode.BRIGHTNESS}:
-            self._color_mode = ColorMode.BRIGHTNESS
+            self._attr_color_mode = ColorMode.BRIGHTNESS
         else:
-            self._color_mode = ColorMode.UNKNOWN
+            self._attr_color_mode = ColorMode.UNKNOWN
 
         # RGB support
         if red_val and green_val and blue_val:
@@ -491,9 +462,9 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
             blue = multi_color.get(COLOR_SWITCH_COMBINED_BLUE, blue_val.value)
             if red is not None and green is not None and blue is not None:
                 # convert to HS
-                self._hs_color = color_util.color_RGB_to_hs(red, green, blue)
+                self._attr_hs_color = color_util.color_RGB_to_hs(red, green, blue)
                 # Light supports color, set color mode to hs
-                self._color_mode = ColorMode.HS
+                self._attr_color_mode = ColorMode.HS
 
         # color temperature support
         if ww_val and cw_val:
@@ -501,14 +472,16 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
             cold_white = multi_color.get(COLOR_SWITCH_COMBINED_COLD_WHITE, cw_val.value)
             # Calculate color temps based on whites
             if cold_white or warm_white:
-                self._color_temp = color_util.color_temperature_mired_to_kelvin(
-                    MAX_MIREDS
-                    - ((cast(int, cold_white) / 255) * (MAX_MIREDS - MIN_MIREDS))
+                self._attr_color_temp_kelvin = (
+                    color_util.color_temperature_mired_to_kelvin(
+                        MAX_MIREDS
+                        - ((cast(int, cold_white) / 255) * (MAX_MIREDS - MIN_MIREDS))
+                    )
                 )
                 # White channels turned on, set color mode to color_temp
-                self._color_mode = ColorMode.COLOR_TEMP
+                self._attr_color_mode = ColorMode.COLOR_TEMP
             else:
-                self._color_temp = None
+                self._attr_color_temp_kelvin = None
         # only one white channel (warm white) = rgbw support
         elif red_val and green_val and blue_val and ww_val:
             white = multi_color.get(COLOR_SWITCH_COMBINED_WARM_WHITE, ww_val.value)
@@ -519,9 +492,9 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
                     and blue is not None
                     and white is not None
                 )
-            self._rgbw_color = (red, green, blue, white)
+            self._attr_rgbw_color = (red, green, blue, white)
             # Light supports rgbw, set color mode to rgbw
-            self._color_mode = ColorMode.RGBW
+            self._attr_color_mode = ColorMode.RGBW
         # only one white channel (cool white) = rgbw support
         elif cw_val:
             self._supports_rgbw = True
@@ -533,9 +506,9 @@ class ZwaveLight(ZWaveBaseEntity, LightEntity):
                     and blue is not None
                     and white is not None
                 )
-            self._rgbw_color = (red, green, blue, white)
+            self._attr_rgbw_color = (red, green, blue, white)
             # Light supports rgbw, set color mode to rgbw
-            self._color_mode = ColorMode.RGBW
+            self._attr_color_mode = ColorMode.RGBW
 
 
 class ZwaveColorOnOffLight(ZwaveLight):
@@ -620,8 +593,8 @@ class ZwaveColorOnOffLight(ZwaveLight):
                 new_colors = {}
                 for color, value in self._last_on_color.items():
                     new_colors[color] = round(value * new_scale)
-            elif hs_color is None and self._color_mode == ColorMode.HS:
-                hs_color = self._hs_color
+            elif hs_color is None and self._attr_color_mode == ColorMode.HS:
+                hs_color = self._attr_hs_color
         elif hs_color is not None and brightness is None:
             # Turned on by using the color controls
             current_brightness = self.brightness

homeassistant/generated/config_flows.py

@@ -570,6 +570,7 @@ FLOWS = {
         "rapt_ble",
         "rdw",
         "recollect_waste",
+        "redgtech",
         "refoss",
         "rehlko",
         "remote_calendar",

homeassistant/generated/entity_platforms.py

@@ -29,7 +29,6 @@ class EntityPlatforms(StrEnum):
     HUMIDIFIER = "humidifier"
     IMAGE = "image"
     IMAGE_PROCESSING = "image_processing"
-    INFRARED = "infrared"
     LAWN_MOWER = "lawn_mower"
     LIGHT = "light"
     LOCK = "lock"

homeassistant/generated/integrations.json

@@ -5583,6 +5583,12 @@
       "config_flow": false,
       "iot_class": "cloud_polling"
     },
+    "redgtech": {
+      "name": "Redgtech",
+      "integration_type": "service",
+      "config_flow": true,
+      "iot_class": "cloud_polling"
+    },
     "refoss": {
       "name": "Refoss",
       "integration_type": "hub",

homeassistant/package_constraints.txt

@@ -37,11 +37,11 @@ fnv-hash-fast==1.6.0
 go2rtc-client==0.4.0
 ha-ffmpeg==3.2.2
 habluetooth==5.8.0
-hass-nabucasa==1.12.0
+hass-nabucasa==1.13.0
 hassil==3.5.0
 home-assistant-bluetooth==1.13.1
 home-assistant-frontend==20260128.6
-home-assistant-intents==2026.2.3
+home-assistant-intents==2026.1.28
 httpx==0.28.1
 ifaddr==0.2.0
 Jinja2==3.1.6

mypy.ini

@@ -2576,16 +2576,6 @@ disallow_untyped_defs = true
 warn_return_any = true
 warn_unreachable = true
 
-[mypy-homeassistant.components.infrared.*]
-check_untyped_defs = true
-disallow_incomplete_defs = true
-disallow_subclassing_any = true
-disallow_untyped_calls = true
-disallow_untyped_decorators = true
-disallow_untyped_defs = true
-warn_return_any = true
-warn_unreachable = true
-
 [mypy-homeassistant.components.input_button.*]
 check_untyped_defs = true
 disallow_incomplete_defs = true
@@ -4116,6 +4106,16 @@ disallow_untyped_defs = true
 warn_return_any = true
 warn_unreachable = true
 
+[mypy-homeassistant.components.redgtech.*]
+check_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_subclassing_any = true
+disallow_untyped_calls = true
+disallow_untyped_decorators = true
+disallow_untyped_defs = true
+warn_return_any = true
+warn_unreachable = true
+
 [mypy-homeassistant.components.remember_the_milk.*]
 check_untyped_defs = true
 disallow_incomplete_defs = true

pyproject.toml

@@ -51,7 +51,7 @@ dependencies = [
   "fnv-hash-fast==1.6.0",
   # hass-nabucasa is imported by helpers which don't depend on the cloud
   # integration
-  "hass-nabucasa==1.12.0",
+  "hass-nabucasa==1.13.0",
   # When bumping httpx, please check the version pins of
   # httpcore, anyio, and h11 in gen_requirements_all
   "httpx==0.28.1",

requirements.txt

@@ -25,10 +25,10 @@ cronsim==2.7
 cryptography==46.0.2
 fnv-hash-fast==1.6.0
 ha-ffmpeg==3.2.2
-hass-nabucasa==1.12.0
+hass-nabucasa==1.13.0
 hassil==3.5.0
 home-assistant-bluetooth==1.13.1
-home-assistant-intents==2026.2.3
+home-assistant-intents==2026.1.28
 httpx==0.28.1
 ifaddr==0.2.0
 Jinja2==3.1.6

requirements_all.txt

@@ -505,7 +505,7 @@ anova-wifi==0.17.0
 anthemav==1.4.1
 
 # homeassistant.components.anthropic
-anthropic==0.75.0
+anthropic==0.78.0
 
 # homeassistant.components.mcp_server
 anyio==4.10.0
@@ -797,7 +797,7 @@ deluge-client==1.10.2
 demetriek==1.3.0
 
 # homeassistant.components.denonavr
-denonavr==1.3.1
+denonavr==1.3.2
 
 # homeassistant.components.devialet
 devialet==1.5.7
@@ -938,7 +938,7 @@ eufylife-ble-client==0.1.8
 # evdev==1.6.1
 
 # homeassistant.components.evohome
-evohome-async==1.0.6
+evohome-async==1.1.3
 
 # homeassistant.components.bryant_evolution
 evolutionhttp==0.0.18
@@ -1105,7 +1105,7 @@ google-nest-sdm==9.1.2
 google-photos-library-api==0.12.1
 
 # homeassistant.components.google_air_quality
-google_air_quality_api==3.0.0
+google_air_quality_api==3.0.1
 
 # homeassistant.components.slide
 # homeassistant.components.slide_local
@@ -1175,7 +1175,7 @@ habluetooth==5.8.0
 hanna-cloud==0.0.7
 
 # homeassistant.components.cloud
-hass-nabucasa==1.12.0
+hass-nabucasa==1.13.0
 
 # homeassistant.components.splunk
 hass-splunk==0.1.1
@@ -1222,7 +1222,7 @@ holidays==0.84
 home-assistant-frontend==20260128.6
 
 # homeassistant.components.conversation
-home-assistant-intents==2026.2.3
+home-assistant-intents==2026.1.28
 
 # homeassistant.components.gentex_homelink
 homelink-integration-api==0.0.1
@@ -2032,7 +2032,7 @@ pyegps==0.2.5
 pyemoncms==0.1.3
 
 # homeassistant.components.enphase_envoy
-pyenphase==2.4.3
+pyenphase==2.4.5
 
 # homeassistant.components.envisalink
 pyenvisalink==4.7
@@ -2319,7 +2319,7 @@ pypaperless==4.1.1
 pypca==0.0.7
 
 # homeassistant.components.lcn
-pypck==0.9.9
+pypck==0.9.10
 
 # homeassistant.components.pglab
 pypglab==0.0.5
@@ -2434,7 +2434,7 @@ pysma==1.1.0
 pysmappee==0.2.29
 
 # homeassistant.components.smarla
-pysmarlaapi==0.9.3
+pysmarlaapi==0.13.0
 
 # homeassistant.components.smartthings
 pysmartthings==3.5.1
@@ -2744,6 +2744,9 @@ rapt-ble==0.1.2
 # homeassistant.components.raspyrfm
 raspyrfm-client==1.2.9
 
+# homeassistant.components.redgtech
+redgtech-api==0.1.38
+
 # homeassistant.components.refoss
 refoss-ha==1.2.5
 

requirements_test_all.txt

@@ -481,7 +481,7 @@ anova-wifi==0.17.0
 anthemav==1.4.1
 
 # homeassistant.components.anthropic
-anthropic==0.75.0
+anthropic==0.78.0
 
 # homeassistant.components.mcp_server
 anyio==4.10.0
@@ -706,7 +706,7 @@ deluge-client==1.10.2
 demetriek==1.3.0
 
 # homeassistant.components.denonavr
-denonavr==1.3.1
+denonavr==1.3.2
 
 # homeassistant.components.devialet
 devialet==1.5.7
@@ -826,7 +826,7 @@ eternalegypt==0.0.18
 eufylife-ble-client==0.1.8
 
 # homeassistant.components.evohome
-evohome-async==1.0.6
+evohome-async==1.1.3
 
 # homeassistant.components.bryant_evolution
 evolutionhttp==0.0.18
@@ -981,7 +981,7 @@ google-nest-sdm==9.1.2
 google-photos-library-api==0.12.1
 
 # homeassistant.components.google_air_quality
-google_air_quality_api==3.0.0
+google_air_quality_api==3.0.1
 
 # homeassistant.components.slide
 # homeassistant.components.slide_local
@@ -1045,7 +1045,7 @@ habluetooth==5.8.0
 hanna-cloud==0.0.7
 
 # homeassistant.components.cloud
-hass-nabucasa==1.12.0
+hass-nabucasa==1.13.0
 
 # homeassistant.components.assist_satellite
 # homeassistant.components.conversation
@@ -1080,7 +1080,7 @@ holidays==0.84
 home-assistant-frontend==20260128.6
 
 # homeassistant.components.conversation
-home-assistant-intents==2026.2.3
+home-assistant-intents==2026.1.28
 
 # homeassistant.components.gentex_homelink
 homelink-integration-api==0.0.1
@@ -1730,7 +1730,7 @@ pyegps==0.2.5
 pyemoncms==0.1.3
 
 # homeassistant.components.enphase_envoy
-pyenphase==2.4.3
+pyenphase==2.4.5
 
 # homeassistant.components.everlights
 pyeverlights==0.1.0
@@ -1966,7 +1966,7 @@ pypalazzetti==0.1.20
 pypaperless==4.1.1
 
 # homeassistant.components.lcn
-pypck==0.9.9
+pypck==0.9.10
 
 # homeassistant.components.pglab
 pypglab==0.0.5
@@ -2060,7 +2060,7 @@ pysma==1.1.0
 pysmappee==0.2.29
 
 # homeassistant.components.smarla
-pysmarlaapi==0.9.3
+pysmarlaapi==0.13.0
 
 # homeassistant.components.smartthings
 pysmartthings==3.5.1
@@ -2310,6 +2310,9 @@ radiotherm==2.1.0
 # homeassistant.components.rapt_ble
 rapt-ble==0.1.2
 
+# homeassistant.components.redgtech
+redgtech-api==0.1.38
+
 # homeassistant.components.refoss
 refoss-ha==1.2.5
 

script/hassfest/quality_scale.py

@@ -2039,7 +2039,6 @@ INTEGRATIONS_WITHOUT_SCALE = [
     "versasense",
     "version",
     "vicare",
-    "vesync",
     "viaggiatreno",
     "vilfo",
     "vivotek",

tests/components/alexa_devices/test_services.py

@@ -188,3 +188,69 @@ async def test_config_entry_not_loaded(
     assert exc_info.value.translation_domain == DOMAIN
     assert exc_info.value.translation_key == "entry_not_loaded"
     assert exc_info.value.translation_placeholders == {"entry": mock_config_entry.title}
+
+
+async def test_invalid_config_entry(
+    hass: HomeAssistant,
+    device_registry: dr.DeviceRegistry,
+    mock_amazon_devices_client: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test invalid config entry."""
+
+    await setup_integration(hass, mock_config_entry)
+
+    device_entry = device_registry.async_get_device(
+        identifiers={(DOMAIN, TEST_DEVICE_1_SN)}
+    )
+    assert device_entry
+
+    device_entry.config_entries.add("non_existing_entry_id")
+    await hass.async_block_till_done()
+
+    # Call Service
+    await hass.services.async_call(
+        DOMAIN,
+        SERVICE_SOUND_NOTIFICATION,
+        {
+            ATTR_SOUND: "bell_02",
+            ATTR_DEVICE_ID: device_entry.id,
+        },
+        blocking=True,
+    )
+    # No exception should be raised
+    assert mock_amazon_devices_client.call_alexa_sound.call_count == 1
+
+
+async def test_missing_config_entry(
+    hass: HomeAssistant,
+    device_registry: dr.DeviceRegistry,
+    mock_amazon_devices_client: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test missing config entry."""
+
+    await setup_integration(hass, mock_config_entry)
+
+    device_entry = device_registry.async_get_device(
+        identifiers={(DOMAIN, TEST_DEVICE_1_SN)}
+    )
+    assert device_entry
+
+    device_entry.config_entries.clear()
+
+    # Call Service
+    with pytest.raises(ServiceValidationError) as exc_info:
+        await hass.services.async_call(
+            DOMAIN,
+            SERVICE_SOUND_NOTIFICATION,
+            {
+                ATTR_SOUND: "bell_02",
+                ATTR_DEVICE_ID: device_entry.id,
+            },
+            blocking=True,
+        )
+
+    assert exc_info.value.translation_domain == DOMAIN
+    assert exc_info.value.translation_key == "config_entry_not_found"
+    assert exc_info.value.translation_placeholders == {"device_id": device_entry.id}

tests/components/alexa_devices/test_utils.py

@@ -81,8 +81,8 @@ async def test_alexa_unique_id_migration(
     )
 
     entity = entity_registry.async_get_or_create(
-        SWITCH_DOMAIN,
         DOMAIN,
+        SWITCH_DOMAIN,
         unique_id=f"{TEST_DEVICE_1_SN}-do_not_disturb",
         device_id=device.id,
         config_entry=mock_config_entry,

tests/components/cloudflare_r2/test_backup.py

@@ -367,6 +367,57 @@ async def test_agents_upload_network_failure(
     assert "Upload failed for cloudflare_r2" in caplog.text
 
 
+async def test_multipart_upload_consistent_part_sizes(
+    hass: HomeAssistant,
+    mock_client: MagicMock,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test that multipart upload uses consistent part sizes.
+
+    S3/R2 requires all non-trailing parts to have the same size. This test
+    verifies that varying chunk sizes still result in consistent part sizes.
+    """
+    agent = R2BackupAgent(hass, mock_config_entry)
+
+    # simulate varying chunk data sizes
+    # total data: 12 + 12 + 10 + 12 + 5 = 51 MiB
+    chunk_sizes = [12, 12, 10, 12, 5]  # in units of 1 MiB
+    mib = 2**20
+
+    async def mock_stream():
+        for size in chunk_sizes:
+            yield b"x" * (size * mib)
+
+    async def open_stream():
+        return mock_stream()
+
+    # Record the sizes of each uploaded part
+    uploaded_part_sizes: list[int] = []
+
+    async def record_upload_part(**kwargs):
+        body = kwargs.get("Body", b"")
+        uploaded_part_sizes.append(len(body))
+        return {"ETag": f"etag-{len(uploaded_part_sizes)}"}
+
+    mock_client.upload_part.side_effect = record_upload_part
+
+    await agent._upload_multipart("test.tar", open_stream)
+
+    # Verify that all non-trailing parts have the same size
+    assert len(uploaded_part_sizes) >= 2, "Expected at least 2 parts"
+    non_trailing_parts = uploaded_part_sizes[:-1]
+    assert all(size == MULTIPART_MIN_PART_SIZE_BYTES for size in non_trailing_parts), (
+        f"All non-trailing parts should be {MULTIPART_MIN_PART_SIZE_BYTES} bytes, got {non_trailing_parts}"
+    )
+
+    # Verify the trailing part contains the remainder
+    total_data = sum(chunk_sizes) * mib
+    expected_trailing = total_data % MULTIPART_MIN_PART_SIZE_BYTES
+    if expected_trailing == 0:
+        expected_trailing = MULTIPART_MIN_PART_SIZE_BYTES
+    assert uploaded_part_sizes[-1] == expected_trailing
+
+
 async def test_agents_download(
     hass_client: ClientSessionGenerator,
     mock_client: MagicMock,

tests/components/emulated_hue/test_hue_api.py

@@ -814,7 +814,9 @@ async def test_put_light_state(
 
     # mock light.turn_on call
     attributes = hass.states.get("light.ceiling_lights").attributes
-    supported_features = attributes[ATTR_SUPPORTED_FEATURES] | light.SUPPORT_TRANSITION
+    supported_features = (
+        attributes[ATTR_SUPPORTED_FEATURES] | light.LightEntityFeature.TRANSITION
+    )
     attributes = {**attributes, ATTR_SUPPORTED_FEATURES: supported_features}
     hass.states.async_set("light.ceiling_lights", STATE_ON, attributes)
     call_turn_on = async_mock_service(hass, "light", "turn_on")

tests/components/esphome/test_infrared.py

@@ -1,166 +0,0 @@
-"""Test ESPHome infrared platform."""
-
-from aioesphomeapi import APIClient, InfraredCapability, InfraredInfo
-import pytest
-
-from homeassistant.components import infrared
-from homeassistant.const import STATE_UNAVAILABLE
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-
-from .conftest import MockESPHomeDeviceType
-
-ENTITY_ID = "infrared.test_ir"
-
-
-async def _mock_ir_device(
-    mock_esphome_device: MockESPHomeDeviceType,
-    mock_client: APIClient,
-    capabilities: InfraredCapability = InfraredCapability.TRANSMITTER,
-) -> MockESPHomeDeviceType:
-    entity_info = [
-        InfraredInfo(object_id="ir", key=1, name="IR", capabilities=capabilities)
-    ]
-    return await mock_esphome_device(
-        mock_client=mock_client, entity_info=entity_info, states=[]
-    )
-
-
-@pytest.mark.parametrize(
-    ("capabilities", "entity_created"),
-    [
-        (InfraredCapability.TRANSMITTER, True),
-        (InfraredCapability.RECEIVER, False),
-        (InfraredCapability.TRANSMITTER | InfraredCapability.RECEIVER, True),
-        (0, False),
-    ],
-)
-async def test_infrared_entity_transmitter(
-    hass: HomeAssistant,
-    mock_client: APIClient,
-    mock_esphome_device: MockESPHomeDeviceType,
-    capabilities: InfraredCapability,
-    entity_created: bool,
-) -> None:
-    """Test infrared entity with transmitter capability is created."""
-    await _mock_ir_device(mock_esphome_device, mock_client, capabilities)
-
-    state = hass.states.get(ENTITY_ID)
-    assert (state is not None) == entity_created
-
-    emitters = infrared.async_get_emitters(hass)
-    assert (len(emitters) == 1) == entity_created
-
-
-async def test_infrared_multiple_entities_mixed_capabilities(
-    hass: HomeAssistant,
-    mock_client: APIClient,
-    mock_esphome_device: MockESPHomeDeviceType,
-) -> None:
-    """Test multiple infrared entities with mixed capabilities."""
-    entity_info = [
-        InfraredInfo(
-            object_id="ir_transmitter",
-            key=1,
-            name="IR Transmitter",
-            capabilities=InfraredCapability.TRANSMITTER,
-        ),
-        InfraredInfo(
-            object_id="ir_receiver",
-            key=2,
-            name="IR Receiver",
-            capabilities=InfraredCapability.RECEIVER,
-        ),
-        InfraredInfo(
-            object_id="ir_transceiver",
-            key=3,
-            name="IR Transceiver",
-            capabilities=InfraredCapability.TRANSMITTER | InfraredCapability.RECEIVER,
-        ),
-    ]
-    await mock_esphome_device(
-        mock_client=mock_client,
-        entity_info=entity_info,
-        states=[],
-    )
-
-    # Only transmitter and transceiver should be created
-    assert hass.states.get("infrared.test_ir_transmitter") is not None
-    assert hass.states.get("infrared.test_ir_receiver") is None
-    assert hass.states.get("infrared.test_ir_transceiver") is not None
-
-    emitters = infrared.async_get_emitters(hass)
-    assert len(emitters) == 2
-
-
-async def test_infrared_send_command_success(
-    hass: HomeAssistant,
-    mock_client: APIClient,
-    mock_esphome_device: MockESPHomeDeviceType,
-) -> None:
-    """Test sending IR command successfully."""
-    await _mock_ir_device(mock_esphome_device, mock_client)
-
-    command = infrared.NECInfraredCommand(address=0x04, command=0x08, modulation=38000)
-    await infrared.async_send_command(hass, ENTITY_ID, command)
-
-    # Verify the command was sent to the ESPHome client
-    mock_client.infrared_rf_transmit_raw_timings.assert_called_once()
-    call_args = mock_client.infrared_rf_transmit_raw_timings.call_args
-    assert call_args[0][0] == 1  # key
-    assert call_args[1]["carrier_frequency"] == 38000
-
-    # Verify timings (alternating positive/negative values)
-    timings = call_args[1]["timings"]
-    assert len(timings) > 0
-    for i in range(0, len(timings), 2):
-        assert timings[i] >= 0
-    for i in range(1, len(timings), 2):
-        assert timings[i] <= 0
-
-
-async def test_infrared_send_command_failure(
-    hass: HomeAssistant,
-    mock_client: APIClient,
-    mock_esphome_device: MockESPHomeDeviceType,
-) -> None:
-    """Test sending IR command with failure raises HomeAssistantError."""
-    await _mock_ir_device(mock_esphome_device, mock_client)
-
-    mock_client.infrared_rf_transmit_raw_timings.side_effect = Exception(
-        "Connection lost"
-    )
-
-    command = infrared.NECInfraredCommand(address=0x04, command=0x08, modulation=38000)
-
-    with pytest.raises(HomeAssistantError) as exc_info:
-        await infrared.async_send_command(hass, ENTITY_ID, command)
-    assert exc_info.value.translation_domain == "esphome"
-    assert exc_info.value.translation_key == "error_sending_ir_command"
-
-
-async def test_infrared_entity_availability(
-    hass: HomeAssistant,
-    mock_client: APIClient,
-    mock_esphome_device: MockESPHomeDeviceType,
-) -> None:
-    """Test infrared entity becomes available after device reconnects."""
-    mock_device = await _mock_ir_device(mock_esphome_device, mock_client)
-
-    state = hass.states.get(ENTITY_ID)
-    assert state is not None
-    assert state.state != STATE_UNAVAILABLE
-
-    await mock_device.mock_disconnect(False)
-    await hass.async_block_till_done()
-
-    state = hass.states.get(ENTITY_ID)
-    assert state is not None
-    assert state.state == STATE_UNAVAILABLE
-
-    await mock_device.mock_connect()
-    await hass.async_block_till_done()
-
-    state = hass.states.get(ENTITY_ID)
-    assert state is not None
-    assert state.state != STATE_UNAVAILABLE

tests/components/evohome/conftest.py

@@ -168,7 +168,7 @@ async def setup_evohome(
             "evohomeasync2.auth.CredentialsManagerBase._post_request",
             mock_post_request(install),
         ),
-        patch("evohome.auth.AbstractAuth._make_request", mock_make_request(install)),
+        patch("_evohome.auth.AbstractAuth._make_request", mock_make_request(install)),
     ):
         evo: EvohomeClient | None = None
 

tests/components/evohome/snapshots/test_climate.ambr

@@ -167,6 +167,836 @@
     ),
   ])
 # ---
+# name: test_entities_update_over_time[default][climate.bathroom_dn-state-initial]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 20.0,
+      'friendly_name': 'Bathroom Dn',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 16.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 7, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.1,
+          'this_sp_from': HAFakeDatetime(2024, 7, 9, 23, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 15.9,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 20.0,
+        }),
+        'zone_id': '3432579',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 16.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.bathroom_dn',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.bathroom_dn-state-updated]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 20.0,
+      'friendly_name': 'Bathroom Dn',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 16.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 22, 10, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.6,
+          'this_sp_from': HAFakeDatetime(2024, 7, 10, 8, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 16.0,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 20.0,
+        }),
+        'zone_id': '3432579',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 16.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.bathroom_dn',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.dead_zone-state-initial]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': None,
+      'friendly_name': 'Dead Zone',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 17.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 7, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.1,
+          'this_sp_from': HAFakeDatetime(2024, 7, 9, 23, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 15.9,
+        }),
+        'temperature_status': dict({
+          'is_available': False,
+        }),
+        'zone_id': '3432521',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 17.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.dead_zone',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.dead_zone-state-updated]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': None,
+      'friendly_name': 'Dead Zone',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 17.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 22, 10, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.6,
+          'this_sp_from': HAFakeDatetime(2024, 7, 10, 8, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 16.0,
+        }),
+        'temperature_status': dict({
+          'is_available': False,
+        }),
+        'zone_id': '3432521',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 17.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.dead_zone',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.front_room-state-initial]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.0,
+      'friendly_name': 'Front Room',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'temporary',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'TemporaryOverride',
+          'target_heat_temperature': 21.0,
+          'until': '2022-03-07T19:00:00+00:00',
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 7, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.1,
+          'this_sp_from': HAFakeDatetime(2024, 7, 9, 23, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 15.9,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 19.0,
+        }),
+        'zone_id': '3432577',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 21.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.front_room',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.front_room-state-updated]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.0,
+      'friendly_name': 'Front Room',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'temporary',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'TemporaryOverride',
+          'target_heat_temperature': 21.0,
+          'until': '2022-03-07T19:00:00+00:00',
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 22, 10, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.6,
+          'this_sp_from': HAFakeDatetime(2024, 7, 10, 8, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 16.0,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 19.0,
+        }),
+        'zone_id': '3432577',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 21.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.front_room',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.kids_room-state-initial]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.5,
+      'friendly_name': 'Kids Room',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 17.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 7, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.1,
+          'this_sp_from': HAFakeDatetime(2024, 7, 9, 23, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 15.9,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 19.5,
+        }),
+        'zone_id': '3449703',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 17.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.kids_room',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.kids_room-state-updated]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.5,
+      'friendly_name': 'Kids Room',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 17.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 22, 10, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.6,
+          'this_sp_from': HAFakeDatetime(2024, 7, 10, 8, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 16.0,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 19.5,
+        }),
+        'zone_id': '3449703',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 17.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.kids_room',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.kitchen-state-initial]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 20.0,
+      'friendly_name': 'Kitchen',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 17.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 7, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.1,
+          'this_sp_from': HAFakeDatetime(2024, 7, 9, 23, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 15.9,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 20.0,
+        }),
+        'zone_id': '3432578',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 17.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.kitchen',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.kitchen-state-updated]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 20.0,
+      'friendly_name': 'Kitchen',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 17.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 22, 10, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.6,
+          'this_sp_from': HAFakeDatetime(2024, 7, 10, 8, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 16.0,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 20.0,
+        }),
+        'zone_id': '3432578',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 17.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.kitchen',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.main_bedroom-state-initial]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 21.0,
+      'friendly_name': 'Main Bedroom',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 16.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 7, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.1,
+          'this_sp_from': HAFakeDatetime(2024, 7, 9, 23, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 15.9,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 21.0,
+        }),
+        'zone_id': '3432580',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 16.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.main_bedroom',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.main_bedroom-state-updated]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 21.0,
+      'friendly_name': 'Main Bedroom',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'none',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'FollowSchedule',
+          'target_heat_temperature': 16.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 22, 10, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.6,
+          'this_sp_from': HAFakeDatetime(2024, 7, 10, 8, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 16.0,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 21.0,
+        }),
+        'zone_id': '3432580',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 16.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.main_bedroom',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.main_room-state-initial]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.0,
+      'friendly_name': 'Main Room',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'permanent',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'PermanentOverride',
+          'target_heat_temperature': 17.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 7, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.1,
+          'this_sp_from': HAFakeDatetime(2024, 7, 9, 23, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 15.9,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 19.0,
+        }),
+        'zone_id': '3432576',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 17.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.main_room',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.main_room-state-updated]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.0,
+      'friendly_name': 'Main Room',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'permanent',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'PermanentOverride',
+          'target_heat_temperature': 17.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 22, 10, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.6,
+          'this_sp_from': HAFakeDatetime(2024, 7, 10, 8, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 16.0,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 19.0,
+        }),
+        'zone_id': '3432576',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 17.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.main_room',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.my_home-state-initial]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.7,
+      'friendly_name': 'My Home',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'icon': 'mdi:thermostat',
+      'max_temp': 35,
+      'min_temp': 7,
+      'preset_mode': 'eco',
+      'preset_modes': list([
+        'Reset',
+        'eco',
+        'away',
+        'home',
+        'Custom',
+      ]),
+      'status': dict({
+        'activeSystemFaults': tuple(
+        ),
+        'system_id': '3432522',
+        'system_mode_status': dict({
+          'is_permanent': True,
+          'mode': 'AutoWithEco',
+        }),
+      }),
+      'supported_features': <ClimateEntityFeature: 400>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.my_home',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.my_home-state-updated]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.7,
+      'friendly_name': 'My Home',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'icon': 'mdi:thermostat',
+      'max_temp': 35,
+      'min_temp': 7,
+      'preset_mode': 'eco',
+      'preset_modes': list([
+        'Reset',
+        'eco',
+        'away',
+        'home',
+        'Custom',
+      ]),
+      'status': dict({
+        'activeSystemFaults': tuple(
+        ),
+        'system_id': '3432522',
+        'system_mode_status': dict({
+          'is_permanent': True,
+          'mode': 'AutoWithEco',
+        }),
+      }),
+      'supported_features': <ClimateEntityFeature: 400>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.my_home',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.spare_room-state-initial]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.5,
+      'friendly_name': 'Spare Room',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'permanent',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'PermanentOverride',
+          'target_heat_temperature': 14.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 7, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.1,
+          'this_sp_from': HAFakeDatetime(2024, 7, 9, 23, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 15.9,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 19.5,
+        }),
+        'zone_id': '3450733',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 14.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.spare_room',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
+# name: test_entities_update_over_time[default][climate.spare_room-state-updated]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_temperature': 19.5,
+      'friendly_name': 'Spare Room',
+      'hvac_modes': list([
+        <HVACMode.OFF: 'off'>,
+        <HVACMode.HEAT: 'heat'>,
+      ]),
+      'max_temp': 35.0,
+      'min_temp': 5.0,
+      'preset_mode': 'permanent',
+      'preset_modes': list([
+        'none',
+        'temporary',
+        'permanent',
+      ]),
+      'status': dict({
+        'activeFaults': tuple(
+        ),
+        'setpoint_status': dict({
+          'setpoint_mode': 'PermanentOverride',
+          'target_heat_temperature': 14.0,
+        }),
+        'setpoints': dict({
+          'next_sp_from': HAFakeDatetime(2024, 7, 10, 22, 10, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'next_sp_temp': 18.6,
+          'this_sp_from': HAFakeDatetime(2024, 7, 10, 8, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/London')),
+          'this_sp_temp': 16.0,
+        }),
+        'temperature_status': dict({
+          'is_available': True,
+          'temperature': 19.5,
+        }),
+        'zone_id': '3450733',
+      }),
+      'supported_features': <ClimateEntityFeature: 401>,
+      'temperature': 14.0,
+    }),
+    'context': <ANY>,
+    'entity_id': 'climate.spare_room',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'heat',
+  })
+# ---
 # name: test_setup_platform[botched][climate.bathroom_dn-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({

tests/components/evohome/test_climate.py

@@ -5,6 +5,7 @@ All evohome systems have controllers and at least one zone.
 
 from __future__ import annotations
 
+from datetime import timedelta
 from unittest.mock import patch
 
 from freezegun.api import FrozenDateTimeFactory
@@ -32,6 +33,8 @@ from homeassistant.exceptions import HomeAssistantError
 from .conftest import setup_evohome
 from .const import TEST_INSTALLS
 
+from tests.common import async_fire_time_changed
+
 
 @pytest.mark.parametrize("install", [*TEST_INSTALLS, "botched"])
 async def test_setup_platform(
@@ -43,7 +46,7 @@ async def test_setup_platform(
 ) -> None:
     """Test entities and their states after setup of evohome."""
 
-    # Cannot use the evohome fixture, as need to set dtm first
+    # Cannot use the evohome fixture here, as need to set dtm first
     #  - some extended state attrs are relative the current time
     freezer.move_to("2024-07-10T12:00:00Z")
 
@@ -54,6 +57,36 @@ async def test_setup_platform(
         assert x == snapshot(name=f"{x.entity_id}-state")
 
 
+@pytest.mark.parametrize("install", ["default"])
+async def test_entities_update_over_time(
+    hass: HomeAssistant,
+    config: dict[str, str],
+    install: str,
+    snapshot: SnapshotAssertion,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """Test extended attributes update as time passes.
+
+    Verifies that time-dependent state attrs (e.g. schedules) vary as time advances.
+    """
+
+    # Cannot use the evohome fixture here, as need to set dtm first
+    #  - some extended state attrs are relative the current time
+    freezer.move_to("2024-07-10T05:30:00Z")
+
+    # stay inside this context to have the mocked RESTful API
+    async for _ in setup_evohome(hass, config, install=install):
+        for x in hass.states.async_all(Platform.CLIMATE):
+            assert x == snapshot(name=f"{x.entity_id}-state-initial")
+
+        freezer.tick(timedelta(hours=12))
+        async_fire_time_changed(hass)
+        await hass.async_block_till_done(wait_background_tasks=True)
+
+        for x in hass.states.async_all(Platform.CLIMATE):
+            assert x == snapshot(name=f"{x.entity_id}-state-updated")
+
+
 @pytest.mark.parametrize("install", TEST_INSTALLS)
 async def test_ctl_set_hvac_mode(
     hass: HomeAssistant,

tests/components/evohome/test_init.py

@@ -31,13 +31,9 @@ _MSG_USR = (
     "special characters accepted via the vendor's website are not valid here."
 )
 
-LOG_HINT_429_CREDS = ("evohome.credentials", logging.ERROR, _MSG_429)
-LOG_HINT_OTH_CREDS = ("evohome.credentials", logging.ERROR, _MSG_OTH)
-LOG_HINT_USR_CREDS = ("evohome.credentials", logging.ERROR, _MSG_USR)
-
-LOG_HINT_429_AUTH = ("evohome.auth", logging.ERROR, _MSG_429)
-LOG_HINT_OTH_AUTH = ("evohome.auth", logging.ERROR, _MSG_OTH)
-LOG_HINT_USR_AUTH = ("evohome.auth", logging.ERROR, _MSG_USR)
+LOG_HINT_429_AUTH = ("evohomeasync2.auth", logging.ERROR, _MSG_429)
+LOG_HINT_OTH_AUTH = ("evohomeasync2.auth", logging.ERROR, _MSG_OTH)
+LOG_HINT_USR_AUTH = ("evohomeasync2.auth", logging.ERROR, _MSG_USR)
 
 LOG_FAIL_CONNECTION = (
     "homeassistant.components.evohome",
@@ -110,10 +106,10 @@ EXC_BAD_GATEWAY = aiohttp.ClientResponseError(
 )
 
 AUTHENTICATION_TESTS: dict[Exception, list] = {
-    EXC_BAD_CONNECTION: [LOG_HINT_OTH_CREDS, LOG_FAIL_CONNECTION, LOG_SETUP_FAILED],
-    EXC_BAD_CREDENTIALS: [LOG_HINT_USR_CREDS, LOG_FAIL_CREDENTIALS, LOG_SETUP_FAILED],
-    EXC_BAD_GATEWAY: [LOG_HINT_OTH_CREDS, LOG_FAIL_GATEWAY, LOG_SETUP_FAILED],
-    EXC_TOO_MANY_REQUESTS: [LOG_HINT_429_CREDS, LOG_FAIL_TOO_MANY, LOG_SETUP_FAILED],
+    EXC_BAD_CONNECTION: [LOG_HINT_OTH_AUTH, LOG_FAIL_CONNECTION, LOG_SETUP_FAILED],
+    EXC_BAD_CREDENTIALS: [LOG_HINT_USR_AUTH, LOG_FAIL_CREDENTIALS, LOG_SETUP_FAILED],
+    EXC_BAD_GATEWAY: [LOG_HINT_OTH_AUTH, LOG_FAIL_GATEWAY, LOG_SETUP_FAILED],
+    EXC_TOO_MANY_REQUESTS: [LOG_HINT_429_AUTH, LOG_FAIL_TOO_MANY, LOG_SETUP_FAILED],
 }
 
 CLIENT_REQUEST_TESTS: dict[Exception, list] = {
@@ -137,7 +133,8 @@ async def test_authentication_failure_v2(
 
     with (
         patch(
-            "evohome.credentials.CredentialsManagerBase._request", side_effect=exception
+            "_evohome.credentials.CredentialsManagerBase._request",
+            side_effect=exception,
         ),
         caplog.at_level(logging.WARNING),
     ):
@@ -165,7 +162,7 @@ async def test_client_request_failure_v2(
             "evohomeasync2.auth.CredentialsManagerBase._post_request",
             mock_post_request("default"),
         ),
-        patch("evohome.auth.AbstractAuth._request", side_effect=exception),
+        patch("_evohome.auth.AbstractAuth._request", side_effect=exception),
         caplog.at_level(logging.WARNING),
     ):
         result = await async_setup_component(hass, DOMAIN, {DOMAIN: config})

tests/components/fressnapf_tracker/conftest.py

@@ -35,6 +35,38 @@ MOCK_SERIAL_NUMBER = "ABC123456"
 MOCK_DEVICE_TOKEN = "mock_device_token"
 
 
+def create_mock_tracker() -> Tracker:
+    """Create a fresh mock Tracker instance."""
+    return Tracker(
+        name="Fluffy",
+        battery=85,
+        charging=False,
+        position=Position(
+            lat=52.520008,
+            lng=13.404954,
+            accuracy=10,
+            timestamp="2024-01-15T12:00:00Z",
+        ),
+        tracker_settings=TrackerSettings(
+            generation="GPS Tracker 2.0",
+            features=TrackerFeatures(
+                flash_light=True, energy_saving_mode=True, live_tracking=True
+            ),
+        ),
+        led_brightness=LedBrightness(status="ok", value=50),
+        energy_saving=EnergySaving(status="ok", value=1),
+        deep_sleep=None,
+        led_activatable=LedActivatable(
+            has_led=True,
+            seen_recently=True,
+            nonempty_battery=True,
+            not_charging=True,
+            overall=True,
+        ),
+        icon="http://res.cloudinary.com/iot-venture/image/upload/v1717594357/kyaqq7nfitrdvaoakb8s.jpg",
+    )
+
+
 @pytest.fixture
 def mock_setup_entry() -> Generator[AsyncMock]:
     """Override async_setup_entry."""
@@ -102,42 +134,26 @@ def mock_auth_client(mock_device: Device) -> Generator[MagicMock]:
 
 
 @pytest.fixture
-def mock_api_client() -> Generator[MagicMock]:
-    """Mock the ApiClient."""
+def mock_api_client_init() -> Generator[MagicMock]:
+    """Mock the ApiClient used by _tracker_is_valid in __init__.py."""
     with patch(
-        "homeassistant.components.fressnapf_tracker.coordinator.ApiClient"
-    ) as mock_api_client:
-        client = mock_api_client.return_value
-        client.get_tracker = AsyncMock(
-            return_value=Tracker(
-                name="Fluffy",
-                battery=85,
-                charging=False,
-                position=Position(
-                    lat=52.520008,
-                    lng=13.404954,
-                    accuracy=10,
-                    timestamp="2024-01-15T12:00:00Z",
-                ),
-                tracker_settings=TrackerSettings(
-                    generation="GPS Tracker 2.0",
-                    features=TrackerFeatures(
-                        flash_light=True, energy_saving_mode=True, live_tracking=True
-                    ),
-                ),
-                led_brightness=LedBrightness(status="ok", value=50),
-                energy_saving=EnergySaving(status="ok", value=1),
-                deep_sleep=None,
-                led_activatable=LedActivatable(
-                    has_led=True,
-                    seen_recently=True,
-                    nonempty_battery=True,
-                    not_charging=True,
-                    overall=True,
-                ),
-                icon="http://res.cloudinary.com/iot-venture/image/upload/v1717594357/kyaqq7nfitrdvaoakb8s.jpg",
-            )
-        )
+        "homeassistant.components.fressnapf_tracker.ApiClient",
+        autospec=True,
+    ) as mock_client:
+        client = mock_client.return_value
+        client.get_tracker = AsyncMock(return_value=create_mock_tracker())
+        yield client
+
+
+@pytest.fixture
+def mock_api_client_coordinator() -> Generator[MagicMock]:
+    """Mock the ApiClient used by the coordinator."""
+    with patch(
+        "homeassistant.components.fressnapf_tracker.coordinator.ApiClient",
+        autospec=True,
+    ) as mock_client:
+        client = mock_client.return_value
+        client.get_tracker = AsyncMock(return_value=create_mock_tracker())
         client.set_led_brightness = AsyncMock(return_value=None)
         client.set_energy_saving = AsyncMock(return_value=None)
         yield client
@@ -162,7 +178,8 @@ def mock_config_entry() -> MockConfigEntry:
 async def init_integration(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
-    mock_api_client: MagicMock,
+    mock_api_client_init: MagicMock,
+    mock_api_client_coordinator: MagicMock,
     mock_auth_client: MagicMock,
 ) -> MockConfigEntry:
     """Set up the integration for testing."""

tests/components/fressnapf_tracker/test_config_flow.py

@@ -216,7 +216,9 @@ async def test_user_flow_duplicate_phone_number(
         ),
     ],
 )
-@pytest.mark.usefixtures("mock_api_client", "mock_auth_client")
+@pytest.mark.usefixtures(
+    "mock_api_client_init", "mock_api_client_coordinator", "mock_auth_client"
+)
 async def test_reauth_reconfigure_flow(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
@@ -270,7 +272,7 @@ async def test_reauth_reconfigure_flow(
         ),
     ],
 )
-@pytest.mark.usefixtures("mock_api_client")
+@pytest.mark.usefixtures("mock_api_client_init", "mock_api_client_coordinator")
 async def test_reauth_reconfigure_flow_invalid_phone_number(
     hass: HomeAssistant,
     mock_auth_client: MagicMock,
@@ -333,7 +335,7 @@ async def test_reauth_reconfigure_flow_invalid_phone_number(
         ),
     ],
 )
-@pytest.mark.usefixtures("mock_api_client")
+@pytest.mark.usefixtures("mock_api_client_init", "mock_api_client_coordinator")
 async def test_reauth_reconfigure_flow_invalid_sms_code(
     hass: HomeAssistant,
     mock_auth_client: MagicMock,
@@ -393,7 +395,7 @@ async def test_reauth_reconfigure_flow_invalid_sms_code(
         ),
     ],
 )
-@pytest.mark.usefixtures("mock_api_client")
+@pytest.mark.usefixtures("mock_api_client_init", "mock_api_client_coordinator")
 async def test_reauth_reconfigure_flow_invalid_user_id(
     hass: HomeAssistant,
     mock_auth_client: MagicMock,

tests/components/fressnapf_tracker/test_device_tracker.py

@@ -40,12 +40,12 @@ async def test_device_tracker_no_position(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
     mock_tracker_no_position: Tracker,
-    mock_api_client: MagicMock,
+    mock_api_client_init: MagicMock,
 ) -> None:
     """Test device tracker is unavailable when position is None."""
     mock_config_entry.add_to_hass(hass)
 
-    mock_api_client.get_tracker = AsyncMock(return_value=mock_tracker_no_position)
+    mock_api_client_init.get_tracker = AsyncMock(return_value=mock_tracker_no_position)
     await hass.config_entries.async_setup(mock_config_entry.entry_id)
     await hass.async_block_till_done()
 

tests/components/fressnapf_tracker/test_init.py

@@ -1,19 +1,40 @@
 """Test the Fressnapf Tracker integration init."""
 
-from unittest.mock import AsyncMock, MagicMock
+from collections.abc import Generator
+from unittest.mock import AsyncMock, MagicMock, patch
 
+from fressnapftracker import (
+    FressnapfTrackerError,
+    FressnapfTrackerInvalidTrackerResponseError,
+)
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
+from homeassistant.components.fressnapf_tracker.const import DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers import device_registry as dr, issue_registry as ir
+
+from .conftest import MOCK_SERIAL_NUMBER
 
 from tests.common import MockConfigEntry
 
 
-@pytest.mark.usefixtures("mock_auth_client")
-@pytest.mark.usefixtures("mock_api_client")
+@pytest.fixture
+def mock_api_client_malformed_tracker() -> Generator[MagicMock]:
+    """Mock the ApiClient for a malformed tracker response in _tracker_is_valid."""
+    with patch(
+        "homeassistant.components.fressnapf_tracker.ApiClient",
+        autospec=True,
+    ) as mock_api_client:
+        client = mock_api_client.return_value
+        client.get_tracker = AsyncMock(
+            side_effect=FressnapfTrackerInvalidTrackerResponseError("Invalid tracker")
+        )
+        yield client
+
+
+@pytest.mark.usefixtures("mock_auth_client", "mock_api_client_init")
 async def test_setup_entry(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
@@ -27,8 +48,7 @@ async def test_setup_entry(
     assert mock_config_entry.state is ConfigEntryState.LOADED
 
 
-@pytest.mark.usefixtures("mock_auth_client")
-@pytest.mark.usefixtures("mock_api_client")
+@pytest.mark.usefixtures("mock_auth_client", "mock_api_client_init")
 async def test_unload_entry(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
@@ -48,15 +68,18 @@ async def test_unload_entry(
 
 
 @pytest.mark.usefixtures("mock_auth_client")
-async def test_setup_entry_api_error(
+async def test_setup_entry_tracker_is_valid_api_error(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
-    mock_api_client: MagicMock,
+    mock_api_client_init: MagicMock,
 ) -> None:
-    """Test setup fails when API returns error."""
+    """Test setup retries when API returns error during _tracker_is_valid."""
     mock_config_entry.add_to_hass(hass)
 
-    mock_api_client.get_tracker = AsyncMock(side_effect=Exception("API Error"))
+    mock_api_client_init.get_tracker = AsyncMock(
+        side_effect=FressnapfTrackerError("API Error")
+    )
+
     await hass.config_entries.async_setup(mock_config_entry.entry_id)
     await hass.async_block_till_done()
 
@@ -78,3 +101,48 @@ async def test_state_entity_device_snapshots(
         assert device_entry == snapshot(name=f"{device_entry.name}-entry"), (
             f"device entry snapshot failed for {device_entry.name}"
         )
+
+
+@pytest.mark.usefixtures("mock_auth_client", "mock_api_client_malformed_tracker")
+async def test_invalid_tracker(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    issue_registry: ir.IssueRegistry,
+) -> None:
+    """Test that an issue is created when an invalid tracker is detected."""
+    mock_config_entry.add_to_hass(hass)
+
+    await hass.config_entries.async_setup(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    assert mock_config_entry.state is ConfigEntryState.LOADED
+    assert len(issue_registry.issues) == 1
+
+    issue_id = f"invalid_fressnapf_tracker_{MOCK_SERIAL_NUMBER}"
+    assert issue_registry.async_get_issue(DOMAIN, issue_id)
+
+
+@pytest.mark.usefixtures("mock_auth_client", "mock_api_client_malformed_tracker")
+async def test_invalid_tracker_already_exists(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    issue_registry: ir.IssueRegistry,
+) -> None:
+    """Test that an existing issue is not duplicated."""
+    ir.async_create_issue(
+        hass,
+        DOMAIN,
+        f"invalid_fressnapf_tracker_{MOCK_SERIAL_NUMBER}",
+        is_fixable=False,
+        severity=ir.IssueSeverity.WARNING,
+        translation_key="invalid_fressnapf_tracker",
+        translation_placeholders={"tracker_id": MOCK_SERIAL_NUMBER},
+    )
+
+    mock_config_entry.add_to_hass(hass)
+
+    await hass.config_entries.async_setup(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    assert mock_config_entry.state is ConfigEntryState.LOADED
+    assert len(issue_registry.issues) == 1

tests/components/fressnapf_tracker/test_light.py

@@ -63,10 +63,10 @@ async def test_not_added_when_no_led(
     hass: HomeAssistant,
     entity_registry: er.EntityRegistry,
     mock_config_entry: MockConfigEntry,
-    mock_api_client: MagicMock,
+    mock_api_client_init: MagicMock,
 ) -> None:
     """Test light entity is created correctly."""
-    mock_api_client.get_tracker.return_value = TRACKER_NO_LED
+    mock_api_client_init.get_tracker.return_value = TRACKER_NO_LED
 
     mock_config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(mock_config_entry.entry_id)
@@ -81,7 +81,7 @@ async def test_not_added_when_no_led(
 @pytest.mark.usefixtures("init_integration")
 async def test_turn_on(
     hass: HomeAssistant,
-    mock_api_client: MagicMock,
+    mock_api_client_coordinator: MagicMock,
 ) -> None:
     """Test turning the light on."""
     entity_id = "light.fluffy_flashlight"
@@ -97,13 +97,13 @@ async def test_turn_on(
         blocking=True,
     )
 
-    mock_api_client.set_led_brightness.assert_called_once_with(100)
+    mock_api_client_coordinator.set_led_brightness.assert_called_once_with(100)
 
 
 @pytest.mark.usefixtures("init_integration")
 async def test_turn_on_with_brightness(
     hass: HomeAssistant,
-    mock_api_client: MagicMock,
+    mock_api_client_coordinator: MagicMock,
 ) -> None:
     """Test turning the light on with brightness."""
     entity_id = "light.fluffy_flashlight"
@@ -116,13 +116,13 @@ async def test_turn_on_with_brightness(
     )
 
     # 128/255 * 100 = 50
-    mock_api_client.set_led_brightness.assert_called_once_with(50)
+    mock_api_client_coordinator.set_led_brightness.assert_called_once_with(50)
 
 
 @pytest.mark.usefixtures("init_integration")
 async def test_turn_off(
     hass: HomeAssistant,
-    mock_api_client: MagicMock,
+    mock_api_client_coordinator: MagicMock,
 ) -> None:
     """Test turning the light off."""
     entity_id = "light.fluffy_flashlight"
@@ -138,7 +138,7 @@ async def test_turn_off(
         blocking=True,
     )
 
-    mock_api_client.set_led_brightness.assert_called_once_with(0)
+    mock_api_client_coordinator.set_led_brightness.assert_called_once_with(0)
 
 
 @pytest.mark.parametrize(
@@ -153,12 +153,13 @@ async def test_turn_off(
 async def test_turn_on_led_not_activatable(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
-    mock_api_client: MagicMock,
+    mock_api_client_init: MagicMock,
+    mock_api_client_coordinator: MagicMock,
     activatable_parameter: str,
 ) -> None:
     """Test turning on the light when LED is not activatable raises."""
     setattr(
-        mock_api_client.get_tracker.return_value.led_activatable,
+        mock_api_client_init.get_tracker.return_value.led_activatable,
         activatable_parameter,
         False,
     )
@@ -177,7 +178,7 @@ async def test_turn_on_led_not_activatable(
             blocking=True,
         )
 
-    mock_api_client.set_led_brightness.assert_not_called()
+    mock_api_client_coordinator.set_led_brightness.assert_not_called()
 
 
 @pytest.mark.parametrize(
@@ -191,11 +192,11 @@ async def test_turn_on_led_not_activatable(
     ],
 )
 @pytest.mark.parametrize("service", [SERVICE_TURN_ON, SERVICE_TURN_OFF])
-@pytest.mark.usefixtures("mock_auth_client")
+@pytest.mark.usefixtures("mock_auth_client", "mock_api_client_init")
 async def test_turn_on_off_error(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
-    mock_api_client: MagicMock,
+    mock_api_client_coordinator: MagicMock,
     api_exception: FressnapfTrackerError,
     expected_exception: type[HomeAssistantError],
     service: str,
@@ -208,7 +209,7 @@ async def test_turn_on_off_error(
 
     entity_id = "light.fluffy_flashlight"
 
-    mock_api_client.set_led_brightness.side_effect = api_exception
+    mock_api_client_coordinator.set_led_brightness.side_effect = api_exception
     with pytest.raises(expected_exception):
         await hass.services.async_call(
             LIGHT_DOMAIN,

tests/components/fressnapf_tracker/test_switch.py

@@ -62,10 +62,10 @@ async def test_not_added_when_no_energy_saving_mode(
     hass: HomeAssistant,
     entity_registry: er.EntityRegistry,
     mock_config_entry: MockConfigEntry,
-    mock_api_client: MagicMock,
+    mock_api_client_init: MagicMock,
 ) -> None:
     """Test switch entity is created correctly."""
-    mock_api_client.get_tracker.return_value = TRACKER_NO_ENERGY_SAVING_MODE
+    mock_api_client_init.get_tracker.return_value = TRACKER_NO_ENERGY_SAVING_MODE
 
     mock_config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(mock_config_entry.entry_id)
@@ -80,7 +80,7 @@ async def test_not_added_when_no_energy_saving_mode(
 @pytest.mark.usefixtures("init_integration")
 async def test_turn_on(
     hass: HomeAssistant,
-    mock_api_client: MagicMock,
+    mock_api_client_coordinator: MagicMock,
 ) -> None:
     """Test turning the switch on."""
     entity_id = "switch.fluffy_sleep_mode"
@@ -96,13 +96,13 @@ async def test_turn_on(
         blocking=True,
     )
 
-    mock_api_client.set_energy_saving.assert_called_once_with(True)
+    mock_api_client_coordinator.set_energy_saving.assert_called_once_with(True)
 
 
 @pytest.mark.usefixtures("init_integration")
 async def test_turn_off(
     hass: HomeAssistant,
-    mock_api_client: MagicMock,
+    mock_api_client_coordinator: MagicMock,
 ) -> None:
     """Test turning the switch off."""
     entity_id = "switch.fluffy_sleep_mode"
@@ -118,7 +118,7 @@ async def test_turn_off(
         blocking=True,
     )
 
-    mock_api_client.set_energy_saving.assert_called_once_with(False)
+    mock_api_client_coordinator.set_energy_saving.assert_called_once_with(False)
 
 
 @pytest.mark.parametrize(
@@ -132,11 +132,11 @@ async def test_turn_off(
     ],
 )
 @pytest.mark.parametrize("service", [SERVICE_TURN_ON, SERVICE_TURN_OFF])
-@pytest.mark.usefixtures("mock_auth_client")
+@pytest.mark.usefixtures("mock_auth_client", "mock_api_client_init")
 async def test_turn_on_off_error(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
-    mock_api_client: MagicMock,
+    mock_api_client_coordinator: MagicMock,
     api_exception: FressnapfTrackerError,
     expected_exception: type[HomeAssistantError],
     service: str,
@@ -149,7 +149,7 @@ async def test_turn_on_off_error(
 
     entity_id = "switch.fluffy_sleep_mode"
 
-    mock_api_client.set_energy_saving.side_effect = api_exception
+    mock_api_client_coordinator.set_energy_saving.side_effect = api_exception
     with pytest.raises(expected_exception):
         await hass.services.async_call(
             SWITCH_DOMAIN,

tests/components/group/test_sensor.py

@@ -12,6 +12,7 @@ import pytest
 from homeassistant import config as hass_config
 from homeassistant.components.group import DOMAIN
 from homeassistant.components.group.sensor import (
+    ATTR_FIRST_AVAILABLE_ENTITY_ID,
     ATTR_LAST_ENTITY_ID,
     ATTR_MAX_ENTITY_ID,
     ATTR_MIN_ENTITY_ID,
@@ -86,6 +87,11 @@ def set_or_remove_state(
         ("mean", MEAN, {}),
         ("median", MEDIAN, {}),
         ("last", VALUES[2], {ATTR_LAST_ENTITY_ID: "sensor.test_3"}),
+        (
+            "first_available",
+            VALUES[0],
+            {ATTR_FIRST_AVAILABLE_ENTITY_ID: "sensor.test_1"},
+        ),
         ("range", RANGE, {}),
         ("stdev", STDEV, {}),
         ("sum", SUM_VALUE, {}),
@@ -861,6 +867,62 @@ async def test_last_sensor(hass: HomeAssistant) -> None:
         assert state.attributes.get("last_entity_id") == entity_id
 
 
+async def test_first_available_sensor(hass: HomeAssistant) -> None:
+    """Test the first available sensor."""
+    config = {
+        SENSOR_DOMAIN: {
+            "platform": DOMAIN,
+            "name": "test_first_available",
+            "type": "first_available",
+            "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
+            "unique_id": "very_unique_id_first_available_sensor",
+            "ignore_non_numeric": True,
+        }
+    }
+
+    assert await async_setup_component(hass, "sensor", config)
+    await hass.async_block_till_done()
+
+    entity_ids = config["sensor"]["entities"]
+
+    # Ensure that while sensor states are being set
+    # the group will always point to the first available sensor.
+
+    for entity_id, value in dict(zip(entity_ids, VALUES, strict=False)).items():
+        hass.states.async_set(entity_id, value)
+        await hass.async_block_till_done()
+        state = hass.states.get("sensor.test_first_available")
+        assert str(float(VALUES[0])) == state.state
+        assert entity_ids[0] == state.attributes.get("first_available_entity_id")
+
+    # If the second sensor of the group becomes unavailable
+    # then the first one should still be taken.
+
+    hass.states.async_set(entity_ids[1], STATE_UNAVAILABLE)
+    await hass.async_block_till_done()
+    state = hass.states.get("sensor.test_first_available")
+    assert str(float(VALUES[0])) == state.state
+    assert entity_ids[0] == state.attributes.get("first_available_entity_id")
+
+    # If the first sensor of the group becomes now unavailable
+    # then the third one should be taken.
+
+    hass.states.async_set(entity_ids[0], STATE_UNAVAILABLE)
+    await hass.async_block_till_done()
+    state = hass.states.get("sensor.test_first_available")
+    assert str(float(VALUES[2])) == state.state
+    assert entity_ids[2] == state.attributes.get("first_available_entity_id")
+
+    # If all sensors of the group become unavailable
+    # then the group should also be unavailable.
+
+    hass.states.async_set(entity_ids[2], STATE_UNAVAILABLE)
+    await hass.async_block_till_done()
+    state = hass.states.get("sensor.test_first_available")
+    assert state.state == STATE_UNAVAILABLE
+    assert state.attributes.get("first_available_entity_id") is None
+
+
 async def test_sensors_attributes_added_when_entity_info_available(
     hass: HomeAssistant,
 ) -> None:

tests/components/infrared/__init__.py

@@ -1 +0,0 @@
-"""Tests for the Infrared integration."""

tests/components/infrared/conftest.py

@@ -1,37 +0,0 @@
-"""Common fixtures for the Infrared tests."""
-
-import pytest
-
-from homeassistant.components.infrared import InfraredCommand, InfraredEntity
-from homeassistant.components.infrared.const import DOMAIN
-from homeassistant.core import HomeAssistant
-from homeassistant.setup import async_setup_component
-
-
-@pytest.fixture
-async def init_integration(hass: HomeAssistant) -> None:
-    """Set up the Infrared integration for testing."""
-    assert await async_setup_component(hass, DOMAIN, {})
-    await hass.async_block_till_done()
-
-
-class MockInfraredEntity(InfraredEntity):
-    """Mock infrared entity for testing."""
-
-    _attr_has_entity_name = True
-    _attr_name = "Test IR transmitter"
-
-    def __init__(self, unique_id: str) -> None:
-        """Initialize mock entity."""
-        self._attr_unique_id = unique_id
-        self.send_command_calls: list[InfraredCommand] = []
-
-    async def async_send_command(self, command: InfraredCommand) -> None:
-        """Mock send command."""
-        self.send_command_calls.append(command)
-
-
-@pytest.fixture
-def mock_infrared_entity() -> MockInfraredEntity:
-    """Return a mock infrared entity."""
-    return MockInfraredEntity("test_ir_transmitter")

tests/components/infrared/test_init.py

@@ -1,146 +0,0 @@
-"""Tests for the Infrared integration setup."""
-
-from unittest.mock import AsyncMock
-
-from freezegun.api import FrozenDateTimeFactory
-import pytest
-
-from homeassistant.components.infrared import (
-    DATA_COMPONENT,
-    DOMAIN,
-    NECInfraredCommand,
-    async_get_emitters,
-    async_send_command,
-)
-from homeassistant.const import STATE_UNKNOWN
-from homeassistant.core import HomeAssistant, State
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.setup import async_setup_component
-from homeassistant.util import dt as dt_util
-
-from .conftest import MockInfraredEntity
-
-from tests.common import mock_restore_cache
-
-
-async def test_get_entities_integration_setup(hass: HomeAssistant) -> None:
-    """Test getting entities when the integration is not setup."""
-    assert async_get_emitters(hass) == []
-
-
-@pytest.mark.usefixtures("init_integration")
-async def test_get_entities_empty(hass: HomeAssistant) -> None:
-    """Test getting entities when none are registered."""
-    assert async_get_emitters(hass) == []
-
-
-@pytest.mark.usefixtures("init_integration")
-async def test_infrared_entity_initial_state(
-    hass: HomeAssistant, mock_infrared_entity: MockInfraredEntity
-) -> None:
-    """Test infrared entity has no state before any command is sent."""
-    component = hass.data[DATA_COMPONENT]
-    await component.async_add_entities([mock_infrared_entity])
-
-    state = hass.states.get("infrared.test_ir_transmitter")
-    assert state is not None
-    assert state.state == STATE_UNKNOWN
-
-
-@pytest.mark.usefixtures("init_integration")
-async def test_async_send_command_success(
-    hass: HomeAssistant,
-    mock_infrared_entity: MockInfraredEntity,
-    freezer: FrozenDateTimeFactory,
-) -> None:
-    """Test sending command via async_send_command helper."""
-    # Add the mock entity to the component
-    component = hass.data[DATA_COMPONENT]
-    await component.async_add_entities([mock_infrared_entity])
-
-    # Freeze time so we can verify the state update
-    now = dt_util.utcnow()
-    freezer.move_to(now)
-
-    command = NECInfraredCommand(address=0x04FB, command=0x08F7, modulation=38000)
-    await async_send_command(hass, mock_infrared_entity.entity_id, command)
-
-    assert len(mock_infrared_entity.send_command_calls) == 1
-    assert mock_infrared_entity.send_command_calls[0] is command
-
-    state = hass.states.get("infrared.test_ir_transmitter")
-    assert state is not None
-    assert state.state == now.isoformat(timespec="milliseconds")
-
-
-@pytest.mark.usefixtures("init_integration")
-async def test_async_send_command_error_does_not_update_state(
-    hass: HomeAssistant,
-    mock_infrared_entity: MockInfraredEntity,
-) -> None:
-    """Test that state is not updated when async_send_command raises an error."""
-    component = hass.data[DATA_COMPONENT]
-    await component.async_add_entities([mock_infrared_entity])
-
-    state = hass.states.get("infrared.test_ir_transmitter")
-    assert state is not None
-    assert state.state == STATE_UNKNOWN
-
-    command = NECInfraredCommand(address=0x04FB, command=0x08F7, modulation=38000)
-
-    mock_infrared_entity.async_send_command = AsyncMock(
-        side_effect=HomeAssistantError("Transmission failed")
-    )
-
-    with pytest.raises(HomeAssistantError, match="Transmission failed"):
-        await async_send_command(hass, mock_infrared_entity.entity_id, command)
-
-    # Verify state was not updated after the error
-    state = hass.states.get("infrared.test_ir_transmitter")
-    assert state is not None
-    assert state.state == STATE_UNKNOWN
-
-
-@pytest.mark.usefixtures("init_integration")
-async def test_async_send_command_entity_not_found(hass: HomeAssistant) -> None:
-    """Test async_send_command raises error when entity not found."""
-    command = NECInfraredCommand(
-        address=0x04FB, command=0x08F7, modulation=38000, repeat_count=1
-    )
-
-    with pytest.raises(
-        HomeAssistantError,
-        match="Infrared entity `infrared.nonexistent_entity` not found",
-    ):
-        await async_send_command(hass, "infrared.nonexistent_entity", command)
-
-
-async def test_async_send_command_component_not_loaded(hass: HomeAssistant) -> None:
-    """Test async_send_command raises error when component not loaded."""
-    command = NECInfraredCommand(
-        address=0x04FB, command=0x08F7, modulation=38000, repeat_count=1
-    )
-
-    with pytest.raises(HomeAssistantError, match="component_not_loaded"):
-        await async_send_command(hass, "infrared.some_entity", command)
-
-
-async def test_infrared_entity_state_restore(
-    hass: HomeAssistant,
-    mock_infrared_entity: MockInfraredEntity,
-) -> None:
-    """Test infrared entity restores state from previous session."""
-    previous_timestamp = "2026-01-01T12:00:00.000+00:00"
-    mock_restore_cache(
-        hass, [State("infrared.test_ir_transmitter", previous_timestamp)]
-    )
-
-    assert await async_setup_component(hass, DOMAIN, {})
-    await hass.async_block_till_done()
-
-    component = hass.data[DATA_COMPONENT]
-    await component.async_add_entities([mock_infrared_entity])
-
-    state = hass.states.get("infrared.test_ir_transmitter")
-    assert state is not None
-    assert state.state == previous_timestamp

tests/components/infrared/test_protocols.py

@@ -1,128 +0,0 @@
-"""Tests for the Infrared protocol definitions."""
-
-from homeassistant.components.infrared import NECInfraredCommand, Timing
-
-
-def test_nec_command_get_raw_timings_standard() -> None:
-    """Test NEC command raw timings generation for standard 8-bit address."""
-    expected_raw_timings = [
-        Timing(high_us=9000, low_us=4500),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=0),
-    ]
-    command = NECInfraredCommand(
-        address=0x04, command=0x08, modulation=38000, repeat_count=0
-    )
-    timings = command.get_raw_timings()
-    assert timings == expected_raw_timings
-
-    # Same command now with 2 repeats
-    command_with_repeats = NECInfraredCommand(
-        address=command.address,
-        command=command.command,
-        modulation=command.modulation,
-        repeat_count=2,
-    )
-    timings_with_repeats = command_with_repeats.get_raw_timings()
-    assert timings_with_repeats == [
-        *expected_raw_timings[:-1],
-        Timing(high_us=562, low_us=96000),
-        Timing(high_us=9000, low_us=2250),
-        Timing(high_us=562, low_us=96000),
-        Timing(high_us=9000, low_us=2250),
-        Timing(high_us=562, low_us=0),
-    ]
-
-
-def test_nec_command_get_raw_timings_extended() -> None:
-    """Test NEC command raw timings generation for extended 16-bit address."""
-    expected_raw_timings = [
-        Timing(high_us=9000, low_us=4500),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=562),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=1687),
-        Timing(high_us=562, low_us=0),
-    ]
-
-    command = NECInfraredCommand(
-        address=0x04FB, command=0x08, modulation=38000, repeat_count=0
-    )
-    timings = command.get_raw_timings()
-    assert timings == expected_raw_timings
-
-    # Same command now with 2 repeats
-    command_with_repeats = NECInfraredCommand(
-        address=command.address,
-        command=command.command,
-        modulation=command.modulation,
-        repeat_count=2,
-    )
-    timings_with_repeats = command_with_repeats.get_raw_timings()
-    assert timings_with_repeats == [
-        *expected_raw_timings[:-1],
-        Timing(high_us=562, low_us=96000),
-        Timing(high_us=9000, low_us=2250),
-        Timing(high_us=562, low_us=96000),
-        Timing(high_us=9000, low_us=2250),
-        Timing(high_us=562, low_us=0),
-    ]

tests/components/light/common.py

@@ -26,6 +26,7 @@ from homeassistant.components.light import (
     DOMAIN,
     ColorMode,
     LightEntity,
+    LightEntityFeature,
 )
 from homeassistant.const import (
     ATTR_ENTITY_ID,
@@ -156,7 +157,7 @@ class MockLight(MockToggleEntity, LightEntity):
 
     _attr_max_color_temp_kelvin = DEFAULT_MAX_KELVIN
     _attr_min_color_temp_kelvin = DEFAULT_MIN_KELVIN
-    supported_features = 0
+    supported_features = LightEntityFeature(0)
 
     brightness = None
     color_temp_kelvin = None

tests/components/light/test_init.py

@@ -1,7 +1,5 @@
 """The tests for the Light component."""
 
-from types import ModuleType
-from typing import Literal
 from unittest.mock import MagicMock, mock_open, patch
 
 import pytest
@@ -30,9 +28,6 @@ from tests.common import (
     MockEntityPlatform,
     MockUser,
     async_mock_service,
-    help_test_all,
-    import_and_test_deprecated_constant,
-    import_and_test_deprecated_constant_enum,
     setup_test_component_platform,
 )
 
@@ -137,13 +132,10 @@ async def test_services(
     ent3.supported_color_modes = [light.ColorMode.HS]
     ent1.supported_features = light.LightEntityFeature.TRANSITION
     ent2.supported_features = (
-        light.SUPPORT_COLOR
-        | light.LightEntityFeature.EFFECT
-        | light.LightEntityFeature.TRANSITION
+        light.LightEntityFeature.EFFECT | light.LightEntityFeature.TRANSITION
     )
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    ent2.supported_color_modes = None
-    ent2.color_mode = None
+    ent2.supported_color_modes = [light.ColorMode.HS]
+    ent2.color_mode = light.ColorMode.HS
     ent3.supported_features = (
         light.LightEntityFeature.FLASH | light.LightEntityFeature.TRANSITION
     )
@@ -903,16 +895,12 @@ async def test_light_brightness_step(hass: HomeAssistant) -> None:
     setup_test_component_platform(hass, light.DOMAIN, entities)
 
     entity0 = entities[0]
-    entity0.supported_features = light.SUPPORT_BRIGHTNESS
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity0.supported_color_modes = None
-    entity0.color_mode = None
+    entity0.supported_color_modes = {light.ColorMode.BRIGHTNESS}
+    entity0.color_mode = light.ColorMode.BRIGHTNESS
     entity0.brightness = 100
     entity1 = entities[1]
-    entity1.supported_features = light.SUPPORT_BRIGHTNESS
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity1.supported_color_modes = None
-    entity1.color_mode = None
+    entity1.supported_color_modes = {light.ColorMode.BRIGHTNESS}
+    entity1.color_mode = light.ColorMode.BRIGHTNESS
     entity1.brightness = 50
     assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
     await hass.async_block_till_done()
@@ -955,10 +943,8 @@ async def test_light_brightness_step_pct(hass: HomeAssistant) -> None:
 
     setup_test_component_platform(hass, light.DOMAIN, [entity])
 
-    entity.supported_features = light.SUPPORT_BRIGHTNESS
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity.supported_color_modes = None
-    entity.color_mode = None
+    entity.supported_color_modes = {light.ColorMode.BRIGHTNESS}
+    entity.color_mode = light.ColorMode.BRIGHTNESS
     entity.brightness = 255
     assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
     await hass.async_block_till_done()
@@ -1000,10 +986,8 @@ async def test_light_brightness_pct_conversion(
     setup_test_component_platform(hass, light.DOMAIN, mock_light_entities)
 
     entity = mock_light_entities[0]
-    entity.supported_features = light.SUPPORT_BRIGHTNESS
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity.supported_color_modes = None
-    entity.color_mode = None
+    entity.supported_color_modes = {light.ColorMode.BRIGHTNESS}
+    entity.color_mode = light.ColorMode.BRIGHTNESS
     entity.brightness = 100
     assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
     await hass.async_block_till_done()
@@ -1152,167 +1136,6 @@ invalid_no_brightness_no_color_no_transition,,,
         assert invalid_profile_name not in profiles.data
 
 
-@pytest.mark.parametrize("light_state", [STATE_ON, STATE_OFF])
-async def test_light_backwards_compatibility_supported_color_modes(
-    hass: HomeAssistant, light_state: Literal["on", "off"]
-) -> None:
-    """Test supported_color_modes if not implemented by the entity."""
-    entities = [
-        MockLight("Test_0", light_state),
-        MockLight("Test_1", light_state),
-        MockLight("Test_2", light_state),
-        MockLight("Test_3", light_state),
-        MockLight("Test_4", light_state),
-    ]
-
-    entity0 = entities[0]
-
-    entity1 = entities[1]
-    entity1.supported_features = light.SUPPORT_BRIGHTNESS
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity1.supported_color_modes = None
-    entity1.color_mode = None
-
-    entity2 = entities[2]
-    entity2.supported_features = light.SUPPORT_BRIGHTNESS | light.SUPPORT_COLOR_TEMP
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity2.supported_color_modes = None
-    entity2.color_mode = None
-
-    entity3 = entities[3]
-    entity3.supported_features = light.SUPPORT_BRIGHTNESS | light.SUPPORT_COLOR
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity3.supported_color_modes = None
-    entity3.color_mode = None
-
-    entity4 = entities[4]
-    entity4.supported_features = (
-        light.SUPPORT_BRIGHTNESS | light.SUPPORT_COLOR | light.SUPPORT_COLOR_TEMP
-    )
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity4.supported_color_modes = None
-    entity4.color_mode = None
-
-    setup_test_component_platform(hass, light.DOMAIN, entities)
-
-    assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
-    await hass.async_block_till_done()
-
-    state = hass.states.get(entity0.entity_id)
-    assert state.attributes["supported_color_modes"] == [light.ColorMode.ONOFF]
-    if light_state == STATE_OFF:
-        assert state.attributes["color_mode"] is None
-    else:
-        assert state.attributes["color_mode"] == light.ColorMode.ONOFF
-
-    state = hass.states.get(entity1.entity_id)
-    assert state.attributes["supported_color_modes"] == [light.ColorMode.BRIGHTNESS]
-    if light_state == STATE_OFF:
-        assert state.attributes["color_mode"] is None
-    else:
-        assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
-
-    state = hass.states.get(entity2.entity_id)
-    assert state.attributes["supported_color_modes"] == [light.ColorMode.COLOR_TEMP]
-    if light_state == STATE_OFF:
-        assert state.attributes["color_mode"] is None
-    else:
-        assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
-
-    state = hass.states.get(entity3.entity_id)
-    assert state.attributes["supported_color_modes"] == [light.ColorMode.HS]
-    if light_state == STATE_OFF:
-        assert state.attributes["color_mode"] is None
-    else:
-        assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
-
-    state = hass.states.get(entity4.entity_id)
-    assert state.attributes["supported_color_modes"] == [
-        light.ColorMode.COLOR_TEMP,
-        light.ColorMode.HS,
-    ]
-    if light_state == STATE_OFF:
-        assert state.attributes["color_mode"] is None
-    else:
-        assert state.attributes["color_mode"] == light.ColorMode.UNKNOWN
-
-
-async def test_light_backwards_compatibility_color_mode(hass: HomeAssistant) -> None:
-    """Test color_mode if not implemented by the entity."""
-    entities = [
-        MockLight("Test_0", STATE_ON),
-        MockLight("Test_1", STATE_ON),
-        MockLight("Test_2", STATE_ON),
-        MockLight("Test_3", STATE_ON),
-        MockLight("Test_4", STATE_ON),
-    ]
-
-    entity0 = entities[0]
-
-    entity1 = entities[1]
-    entity1.supported_features = light.SUPPORT_BRIGHTNESS
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity1.supported_color_modes = None
-    entity1.color_mode = None
-    entity1.brightness = 100
-
-    entity2 = entities[2]
-    entity2.supported_features = light.SUPPORT_BRIGHTNESS | light.SUPPORT_COLOR_TEMP
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity2.supported_color_modes = None
-    entity2.color_mode = None
-    entity2.color_temp_kelvin = 10000
-
-    entity3 = entities[3]
-    entity3.supported_features = light.SUPPORT_BRIGHTNESS | light.SUPPORT_COLOR
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity3.supported_color_modes = None
-    entity3.color_mode = None
-    entity3.hs_color = (240, 100)
-
-    entity4 = entities[4]
-    entity4.supported_features = (
-        light.SUPPORT_BRIGHTNESS | light.SUPPORT_COLOR | light.SUPPORT_COLOR_TEMP
-    )
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity4.supported_color_modes = None
-    entity4.color_mode = None
-    entity4.hs_color = (240, 100)
-    entity4.color_temp_kelvin = 10000
-
-    setup_test_component_platform(hass, light.DOMAIN, entities)
-
-    assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
-    await hass.async_block_till_done()
-
-    state = hass.states.get(entity0.entity_id)
-    assert state.attributes["supported_color_modes"] == [light.ColorMode.ONOFF]
-    assert state.attributes["color_mode"] == light.ColorMode.ONOFF
-
-    state = hass.states.get(entity1.entity_id)
-    assert state.attributes["supported_color_modes"] == [light.ColorMode.BRIGHTNESS]
-    assert state.attributes["color_mode"] == light.ColorMode.BRIGHTNESS
-
-    state = hass.states.get(entity2.entity_id)
-    assert state.attributes["supported_color_modes"] == [light.ColorMode.COLOR_TEMP]
-    assert state.attributes["color_mode"] == light.ColorMode.COLOR_TEMP
-    assert state.attributes["rgb_color"] == (202, 218, 255)
-    assert state.attributes["hs_color"] == (221.575, 20.9)
-    assert state.attributes["xy_color"] == (0.278, 0.287)
-
-    state = hass.states.get(entity3.entity_id)
-    assert state.attributes["supported_color_modes"] == [light.ColorMode.HS]
-    assert state.attributes["color_mode"] == light.ColorMode.HS
-
-    state = hass.states.get(entity4.entity_id)
-    assert state.attributes["supported_color_modes"] == [
-        light.ColorMode.COLOR_TEMP,
-        light.ColorMode.HS,
-    ]
-    # hs color prioritized over color_temp, light should report mode ColorMode.HS
-    assert state.attributes["color_mode"] == light.ColorMode.HS
-
-
 async def test_light_service_call_rgbw(hass: HomeAssistant) -> None:
     """Test rgbw functionality in service calls."""
     entity0 = MockLight("Test_rgbw", STATE_ON)
@@ -1478,7 +1301,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
         MockLight("Test_rgb", STATE_ON),
         MockLight("Test_xy", STATE_ON),
         MockLight("Test_all", STATE_ON),
-        MockLight("Test_legacy", STATE_ON),
         MockLight("Test_rgbw", STATE_ON),
         MockLight("Test_rgbww", STATE_ON),
         MockLight("Test_temperature", STATE_ON),
@@ -1502,19 +1324,13 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     }
 
     entity4 = entities[4]
-    entity4.supported_features = light.SUPPORT_COLOR
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity4.supported_color_modes = None
-    entity4.color_mode = None
+    entity4.supported_color_modes = {light.ColorMode.RGBW}
 
     entity5 = entities[5]
-    entity5.supported_color_modes = {light.ColorMode.RGBW}
+    entity5.supported_color_modes = {light.ColorMode.RGBWW}
 
     entity6 = entities[6]
-    entity6.supported_color_modes = {light.ColorMode.RGBWW}
-
-    entity7 = entities[7]
-    entity7.supported_color_modes = {light.ColorMode.COLOR_TEMP}
+    entity6.supported_color_modes = {light.ColorMode.COLOR_TEMP}
 
     assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
     await hass.async_block_till_done()
@@ -1536,15 +1352,12 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     ]
 
     state = hass.states.get(entity4.entity_id)
-    assert state.attributes["supported_color_modes"] == [light.ColorMode.HS]
-
-    state = hass.states.get(entity5.entity_id)
     assert state.attributes["supported_color_modes"] == [light.ColorMode.RGBW]
 
-    state = hass.states.get(entity6.entity_id)
+    state = hass.states.get(entity5.entity_id)
     assert state.attributes["supported_color_modes"] == [light.ColorMode.RGBWW]
 
-    state = hass.states.get(entity7.entity_id)
+    state = hass.states.get(entity6.entity_id)
     assert state.attributes["supported_color_modes"] == [light.ColorMode.COLOR_TEMP]
 
     await hass.services.async_call(
@@ -1559,7 +1372,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 100,
             "hs_color": (240, 100),
@@ -1575,12 +1387,10 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 255, "hs_color": (240.0, 100.0)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 255, "hs_color": (240.0, 100.0)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 255, "rgbw_color": (0, 0, 255, 0)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 255, "rgbww_color": (0, 0, 255, 0, 0)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 255, "color_temp_kelvin": 1739}
 
     await hass.services.async_call(
@@ -1595,7 +1405,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 100,
             "hs_color": (240, 0),
@@ -1611,13 +1420,11 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 255, "hs_color": (240.0, 0.0)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 255, "hs_color": (240.0, 0.0)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 255, "rgbw_color": (0, 0, 0, 255)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     # The midpoint of the white channels is warm, compensated by adding green + blue
     assert data == {"brightness": 255, "rgbww_color": (0, 76, 141, 255, 255)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 255, "color_temp_kelvin": 5962}
 
     await hass.services.async_call(
@@ -1632,7 +1439,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 50,
             "rgb_color": (128, 0, 0),
@@ -1648,12 +1454,10 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 128, "rgb_color": (128, 0, 0)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 128, "hs_color": (0.0, 100.0)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbw_color": (128, 0, 0, 0)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbww_color": (128, 0, 0, 0, 0)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 128, "color_temp_kelvin": 6279}
 
     await hass.services.async_call(
@@ -1668,7 +1472,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 50,
             "rgb_color": (255, 255, 255),
@@ -1684,13 +1487,11 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 128, "rgb_color": (255, 255, 255)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 128, "hs_color": (0.0, 0.0)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbw_color": (0, 0, 0, 255)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     # The midpoint the white channels is warm, compensated by adding green + blue
     assert data == {"brightness": 128, "rgbww_color": (0, 76, 141, 255, 255)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 128, "color_temp_kelvin": 5962}
 
     await hass.services.async_call(
@@ -1705,7 +1506,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 50,
             "xy_color": (0.1, 0.8),
@@ -1721,12 +1521,10 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 128, "xy_color": (0.1, 0.8)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 128, "hs_color": (125.176, 100.0)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbw_color": (0, 255, 22, 0)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbww_color": (0, 255, 22, 0, 0)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 128, "color_temp_kelvin": 8645}
 
     await hass.services.async_call(
@@ -1741,7 +1539,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 50,
             "xy_color": (0.323, 0.329),
@@ -1757,13 +1554,11 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 128, "xy_color": (0.323, 0.329)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 128, "hs_color": (0.0, 0.392)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbw_color": (1, 0, 0, 255)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     # The midpoint the white channels is warm, compensated by adding green + blue
     assert data == {"brightness": 128, "rgbww_color": (0, 75, 140, 255, 255)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 128, "color_temp_kelvin": 5962}
 
     await hass.services.async_call(
@@ -1778,7 +1573,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 50,
             "rgbw_color": (128, 0, 0, 64),
@@ -1794,13 +1588,11 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 128, "rgb_color": (128, 43, 43)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 128, "hs_color": (0.0, 66.406)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbw_color": (128, 0, 0, 64)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     # The midpoint the white channels is warm, compensated by adding green + blue
     assert data == {"brightness": 128, "rgbww_color": (128, 0, 30, 117, 117)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 128, "color_temp_kelvin": 3011}
 
     await hass.services.async_call(
@@ -1815,7 +1607,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 50,
             "rgbw_color": (255, 255, 255, 255),
@@ -1831,13 +1622,11 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 128, "rgb_color": (255, 255, 255)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 128, "hs_color": (0.0, 0.0)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbw_color": (255, 255, 255, 255)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     # The midpoint the white channels is warm, compensated by adding green + blue
     assert data == {"brightness": 128, "rgbww_color": (0, 76, 141, 255, 255)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 128, "color_temp_kelvin": 5962}
 
     await hass.services.async_call(
@@ -1852,7 +1641,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 50,
             "rgbww_color": (128, 0, 0, 64, 32),
@@ -1868,12 +1656,10 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 128, "rgb_color": (128, 33, 26)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 128, "hs_color": (4.118, 79.688)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbw_color": (128, 9, 0, 33)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbww_color": (128, 0, 0, 64, 32)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 128, "color_temp_kelvin": 3845}
 
     await hass.services.async_call(
@@ -1888,7 +1674,6 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
                 entity4.entity_id,
                 entity5.entity_id,
                 entity6.entity_id,
-                entity7.entity_id,
             ],
             "brightness_pct": 50,
             "rgbww_color": (255, 255, 255, 255, 255),
@@ -1904,13 +1689,11 @@ async def test_light_service_call_color_conversion(hass: HomeAssistant) -> None:
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 128, "rgb_color": (255, 217, 185)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 128, "hs_color": (27.429, 27.451)}
-    _, data = entity5.last_call("turn_on")
     # The midpoint the white channels is warm, compensated by decreasing green + blue
     assert data == {"brightness": 128, "rgbw_color": (96, 44, 0, 255)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 128, "rgbww_color": (255, 255, 255, 255, 255)}
-    _, data = entity7.last_call("turn_on")
+    _, data = entity6.last_call("turn_on")
     assert data == {"brightness": 128, "color_temp_kelvin": 3451}
 
 
@@ -1923,7 +1706,6 @@ async def test_light_service_call_color_conversion_named_tuple(
         MockLight("Test_rgb", STATE_ON),
         MockLight("Test_xy", STATE_ON),
         MockLight("Test_all", STATE_ON),
-        MockLight("Test_legacy", STATE_ON),
         MockLight("Test_rgbw", STATE_ON),
         MockLight("Test_rgbww", STATE_ON),
     ]
@@ -1946,16 +1728,10 @@ async def test_light_service_call_color_conversion_named_tuple(
     }
 
     entity4 = entities[4]
-    entity4.supported_features = light.SUPPORT_COLOR
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity4.supported_color_modes = None
-    entity4.color_mode = None
+    entity4.supported_color_modes = {light.ColorMode.RGBW}
 
     entity5 = entities[5]
-    entity5.supported_color_modes = {light.ColorMode.RGBW}
-
-    entity6 = entities[6]
-    entity6.supported_color_modes = {light.ColorMode.RGBWW}
+    entity5.supported_color_modes = {light.ColorMode.RGBWW}
 
     assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
     await hass.async_block_till_done()
@@ -1971,7 +1747,6 @@ async def test_light_service_call_color_conversion_named_tuple(
                 entity3.entity_id,
                 entity4.entity_id,
                 entity5.entity_id,
-                entity6.entity_id,
             ],
             "brightness_pct": 25,
             "rgb_color": color_util.RGBColor(128, 0, 0),
@@ -1987,10 +1762,8 @@ async def test_light_service_call_color_conversion_named_tuple(
     _, data = entity3.last_call("turn_on")
     assert data == {"brightness": 64, "rgb_color": (128, 0, 0)}
     _, data = entity4.last_call("turn_on")
-    assert data == {"brightness": 64, "hs_color": (0.0, 100.0)}
-    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 64, "rgbw_color": (128, 0, 0, 0)}
-    _, data = entity6.last_call("turn_on")
+    _, data = entity5.last_call("turn_on")
     assert data == {"brightness": 64, "rgbww_color": (128, 0, 0, 0, 0)}
 
 
@@ -2327,7 +2100,6 @@ async def test_light_state_color_conversion(hass: HomeAssistant) -> None:
         MockLight("Test_hs", STATE_ON),
         MockLight("Test_rgb", STATE_ON),
         MockLight("Test_xy", STATE_ON),
-        MockLight("Test_legacy", STATE_ON),
     ]
     setup_test_component_platform(hass, light.DOMAIN, entities)
 
@@ -2352,13 +2124,6 @@ async def test_light_state_color_conversion(hass: HomeAssistant) -> None:
     entity2.rgb_color = "Invalid"  # Should be ignored
     entity2.xy_color = (0.1, 0.8)
 
-    entity3 = entities[3]
-    entity3.hs_color = (240, 100)
-    entity3.supported_features = light.SUPPORT_COLOR
-    # Set color modes to none to trigger backwards compatibility in LightEntity
-    entity3.supported_color_modes = None
-    entity3.color_mode = None
-
     assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})
     await hass.async_block_till_done()
 
@@ -2380,12 +2145,6 @@ async def test_light_state_color_conversion(hass: HomeAssistant) -> None:
     assert state.attributes["rgb_color"] == (0, 255, 22)
     assert state.attributes["xy_color"] == (0.1, 0.8)
 
-    state = hass.states.get(entity3.entity_id)
-    assert state.attributes["color_mode"] == light.ColorMode.HS
-    assert state.attributes["hs_color"] == (240, 100)
-    assert state.attributes["rgb_color"] == (0, 0, 255)
-    assert state.attributes["xy_color"] == (0.136, 0.04)
-
 
 async def test_services_filter_parameters(
     hass: HomeAssistant,
@@ -2620,31 +2379,6 @@ def test_filter_supported_color_modes() -> None:
     assert light.filter_supported_color_modes(supported) == {light.ColorMode.BRIGHTNESS}
 
 
-def test_deprecated_supported_features_ints(
-    hass: HomeAssistant, caplog: pytest.LogCaptureFixture
-) -> None:
-    """Test deprecated supported features ints."""
-
-    class MockLightEntityEntity(light.LightEntity):
-        @property
-        def supported_features(self) -> int:
-            """Return supported features."""
-            return 1
-
-    entity = MockLightEntityEntity()
-    entity.hass = hass
-    entity.platform = MockEntityPlatform(hass, domain="test", platform_name="test")
-    assert entity.supported_features_compat is light.LightEntityFeature(1)
-    assert "MockLightEntityEntity" in caplog.text
-    assert "is using deprecated supported features values" in caplog.text
-    assert "Instead it should use" in caplog.text
-    assert "LightEntityFeature" in caplog.text
-    assert "and color modes" in caplog.text
-    caplog.clear()
-    assert entity.supported_features_compat is light.LightEntityFeature(1)
-    assert "is using deprecated supported features values" not in caplog.text
-
-
 @pytest.mark.parametrize(
     ("color_mode", "supported_color_modes", "warning_expected"),
     [
@@ -2871,46 +2605,3 @@ def test_missing_kelvin_property_warnings(
 
     assert state.attributes[light.ATTR_MIN_COLOR_TEMP_KELVIN] == expected_values[0]
     assert state.attributes[light.ATTR_MAX_COLOR_TEMP_KELVIN] == expected_values[1]
-
-
-@pytest.mark.parametrize(
-    "module",
-    [light],
-)
-def test_all(module: ModuleType) -> None:
-    """Test module.__all__ is correctly set."""
-    help_test_all(module)
-
-
-@pytest.mark.parametrize(
-    ("constant_name", "constant_value", "constant_replacement"),
-    [
-        ("SUPPORT_BRIGHTNESS", 1, "supported_color_modes"),
-        ("SUPPORT_COLOR_TEMP", 2, "supported_color_modes"),
-        ("SUPPORT_COLOR", 16, "supported_color_modes"),
-    ],
-)
-def test_deprecated_light_constants(
-    caplog: pytest.LogCaptureFixture,
-    constant_name: str,
-    constant_value: int | str,
-    constant_replacement: str,
-) -> None:
-    """Test deprecated light constants."""
-    import_and_test_deprecated_constant(
-        caplog, light, constant_name, constant_replacement, constant_value, "2026.1"
-    )
-
-
-@pytest.mark.parametrize(
-    "entity_feature",
-    list(light.LightEntityFeature),
-)
-def test_deprecated_support_light_constants_enums(
-    caplog: pytest.LogCaptureFixture,
-    entity_feature: light.LightEntityFeature,
-) -> None:
-    """Test deprecated support light constants."""
-    import_and_test_deprecated_constant_enum(
-        caplog, light, entity_feature, "SUPPORT_", "2026.1"
-    )