Add re-auth flow for Waterfurnace (#165406)

Co-authored-by: RaHehl <rahehl@users.noreply.github.com>

.strict-typing

@@ -570,6 +570,7 @@ homeassistant.components.trafikverket_train.*
 homeassistant.components.trafikverket_weatherstation.*
 homeassistant.components.transmission.*
 homeassistant.components.trend.*
+homeassistant.components.trmnl.*
 homeassistant.components.tts.*
 homeassistant.components.twentemilieu.*
 homeassistant.components.unifi.*

CODEOWNERS

@@ -1770,6 +1770,8 @@ build.json @home-assistant/supervisor
 /tests/components/trend/ @jpbede
 /homeassistant/components/triggercmd/ @rvmey
 /tests/components/triggercmd/ @rvmey
+/homeassistant/components/trmnl/ @joostlek
+/tests/components/trmnl/ @joostlek
 /homeassistant/components/tts/ @home-assistant/core
 /tests/components/tts/ @home-assistant/core
 /homeassistant/components/tuya/ @Tuya @zlinoliver
@@ -1786,6 +1788,8 @@ build.json @home-assistant/supervisor
 /tests/components/ukraine_alarm/ @PaulAnnekov
 /homeassistant/components/unifi/ @Kane610
 /tests/components/unifi/ @Kane610
+/homeassistant/components/unifi_access/ @imhotep @RaHehl
+/tests/components/unifi_access/ @imhotep @RaHehl
 /homeassistant/components/unifi_direct/ @tofuSCHNITZEL
 /homeassistant/components/unifiled/ @florisvdk
 /homeassistant/components/unifiprotect/ @RaHehl

homeassistant/brands/ubiquiti.json

@@ -1,5 +1,12 @@
 {
   "domain": "ubiquiti",
   "name": "Ubiquiti",
-  "integrations": ["airos", "unifi", "unifi_direct", "unifiled", "unifiprotect"]
+  "integrations": [
+    "airos",
+    "unifi",
+    "unifi_access",
+    "unifi_direct",
+    "unifiled",
+    "unifiprotect"
+  ]
 }

homeassistant/components/alexa_devices/entity.py

@@ -1,6 +1,5 @@
 """Defines a base Alexa Devices entity."""
 
-from aioamazondevices.const.devices import SPEAKER_GROUP_DEVICE_TYPE
 from aioamazondevices.structures import AmazonDevice
 
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -25,20 +24,15 @@ class AmazonEntity(CoordinatorEntity[AmazonDevicesCoordinator]):
         """Initialize the entity."""
         super().__init__(coordinator)
         self._serial_num = serial_num
-        model = self.device.model
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, serial_num)},
             name=self.device.account_name,
-            model=model,
+            model=self.device.model,
             model_id=self.device.device_type,
             manufacturer=self.device.manufacturer or "Amazon",
             hw_version=self.device.hardware_version,
-            sw_version=(
-                self.device.software_version
-                if model != SPEAKER_GROUP_DEVICE_TYPE
-                else None
-            ),
-            serial_number=serial_num if model != SPEAKER_GROUP_DEVICE_TYPE else None,
+            sw_version=self.device.software_version,
+            serial_number=serial_num,
         )
         self.entity_description = description
         self._attr_unique_id = f"{serial_num}-{description.key}"

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==13.0.0"]
+  "requirements": ["aioamazondevices==13.0.1"]
 }

homeassistant/components/arcam_fmj/__init__.py

@@ -17,7 +17,7 @@ from .coordinator import ArcamFmjConfigEntry, ArcamFmjCoordinator, ArcamFmjRunti
 _LOGGER = logging.getLogger(__name__)
 
 
-PLATFORMS = [Platform.MEDIA_PLAYER]
+PLATFORMS = [Platform.MEDIA_PLAYER, Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ArcamFmjConfigEntry) -> bool:

homeassistant/components/arcam_fmj/entity.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import ArcamFmjCoordinator
@@ -12,9 +13,16 @@ class ArcamFmjEntity(CoordinatorEntity[ArcamFmjCoordinator]):
 
     _attr_has_entity_name = True
 
-    def __init__(self, coordinator: ArcamFmjCoordinator) -> None:
+    def __init__(
+        self,
+        coordinator: ArcamFmjCoordinator,
+        description: EntityDescription | None = None,
+    ) -> None:
         """Initialize the entity."""
         super().__init__(coordinator)
         self._attr_device_info = coordinator.device_info
         self._attr_entity_registry_enabled_default = coordinator.state.zn == 1
         self._attr_unique_id = coordinator.zone_unique_id
+        if description is not None:
+            self._attr_unique_id = f"{self._attr_unique_id}-{description.key}"
+            self.entity_description = description

homeassistant/components/arcam_fmj/sensor.py

@@ -0,0 +1,162 @@
+"""Arcam sensors for incoming stream info."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from arcam.fmj import IncomingVideoAspectRatio, IncomingVideoColorspace
+from arcam.fmj.state import IncomingAudioConfig, IncomingAudioFormat, State
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import EntityCategory, UnitOfFrequency
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import ArcamFmjConfigEntry
+from .entity import ArcamFmjEntity
+
+
+@dataclass(frozen=True, kw_only=True)
+class ArcamFmjSensorEntityDescription(SensorEntityDescription):
+    """Describes an Arcam FMJ sensor entity."""
+
+    value_fn: Callable[[State], int | float | str | None]
+
+
+SENSORS: tuple[ArcamFmjSensorEntityDescription, ...] = (
+    ArcamFmjSensorEntityDescription(
+        key="incoming_video_horizontal_resolution",
+        translation_key="incoming_video_horizontal_resolution",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement="px",
+        suggested_display_precision=0,
+        value_fn=lambda state: (
+            vp.horizontal_resolution
+            if (vp := state.get_incoming_video_parameters()) is not None
+            else None
+        ),
+    ),
+    ArcamFmjSensorEntityDescription(
+        key="incoming_video_vertical_resolution",
+        translation_key="incoming_video_vertical_resolution",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement="px",
+        suggested_display_precision=0,
+        value_fn=lambda state: (
+            vp.vertical_resolution
+            if (vp := state.get_incoming_video_parameters()) is not None
+            else None
+        ),
+    ),
+    ArcamFmjSensorEntityDescription(
+        key="incoming_video_refresh_rate",
+        translation_key="incoming_video_refresh_rate",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        device_class=SensorDeviceClass.FREQUENCY,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfFrequency.HERTZ,
+        suggested_display_precision=0,
+        value_fn=lambda state: (
+            vp.refresh_rate
+            if (vp := state.get_incoming_video_parameters()) is not None
+            else None
+        ),
+    ),
+    ArcamFmjSensorEntityDescription(
+        key="incoming_video_aspect_ratio",
+        translation_key="incoming_video_aspect_ratio",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        device_class=SensorDeviceClass.ENUM,
+        options=[member.name.lower() for member in IncomingVideoAspectRatio],
+        value_fn=lambda state: (
+            vp.aspect_ratio.name.lower()
+            if (vp := state.get_incoming_video_parameters()) is not None
+            else None
+        ),
+    ),
+    ArcamFmjSensorEntityDescription(
+        key="incoming_video_colorspace",
+        translation_key="incoming_video_colorspace",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        device_class=SensorDeviceClass.ENUM,
+        options=[member.name.lower() for member in IncomingVideoColorspace],
+        value_fn=lambda state: (
+            vp.colorspace.name.lower()
+            if (vp := state.get_incoming_video_parameters()) is not None
+            else None
+        ),
+    ),
+    ArcamFmjSensorEntityDescription(
+        key="incoming_audio_format",
+        translation_key="incoming_audio_format",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        device_class=SensorDeviceClass.ENUM,
+        options=[member.name.lower() for member in IncomingAudioFormat],
+        value_fn=lambda state: (
+            result.name.lower()
+            if (result := state.get_incoming_audio_format()[0]) is not None
+            else None
+        ),
+    ),
+    ArcamFmjSensorEntityDescription(
+        key="incoming_audio_config",
+        translation_key="incoming_audio_config",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        device_class=SensorDeviceClass.ENUM,
+        options=[member.name.lower() for member in IncomingAudioConfig],
+        value_fn=lambda state: (
+            result.name.lower()
+            if (result := state.get_incoming_audio_format()[1]) is not None
+            else None
+        ),
+    ),
+    ArcamFmjSensorEntityDescription(
+        key="incoming_audio_sample_rate",
+        translation_key="incoming_audio_sample_rate",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        device_class=SensorDeviceClass.FREQUENCY,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfFrequency.HERTZ,
+        suggested_display_precision=0,
+        value_fn=lambda state: (
+            None
+            if (sample_rate := state.get_incoming_audio_sample_rate()) == 0
+            else sample_rate
+        ),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ArcamFmjConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Arcam FMJ sensors from a config entry."""
+    coordinators = config_entry.runtime_data.coordinators
+
+    entities: list[ArcamFmjSensorEntity] = []
+    for coordinator in coordinators.values():
+        entities.extend(
+            ArcamFmjSensorEntity(coordinator, description) for description in SENSORS
+        )
+    async_add_entities(entities)
+
+
+class ArcamFmjSensorEntity(ArcamFmjEntity, SensorEntity):
+    """Representation of an Arcam FMJ sensor."""
+
+    entity_description: ArcamFmjSensorEntityDescription
+
+    @property
+    def native_value(self) -> int | float | str | None:
+        """Return the sensor value."""
+        return self.entity_description.value_fn(self.coordinator.state)

homeassistant/components/arcam_fmj/strings.json

@@ -23,5 +23,116 @@
     "trigger_type": {
       "turn_on": "{entity_name} was requested to turn on"
     }
+  },
+  "entity": {
+    "sensor": {
+      "incoming_audio_config": {
+        "name": "Incoming audio configuration",
+        "state": {
+          "auro_10_1": "Auro 10.1",
+          "auro_11_1": "Auro 11.1",
+          "auro_13_1": "Auro 13.1",
+          "auro_2_2_2": "Auro 2.2.2",
+          "auro_5_0": "Auro 5.0",
+          "auro_5_1": "Auro 5.1",
+          "auro_8_0": "Auro 8.0",
+          "auro_9_1": "Auro 9.1",
+          "auro_quad": "Auro quad",
+          "dual_mono": "Dual mono",
+          "dual_mono_lfe": "Dual mono + LFE",
+          "mono": "Mono",
+          "mono_lfe": "Mono + LFE",
+          "stereo_center": "Stereo center",
+          "stereo_center_lfe": "Stereo center + LFE",
+          "stereo_center_surr_lr": "Stereo center surround L/R",
+          "stereo_center_surr_lr_back_lr": "Stereo center surround L/R back L/R",
+          "stereo_center_surr_lr_back_lr_lfe": "Stereo center surround L/R back L/R + LFE",
+          "stereo_center_surr_lr_back_matrix": "Stereo center surround L/R back matrix",
+          "stereo_center_surr_lr_back_matrix_lfe": "Stereo center surround L/R back matrix + LFE",
+          "stereo_center_surr_lr_back_mono": "Stereo center surround L/R back mono",
+          "stereo_center_surr_lr_back_mono_lfe": "Stereo center surround L/R back mono + LFE",
+          "stereo_center_surr_lr_lfe": "Stereo center surround L/R + LFE",
+          "stereo_center_surr_mono": "Stereo center surround mono",
+          "stereo_center_surr_mono_lfe": "Stereo center surround mono + LFE",
+          "stereo_downmix": "Stereo downmix",
+          "stereo_downmix_lfe": "Stereo downmix + LFE",
+          "stereo_lfe": "Stereo + LFE",
+          "stereo_only": "Stereo only",
+          "stereo_only_lo_ro": "Stereo only Lo/Ro",
+          "stereo_only_lo_ro_lfe": "Stereo only Lo/Ro + LFE",
+          "stereo_surr_lr": "Stereo surround L/R",
+          "stereo_surr_lr_back_lr": "Stereo surround L/R back L/R",
+          "stereo_surr_lr_back_lr_lfe": "Stereo surround L/R back L/R + LFE",
+          "stereo_surr_lr_back_matrix": "Stereo surround L/R back matrix",
+          "stereo_surr_lr_back_matrix_lfe": "Stereo surround L/R back matrix + LFE",
+          "stereo_surr_lr_back_mono": "Stereo surround L/R back mono",
+          "stereo_surr_lr_back_mono_lfe": "Stereo surround L/R back mono + LFE",
+          "stereo_surr_lr_lfe": "Stereo surround L/R + LFE",
+          "stereo_surr_mono": "Stereo surround mono",
+          "stereo_surr_mono_lfe": "Stereo surround mono + LFE",
+          "undetected": "Undetected",
+          "unknown": "Unknown"
+        }
+      },
+      "incoming_audio_format": {
+        "name": "Incoming audio format",
+        "state": {
+          "analogue_direct": "Analogue direct",
+          "auro_3d": "Auro-3D",
+          "dolby_atmos": "Dolby Atmos",
+          "dolby_digital": "Dolby Digital",
+          "dolby_digital_ex": "Dolby Digital EX",
+          "dolby_digital_plus": "Dolby Digital Plus",
+          "dolby_digital_surround": "Dolby Digital Surround",
+          "dolby_digital_true_hd": "Dolby TrueHD",
+          "dts": "DTS",
+          "dts_96_24": "DTS 96/24",
+          "dts_core": "DTS Core",
+          "dts_es_discrete": "DTS-ES Discrete",
+          "dts_es_discrete_96_24": "DTS-ES Discrete 96/24",
+          "dts_es_matrix": "DTS-ES Matrix",
+          "dts_es_matrix_96_24": "DTS-ES Matrix 96/24",
+          "dts_hd_high_res_audio": "DTS-HD High Resolution Audio",
+          "dts_hd_master_audio": "DTS-HD Master Audio",
+          "dts_low_bit_rate": "DTS Low Bit Rate",
+          "dts_x": "DTS:X",
+          "imax_enhanced": "IMAX Enhanced",
+          "pcm": "PCM",
+          "pcm_zero": "PCM zero",
+          "undetected": "Undetected",
+          "unsupported": "Unsupported"
+        }
+      },
+      "incoming_audio_sample_rate": {
+        "name": "Incoming audio sample rate"
+      },
+      "incoming_video_aspect_ratio": {
+        "name": "Incoming video aspect ratio",
+        "state": {
+          "aspect_16_9": "16:9",
+          "aspect_4_3": "4:3",
+          "undefined": "Undefined"
+        }
+      },
+      "incoming_video_colorspace": {
+        "name": "Incoming video colorspace",
+        "state": {
+          "dolby_vision": "Dolby Vision",
+          "hdr10": "HDR10",
+          "hdr10_plus": "HDR10+",
+          "hlg": "HLG",
+          "normal": "Normal"
+        }
+      },
+      "incoming_video_horizontal_resolution": {
+        "name": "Incoming video horizontal resolution"
+      },
+      "incoming_video_refresh_rate": {
+        "name": "Incoming video refresh rate"
+      },
+      "incoming_video_vertical_resolution": {
+        "name": "Incoming video vertical resolution"
+      }
+    }
   }
 }

homeassistant/components/chess_com/diagnostics.py

@@ -0,0 +1,22 @@
+"""Diagnostics support for Chess.com."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import Any
+
+from homeassistant.core import HomeAssistant
+
+from .coordinator import ChessConfigEntry
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: ChessConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    coordinator = entry.runtime_data
+
+    return {
+        "player": asdict(coordinator.data.player),
+        "stats": asdict(coordinator.data.stats),
+    }

homeassistant/components/chess_com/quality_scale.yaml

@@ -41,7 +41,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: todo
+  diagnostics: done
   discovery-update-info:
     status: exempt
     comment: Can't detect a game

homeassistant/components/cover/intent.py

@@ -15,7 +15,6 @@ async def async_setup_intents(hass: HomeAssistant) -> None:
             INTENT_OPEN_COVER,
             DOMAIN,
             SERVICE_OPEN_COVER,
-            "Opening {}",
             description="Opens a cover",
             platforms={DOMAIN},
             device_classes={CoverDeviceClass},
@@ -27,7 +26,6 @@ async def async_setup_intents(hass: HomeAssistant) -> None:
             INTENT_CLOSE_COVER,
             DOMAIN,
             SERVICE_CLOSE_COVER,
-            "Closing {}",
             description="Closes a cover",
             platforms={DOMAIN},
             device_classes={CoverDeviceClass},

homeassistant/components/hassio/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/hassio",
   "iot_class": "local_polling",
   "quality_scale": "internal",
-  "requirements": ["aiohasupervisor==0.4.0"],
+  "requirements": ["aiohasupervisor==0.3.3"],
   "single_config_entry": true
 }

homeassistant/components/home_connect/services.py

@@ -46,10 +46,12 @@ PROGRAM_OPTIONS = {
         value,
     )
     for key, value in {
-        OptionKey.BSH_COMMON_DURATION: int,
-        OptionKey.BSH_COMMON_START_IN_RELATIVE: int,
-        OptionKey.BSH_COMMON_FINISH_IN_RELATIVE: int,
-        OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_FILL_QUANTITY: int,
+        OptionKey.BSH_COMMON_DURATION: vol.All(int, vol.Range(min=0)),
+        OptionKey.BSH_COMMON_START_IN_RELATIVE: vol.All(int, vol.Range(min=0)),
+        OptionKey.BSH_COMMON_FINISH_IN_RELATIVE: vol.All(int, vol.Range(min=0)),
+        OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_FILL_QUANTITY: vol.All(
+            int, vol.Range(min=0)
+        ),
         OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_MULTIPLE_BEVERAGES: bool,
         OptionKey.DISHCARE_DISHWASHER_INTENSIV_ZONE: bool,
         OptionKey.DISHCARE_DISHWASHER_BRILLIANCE_DRY: bool,
@@ -60,7 +62,10 @@ PROGRAM_OPTIONS = {
         OptionKey.DISHCARE_DISHWASHER_HYGIENE_PLUS: bool,
         OptionKey.DISHCARE_DISHWASHER_ECO_DRY: bool,
         OptionKey.DISHCARE_DISHWASHER_ZEOLITE_DRY: bool,
-        OptionKey.COOKING_OVEN_SETPOINT_TEMPERATURE: int,
+        OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_PERCENTAGE: vol.All(
+            int, vol.Range(min=1, max=100)
+        ),
+        OptionKey.COOKING_OVEN_SETPOINT_TEMPERATURE: vol.All(int, vol.Range(min=0)),
         OptionKey.COOKING_OVEN_FAST_PRE_HEAT: bool,
         OptionKey.LAUNDRY_CARE_WASHER_I_DOS_1_ACTIVE: bool,
         OptionKey.LAUNDRY_CARE_WASHER_I_DOS_2_ACTIVE: bool,

homeassistant/components/intelliclima/fan.py

@@ -74,7 +74,7 @@ class IntelliClimaVMCFan(IntelliClimaECOEntity, FanEntity):
         """Return the current speed percentage."""
         device_data = self._device_data
 
-        if device_data.speed_set == FanSpeed.auto:
+        if device_data.speed_set == FanSpeed.auto_get:
             return None
 
         return ranged_value_to_percentage(self._speed_range, int(device_data.speed_set))
@@ -92,7 +92,7 @@ class IntelliClimaVMCFan(IntelliClimaECOEntity, FanEntity):
         if device_data.mode_set == FanMode.off:
             return None
         if (
-            device_data.speed_set == FanSpeed.auto
+            device_data.speed_set == FanSpeed.auto_get
             and device_data.mode_set == FanMode.sensor
         ):
             return "auto"
@@ -111,7 +111,7 @@ class IntelliClimaVMCFan(IntelliClimaECOEntity, FanEntity):
         infinitely.
         """
         percentage = 25 if percentage == 0 else percentage
-        await self.async_set_mode_speed(fan_mode=preset_mode, percentage=percentage)
+        await self.async_set_mode_speed(preset_mode=preset_mode, percentage=percentage)
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn off the fan."""
@@ -124,10 +124,10 @@ class IntelliClimaVMCFan(IntelliClimaECOEntity, FanEntity):
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set preset mode."""
-        await self.async_set_mode_speed(fan_mode=preset_mode)
+        await self.async_set_mode_speed(preset_mode=preset_mode)
 
     async def async_set_mode_speed(
-        self, fan_mode: str | None = None, percentage: int | None = None
+        self, preset_mode: str | None = None, percentage: int | None = None
     ) -> None:
         """Set mode and speed.
 
@@ -137,7 +137,7 @@ class IntelliClimaVMCFan(IntelliClimaECOEntity, FanEntity):
         percentage = self.percentage if percentage is None else percentage
         percentage = 25 if percentage is None else percentage
 
-        if fan_mode == "auto":
+        if preset_mode == "auto":
             # auto is a special case with special mode and speed setting
             await self.coordinator.api.ecocomfort.set_mode_speed_auto(self._device_sn)
             await self.coordinator.async_request_refresh()
@@ -148,21 +148,20 @@ class IntelliClimaVMCFan(IntelliClimaECOEntity, FanEntity):
             return
 
         # Determine the fan mode
-        if fan_mode is not None:
-            # Set to requested fan_mode
-            mode = fan_mode
-        elif not self.is_on:
+        if not self.is_on:
             # Default to alternate fan mode if not turned on
             mode = FanMode.alternate
         else:
             # Maintain current mode
             mode = self._device_data.mode_set
 
-        speed = str(
-            math.ceil(
-                percentage_to_ranged_value(
-                    self._speed_range,
-                    percentage,
+        speed = FanSpeed(
+            str(
+                math.ceil(
+                    percentage_to_ranged_value(
+                        self._speed_range,
+                        percentage,
+                    )
                 )
             )
         )

homeassistant/components/intelliclima/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["pyintelliclima==0.2.2"]
+  "requirements": ["pyintelliclima==0.3.1"]
 }

homeassistant/components/intelliclima/select.py

@@ -68,12 +68,12 @@ class IntelliClimaVMCFanModeSelect(IntelliClimaECOEntity, SelectEntity):
 
         # If in auto mode (sensor mode with auto speed), return None (handled by fan entity preset mode)
         if (
-            device_data.speed_set == FanSpeed.auto
+            device_data.speed_set == FanSpeed.auto_get
             and device_data.mode_set == FanMode.sensor
         ):
             return None
 
-        return INTELLICLIMA_MODE_TO_FAN_MODE.get(FanMode(device_data.mode_set))
+        return INTELLICLIMA_MODE_TO_FAN_MODE.get(device_data.mode_set)
 
     async def async_select_option(self, option: str) -> None:
         """Set the fan mode."""
@@ -83,7 +83,7 @@ class IntelliClimaVMCFanModeSelect(IntelliClimaECOEntity, SelectEntity):
 
         # Determine speed: keep current speed if available, otherwise default to sleep
         if (
-            device_data.speed_set == FanSpeed.auto
+            device_data.speed_set == FanSpeed.auto_get
             or device_data.mode_set == FanMode.off
         ):
             speed = FanSpeed.sleep

homeassistant/components/intelliclima/strings.json

@@ -6,7 +6,7 @@
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "no_devices": "No IntelliClima devices found in your account",
+      "no_devices": "No supported IntelliClima devices were found in your account",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {

homeassistant/components/litterrobot/config_flow.py

@@ -10,7 +10,7 @@ from pylitterbot import Account
 from pylitterbot.exceptions import LitterRobotException, LitterRobotLoginException
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
@@ -21,6 +21,7 @@ _LOGGER = logging.getLogger(__name__)
 STEP_USER_DATA_SCHEMA = vol.Schema(
     {vol.Required(CONF_USERNAME): str, vol.Required(CONF_PASSWORD): str}
 )
+STEP_REAUTH_RECONFIGURE_SCHEMA = vol.Schema({vol.Required(CONF_PASSWORD): str})
 
 
 class LitterRobotConfigFlow(ConfigFlow, domain=DOMAIN):
@@ -43,24 +44,45 @@ class LitterRobotConfigFlow(ConfigFlow, domain=DOMAIN):
         self, user_input: dict[str, str] | None = None
     ) -> ConfigFlowResult:
         """Handle user's reauth credentials."""
-        errors = {}
+        errors: dict[str, str] = {}
         if user_input:
-            user_input = user_input | {CONF_USERNAME: self.username}
-            if not (error := await self._async_validate_input(user_input)):
-                await self.async_set_unique_id(self._account_user_id)
-                self._abort_if_unique_id_mismatch()
-                return self.async_update_reload_and_abort(
-                    self._get_reauth_entry(), data_updates=user_input
-                )
+            reauth_entry = self._get_reauth_entry()
+            result, errors = await self._async_validate_and_update_entry(
+                reauth_entry, user_input
+            )
+            if result is not None:
+                return result
 
-            errors["base"] = error
         return self.async_show_form(
             step_id="reauth_confirm",
-            data_schema=vol.Schema({vol.Required(CONF_PASSWORD): str}),
+            data_schema=STEP_REAUTH_RECONFIGURE_SCHEMA,
             description_placeholders={CONF_USERNAME: self.username},
             errors=errors,
         )
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a reconfiguration flow request."""
+        reconfigure_entry = self._get_reconfigure_entry()
+        self.username = reconfigure_entry.data[CONF_USERNAME]
+
+        self._async_abort_entries_match({CONF_USERNAME: self.username})
+
+        errors: dict[str, str] = {}
+        if user_input:
+            result, errors = await self._async_validate_and_update_entry(
+                reconfigure_entry, user_input
+            )
+            if result is not None:
+                return result
+
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=STEP_REAUTH_RECONFIGURE_SCHEMA,
+            errors=errors,
+        )
+
     async def async_step_user(
         self, user_input: Mapping[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -81,6 +103,25 @@ class LitterRobotConfigFlow(ConfigFlow, domain=DOMAIN):
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
 
+    async def _async_validate_and_update_entry(
+        self, entry: ConfigEntry, user_input: dict[str, Any]
+    ) -> tuple[ConfigFlowResult | None, dict[str, str]]:
+        """Validate credentials and update an existing entry if valid."""
+        errors: dict[str, str] = {}
+        full_input: dict[str, Any] = user_input | {CONF_USERNAME: self.username}
+        if not (error := await self._async_validate_input(full_input)):
+            await self.async_set_unique_id(self._account_user_id)
+            self._abort_if_unique_id_mismatch()
+            return (
+                self.async_update_reload_and_abort(
+                    entry,
+                    data_updates=full_input,
+                ),
+                errors,
+            )
+        errors["base"] = error
+        return None, errors
+
     async def _async_validate_input(self, user_input: Mapping[str, Any]) -> str:
         """Validate login credentials."""
         account = Account(websession=async_get_clientsession(self.hass))

homeassistant/components/litterrobot/coordinator.py

@@ -46,11 +46,22 @@ class LitterRobotDataUpdateCoordinator(DataUpdateCoordinator[None]):
 
     async def _async_update_data(self) -> None:
         """Update all device states from the Litter-Robot API."""
-        await self.account.refresh_robots()
-        await self.account.load_pets()
-        for pet in self.account.pets:
-            # Need to fetch weight history for `get_visits_since`
-            await pet.fetch_weight_history()
+        try:
+            await self.account.refresh_robots()
+            await self.account.load_pets()
+            for pet in self.account.pets:
+                # Need to fetch weight history for `get_visits_since`
+                await pet.fetch_weight_history()
+        except LitterRobotLoginException as ex:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN, translation_key="invalid_credentials"
+            ) from ex
+        except LitterRobotException as ex:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect",
+                translation_placeholders={"error": str(ex)},
+            ) from ex
 
     async def _async_setup(self) -> None:
         """Set up the coordinator."""
@@ -63,9 +74,15 @@ class LitterRobotDataUpdateCoordinator(DataUpdateCoordinator[None]):
                 load_pets=True,
             )
         except LitterRobotLoginException as ex:
-            raise ConfigEntryAuthFailed("Invalid credentials") from ex
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN, translation_key="invalid_credentials"
+            ) from ex
         except LitterRobotException as ex:
-            raise UpdateFailed("Unable to connect to Whisker API") from ex
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect",
+                translation_placeholders={"error": str(ex)},
+            ) from ex
 
     def litter_robots(self) -> Generator[LitterRobot]:
         """Get Litter-Robots from the account."""

homeassistant/components/litterrobot/quality_scale.yaml

@@ -29,9 +29,9 @@ rules:
     status: done
     comment: No options to configure
   docs-installation-parameters: done
-  entity-unavailable: todo
+  entity-unavailable: done
   integration-owner: done
-  log-when-unavailable: todo
+  log-when-unavailable: done
   parallel-updates: done
   reauthentication-flow: done
   test-coverage:
@@ -49,23 +49,21 @@ rules:
   discovery:
     status: todo
     comment: Need to validate discovery
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
   docs-supported-functions: done
-  docs-troubleshooting: todo
-  docs-use-cases: todo
+  docs-troubleshooting: done
+  docs-use-cases: done
   dynamic-devices: todo
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done
-  entity-translations:
-    status: todo
-    comment: Make sure all translated states are in sentence case
-  exception-translations: todo
+  entity-translations: done
+  exception-translations: done
   icon-translations: done
-  reconfiguration-flow: todo
+  reconfiguration-flow: done
   repair-issues:
     status: done
     comment: |

homeassistant/components/litterrobot/strings.json

@@ -3,6 +3,7 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "unique_id_mismatch": "The Whisker account does not match the previously configured account. Please re-authenticate using the same account, or remove this integration and set it up again if you want to use a different account."
     },
     "error": {
@@ -21,6 +22,14 @@
         "description": "Please update your password for {username}",
         "title": "[%key:common::config_flow::title::reauth%]"
       },
+      "reconfigure": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "password": "[%key:component::litterrobot::config::step::user::data_description::password%]"
+        }
+      },
       "user": {
         "data": {
           "password": "[%key:common::config_flow::data::password%]",
@@ -196,11 +205,17 @@
     }
   },
   "exceptions": {
+    "cannot_connect": {
+      "message": "Unable to fetch data from the Whisker API: {error}"
+    },
     "command_failed": {
       "message": "An error occurred while communicating with the device: {error}"
     },
     "firmware_update_failed": {
       "message": "Unable to start firmware update on {name}"
+    },
+    "invalid_credentials": {
+      "message": "Invalid credentials. Please check your username and password, then try again"
     }
   },
   "issues": {

homeassistant/components/matter/strings.json

@@ -325,11 +325,11 @@
         }
       },
       "startup_on_off": {
-        "name": "Power-on behavior on startup",
+        "name": "Power-on behavior",
         "state": {
           "off": "[%key:common::state::off%]",
           "on": "[%key:common::state::on%]",
-          "previous": "Previous",
+          "previous": "Previous state",
           "toggle": "[%key:common::action::toggle%]"
         }
       },

homeassistant/components/miele/const.py

@@ -500,6 +500,7 @@ class DishWasherProgramId(MieleEnum, missing_to_none=True):
     pasta_paela = 14
     tall_items = 17, 42
     glasses_warm = 19
+    quick_intense = 21
     normal = 30
     power_wash = 44, 204
     comfort_wash = 203

homeassistant/components/miele/strings.json

@@ -759,6 +759,7 @@
           "pyrolytic": "Pyrolytic",
           "quiche_lorraine": "Quiche Lorraine",
           "quick_hygiene": "QuickHygiene",
+          "quick_intense": "QuickIntense",
           "quick_mw": "Quick MW",
           "quick_power_dry": "QuickPowerDry",
           "quick_power_wash": "QuickPowerWash",

homeassistant/components/pooldose/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "platinum",
-  "requirements": ["python-pooldose==0.8.2"]
+  "requirements": ["python-pooldose==0.8.5"]
 }

homeassistant/components/smartthings/binary_sensor.py

@@ -200,6 +200,14 @@ CAPABILITY_TO_SENSORS: dict[
             supported_states_attributes=Attribute.SUPPORTED_STATUS,
         )
     },
+    Capability.CUSTOM_COOKTOP_OPERATING_STATE: {
+        Attribute.COOKTOP_OPERATING_STATE: SmartThingsBinarySensorEntityDescription(
+            key=Attribute.COOKTOP_OPERATING_STATE,
+            translation_key="cooktop_operating_state",
+            is_on_key="run",
+            supported_states_attributes=Attribute.SUPPORTED_COOKTOP_OPERATING_STATE,
+        )
+    },
 }
 
 

homeassistant/components/smartthings/manifest.json

@@ -25,6 +25,10 @@
       "hostname": "hub*",
       "macaddress": "286D97*"
     },
+    {
+      "hostname": "smarthub",
+      "macaddress": "683A48*"
+    },
     {
       "hostname": "samsung-*"
     }

homeassistant/components/smartthings/strings.json

@@ -49,6 +49,9 @@
       "child_lock": {
         "name": "Child lock"
       },
+      "cooktop_operating_state": {
+        "name": "[%key:component::smartthings::entity::sensor::cooktop_operating_state::name%]"
+      },
       "cool_select_plus_door": {
         "name": "CoolSelect+ door"
       },

homeassistant/components/telegram_bot/bot.py

@@ -7,7 +7,6 @@ import io
 import logging
 import os
 from pathlib import Path
-from ssl import SSLContext
 from types import MappingProxyType
 from typing import Any, cast
 
@@ -48,8 +47,8 @@ from homeassistant.const import (
 from homeassistant.core import Context, HomeAssistant
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.util.json import JsonValueType
-from homeassistant.util.ssl import get_default_context, get_default_no_verify_context
 
 from .const import (
     ATTR_ARGS,
@@ -566,11 +565,7 @@ class TelegramNotificationService:
             username=kwargs.get(ATTR_USERNAME, ""),
             password=kwargs.get(ATTR_PASSWORD, ""),
             authentication=kwargs.get(ATTR_AUTHENTICATION),
-            verify_ssl=(
-                get_default_context()
-                if kwargs.get(ATTR_VERIFY_SSL, False)
-                else get_default_no_verify_context()
-            ),
+            verify_ssl=kwargs.get(ATTR_VERIFY_SSL, False),
         )
 
         media: InputMedia
@@ -738,11 +733,7 @@ class TelegramNotificationService:
             username=kwargs.get(ATTR_USERNAME, ""),
             password=kwargs.get(ATTR_PASSWORD, ""),
             authentication=kwargs.get(ATTR_AUTHENTICATION),
-            verify_ssl=(
-                get_default_context()
-                if kwargs.get(ATTR_VERIFY_SSL, False)
-                else get_default_no_verify_context()
-            ),
+            verify_ssl=kwargs.get(ATTR_VERIFY_SSL, False),
         )
 
         if file_type == SERVICE_SEND_PHOTO:
@@ -1055,7 +1046,7 @@ async def load_data(
     username: str,
     password: str,
     authentication: str | None,
-    verify_ssl: SSLContext,
+    verify_ssl: bool,
     num_retries: int = 5,
 ) -> io.BytesIO:
     """Load data into ByteIO/File container from a source."""
@@ -1071,16 +1062,13 @@ async def load_data(
         elif authentication == HTTP_BASIC_AUTHENTICATION:
             params["auth"] = httpx.BasicAuth(username, password)
 
-        if verify_ssl is not None:
-            params["verify"] = verify_ssl
-
         retry_num = 0
-        async with httpx.AsyncClient(
-            timeout=DEFAULT_TIMEOUT_SECONDS, headers=headers, **params
-        ) as client:
+        async with get_async_client(hass, verify_ssl) as client:
             while retry_num < num_retries:
                 try:
-                    req = await client.get(url)
+                    response = await client.get(
+                        url, headers=headers, timeout=DEFAULT_TIMEOUT_SECONDS, **params
+                    )
                 except (httpx.HTTPError, httpx.InvalidURL) as err:
                     raise HomeAssistantError(
                         translation_domain=DOMAIN,
@@ -1088,15 +1076,15 @@ async def load_data(
                         translation_placeholders={"error": str(err)},
                     ) from err
 
-                if req.status_code != 200:
+                if response.status_code != 200:
                     _LOGGER.warning(
                         "Status code %s (retry #%s) loading %s",
-                        req.status_code,
+                        response.status_code,
                         retry_num + 1,
                         url,
                     )
                 else:
-                    data = io.BytesIO(req.content)
+                    data = io.BytesIO(response.content)
                     if data.read():
                         data.seek(0)
                         data.name = url
@@ -1111,7 +1099,7 @@ async def load_data(
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="failed_to_load_url",
-                translation_placeholders={"error": str(req.status_code)},
+                translation_placeholders={"error": str(response.status_code)},
             )
     elif filepath is not None:
         if hass.config.is_allowed_path(filepath):

homeassistant/components/trmnl/__init__.py

@@ -0,0 +1,29 @@
+"""The TRMNL integration."""
+
+from __future__ import annotations
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import TRMNLConfigEntry, TRMNLCoordinator
+
+PLATFORMS: list[Platform] = [Platform.SENSOR, Platform.SWITCH]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: TRMNLConfigEntry) -> bool:
+    """Set up TRMNL from a config entry."""
+
+    coordinator = TRMNLCoordinator(hass, entry)
+
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: TRMNLConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/trmnl/config_flow.py

@@ -0,0 +1,64 @@
+"""Config flow for TRMNL."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from trmnl import TRMNLClient
+from trmnl.exceptions import TRMNLAuthenticationError, TRMNLError
+import voluptuous as vol
+
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_KEY
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN, LOGGER
+
+STEP_USER_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str})
+
+
+class TRMNLConfigFlow(ConfigFlow, domain=DOMAIN):
+    """TRMNL config flow."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a flow initialized by the user or reauth."""
+        errors: dict[str, str] = {}
+        if user_input:
+            session = async_get_clientsession(self.hass)
+            client = TRMNLClient(token=user_input[CONF_API_KEY], session=session)
+            try:
+                user = await client.get_me()
+            except TRMNLAuthenticationError:
+                errors["base"] = "invalid_auth"
+            except TRMNLError:
+                errors["base"] = "cannot_connect"
+            except Exception:  # noqa: BLE001
+                LOGGER.exception("Unexpected error")
+                errors["base"] = "unknown"
+            else:
+                await self.async_set_unique_id(str(user.identifier))
+                if self.source == SOURCE_REAUTH:
+                    self._abort_if_unique_id_mismatch()
+                    return self.async_update_reload_and_abort(
+                        self._get_reauth_entry(),
+                        data_updates={CONF_API_KEY: user_input[CONF_API_KEY]},
+                    )
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(
+                    title=user.name,
+                    data={CONF_API_KEY: user_input[CONF_API_KEY]},
+                )
+        return self.async_show_form(
+            step_id="user",
+            data_schema=STEP_USER_SCHEMA,
+            errors=errors,
+        )
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauth upon an API authentication error."""
+        return await self.async_step_user()

homeassistant/components/trmnl/const.py

@@ -0,0 +1,7 @@
+"""Constants for the TRMNL integration."""
+
+import logging
+
+DOMAIN = "trmnl"
+
+LOGGER = logging.getLogger(__package__)

homeassistant/components/trmnl/coordinator.py

@@ -0,0 +1,69 @@
+"""Define an object to manage fetching TRMNL data."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+
+from trmnl import TRMNLClient
+from trmnl.exceptions import TRMNLAuthenticationError, TRMNLError
+from trmnl.models import Device
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_API_KEY
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN, LOGGER
+
+type TRMNLConfigEntry = ConfigEntry[TRMNLCoordinator]
+
+
+class TRMNLCoordinator(DataUpdateCoordinator[dict[int, Device]]):
+    """Class to manage fetching TRMNL data."""
+
+    config_entry: TRMNLConfigEntry
+
+    def __init__(self, hass: HomeAssistant, config_entry: TRMNLConfigEntry) -> None:
+        """Initialize coordinator."""
+        super().__init__(
+            hass,
+            logger=LOGGER,
+            config_entry=config_entry,
+            name=DOMAIN,
+            update_interval=timedelta(hours=1),
+        )
+        self.client = TRMNLClient(
+            token=config_entry.data[CONF_API_KEY],
+            session=async_get_clientsession(hass),
+        )
+
+    async def _async_update_data(self) -> dict[int, Device]:
+        """Fetch data from TRMNL."""
+        try:
+            devices = await self.client.get_devices()
+        except TRMNLAuthenticationError as err:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="authentication_error",
+            ) from err
+        except TRMNLError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error",
+                translation_placeholders={"error": str(err)},
+            ) from err
+        new_data = {device.identifier: device for device in devices}
+        if self.data is not None:
+            device_registry = dr.async_get(self.hass)
+            for device_id in set(self.data) - set(new_data):
+                if entry := device_registry.async_get_device(
+                    identifiers={(DOMAIN, str(device_id))}
+                ):
+                    device_registry.async_update_device(
+                        device_id=entry.id,
+                        remove_config_entry_id=self.config_entry.entry_id,
+                    )
+        return new_data

homeassistant/components/trmnl/diagnostics.py

@@ -0,0 +1,25 @@
+"""Diagnostics support for TRMNL."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.core import HomeAssistant
+
+from .coordinator import TRMNLConfigEntry
+
+TO_REDACT = {"mac_address"}
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: TRMNLConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    return {
+        "data": [
+            async_redact_data(asdict(device), TO_REDACT)
+            for device in entry.runtime_data.data.values()
+        ],
+    }

homeassistant/components/trmnl/entity.py

@@ -0,0 +1,39 @@
+"""Base class for TRMNL entities."""
+
+from __future__ import annotations
+
+from trmnl.models import Device
+
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import TRMNLCoordinator
+
+
+class TRMNLEntity(CoordinatorEntity[TRMNLCoordinator]):
+    """Defines a base TRMNL entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, coordinator: TRMNLCoordinator, device_id: int) -> None:
+        """Initialize TRMNL entity."""
+        super().__init__(coordinator)
+        self._device_id = device_id
+        device = self._device
+        self._attr_device_info = DeviceInfo(
+            connections={(CONNECTION_NETWORK_MAC, device.mac_address)},
+            identifiers={(DOMAIN, str(device_id))},
+            name=device.name,
+            manufacturer="TRMNL",
+        )
+
+    @property
+    def _device(self) -> Device:
+        """Return the device from coordinator data."""
+        return self.coordinator.data[self._device_id]
+
+    @property
+    def available(self) -> bool:
+        """Return if the device is available."""
+        return super().available and self._device_id in self.coordinator.data

homeassistant/components/trmnl/icons.json

@@ -0,0 +1,12 @@
+{
+  "entity": {
+    "switch": {
+      "sleep_mode": {
+        "default": "mdi:sleep-off",
+        "state": {
+          "on": "mdi:sleep"
+        }
+      }
+    }
+  }
+}

homeassistant/components/trmnl/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "trmnl",
+  "name": "TRMNL",
+  "codeowners": ["@joostlek"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/trmnl",
+  "integration_type": "hub",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["trmnl==0.1.0"]
+}

homeassistant/components/trmnl/quality_scale.yaml

@@ -0,0 +1,74 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: This integration does not provide additional 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: This integration does not provide additional actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: Entities of this integration do not explicitly subscribe to 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: todo
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: There are no configuration parameters
+  docs-installation-parameters: todo
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: done
+  test-coverage: todo
+
+  # Gold
+  devices: done
+  diagnostics: done
+  discovery-update-info:
+    status: exempt
+    comment: Uses the cloud API
+  discovery:
+    status: exempt
+    comment: Can't be discovered
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: There are no repairable issues
+  stale-devices: done
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/trmnl/sensor.py

@@ -0,0 +1,92 @@
+"""Support for TRMNL sensors."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from trmnl.models import Device
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import (
+    PERCENTAGE,
+    SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+    EntityCategory,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import TRMNLConfigEntry
+from .coordinator import TRMNLCoordinator
+from .entity import TRMNLEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class TRMNLSensorEntityDescription(SensorEntityDescription):
+    """Describes a TRMNL sensor entity."""
+
+    value_fn: Callable[[Device], int | float | None]
+
+
+SENSOR_DESCRIPTIONS: tuple[TRMNLSensorEntityDescription, ...] = (
+    TRMNLSensorEntityDescription(
+        key="battery",
+        device_class=SensorDeviceClass.BATTERY,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda device: device.percent_charged,
+    ),
+    TRMNLSensorEntityDescription(
+        key="rssi",
+        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
+        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        value_fn=lambda device: device.rssi,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: TRMNLConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up TRMNL sensor entities based on a config entry."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        TRMNLSensor(coordinator, device_id, description)
+        for device_id in coordinator.data
+        for description in SENSOR_DESCRIPTIONS
+    )
+
+
+class TRMNLSensor(TRMNLEntity, SensorEntity):
+    """Defines a TRMNL sensor."""
+
+    entity_description: TRMNLSensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: TRMNLCoordinator,
+        device_id: int,
+        description: TRMNLSensorEntityDescription,
+    ) -> None:
+        """Initialize TRMNL sensor."""
+        super().__init__(coordinator, device_id)
+        self.entity_description = description
+        self._attr_unique_id = f"{device_id}_{description.key}"
+
+    @property
+    def native_value(self) -> int | float | None:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self._device)

homeassistant/components/trmnl/strings.json

@@ -0,0 +1,39 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "unique_id_mismatch": "The API key belongs to a different account. Please use the API key for the original account."
+    },
+    "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": {
+          "api_key": "[%key:common::config_flow::data::api_key%]"
+        },
+        "data_description": {
+          "api_key": "The API key for your TRMNL account."
+        }
+      }
+    }
+  },
+  "entity": {
+    "switch": {
+      "sleep_mode": {
+        "name": "Sleep mode"
+      }
+    }
+  },
+  "exceptions": {
+    "authentication_error": {
+      "message": "Authentication failed. Please check your API key."
+    },
+    "update_error": {
+      "message": "An error occurred while communicating with TRMNL: {error}"
+    }
+  }
+}

homeassistant/components/trmnl/switch.py

@@ -0,0 +1,91 @@
+"""Support for TRMNL switch entities."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from trmnl.models import Device
+
+from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import TRMNLConfigEntry
+from .coordinator import TRMNLCoordinator
+from .entity import TRMNLEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class TRMNLSwitchEntityDescription(SwitchEntityDescription):
+    """Describes a TRMNL switch entity."""
+
+    value_fn: Callable[[Device], bool]
+    set_value_fn: Callable[[TRMNLCoordinator, int, bool], Coroutine[Any, Any, None]]
+
+
+SWITCH_DESCRIPTIONS: tuple[TRMNLSwitchEntityDescription, ...] = (
+    TRMNLSwitchEntityDescription(
+        key="sleep_mode",
+        translation_key="sleep_mode",
+        entity_category=EntityCategory.CONFIG,
+        value_fn=lambda device: device.sleep_mode_enabled,
+        set_value_fn=lambda coordinator, device_id, value: (
+            coordinator.client.update_device(device_id, sleep_mode_enabled=value)
+        ),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: TRMNLConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up TRMNL switch entities based on a config entry."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        TRMNLSwitchEntity(coordinator, device_id, description)
+        for device_id in coordinator.data
+        for description in SWITCH_DESCRIPTIONS
+    )
+
+
+class TRMNLSwitchEntity(TRMNLEntity, SwitchEntity):
+    """Defines a TRMNL switch entity."""
+
+    entity_description: TRMNLSwitchEntityDescription
+
+    def __init__(
+        self,
+        coordinator: TRMNLCoordinator,
+        device_id: int,
+        description: TRMNLSwitchEntityDescription,
+    ) -> None:
+        """Initialize TRMNL switch entity."""
+        super().__init__(coordinator, device_id)
+        self.entity_description = description
+        self._attr_unique_id = f"{device_id}_{description.key}"
+
+    @property
+    def is_on(self) -> bool:
+        """Return if sleep mode is enabled."""
+        return self.entity_description.value_fn(self._device)
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Enable sleep mode."""
+        await self.entity_description.set_value_fn(
+            self.coordinator, self._device_id, True
+        )
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Disable sleep mode."""
+        await self.entity_description.set_value_fn(
+            self.coordinator, self._device_id, False
+        )
+        await self.coordinator.async_request_refresh()

homeassistant/components/unifi/__init__.py

@@ -76,9 +76,7 @@ async def async_remove_config_entry_device(
     """Remove config entry from a device."""
     hub = config_entry.runtime_data
     return not any(
-        identifier
-        for _, identifier in device_entry.connections
-        if identifier in hub.api.clients or identifier in hub.api.devices
+        identifier in hub.api.devices for _, identifier in device_entry.connections
     )
 
 

homeassistant/components/unifi_access/__init__.py

@@ -0,0 +1,54 @@
+"""The UniFi Access integration."""
+
+from __future__ import annotations
+
+from unifi_access_api import ApiAuthError, ApiConnectionError, UnifiAccessApiClient
+
+from homeassistant.const import CONF_API_TOKEN, CONF_HOST, CONF_VERIFY_SSL, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .coordinator import UnifiAccessConfigEntry, UnifiAccessCoordinator
+
+PLATFORMS: list[Platform] = [Platform.BUTTON, Platform.EVENT, Platform.SWITCH]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: UnifiAccessConfigEntry) -> bool:
+    """Set up UniFi Access from a config entry."""
+    session = async_get_clientsession(hass, verify_ssl=entry.data[CONF_VERIFY_SSL])
+
+    client = UnifiAccessApiClient(
+        host=entry.data[CONF_HOST],
+        api_token=entry.data[CONF_API_TOKEN],
+        session=session,
+        verify_ssl=entry.data[CONF_VERIFY_SSL],
+    )
+
+    try:
+        await client.authenticate()
+    except ApiAuthError as err:
+        raise ConfigEntryNotReady(
+            f"Authentication failed for UniFi Access at {entry.data[CONF_HOST]}"
+        ) from err
+    except ApiConnectionError as err:
+        raise ConfigEntryNotReady(
+            f"Unable to connect to UniFi Access at {entry.data[CONF_HOST]}"
+        ) from err
+
+    coordinator = UnifiAccessCoordinator(hass, entry, client)
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+    entry.async_on_unload(client.close)
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(
+    hass: HomeAssistant, entry: UnifiAccessConfigEntry
+) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/unifi_access/button.py

@@ -0,0 +1,53 @@
+"""Button platform for the UniFi Access integration."""
+
+from __future__ import annotations
+
+from unifi_access_api import Door, UnifiAccessError
+
+from homeassistant.components.button import ButtonEntity
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import UnifiAccessConfigEntry, UnifiAccessCoordinator
+from .entity import UnifiAccessEntity
+
+PARALLEL_UPDATES = 1
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: UnifiAccessConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up UniFi Access button entities."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        UnifiAccessUnlockButton(coordinator, door)
+        for door in coordinator.data.doors.values()
+    )
+
+
+class UnifiAccessUnlockButton(UnifiAccessEntity, ButtonEntity):
+    """Representation of a UniFi Access door unlock button."""
+
+    _attr_translation_key = "unlock"
+
+    def __init__(
+        self,
+        coordinator: UnifiAccessCoordinator,
+        door: Door,
+    ) -> None:
+        """Initialize the button entity."""
+        super().__init__(coordinator, door, "unlock")
+
+    async def async_press(self) -> None:
+        """Unlock the door."""
+        try:
+            await self.coordinator.client.unlock_door(self._door_id)
+        except UnifiAccessError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="unlock_failed",
+            ) from err

homeassistant/components/unifi_access/config_flow.py

@@ -0,0 +1,68 @@
+"""Config flow for UniFi Access integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from unifi_access_api import ApiAuthError, ApiConnectionError, UnifiAccessApiClient
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_TOKEN, CONF_HOST, CONF_VERIFY_SSL
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class UnifiAccessConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for UniFi Access."""
+
+    VERSION = 1
+    MINOR_VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            session = async_get_clientsession(
+                self.hass, verify_ssl=user_input[CONF_VERIFY_SSL]
+            )
+            client = UnifiAccessApiClient(
+                host=user_input[CONF_HOST],
+                api_token=user_input[CONF_API_TOKEN],
+                session=session,
+                verify_ssl=user_input[CONF_VERIFY_SSL],
+            )
+            try:
+                await client.authenticate()
+            except ApiAuthError:
+                errors["base"] = "invalid_auth"
+            except ApiConnectionError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
+                return self.async_create_entry(
+                    title="UniFi Access",
+                    data=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_HOST): str,
+                    vol.Required(CONF_API_TOKEN): str,
+                    vol.Required(CONF_VERIFY_SSL, default=False): bool,
+                }
+            ),
+            errors=errors,
+        )

homeassistant/components/unifi_access/const.py

@@ -0,0 +1,3 @@
+"""Constants for the UniFi Access integration."""
+
+DOMAIN = "unifi_access"

homeassistant/components/unifi_access/coordinator.py

@@ -0,0 +1,240 @@
+"""Data update coordinator for the UniFi Access integration."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from dataclasses import dataclass
+import logging
+from typing import Any, cast
+
+from unifi_access_api import (
+    ApiAuthError,
+    ApiConnectionError,
+    ApiError,
+    Door,
+    EmergencyStatus,
+    UnifiAccessApiClient,
+    WsMessageHandler,
+)
+from unifi_access_api.models.websocket import (
+    HwDoorbell,
+    InsightsAdd,
+    LocationUpdateState,
+    LocationUpdateV2,
+    SettingUpdate,
+    V2LocationState,
+    V2LocationUpdate,
+    WebsocketMessage,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+type UnifiAccessConfigEntry = ConfigEntry[UnifiAccessCoordinator]
+
+
+@dataclass(frozen=True)
+class DoorEvent:
+    """Represent a door event from WebSocket."""
+
+    door_id: str
+    category: str
+    event_type: str
+    event_data: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class UnifiAccessData:
+    """Data provided by the UniFi Access coordinator."""
+
+    doors: dict[str, Door]
+    emergency: EmergencyStatus
+
+
+class UnifiAccessCoordinator(DataUpdateCoordinator[UnifiAccessData]):
+    """Coordinator for fetching UniFi Access door data."""
+
+    config_entry: UnifiAccessConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: UnifiAccessConfigEntry,
+        client: UnifiAccessApiClient,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=entry,
+            name=DOMAIN,
+            update_interval=None,
+        )
+        self.client = client
+        self._event_listeners: list[Callable[[DoorEvent], None]] = []
+
+    @callback
+    def async_subscribe_door_events(
+        self,
+        event_callback: Callable[[DoorEvent], None],
+    ) -> CALLBACK_TYPE:
+        """Subscribe to door events (doorbell, access)."""
+
+        def _unsubscribe() -> None:
+            self._event_listeners.remove(event_callback)
+
+        self._event_listeners.append(event_callback)
+        return _unsubscribe
+
+    async def _async_setup(self) -> None:
+        """Set up the WebSocket connection for push updates."""
+        handlers: dict[str, WsMessageHandler] = {
+            "access.data.device.location_update_v2": self._handle_location_update,
+            "access.data.v2.location.update": self._handle_v2_location_update,
+            "access.hw.door_bell": self._handle_doorbell,
+            "access.logs.insights.add": self._handle_insights_add,
+            "access.data.setting.update": self._handle_setting_update,
+        }
+        self.client.start_websocket(
+            handlers,
+            on_connect=self._on_ws_connect,
+            on_disconnect=self._on_ws_disconnect,
+        )
+
+    async def _async_update_data(self) -> UnifiAccessData:
+        """Fetch all doors and emergency status from the API."""
+        try:
+            async with asyncio.timeout(10):
+                doors, emergency = await asyncio.gather(
+                    self.client.get_doors(),
+                    self.client.get_emergency_status(),
+                )
+        except ApiAuthError as err:
+            raise UpdateFailed(f"Authentication failed: {err}") from err
+        except ApiConnectionError as err:
+            raise UpdateFailed(f"Error connecting to API: {err}") from err
+        except ApiError as err:
+            raise UpdateFailed(f"Error communicating with API: {err}") from err
+        except TimeoutError as err:
+            raise UpdateFailed("Timeout communicating with UniFi Access API") from err
+        return UnifiAccessData(
+            doors={door.id: door for door in doors},
+            emergency=emergency,
+        )
+
+    def _on_ws_connect(self) -> None:
+        """Handle WebSocket connection established."""
+        _LOGGER.debug("WebSocket connected to UniFi Access")
+        if not self.last_update_success:
+            self.config_entry.async_create_background_task(
+                self.hass,
+                self.async_request_refresh(),
+                "unifi_access_reconnect_refresh",
+            )
+
+    def _on_ws_disconnect(self) -> None:
+        """Handle WebSocket disconnection."""
+        _LOGGER.warning("WebSocket disconnected from UniFi Access")
+        self.async_set_update_error(
+            UpdateFailed("WebSocket disconnected from UniFi Access")
+        )
+
+    async def _handle_location_update(self, msg: WebsocketMessage) -> None:
+        """Handle location_update_v2 messages."""
+        update = cast(LocationUpdateV2, msg)
+        self._process_door_update(update.data.id, update.data.state)
+
+    async def _handle_v2_location_update(self, msg: WebsocketMessage) -> None:
+        """Handle V2 location update messages."""
+        update = cast(V2LocationUpdate, msg)
+        self._process_door_update(update.data.id, update.data.state)
+
+    def _process_door_update(
+        self, door_id: str, ws_state: LocationUpdateState | V2LocationState | None
+    ) -> None:
+        """Process a door state update from WebSocket."""
+        if self.data is None or door_id not in self.data.doors:
+            return
+
+        if ws_state is None:
+            return
+
+        current_door = self.data.doors[door_id]
+        updates: dict[str, object] = {}
+        if ws_state.dps is not None:
+            updates["door_position_status"] = ws_state.dps
+        if ws_state.lock == "locked":
+            updates["door_lock_relay_status"] = "lock"
+        elif ws_state.lock == "unlocked":
+            updates["door_lock_relay_status"] = "unlock"
+        if not updates:
+            return
+        updated_door = current_door.with_updates(**updates)
+        self.async_set_updated_data(
+            UnifiAccessData(
+                doors={**self.data.doors, door_id: updated_door},
+                emergency=self.data.emergency,
+            )
+        )
+
+    async def _handle_setting_update(self, msg: WebsocketMessage) -> None:
+        """Handle settings update messages (evacuation/lockdown)."""
+        if self.data is None:
+            return
+        update = cast(SettingUpdate, msg)
+        self.async_set_updated_data(
+            UnifiAccessData(
+                doors=self.data.doors,
+                emergency=EmergencyStatus(
+                    evacuation=update.data.evacuation,
+                    lockdown=update.data.lockdown,
+                ),
+            )
+        )
+
+    async def _handle_doorbell(self, msg: WebsocketMessage) -> None:
+        """Handle doorbell press events."""
+        doorbell = cast(HwDoorbell, msg)
+        self._dispatch_door_event(
+            doorbell.data.door_id,
+            "doorbell",
+            "ring",
+            {},
+        )
+
+    async def _handle_insights_add(self, msg: WebsocketMessage) -> None:
+        """Handle access insights events (entry/exit)."""
+        insights = cast(InsightsAdd, msg)
+        door = insights.data.metadata.door
+        if not door.id:
+            return
+        event_type = (
+            "access_granted" if insights.data.result == "ACCESS" else "access_denied"
+        )
+        attrs: dict[str, Any] = {}
+        if insights.data.metadata.actor.display_name:
+            attrs["actor"] = insights.data.metadata.actor.display_name
+        if insights.data.metadata.authentication.display_name:
+            attrs["authentication"] = insights.data.metadata.authentication.display_name
+        if insights.data.result:
+            attrs["result"] = insights.data.result
+        self._dispatch_door_event(door.id, "access", event_type, attrs)
+
+    @callback
+    def _dispatch_door_event(
+        self,
+        door_id: str,
+        category: str,
+        event_type: str,
+        event_data: dict[str, Any],
+    ) -> None:
+        """Dispatch a door event to all subscribed listeners."""
+        event = DoorEvent(door_id, category, event_type, event_data)
+        for listener in self._event_listeners:
+            listener(event)

homeassistant/components/unifi_access/entity.py

@@ -0,0 +1,58 @@
+"""Base entity for the UniFi Access integration."""
+
+from __future__ import annotations
+
+from unifi_access_api import Door
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import UnifiAccessCoordinator
+
+
+class UnifiAccessEntity(CoordinatorEntity[UnifiAccessCoordinator]):
+    """Base entity for UniFi Access doors."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: UnifiAccessCoordinator,
+        door: Door,
+        key: str,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self._door_id = door.id
+        self._attr_unique_id = f"{door.id}-{key}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, door.id)},
+            name=door.name,
+            manufacturer="Ubiquiti",
+        )
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return super().available and self._door_id in self.coordinator.data.doors
+
+    @property
+    def _door(self) -> Door:
+        """Return the current door state from coordinator data."""
+        return self.coordinator.data.doors[self._door_id]
+
+
+class UnifiAccessHubEntity(CoordinatorEntity[UnifiAccessCoordinator]):
+    """Base entity for hub-level (controller-wide) UniFi Access entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, coordinator: UnifiAccessCoordinator) -> None:
+        """Initialize the hub entity."""
+        super().__init__(coordinator)
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, coordinator.config_entry.entry_id)},
+            name="UniFi Access",
+            manufacturer="Ubiquiti",
+        )

homeassistant/components/unifi_access/event.py

@@ -0,0 +1,96 @@
+"""Event platform for the UniFi Access integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from homeassistant.components.event import (
+    EventDeviceClass,
+    EventEntity,
+    EventEntityDescription,
+)
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import DoorEvent, UnifiAccessConfigEntry, UnifiAccessCoordinator
+from .entity import UnifiAccessEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class UnifiAccessEventEntityDescription(EventEntityDescription):
+    """Describes a UniFi Access event entity."""
+
+    category: str
+
+
+DOORBELL_EVENT_DESCRIPTION = UnifiAccessEventEntityDescription(
+    key="doorbell",
+    translation_key="doorbell",
+    device_class=EventDeviceClass.DOORBELL,
+    event_types=["ring"],
+    category="doorbell",
+)
+
+ACCESS_EVENT_DESCRIPTION = UnifiAccessEventEntityDescription(
+    key="access",
+    translation_key="access",
+    event_types=["access_granted", "access_denied"],
+    category="access",
+)
+
+EVENT_DESCRIPTIONS: list[UnifiAccessEventEntityDescription] = [
+    DOORBELL_EVENT_DESCRIPTION,
+    ACCESS_EVENT_DESCRIPTION,
+]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: UnifiAccessConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up UniFi Access event entities."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        UnifiAccessEventEntity(coordinator, door_id, description)
+        for door_id in coordinator.data.doors
+        for description in EVENT_DESCRIPTIONS
+    )
+
+
+class UnifiAccessEventEntity(UnifiAccessEntity, EventEntity):
+    """Representation of a UniFi Access event entity."""
+
+    entity_description: UnifiAccessEventEntityDescription
+
+    def __init__(
+        self,
+        coordinator: UnifiAccessCoordinator,
+        door_id: str,
+        description: UnifiAccessEventEntityDescription,
+    ) -> None:
+        """Initialize the event entity."""
+        door = coordinator.data.doors[door_id]
+        super().__init__(coordinator, door, description.key)
+        self.entity_description = description
+
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to door events when added to hass."""
+        await super().async_added_to_hass()
+        self.async_on_remove(
+            self.coordinator.async_subscribe_door_events(self._async_handle_event)
+        )
+
+    @callback
+    def _async_handle_event(self, event: DoorEvent) -> None:
+        """Handle incoming event from coordinator."""
+        if (
+            event.door_id != self._door_id
+            or event.category != self.entity_description.category
+            or event.event_type not in self.event_types
+        ):
+            return
+        self._trigger_event(event.event_type, event.event_data)
+        self.async_write_ha_state()

homeassistant/components/unifi_access/icons.json

@@ -0,0 +1,22 @@
+{
+  "entity": {
+    "button": {
+      "unlock": {
+        "default": "mdi:lock-open"
+      }
+    },
+    "event": {
+      "access": {
+        "default": "mdi:door"
+      }
+    },
+    "switch": {
+      "evacuation": {
+        "default": "mdi:exit-run"
+      },
+      "lockdown": {
+        "default": "mdi:lock-alert"
+      }
+    }
+  }
+}

homeassistant/components/unifi_access/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "unifi_access",
+  "name": "UniFi Access",
+  "codeowners": ["@imhotep", "@RaHehl"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/unifi_access",
+  "integration_type": "hub",
+  "iot_class": "local_push",
+  "loggers": ["unifi_access_api"],
+  "quality_scale": "bronze",
+  "requirements": ["py-unifi-access==1.1.0"]
+}

homeassistant/components/unifi_access/quality_scale.yaml

@@ -0,0 +1,66 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: Integration does not register custom actions.
+  appropriate-polling:
+    status: exempt
+    comment: Integration uses WebSocket push updates, no polling.
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: Integration does not register custom actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup: done
+  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: todo
+  docs-installation-parameters: todo
+  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: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: done
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: todo

homeassistant/components/unifi_access/strings.json

@@ -0,0 +1,72 @@
+{
+  "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": {
+          "api_token": "[%key:common::config_flow::data::api_token%]",
+          "host": "[%key:common::config_flow::data::host%]",
+          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+        },
+        "data_description": {
+          "api_token": "API token generated in the UniFi Access settings.",
+          "host": "Hostname or IP address of the UniFi Access controller.",
+          "verify_ssl": "Verify the SSL certificate of the controller."
+        }
+      }
+    }
+  },
+  "entity": {
+    "button": {
+      "unlock": {
+        "name": "Unlock"
+      }
+    },
+    "event": {
+      "access": {
+        "name": "Access",
+        "state_attributes": {
+          "event_type": {
+            "state": {
+              "access_denied": "Access denied",
+              "access_granted": "Access granted"
+            }
+          }
+        }
+      },
+      "doorbell": {
+        "name": "Doorbell",
+        "state_attributes": {
+          "event_type": {
+            "state": {
+              "ring": "Ring"
+            }
+          }
+        }
+      }
+    },
+    "switch": {
+      "evacuation": {
+        "name": "Evacuation"
+      },
+      "lockdown": {
+        "name": "Lockdown"
+      }
+    }
+  },
+  "exceptions": {
+    "emergency_failed": {
+      "message": "Failed to set emergency status."
+    },
+    "unlock_failed": {
+      "message": "Failed to unlock the door."
+    }
+  }
+}

homeassistant/components/unifi_access/switch.py

@@ -0,0 +1,110 @@
+"""Switch platform for the UniFi Access integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from unifi_access_api import EmergencyStatus, UnifiAccessError
+
+from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import UnifiAccessConfigEntry, UnifiAccessCoordinator, UnifiAccessData
+from .entity import UnifiAccessHubEntity
+
+PARALLEL_UPDATES = 1
+
+
+@dataclass(frozen=True, kw_only=True)
+class UnifiAccessSwitchEntityDescription(SwitchEntityDescription):
+    """Describes a UniFi Access switch entity."""
+
+    value_fn: Callable[[EmergencyStatus], bool]
+    set_fn: Callable[[EmergencyStatus, bool], EmergencyStatus]
+
+
+SWITCH_DESCRIPTIONS: tuple[UnifiAccessSwitchEntityDescription, ...] = (
+    UnifiAccessSwitchEntityDescription(
+        key="evacuation",
+        translation_key="evacuation",
+        value_fn=lambda s: s.evacuation,
+        set_fn=lambda s, v: EmergencyStatus(evacuation=v, lockdown=s.lockdown),
+    ),
+    UnifiAccessSwitchEntityDescription(
+        key="lockdown",
+        translation_key="lockdown",
+        value_fn=lambda s: s.lockdown,
+        set_fn=lambda s, v: EmergencyStatus(evacuation=s.evacuation, lockdown=v),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: UnifiAccessConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up UniFi Access switch entities."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        UnifiAccessEmergencySwitch(coordinator, description)
+        for description in SWITCH_DESCRIPTIONS
+    )
+
+
+class UnifiAccessEmergencySwitch(UnifiAccessHubEntity, SwitchEntity):
+    """Representation of a UniFi Access emergency switch."""
+
+    entity_description: UnifiAccessSwitchEntityDescription
+
+    def __init__(
+        self,
+        coordinator: UnifiAccessCoordinator,
+        description: UnifiAccessSwitchEntityDescription,
+    ) -> None:
+        """Initialize the switch entity."""
+        super().__init__(coordinator)
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}-{description.key}"
+        self.entity_description = description
+
+    @property
+    def is_on(self) -> bool:
+        """Return True if the switch is on."""
+        return self.entity_description.value_fn(self.coordinator.data.emergency)
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the switch on."""
+        await self._async_set_emergency(True)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the switch off."""
+        await self._async_set_emergency(False)
+
+    async def _async_set_emergency(self, value: bool) -> None:
+        """Set emergency status."""
+        new_status = self.entity_description.set_fn(
+            self.coordinator.data.emergency, value
+        )
+        try:
+            await self.coordinator.client.set_emergency_status(new_status)
+        except UnifiAccessError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="emergency_failed",
+            ) from err
+        # Optimistically update state; the WebSocket confirmation via
+        # access.data.setting.update typically arrives ~200ms later.
+        # Guard against flipping coordinator.last_update_success back to True
+        # while the WebSocket is disconnected and all entities are unavailable.
+        if self.coordinator.last_update_success:
+            self.coordinator.async_set_updated_data(
+                UnifiAccessData(
+                    doors=self.coordinator.data.doors,
+                    emergency=new_status,
+                )
+            )

homeassistant/components/uptime_kuma/sensor.py

@@ -116,13 +116,6 @@ SENSOR_DESCRIPTIONS: tuple[UptimeKumaSensorEntityDescription, ...] = (
         value_fn=lambda m: m.monitor_port,
         create_entity=lambda t: t in HAS_PORT,
     ),
-    UptimeKumaSensorEntityDescription(
-        key=UptimeKumaSensor.PORT,
-        translation_key=UptimeKumaSensor.PORT,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda m: m.monitor_port,
-        create_entity=lambda t: t in HAS_PORT,
-    ),
     UptimeKumaSensorEntityDescription(
         key=UptimeKumaSensor.UPTIME_RATIO_1D,
         translation_key=UptimeKumaSensor.UPTIME_RATIO_1D,

homeassistant/components/victron_ble/sensor.py

@@ -398,7 +398,7 @@ SENSOR_DESCRIPTIONS = {
     Keys.WARNING: VictronBLESensorEntityDescription(
         key=Keys.WARNING,
         device_class=SensorDeviceClass.ENUM,
-        translation_key="alarm",
+        translation_key="warning",
         options=ALARM_OPTIONS,
     ),
     Keys.YIELD_TODAY: VictronBLESensorEntityDescription(

homeassistant/components/victron_ble/strings.json

@@ -248,7 +248,24 @@
         "name": "[%key:component::victron_ble::common::starter_voltage%]"
       },
       "warning": {
-        "name": "Warning"
+        "name": "Warning",
+        "state": {
+          "bms_lockout": "[%key:component::victron_ble::entity::sensor::alarm::state::bms_lockout%]",
+          "dc_ripple": "[%key:component::victron_ble::entity::sensor::alarm::state::dc_ripple%]",
+          "high_starter_voltage": "[%key:component::victron_ble::entity::sensor::alarm::state::high_starter_voltage%]",
+          "high_temperature": "[%key:component::victron_ble::entity::sensor::alarm::state::high_temperature%]",
+          "high_v_ac_out": "[%key:component::victron_ble::entity::sensor::alarm::state::high_v_ac_out%]",
+          "high_voltage": "[%key:component::victron_ble::entity::sensor::alarm::state::high_voltage%]",
+          "low_soc": "[%key:component::victron_ble::entity::sensor::alarm::state::low_soc%]",
+          "low_starter_voltage": "[%key:component::victron_ble::entity::sensor::alarm::state::low_starter_voltage%]",
+          "low_temperature": "[%key:component::victron_ble::entity::sensor::alarm::state::low_temperature%]",
+          "low_v_ac_out": "[%key:component::victron_ble::entity::sensor::alarm::state::low_v_ac_out%]",
+          "low_voltage": "[%key:component::victron_ble::entity::sensor::alarm::state::low_voltage%]",
+          "mid_voltage": "[%key:component::victron_ble::common::midpoint_voltage%]",
+          "no_alarm": "[%key:component::victron_ble::entity::sensor::alarm::state::no_alarm%]",
+          "overload": "[%key:component::victron_ble::entity::sensor::alarm::state::overload%]",
+          "short_circuit": "[%key:component::victron_ble::entity::sensor::alarm::state::short_circuit%]"
+        }
       },
       "yield_today": {
         "name": "Yield today"

homeassistant/components/waterfurnace/config_flow.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 import logging
 from typing import Any
 
@@ -72,6 +73,58 @@ class WaterFurnaceConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauth upon an API authentication error."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Dialog that informs the user that reauth is required."""
+        errors: dict[str, str] = {}
+
+        reauth_entry = self._get_reauth_entry()
+        if user_input is not None:
+            username = user_input[CONF_USERNAME]
+            password = user_input[CONF_PASSWORD]
+
+            client = WaterFurnace(username, password)
+
+            try:
+                await self.hass.async_add_executor_job(client.login)
+            except WFCredentialError:
+                errors["base"] = "invalid_auth"
+            except WFException:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected error during reauthentication")
+                errors["base"] = "unknown"
+
+            # Treat no gwid as a connection failure
+            if not errors and not client.gwid:
+                errors["base"] = "cannot_connect"
+
+            if not errors:
+                await self.async_set_unique_id(client.gwid)
+                self._abort_if_unique_id_mismatch(reason="wrong_account")
+
+                return self.async_update_reload_and_abort(
+                    reauth_entry,
+                    title=f"WaterFurnace {username}",
+                    data_updates={**reauth_entry.data, **user_input},
+                )
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=self.add_suggested_values_to_schema(
+                STEP_USER_DATA_SCHEMA,
+                {CONF_USERNAME: reauth_entry.data[CONF_USERNAME]},
+            ),
+            errors=errors,
+        )
+
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Handle import from YAML configuration."""
         username = import_data[CONF_USERNAME]

homeassistant/components/waterfurnace/strings.json

@@ -4,7 +4,9 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
       "cannot_connect": "Please verify your credentials.",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "Unexpected error, please try again."
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "unknown": "Unexpected error, please try again.",
+      "wrong_account": "You must reauthenticate with the same WaterFurnace account that was originally configured."
     },
     "error": {
       "cannot_connect": "Failed to connect to WaterFurnace service",
@@ -12,6 +14,18 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
+      "reauth_confirm": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]",
+          "username": "[%key:common::config_flow::data::username%]"
+        },
+        "data_description": {
+          "password": "[%key:component::waterfurnace::config::step::user::data_description::password%]",
+          "username": "[%key:component::waterfurnace::config::step::user::data_description::username%]"
+        },
+        "description": "Please re-enter your WaterFurnace Symphony account credentials.",
+        "title": "[%key:common::config_flow::title::reauth%]"
+      },
       "user": {
         "data": {
           "password": "[%key:common::config_flow::data::password%]",

homeassistant/components/waze_travel_time/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["pywaze", "homeassistant.helpers.location"],
-  "requirements": ["pywaze==1.1.1"]
+  "requirements": ["pywaze==1.2.0"]
 }

homeassistant/components/webdav/backup.py

@@ -156,6 +156,7 @@ class WebDavBackupAgent(BackupAgent):
             f"{self._backup_path}/{filename_tar}",
             timeout=BACKUP_TIMEOUT,
             content_length=backup.size,
+            progress=lambda current, total: on_progress(bytes_uploaded=current),
         )
 
         _LOGGER.debug(

homeassistant/components/zha/strings.json

@@ -942,7 +942,7 @@
         "name": "Start-up color temperature"
       },
       "start_up_current_level": {
-        "name": "Start-up current level"
+        "name": "Power-on level"
       },
       "startup_time": {
         "name": "Startup time"
@@ -1298,7 +1298,7 @@
         "name": "Speed"
       },
       "start_up_on_off": {
-        "name": "Start-up behavior"
+        "name": "Power-on behavior"
       },
       "status_indication": {
         "name": "Status indication"

homeassistant/generated/config_flows.py

@@ -743,6 +743,7 @@ FLOWS = {
         "trane",
         "transmission",
         "triggercmd",
+        "trmnl",
         "tuya",
         "twentemilieu",
         "twilio",
@@ -751,6 +752,7 @@ FLOWS = {
         "uhoo",
         "ukraine_alarm",
         "unifi",
+        "unifi_access",
         "unifiprotect",
         "upb",
         "upcloud",

homeassistant/generated/dhcp.py

@@ -817,6 +817,11 @@ DHCP: Final[list[dict[str, str | bool]]] = [
         "hostname": "hub*",
         "macaddress": "286D97*",
     },
+    {
+        "domain": "smartthings",
+        "hostname": "smarthub",
+        "macaddress": "683A48*",
+    },
     {
         "domain": "smartthings",
         "hostname": "samsung-*",

homeassistant/generated/integrations.json

@@ -7244,6 +7244,12 @@
       "config_flow": true,
       "iot_class": "cloud_polling"
     },
+    "trmnl": {
+      "name": "TRMNL",
+      "integration_type": "hub",
+      "config_flow": true,
+      "iot_class": "cloud_polling"
+    },
     "tuya": {
       "name": "Tuya",
       "integration_type": "hub",
@@ -7325,6 +7331,12 @@
           "iot_class": "local_push",
           "name": "UniFi Network"
         },
+        "unifi_access": {
+          "integration_type": "hub",
+          "config_flow": true,
+          "iot_class": "local_push",
+          "name": "UniFi Access"
+        },
         "unifi_direct": {
           "integration_type": "hub",
           "config_flow": false,

homeassistant/helpers/intent.py

@@ -184,6 +184,52 @@ class IntentUnexpectedError(IntentError):
     """Unexpected error while handling intent."""
 
 
+class MatchFailedError(IntentError):
+    """Error when target matching fails."""
+
+    def __init__(
+        self,
+        result: MatchTargetsResult,
+        constraints: MatchTargetsConstraints,
+        preferences: MatchTargetsPreferences | None = None,
+    ) -> None:
+        """Initialize error."""
+        super().__init__()
+
+        self.result = result
+        self.constraints = constraints
+        self.preferences = preferences
+
+    def __str__(self) -> str:
+        """Return string representation."""
+        return f"<MatchFailedError result={self.result}, constraints={self.constraints}, preferences={self.preferences}>"
+
+
+class NoStatesMatchedError(MatchFailedError):
+    """Error when no states match the intent's constraints."""
+
+    def __init__(
+        self,
+        reason: MatchFailedReason,
+        name: str | None = None,
+        area: str | None = None,
+        floor: str | None = None,
+        domains: set[str] | None = None,
+        device_classes: set[str] | None = None,
+    ) -> None:
+        """Initialize error."""
+        super().__init__(
+            result=MatchTargetsResult(False, reason),
+            constraints=MatchTargetsConstraints(
+                name=name,
+                area_name=area,
+                floor_name=floor,
+                domains=domains,
+                device_classes=device_classes,
+            ),
+        )
+
+
 class MatchFailedReason(Enum):
     """Possible reasons for match failure in async_match_targets."""
 
@@ -232,6 +278,29 @@ class MatchFailedReason(Enum):
         )
 
 
+@dataclass
+class MatchTargetsResult:
+    """Result from async_match_targets."""
+
+    is_match: bool
+    """True if one or more entities matched."""
+
+    no_match_reason: MatchFailedReason | None = None
+    """Reason for failed match when is_match = False."""
+
+    states: list[State] = field(default_factory=list)
+    """List of matched entity states."""
+
+    no_match_name: str | None = None
+    """Name of invalid area/floor or duplicate name when match fails for those reasons."""
+
+    areas: list[ar.AreaEntry] = field(default_factory=list)
+    """Areas that were targeted."""
+
+    floors: list[fr.FloorEntry] = field(default_factory=list)
+    """Floors that were targeted."""
+
+
 @dataclass
 class MatchTargetsConstraints:
     """Constraints for async_match_targets."""
@@ -292,75 +361,6 @@ class MatchTargetsPreferences:
     """Id of floor to use when deduplicating names."""
 
 
-@dataclass
-class MatchTargetsResult:
-    """Result from async_match_targets."""
-
-    is_match: bool
-    """True if one or more entities matched."""
-
-    no_match_reason: MatchFailedReason | None = None
-    """Reason for failed match when is_match = False."""
-
-    states: list[State] = field(default_factory=list)
-    """List of matched entity states."""
-
-    no_match_name: str | None = None
-    """Name of invalid area/floor or duplicate name when match fails for those reasons."""
-
-    areas: list[ar.AreaEntry] = field(default_factory=list)
-    """Areas that were targeted."""
-
-    floors: list[fr.FloorEntry] = field(default_factory=list)
-    """Floors that were targeted."""
-
-
-class MatchFailedError(IntentError):
-    """Error when target matching fails."""
-
-    def __init__(
-        self,
-        result: MatchTargetsResult,
-        constraints: MatchTargetsConstraints,
-        preferences: MatchTargetsPreferences | None = None,
-    ) -> None:
-        """Initialize error."""
-        super().__init__()
-
-        self.result = result
-        self.constraints = constraints
-        self.preferences = preferences
-
-    def __str__(self) -> str:
-        """Return string representation."""
-        return f"<MatchFailedError result={self.result}, constraints={self.constraints}, preferences={self.preferences}>"
-
-
-class NoStatesMatchedError(MatchFailedError):
-    """Error when no states match the intent's constraints."""
-
-    def __init__(
-        self,
-        reason: MatchFailedReason,
-        name: str | None = None,
-        area: str | None = None,
-        floor: str | None = None,
-        domains: set[str] | None = None,
-        device_classes: set[str] | None = None,
-    ) -> None:
-        """Initialize error."""
-        super().__init__(
-            result=MatchTargetsResult(False, reason),
-            constraints=MatchTargetsConstraints(
-                name=name,
-                area_name=area,
-                floor_name=floor,
-                domains=domains,
-                device_classes=device_classes,
-            ),
-        )
-
-
 @dataclass
 class MatchTargetsCandidate:
     """Candidate for async_match_targets."""
@@ -915,7 +915,7 @@ class DynamicServiceIntentHandler(IntentHandler):
     def __init__(
         self,
         intent_type: str,
-        speech: str | None = None,
+        *,
         required_slots: _IntentSlotsType | None = None,
         optional_slots: _IntentSlotsType | None = None,
         required_domains: set[str] | None = None,
@@ -927,7 +927,6 @@ class DynamicServiceIntentHandler(IntentHandler):
     ) -> None:
         """Create Service Intent Handler."""
         self.intent_type = intent_type
-        self.speech = speech
         self.required_domains = required_domains
         self.required_features = required_features
         self.required_states = required_states
@@ -1114,7 +1113,6 @@ class DynamicServiceIntentHandler(IntentHandler):
                 )
                 for floor in match_result.floors
             )
-            speech_name = match_result.floors[0].name
         elif match_result.areas:
             success_results.extend(
                 IntentResponseTarget(
@@ -1122,9 +1120,6 @@ class DynamicServiceIntentHandler(IntentHandler):
                 )
                 for area in match_result.areas
             )
-            speech_name = match_result.areas[0].name
-        else:
-            speech_name = states[0].name
 
         service_coros: list[Coroutine[Any, Any, None]] = []
         for state in states:
@@ -1166,9 +1161,6 @@ class DynamicServiceIntentHandler(IntentHandler):
         states = [hass.states.get(state.entity_id) or state for state in states]
         response.async_set_states(states)
 
-        if self.speech is not None:
-            response.async_set_speech(self.speech.format(speech_name))
-
         return response
 
     async def async_call_service(
@@ -1231,7 +1223,7 @@ class ServiceIntentHandler(DynamicServiceIntentHandler):
         intent_type: str,
         domain: str,
         service: str,
-        speech: str | None = None,
+        *,
         required_slots: _IntentSlotsType | None = None,
         optional_slots: _IntentSlotsType | None = None,
         required_domains: set[str] | None = None,
@@ -1244,7 +1236,6 @@ class ServiceIntentHandler(DynamicServiceIntentHandler):
         """Create service handler."""
         super().__init__(
             intent_type,
-            speech=speech,
             required_slots=required_slots,
             optional_slots=optional_slots,
             required_domains=required_domains,

homeassistant/package_constraints.txt

@@ -4,6 +4,7 @@ aiodhcpwatcher==1.2.1
 aiodiscover==2.7.1
 aiodns==4.0.0
 aiogithubapi==26.0.0
+aiohasupervisor==0.3.3
 aiohttp-asyncmdnsresolver==0.1.1
 aiohttp-fast-zlib==0.3.0
 aiohttp==3.13.3

mypy.ini

@@ -5458,6 +5458,16 @@ disallow_untyped_defs = true
 warn_return_any = true
 warn_unreachable = true
 
+[mypy-homeassistant.components.trmnl.*]
+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.tts.*]
 check_untyped_defs = true
 disallow_incomplete_defs = true

pyproject.toml

@@ -28,6 +28,10 @@ dependencies = [
   # module level in `bootstrap.py` and its requirements thus need to be in
   # requirements.txt to ensure they are always installed
   "aiogithubapi==26.0.0",
+  # Integrations may depend on hassio integration without listing it to
+  # change behavior based on presence of supervisor. Deprecated with #127228
+  # Lib can be removed with 2025.11
+  "aiohasupervisor==0.3.3",
   "aiohttp==3.13.3",
   "aiohttp_cors==0.8.1",
   "aiohttp-fast-zlib==0.3.0",

requirements.txt

@@ -5,6 +5,7 @@
 # Home Assistant Core
 aiodns==4.0.0
 aiogithubapi==26.0.0
+aiohasupervisor==0.3.3
 aiohttp-asyncmdnsresolver==0.1.1
 aiohttp-fast-zlib==0.3.0
 aiohttp==3.13.3

requirements_all.txt

@@ -190,7 +190,7 @@ aioairzone-cloud==0.7.2
 aioairzone==1.0.5
 
 # homeassistant.components.alexa_devices
-aioamazondevices==13.0.0
+aioamazondevices==13.0.1
 
 # homeassistant.components.ambient_network
 # homeassistant.components.ambient_station
@@ -276,7 +276,7 @@ aioguardian==2026.01.1
 aioharmony==0.5.3
 
 # homeassistant.components.hassio
-aiohasupervisor==0.4.0
+aiohasupervisor==0.3.3
 
 # homeassistant.components.home_connect
 aiohomeconnect==0.30.0
@@ -1882,6 +1882,9 @@ py-sucks==0.9.11
 # homeassistant.components.synology_dsm
 py-synologydsm-api==2.7.3
 
+# homeassistant.components.unifi_access
+py-unifi-access==1.1.0
+
 # homeassistant.components.atome
 pyAtome==0.1.1
 
@@ -2158,7 +2161,7 @@ pyicloud==2.4.1
 pyinsteon==1.6.4
 
 # homeassistant.components.intelliclima
-pyintelliclima==0.2.2
+pyintelliclima==0.3.1
 
 # homeassistant.components.intesishome
 pyintesishome==1.8.0
@@ -2633,7 +2636,7 @@ python-overseerr==0.9.0
 python-picnic-api2==1.3.1
 
 # homeassistant.components.pooldose
-python-pooldose==0.8.2
+python-pooldose==0.8.5
 
 # homeassistant.components.rabbitair
 python-rabbitair==0.0.8
@@ -2727,7 +2730,7 @@ pyvlx==0.2.30
 pyvolumio==0.1.5
 
 # homeassistant.components.waze_travel_time
-pywaze==1.1.1
+pywaze==1.2.0
 
 # homeassistant.components.weatherflow
 pyweatherflowudp==1.5.0
@@ -3126,6 +3129,9 @@ transmission-rpc==7.0.3
 # homeassistant.components.triggercmd
 triggercmd==0.0.36
 
+# homeassistant.components.trmnl
+trmnl==0.1.0
+
 # homeassistant.components.twinkly
 ttls==1.8.3
 

requirements_test_all.txt

@@ -181,7 +181,7 @@ aioairzone-cloud==0.7.2
 aioairzone==1.0.5
 
 # homeassistant.components.alexa_devices
-aioamazondevices==13.0.0
+aioamazondevices==13.0.1
 
 # homeassistant.components.ambient_network
 # homeassistant.components.ambient_station
@@ -264,7 +264,7 @@ aioguardian==2026.01.1
 aioharmony==0.5.3
 
 # homeassistant.components.hassio
-aiohasupervisor==0.4.0
+aiohasupervisor==0.3.3
 
 # homeassistant.components.home_connect
 aiohomeconnect==0.30.0
@@ -1631,6 +1631,9 @@ py-sucks==0.9.11
 # homeassistant.components.synology_dsm
 py-synologydsm-api==2.7.3
 
+# homeassistant.components.unifi_access
+py-unifi-access==1.1.0
+
 # homeassistant.components.hdmi_cec
 pyCEC==0.5.2
 
@@ -1847,7 +1850,7 @@ pyicloud==2.4.1
 pyinsteon==1.6.4
 
 # homeassistant.components.intelliclima
-pyintelliclima==0.2.2
+pyintelliclima==0.3.1
 
 # homeassistant.components.ipma
 pyipma==3.0.9
@@ -2232,7 +2235,7 @@ python-overseerr==0.9.0
 python-picnic-api2==1.3.1
 
 # homeassistant.components.pooldose
-python-pooldose==0.8.2
+python-pooldose==0.8.5
 
 # homeassistant.components.rabbitair
 python-rabbitair==0.0.8
@@ -2311,7 +2314,7 @@ pyvlx==0.2.30
 pyvolumio==0.1.5
 
 # homeassistant.components.waze_travel_time
-pywaze==1.1.1
+pywaze==1.2.0
 
 # homeassistant.components.weatherflow
 pyweatherflowudp==1.5.0
@@ -2629,6 +2632,9 @@ transmission-rpc==7.0.3
 # homeassistant.components.triggercmd
 triggercmd==0.0.36
 
+# homeassistant.components.trmnl
+trmnl==0.1.0
+
 # homeassistant.components.twinkly
 ttls==1.8.3
 

tests/components/alexa_devices/test_utils.py

@@ -2,10 +2,7 @@
 
 from unittest.mock import AsyncMock
 
-from aioamazondevices.const.devices import (
-    SPEAKER_GROUP_DEVICE_TYPE,
-    SPEAKER_GROUP_FAMILY,
-)
+from aioamazondevices.const.devices import SPEAKER_GROUP_FAMILY
 from aioamazondevices.exceptions import CannotConnect, CannotRetrieveData
 import pytest
 
@@ -117,7 +114,7 @@ async def test_alexa_dnd_group_removal(
         identifiers={(DOMAIN, mock_config_entry.entry_id)},
         name=mock_config_entry.title,
         manufacturer="Amazon",
-        model=SPEAKER_GROUP_DEVICE_TYPE,
+        model="Speaker Group",
         entry_type=dr.DeviceEntryType.SERVICE,
     )
 
@@ -156,7 +153,7 @@ async def test_alexa_unsupported_notification_sensor_removal(
         identifiers={(DOMAIN, mock_config_entry.entry_id)},
         name=mock_config_entry.title,
         manufacturer="Amazon",
-        model=SPEAKER_GROUP_DEVICE_TYPE,
+        model="Speaker Group",
         entry_type=dr.DeviceEntryType.SERVICE,
     )
 

tests/components/arcam_fmj/test_sensor.py

@@ -0,0 +1,94 @@
+"""Tests for Arcam FMJ sensor entities."""
+
+from collections.abc import Generator
+from unittest.mock import Mock, patch
+
+from arcam.fmj import IncomingVideoAspectRatio, IncomingVideoColorspace
+from arcam.fmj.state import IncomingAudioConfig, IncomingAudioFormat, State
+import pytest
+from syrupy.assertion import SnapshotAssertion
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
+
+from tests.common import MockConfigEntry, snapshot_platform
+
+
+@pytest.fixture(autouse=True)
+def sensor_only() -> Generator[None]:
+    """Limit platform setup to sensor only."""
+    with patch("homeassistant.components.arcam_fmj.PLATFORMS", [Platform.SENSOR]):
+        yield
+
+
+@pytest.mark.usefixtures("entity_registry_enabled_by_default", "player_setup")
+async def test_setup(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    snapshot: SnapshotAssertion,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test snapshot of the sensor platform."""
+    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
+
+
+@pytest.mark.usefixtures("player_setup")
+async def test_sensor_video_parameters(
+    hass: HomeAssistant,
+    state_1: State,
+    client: Mock,
+) -> None:
+    """Test video parameter sensors with actual data."""
+    video_params = Mock()
+    video_params.horizontal_resolution = 1920
+    video_params.vertical_resolution = 1080
+    video_params.refresh_rate = 60.0
+    video_params.aspect_ratio = IncomingVideoAspectRatio.ASPECT_16_9
+    video_params.colorspace = IncomingVideoColorspace.HDR10
+
+    state_1.get_incoming_video_parameters.return_value = video_params
+    client.notify_data_updated()
+    await hass.async_block_till_done()
+
+    expected = {
+        "incoming_video_horizontal_resolution": "1920",
+        "incoming_video_vertical_resolution": "1080",
+        "incoming_video_refresh_rate": "60.0",
+        "incoming_video_aspect_ratio": "aspect_16_9",
+        "incoming_video_colorspace": "hdr10",
+    }
+    for key, value in expected.items():
+        state = hass.states.get(f"sensor.arcam_fmj_127_0_0_1_{key}")
+        assert state is not None, f"State missing for {key}"
+        assert state.state == value, f"Expected {value} for {key}, got {state.state}"
+
+
+@pytest.mark.usefixtures("player_setup")
+async def test_sensor_audio_parameters(
+    hass: HomeAssistant,
+    state_1: State,
+    client: Mock,
+) -> None:
+    """Test audio parameter sensors with actual data."""
+    state_1.get_incoming_audio_format.return_value = (
+        IncomingAudioFormat.PCM,
+        IncomingAudioConfig.STEREO_ONLY,
+    )
+    state_1.get_incoming_audio_sample_rate.return_value = 48000
+
+    client.notify_data_updated()
+    await hass.async_block_till_done()
+
+    assert (
+        hass.states.get("sensor.arcam_fmj_127_0_0_1_incoming_audio_format").state
+        == "pcm"
+    )
+    assert (
+        hass.states.get("sensor.arcam_fmj_127_0_0_1_incoming_audio_configuration").state
+        == "stereo_only"
+    )
+    assert (
+        hass.states.get("sensor.arcam_fmj_127_0_0_1_incoming_audio_sample_rate").state
+        == "48000"
+    )

tests/components/chess_com/snapshots/test_diagnostics.ambr

@@ -0,0 +1,59 @@
+# serializer version: 1
+# name: test_diagnostics
+  dict({
+    'player': dict({
+      '_country': None,
+      'avatar': 'https://images.chesscomfiles.com/uploads/v1/user/532748851.d5fefa92.200x200o.da2274e46acd.jpg',
+      'country_url': 'https://api.chess.com/pub/country/NL',
+      'fide': None,
+      'followers': 2,
+      'is_streamer': False,
+      'joined': '2026-02-20T10:48:14',
+      'last_online': '2026-03-06T12:32:59',
+      'location': 'Utrecht',
+      'name': 'Joost',
+      'player_id': 532748851,
+      'status': 'basic',
+      'title': None,
+      'twitch_url': None,
+      'username': 'joostlek',
+    }),
+    'stats': dict({
+      'chess960_daily': None,
+      'chess_blitz': None,
+      'chess_bullet': None,
+      'chess_daily': dict({
+        'last': dict({
+          'date': 1772800350,
+          'rating': 495,
+          'rd': 196,
+        }),
+        'record': dict({
+          'draw': 0,
+          'loss': 4,
+          'time_per_move': 6974,
+          'timeout_percent': 0,
+          'win': 0,
+        }),
+      }),
+      'chess_rapid': None,
+      'lessons': None,
+      'puzzle_rush': dict({
+        'best': dict({
+          'score': 8,
+          'total_attempts': 11,
+        }),
+      }),
+      'tactics': dict({
+        'highest': dict({
+          'date': 1772782351,
+          'rating': 764,
+        }),
+        'lowest': dict({
+          'date': 1771584762,
+          'rating': 400,
+        }),
+      }),
+    }),
+  })
+# ---

tests/components/chess_com/test_diagnostics.py

@@ -0,0 +1,29 @@
+"""Tests for the Chess.com diagnostics."""
+
+from unittest.mock import AsyncMock
+
+from syrupy.assertion import SnapshotAssertion
+
+from homeassistant.core import HomeAssistant
+
+from . import setup_integration
+
+from tests.common import MockConfigEntry
+from tests.components.diagnostics import get_diagnostics_for_config_entry
+from tests.typing import ClientSessionGenerator
+
+
+async def test_diagnostics(
+    hass: HomeAssistant,
+    hass_client: ClientSessionGenerator,
+    mock_chess_client: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+    snapshot: SnapshotAssertion,
+) -> None:
+    """Test diagnostics."""
+    await setup_integration(hass, mock_config_entry)
+
+    assert (
+        await get_diagnostics_for_config_entry(hass, hass_client, mock_config_entry)
+        == snapshot
+    )

tests/components/cover/test_intent.py

@@ -43,7 +43,7 @@ async def test_open_cover_intent(hass: HomeAssistant, slots: dict[str, Any]) ->
     )
     await hass.async_block_till_done()
 
-    assert response.speech["plain"]["speech"] == "Opening garage door"
+    assert response.response_type == intent.IntentResponseType.ACTION_DONE
     assert len(calls) == 1
     call = calls[0]
     assert call.domain == DOMAIN
@@ -75,7 +75,7 @@ async def test_close_cover_intent(hass: HomeAssistant, slots: dict[str, Any]) ->
     )
     await hass.async_block_till_done()
 
-    assert response.speech["plain"]["speech"] == "Closing garage door"
+    assert response.response_type == intent.IntentResponseType.ACTION_DONE
     assert len(calls) == 1
     call = calls[0]
     assert call.domain == DOMAIN

tests/components/hassio/test_issues.py

@@ -72,7 +72,7 @@ def mock_resolution_info(
         if suggestions_by_issue
         else [],
         checks=[
-            Check(enabled=True, slug=CheckType.DOCKER_CONFIG),
+            Check(enabled=True, slug=CheckType.SUPERVISOR_TRUST),
             Check(enabled=True, slug=CheckType.FREE_SPACE),
         ],
     )
@@ -197,7 +197,7 @@ async def test_unsupported_issues(
     """Test issues added for unsupported systems."""
     mock_resolution_info(
         supervisor_client,
-        unsupported=[UnsupportedReason.CONNECTIVITY_CHECK, UnsupportedReason.OS],
+        unsupported=[UnsupportedReason.CONTENT_TRUST, UnsupportedReason.OS],
     )
 
     result = await async_setup_component(hass, "hassio", {})
@@ -210,7 +210,7 @@ async def test_unsupported_issues(
     assert msg["success"]
     assert len(msg["result"]["issues"]) == 2
     assert_repair_in_list(
-        msg["result"]["issues"], unhealthy=False, reason="connectivity_check"
+        msg["result"]["issues"], unhealthy=False, reason="content_trust"
     )
     assert_repair_in_list(msg["result"]["issues"], unhealthy=False, reason="os")
 
@@ -502,7 +502,7 @@ async def test_reasons_added_and_removed(
 
     mock_resolution_info(
         supervisor_client,
-        unsupported=[UnsupportedReason.CONNECTIVITY_CHECK],
+        unsupported=[UnsupportedReason.CONTENT_TRUST],
         unhealthy=[UnhealthyReason.SETUP],
     )
     await client.send_json(
@@ -526,7 +526,7 @@ async def test_reasons_added_and_removed(
     assert len(msg["result"]["issues"]) == 2
     assert_repair_in_list(msg["result"]["issues"], unhealthy=True, reason="setup")
     assert_repair_in_list(
-        msg["result"]["issues"], unhealthy=False, reason="connectivity_check"
+        msg["result"]["issues"], unhealthy=False, reason="content_trust"
     )
 
 

tests/components/intelliclima/conftest.py

@@ -4,6 +4,7 @@ from collections.abc import Generator
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, patch
 
+from pyintelliclima.const import FanMode, FanSpeed
 from pyintelliclima.intelliclima_types import (
     IntelliClimaDevices,
     IntelliClimaECO,
@@ -50,9 +51,9 @@ def single_eco_device() -> IntelliClimaDevices:
         model=IntelliClimaModelType(modello="ECO", tipo="wifi"),
         name="Test VMC",
         houses_id="12345",
-        mode_set="1",
+        mode_set=FanMode.inward,
         mode_state="1",
-        speed_set="3",
+        speed_set=FanSpeed.medium,
         speed_state="3",
         last_online="2025-11-18 10:22:51",
         creation_date="2025-11-18 10:22:51",

tests/components/intelliclima/test_fan.py

@@ -3,6 +3,7 @@
 from collections.abc import AsyncGenerator
 from unittest.mock import AsyncMock, patch
 
+from pyintelliclima.const import FanMode, FanSpeed
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
@@ -103,7 +104,7 @@ async def test_fan_turn_on_service_calls_api(
 
     # Device serial from single_eco_device.crono_sn
     mock_cloud_interface.ecocomfort.set_mode_speed.assert_awaited_once_with(
-        "11223344", "1", "2"
+        "11223344", FanMode.inward, FanSpeed.low
     )
 
 
@@ -119,10 +120,10 @@ async def test_fan_set_percentage_maps_to_speed(
         {ATTR_ENTITY_ID: FAN_ENTITY_ID, ATTR_PERCENTAGE: 15},
         blocking=True,
     )
-    # Initial mode_set="1" (forward) from single_eco_device.
-    # Sleep speed is "1" (25%).
+    # Initial mode_set=FanMode.inward from single_eco_device.
+    # Sleep speed is FanSpeed.sleep (25%).
     mock_cloud_interface.ecocomfort.set_mode_speed.assert_awaited_once_with(
-        "11223344", "1", "1"
+        "11223344", FanMode.inward, FanSpeed.sleep
     )
 
 
@@ -165,18 +166,18 @@ async def test_fan_set_percentage_zero_turns_off(
     ("service_data", "expected_mode", "expected_speed"),
     [
         # percentage=None, preset_mode=None -> defaults to previous speed > 75% (medium),
-        # previous mode > "inward"
-        ({}, "1", "3"),
-        # percentage=0, preset_mode=None -> default 25% (sleep), previous mode (inward)
-        ({ATTR_PERCENTAGE: 0}, "1", "1"),
+        # previous mode > FanMode.inward
+        ({}, FanMode.inward, FanSpeed.medium),
+        # percentage=0, preset_mode=None -> default 25% (FanSpeed.sleep), previous mode (inward)
+        ({ATTR_PERCENTAGE: 0}, FanMode.inward, FanSpeed.sleep),
     ],
 )
 async def test_fan_turn_on_defaulting_behavior(
     hass: HomeAssistant,
     mock_cloud_interface: AsyncMock,
     service_data: dict,
-    expected_mode: str,
-    expected_speed: str,
+    expected_mode: FanMode,
+    expected_speed: FanSpeed,
 ) -> None:
     """turn_on defaults percentage/preset as expected."""
     data = {ATTR_ENTITY_ID: FAN_ENTITY_ID} | service_data

tests/components/intelliclima/test_select.py

@@ -86,10 +86,10 @@ async def test_select_option_keeps_current_speed(
         {ATTR_ENTITY_ID: SELECT_ENTITY_ID, ATTR_OPTION: option},
         blocking=True,
     )
-    # Device starts with speed_set="3" (from single_eco_device in conftest),
+    # Device starts with speed_set=FanSpeed.medium (from single_eco_device in conftest),
     # mode is not off and not auto, so current speed is preserved.
     mock_cloud_interface.ecocomfort.set_mode_speed.assert_awaited_once_with(
-        "11223344", expected_mode, "3"
+        "11223344", expected_mode, FanSpeed.medium
     )
 
 
@@ -119,9 +119,9 @@ async def test_select_option_in_auto_mode_defaults_speed_to_sleep(
     mock_cloud_interface: AsyncMock,
     single_eco_device,
 ) -> None:
-    """When speed_set is FanSpeed.auto (auto preset), selecting an option defaults to sleep speed."""
+    """When speed_set is FanSpeed.auto_get (auto preset), selecting an option defaults to sleep speed."""
     eco = list(single_eco_device.ecocomfort2_devices.values())[0]
-    eco.speed_set = FanSpeed.auto
+    eco.speed_set = FanSpeed.auto_get
     eco.mode_set = FanMode.sensor
 
     await hass.services.async_call(

tests/components/intent/test_init.py

@@ -248,12 +248,11 @@ async def test_cover_intents_loading(hass: HomeAssistant) -> None:
     hass.states.async_set("cover.garage_door", "closed")
     calls = async_mock_service(hass, "cover", SERVICE_OPEN_COVER)
 
-    response = await intent.async_handle(
+    await intent.async_handle(
         hass, "test", "HassOpenCover", {"name": {"value": "garage door"}}
     )
     await hass.async_block_till_done()
 
-    assert response.speech["plain"]["speech"] == "Opening garage door"
     assert len(calls) == 1
     call = calls[0]
     assert call.domain == "cover"

tests/components/litterrobot/test_config_flow.py

@@ -201,3 +201,59 @@ async def test_reauth_wrong_account(hass: HomeAssistant) -> None:
     assert result["reason"] == "unique_id_mismatch"
     assert entry.unique_id == ACCOUNT_USER_ID
     assert entry.data == CONFIG[DOMAIN]
+
+
+async def test_reconfigure(hass: HomeAssistant, mock_account: Account) -> None:
+    """Test reconfiguration flow (with fail and recover)."""
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        data=CONFIG[DOMAIN],
+        unique_id=ACCOUNT_USER_ID,
+    )
+    entry.add_to_hass(hass)
+
+    original_password = entry.data[CONF_PASSWORD]
+    new_password = f"{original_password}_new"
+
+    result = await entry.start_reconfigure_flow(hass)
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "reconfigure"
+
+    with patch(
+        "homeassistant.components.litterrobot.config_flow.Account.connect",
+        side_effect=LitterRobotLoginException,
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            user_input={CONF_PASSWORD: new_password},
+        )
+
+        assert result["type"] is FlowResultType.FORM
+        assert result["errors"] == {"base": "invalid_auth"}
+        assert entry.data[CONF_PASSWORD] == original_password
+
+    with (
+        patch(
+            "homeassistant.components.litterrobot.config_flow.Account.connect",
+            return_value=mock_account,
+        ),
+        patch(
+            "homeassistant.components.litterrobot.config_flow.Account.user_id",
+            new_callable=PropertyMock,
+            return_value=ACCOUNT_USER_ID,
+        ),
+        patch(
+            "homeassistant.components.litterrobot.async_setup_entry",
+            return_value=True,
+        ) as mock_setup_entry,
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            user_input={CONF_PASSWORD: new_password},
+        )
+        assert result["type"] is FlowResultType.ABORT
+        assert result["reason"] == "reconfigure_successful"
+        assert entry.unique_id == ACCOUNT_USER_ID
+        assert entry.data[CONF_PASSWORD] == new_password
+        assert len(mock_setup_entry.mock_calls) == 1

tests/components/litterrobot/test_coordinator.py

@@ -0,0 +1,81 @@
+"""Tests for the Litter-Robot coordinator."""
+
+from unittest.mock import MagicMock
+
+from freezegun.api import FrozenDateTimeFactory
+from pylitterbot.exceptions import LitterRobotException, LitterRobotLoginException
+
+from homeassistant.components.litterrobot.const import DOMAIN
+from homeassistant.components.litterrobot.coordinator import UPDATE_INTERVAL
+from homeassistant.components.vacuum import DOMAIN as VACUUM_DOMAIN
+from homeassistant.config_entries import SOURCE_REAUTH
+from homeassistant.const import STATE_UNAVAILABLE
+from homeassistant.core import HomeAssistant
+
+from .common import VACUUM_ENTITY_ID
+from .conftest import setup_integration
+
+from tests.common import async_fire_time_changed
+
+
+async def test_coordinator_update_error(
+    hass: HomeAssistant,
+    mock_account: MagicMock,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """Test entities become unavailable when coordinator update fails."""
+    await setup_integration(hass, mock_account, VACUUM_DOMAIN)
+
+    assert (state := hass.states.get(VACUUM_ENTITY_ID))
+    assert state.state != STATE_UNAVAILABLE
+
+    # Simulate an API error during update
+    mock_account.refresh_robots.side_effect = LitterRobotException("Unable to connect")
+    freezer.tick(UPDATE_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert (state := hass.states.get(VACUUM_ENTITY_ID))
+    assert state.state == STATE_UNAVAILABLE
+
+    # Recover
+    mock_account.refresh_robots.side_effect = None
+    freezer.tick(UPDATE_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert (state := hass.states.get(VACUUM_ENTITY_ID))
+    assert state.state != STATE_UNAVAILABLE
+
+
+async def test_coordinator_update_auth_error(
+    hass: HomeAssistant,
+    mock_account: MagicMock,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """Test reauthentication flow is triggered on login error during update."""
+    entry = await setup_integration(hass, mock_account, VACUUM_DOMAIN)
+
+    assert (state := hass.states.get(VACUUM_ENTITY_ID))
+    assert state.state != STATE_UNAVAILABLE
+
+    # Simulate an authentication error during update
+    mock_account.refresh_robots.side_effect = LitterRobotLoginException(
+        "Invalid credentials"
+    )
+    freezer.tick(UPDATE_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert (state := hass.states.get(VACUUM_ENTITY_ID))
+    assert state.state == STATE_UNAVAILABLE
+
+    # Ensure a reauthentication flow was triggered
+    flows = hass.config_entries.flow.async_progress()
+    assert len(flows) == 1
+
+    flow = flows[0]
+    assert flow["step_id"] == "reauth_confirm"
+    assert flow["handler"] == DOMAIN
+    assert flow["context"].get("source") == SOURCE_REAUTH
+    assert flow["context"].get("entry_id") == entry.entry_id

tests/components/matter/test_select.py

@@ -86,15 +86,12 @@ async def test_attribute_select_entities(
     matter_node: MatterNode,
 ) -> None:
     """Test select entities are created for attribute based discovery schema(s)."""
-    entity_id = "select.mock_dimmable_light_power_on_behavior_on_startup"
+    entity_id = "select.mock_dimmable_light_power_on_behavior"
     state = hass.states.get(entity_id)
     assert state
     assert state.state == "previous"
     assert state.attributes["options"] == ["on", "off", "toggle", "previous"]
-    assert (
-        state.attributes["friendly_name"]
-        == "Mock Dimmable Light Power-on behavior on startup"
-    )
+    assert state.attributes["friendly_name"] == "Mock Dimmable Light Power-on behavior"
     set_node_attribute(matter_node, 1, 6, 16387, 1)
     await trigger_subscription_callback(hass, matter_client)
     state = hass.states.get(entity_id)

tests/components/smartthings/snapshots/test_binary_sensor.ambr

@@ -298,6 +298,55 @@
     'state': 'off',
   })
 # ---
+# name: test_all_entities[da_ks_cooktop_000001][binary_sensor.table_de_cuisson_operating_state-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'binary_sensor',
+    'entity_category': None,
+    'entity_id': 'binary_sensor.table_de_cuisson_operating_state',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Operating state',
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Operating state',
+    'platform': 'smartthings',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': 'cooktop_operating_state',
+    'unique_id': '5c202ad1-d112-d746-50b8-bd76a554b362_main_custom.cooktopOperatingState_cooktopOperatingState_cooktopOperatingState',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_all_entities[da_ks_cooktop_000001][binary_sensor.table_de_cuisson_operating_state-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Table de cuisson Operating state',
+    }),
+    'context': <ANY>,
+    'entity_id': 'binary_sensor.table_de_cuisson_operating_state',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'off',
+  })
+# ---
 # name: test_all_entities[da_ks_cooktop_000001][binary_sensor.table_de_cuisson_power-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
@@ -1040,6 +1089,55 @@
     'state': 'off',
   })
 # ---
+# name: test_all_entities[da_ks_range_0101x][binary_sensor.vulcan_operating_state-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'binary_sensor',
+    'entity_category': None,
+    'entity_id': 'binary_sensor.vulcan_operating_state',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Operating state',
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Operating state',
+    'platform': 'smartthings',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': 'cooktop_operating_state',
+    'unique_id': '2c3cbaa0-1899-5ddc-7b58-9d657bd48f18_main_custom.cooktopOperatingState_cooktopOperatingState_cooktopOperatingState',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_all_entities[da_ks_range_0101x][binary_sensor.vulcan_operating_state-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Vulcan Operating state',
+    }),
+    'context': <ANY>,
+    'entity_id': 'binary_sensor.vulcan_operating_state',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'off',
+  })
+# ---
 # name: test_all_entities[da_ks_range_0101x][binary_sensor.vulcan_remote_control-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({

tests/components/trmnl/__init__.py

@@ -0,0 +1,13 @@
+"""Tests for the TRMNL integration."""
+
+from homeassistant.core import HomeAssistant
+
+from tests.common import MockConfigEntry
+
+
+async def setup_integration(hass: HomeAssistant, config_entry: MockConfigEntry) -> None:
+    """Set up the TRMNL integration for testing."""
+    config_entry.add_to_hass(hass)
+
+    await hass.config_entries.async_setup(config_entry.entry_id)
+    await hass.async_block_till_done()

tests/components/trmnl/conftest.py

@@ -0,0 +1,55 @@
+"""Common fixtures for the TRMNL tests."""
+
+from collections.abc import Generator
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from trmnl.models import DevicesResponse, UserResponse
+
+from homeassistant.components.trmnl.const import DOMAIN
+from homeassistant.const import CONF_API_KEY
+
+from tests.common import MockConfigEntry, load_fixture
+
+
+@pytest.fixture
+def mock_setup_entry() -> Generator[AsyncMock]:
+    """Override async_setup_entry."""
+    with patch(
+        "homeassistant.components.trmnl.async_setup_entry", return_value=True
+    ) as mock_setup_entry:
+        yield mock_setup_entry
+
+
+@pytest.fixture
+def mock_config_entry() -> MockConfigEntry:
+    """Mock config entry."""
+    return MockConfigEntry(
+        domain=DOMAIN,
+        title="Test",
+        unique_id="30561",
+        data={CONF_API_KEY: "user_aaaaaaaaaa"},
+    )
+
+
+@pytest.fixture
+def mock_trmnl_client() -> Generator[AsyncMock]:
+    """Mock TRMNL client."""
+    with (
+        patch(
+            "homeassistant.components.trmnl.coordinator.TRMNLClient",
+            autospec=True,
+        ) as mock_client,
+        patch(
+            "homeassistant.components.trmnl.config_flow.TRMNLClient",
+            new=mock_client,
+        ),
+    ):
+        client = mock_client.return_value
+        client.get_me.return_value = UserResponse.from_json(
+            load_fixture("me.json", DOMAIN)
+        ).data
+        client.get_devices.return_value = DevicesResponse.from_json(
+            load_fixture("devices.json", DOMAIN)
+        ).data
+        yield client

tests/components/trmnl/fixtures/devices.json

@@ -0,0 +1,17 @@
+{
+  "data": [
+    {
+      "id": 42793,
+      "name": "Test TRMNL",
+      "friendly_id": "1RJXS4",
+      "mac_address": "B0:A6:04:AA:BB:CC",
+      "battery_voltage": 3.87,
+      "rssi": -64,
+      "sleep_mode_enabled": false,
+      "sleep_start_time": 1320,
+      "sleep_end_time": 480,
+      "percent_charged": 72.5,
+      "wifi_strength": 50
+    }
+  ]
+}

tests/components/trmnl/fixtures/me.json

@@ -0,0 +1,14 @@
+{
+  "data": {
+    "id": 30561,
+    "name": "Test",
+    "email": "test@outlook.com",
+    "first_name": "test",
+    "last_name": "test",
+    "locale": "en",
+    "time_zone": "Amsterdam",
+    "time_zone_iana": "Europe/Amsterdam",
+    "utc_offset": 3600,
+    "api_key": "user_aaaaaaaaaa"
+  }
+}

tests/components/trmnl/snapshots/test_diagnostics.ambr

@@ -0,0 +1,20 @@
+# serializer version: 1
+# name: test_diagnostics
+  dict({
+    'data': list([
+      dict({
+        'battery_voltage': 3.87,
+        'friendly_id': '1RJXS4',
+        'identifier': 42793,
+        'mac_address': '**REDACTED**',
+        'name': 'Test TRMNL',
+        'percent_charged': 72.5,
+        'rssi': -64,
+        'sleep_end_time': 480,
+        'sleep_mode_enabled': False,
+        'sleep_start_time': 1320,
+        'wifi_strength': 50,
+      }),
+    ]),
+  })
+# ---

tests/components/trmnl/snapshots/test_init.ambr

@@ -0,0 +1,36 @@
+# serializer version: 1
+# name: test_device
+  DeviceRegistryEntrySnapshot({
+    'area_id': None,
+    'config_entries': <ANY>,
+    'config_entries_subentries': <ANY>,
+    'configuration_url': None,
+    'connections': set({
+      tuple(
+        'mac',
+        'b0:a6:04:aa:bb:cc',
+      ),
+    }),
+    'disabled_by': None,
+    'entry_type': None,
+    'hw_version': None,
+    'id': <ANY>,
+    'identifiers': set({
+      tuple(
+        'trmnl',
+        '42793',
+      ),
+    }),
+    'labels': set({
+    }),
+    'manufacturer': 'TRMNL',
+    'model': None,
+    'model_id': None,
+    'name': 'Test TRMNL',
+    'name_by_user': None,
+    'primary_config_entry': <ANY>,
+    'serial_number': None,
+    'sw_version': None,
+    'via_device_id': None,
+  })
+# ---

tests/components/trmnl/snapshots/test_sensor.ambr

@@ -0,0 +1,109 @@
+# serializer version: 1
+# name: test_all_entities[sensor.test_trmnl_battery-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_trmnl_battery',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Battery',
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
+    'original_icon': None,
+    'original_name': 'Battery',
+    'platform': 'trmnl',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': None,
+    'unique_id': '42793_battery',
+    'unit_of_measurement': '%',
+  })
+# ---
+# name: test_all_entities[sensor.test_trmnl_battery-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'battery',
+      'friendly_name': 'Test TRMNL Battery',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': '%',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_trmnl_battery',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '72.5',
+  })
+# ---
+# name: test_all_entities[sensor.test_trmnl_signal_strength-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_trmnl_signal_strength',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Signal strength',
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.SIGNAL_STRENGTH: 'signal_strength'>,
+    'original_icon': None,
+    'original_name': 'Signal strength',
+    'platform': 'trmnl',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': None,
+    'unique_id': '42793_rssi',
+    'unit_of_measurement': 'dBm',
+  })
+# ---
+# name: test_all_entities[sensor.test_trmnl_signal_strength-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'signal_strength',
+      'friendly_name': 'Test TRMNL Signal strength',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': 'dBm',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_trmnl_signal_strength',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '-64',
+  })
+# ---

tests/components/trmnl/snapshots/test_switch.ambr

@@ -0,0 +1,50 @@
+# serializer version: 1
+# name: test_all_entities[switch.test_trmnl_sleep_mode-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'switch',
+    'entity_category': <EntityCategory.CONFIG: 'config'>,
+    'entity_id': 'switch.test_trmnl_sleep_mode',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Sleep mode',
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Sleep mode',
+    'platform': 'trmnl',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': 'sleep_mode',
+    'unique_id': '42793_sleep_mode',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_all_entities[switch.test_trmnl_sleep_mode-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Test TRMNL Sleep mode',
+    }),
+    'context': <ANY>,
+    'entity_id': 'switch.test_trmnl_sleep_mode',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'off',
+  })
+# ---

tests/components/trmnl/test_config_flow.py

@@ -0,0 +1,172 @@
+"""Test the TRMNL config flow."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+from trmnl.exceptions import TRMNLAuthenticationError, TRMNLError
+
+from homeassistant.components.trmnl.const import DOMAIN
+from homeassistant.config_entries import SOURCE_USER
+from homeassistant.const import CONF_API_KEY
+from homeassistant.core import HomeAssistant
+from homeassistant.data_entry_flow import FlowResultType
+
+from tests.common import MockConfigEntry
+
+
+@pytest.mark.usefixtures("mock_trmnl_client")
+async def test_full_flow(hass: HomeAssistant, mock_setup_entry: AsyncMock) -> None:
+    """Test the full config flow."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"] == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], {CONF_API_KEY: "user_aaaaaaaaaa"}
+    )
+
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == "Test"
+    assert result["data"] == {CONF_API_KEY: "user_aaaaaaaaaa"}
+    assert result["result"].unique_id == "30561"
+    assert len(mock_setup_entry.mock_calls) == 1
+
+
+@pytest.mark.parametrize(
+    ("exception", "error"),
+    [
+        (TRMNLAuthenticationError, "invalid_auth"),
+        (TRMNLError, "cannot_connect"),
+        (Exception, "unknown"),
+    ],
+)
+async def test_form_errors(
+    hass: HomeAssistant,
+    mock_trmnl_client: AsyncMock,
+    mock_setup_entry: AsyncMock,
+    exception: type[Exception],
+    error: str,
+) -> None:
+    """Test we handle form errors."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+
+    mock_trmnl_client.get_me.side_effect = exception
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], {CONF_API_KEY: "user_aaaaaaaaaa"}
+    )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"] == {"base": error}
+
+    mock_trmnl_client.get_me.side_effect = None
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], {CONF_API_KEY: "user_aaaaaaaaaa"}
+    )
+
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert len(mock_setup_entry.mock_calls) == 1
+
+
+@pytest.mark.usefixtures("mock_trmnl_client")
+async def test_duplicate_entry(
+    hass: HomeAssistant, mock_config_entry: MockConfigEntry
+) -> None:
+    """Test we handle duplicate entries."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], {CONF_API_KEY: "user_aaaaaaaaaa"}
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_configured"
+
+
+async def test_reauth_flow(
+    hass: HomeAssistant,
+    mock_trmnl_client: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test the reauth flow."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await mock_config_entry.start_reauth_flow(hass)
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], {CONF_API_KEY: "user_bbbbbbbbbb"}
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "reauth_successful"
+    assert mock_config_entry.data == {CONF_API_KEY: "user_bbbbbbbbbb"}
+
+
+@pytest.mark.parametrize(
+    ("exception", "error"),
+    [
+        (TRMNLAuthenticationError, "invalid_auth"),
+        (TRMNLError, "cannot_connect"),
+        (Exception, "unknown"),
+    ],
+)
+async def test_reauth_flow_errors(
+    hass: HomeAssistant,
+    mock_trmnl_client: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+    exception: type[Exception],
+    error: str,
+) -> None:
+    """Test reauth flow error handling."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await mock_config_entry.start_reauth_flow(hass)
+
+    mock_trmnl_client.get_me.side_effect = exception
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], {CONF_API_KEY: "user_bbbbbbbbbb"}
+    )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"] == {"base": error}
+
+    mock_trmnl_client.get_me.side_effect = None
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], {CONF_API_KEY: "user_bbbbbbbbbb"}
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "reauth_successful"
+
+
+async def test_reauth_flow_wrong_account(
+    hass: HomeAssistant,
+    mock_trmnl_client: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test reauth aborts when the API key belongs to a different account."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await mock_config_entry.start_reauth_flow(hass)
+
+    mock_trmnl_client.get_me.return_value.identifier = 99999
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], {CONF_API_KEY: "user_cccccccccc"}
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "unique_id_mismatch"

tests/components/trmnl/test_diagnostics.py

@@ -0,0 +1,29 @@
+"""Tests for the TRMNL diagnostics."""
+
+from unittest.mock import AsyncMock
+
+from syrupy.assertion import SnapshotAssertion
+
+from homeassistant.core import HomeAssistant
+
+from . import setup_integration
+
+from tests.common import MockConfigEntry
+from tests.components.diagnostics import get_diagnostics_for_config_entry
+from tests.typing import ClientSessionGenerator
+
+
+async def test_diagnostics(
+    hass: HomeAssistant,
+    hass_client: ClientSessionGenerator,
+    mock_trmnl_client: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+    snapshot: SnapshotAssertion,
+) -> None:
+    """Test diagnostics."""
+    await setup_integration(hass, mock_config_entry)
+
+    assert (
+        await get_diagnostics_for_config_entry(hass, hass_client, mock_config_entry)
+        == snapshot
+    )

tests/components/trmnl/test_init.py

@@ -0,0 +1,73 @@
+"""Test the TRMNL initialization."""
+
+from datetime import timedelta
+from unittest.mock import AsyncMock
+
+from freezegun.api import FrozenDateTimeFactory
+from syrupy.assertion import SnapshotAssertion
+
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
+
+from . import setup_integration
+
+from tests.common import MockConfigEntry, async_fire_time_changed
+
+
+async def test_load_unload_entry(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_trmnl_client: AsyncMock,
+) -> None:
+    """Test loading and unloading a config entry."""
+    await setup_integration(hass, mock_config_entry)
+
+    assert mock_config_entry.state is ConfigEntryState.LOADED
+
+    await hass.config_entries.async_unload(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    assert mock_config_entry.state is ConfigEntryState.NOT_LOADED
+
+
+async def test_device(
+    hass: HomeAssistant,
+    device_registry: dr.DeviceRegistry,
+    mock_config_entry: MockConfigEntry,
+    mock_trmnl_client: AsyncMock,
+    snapshot: SnapshotAssertion,
+) -> None:
+    """Test the TRMNL device."""
+    await setup_integration(hass, mock_config_entry)
+
+    device = device_registry.async_get_device(
+        connections={(CONNECTION_NETWORK_MAC, "B0:A6:04:AA:BB:CC")}
+    )
+    assert device
+    assert device == snapshot
+
+
+async def test_stale_device_removed(
+    hass: HomeAssistant,
+    device_registry: dr.DeviceRegistry,
+    mock_config_entry: MockConfigEntry,
+    mock_trmnl_client: AsyncMock,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """Test that a device is removed from the device registry when it disappears."""
+    await setup_integration(hass, mock_config_entry)
+
+    assert device_registry.async_get_device(
+        connections={(CONNECTION_NETWORK_MAC, "B0:A6:04:AA:BB:CC")}
+    )
+
+    mock_trmnl_client.get_devices.return_value = []
+    freezer.tick(timedelta(hours=1))
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert not device_registry.async_get_device(
+        connections={(CONNECTION_NETWORK_MAC, "B0:A6:04:AA:BB:CC")}
+    )