2026.3.0 (#164757)

This reverts commit 37d2c946e8.

.github/workflows/wheels.yml

@@ -209,4 +209,4 @@ jobs:
           skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
           constraints: "homeassistant/package_constraints.txt"
           requirements-diff: "requirements_diff.txt"
-          requirements: "requirements_all.txt"
+          requirements: "requirements_all_wheels_${{ matrix.arch }}.txt"

homeassistant/bootstrap.py

@@ -70,7 +70,7 @@ from .const import (
     SIGNAL_BOOTSTRAP_INTEGRATIONS,
 )
 from .core_config import async_process_ha_core_config
-from .exceptions import HomeAssistantError
+from .exceptions import HomeAssistantError, UnsupportedStorageVersionError
 from .helpers import (
     area_registry,
     category_registry,
@@ -239,6 +239,8 @@ DEFAULT_INTEGRATIONS = {
 }
 DEFAULT_INTEGRATIONS_RECOVERY_MODE = {
     # These integrations are set up if recovery mode is activated.
+    "backup",
+    "cloud",
     "frontend",
 }
 DEFAULT_INTEGRATIONS_SUPERVISOR = {
@@ -433,32 +435,56 @@ def _init_blocking_io_modules_in_executor() -> None:
     is_docker_env()
 
 
-async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
-    """Load the registries and modules that will do blocking I/O."""
+async def async_load_base_functionality(hass: core.HomeAssistant) -> bool:
+    """Load the registries and modules that will do blocking I/O.
+
+    Return whether loading succeeded.
+    """
     if DATA_REGISTRIES_LOADED in hass.data:
-        return
+        return True
+
     hass.data[DATA_REGISTRIES_LOADED] = None
     entity.async_setup(hass)
     frame.async_setup(hass)
     template.async_setup(hass)
     translation.async_setup(hass)
-    await asyncio.gather(
-        create_eager_task(get_internal_store_manager(hass).async_initialize()),
-        create_eager_task(area_registry.async_load(hass)),
-        create_eager_task(category_registry.async_load(hass)),
-        create_eager_task(device_registry.async_load(hass)),
-        create_eager_task(entity_registry.async_load(hass)),
-        create_eager_task(floor_registry.async_load(hass)),
-        create_eager_task(issue_registry.async_load(hass)),
-        create_eager_task(label_registry.async_load(hass)),
-        hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
-        create_eager_task(template.async_load_custom_templates(hass)),
-        create_eager_task(restore_state.async_load(hass)),
-        create_eager_task(hass.config_entries.async_initialize()),
-        create_eager_task(async_get_system_info(hass)),
-        create_eager_task(condition.async_setup(hass)),
-        create_eager_task(trigger.async_setup(hass)),
-    )
+
+    recovery = hass.config.recovery_mode
+    try:
+        await asyncio.gather(
+            create_eager_task(get_internal_store_manager(hass).async_initialize()),
+            create_eager_task(area_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(category_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(device_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(entity_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(floor_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(issue_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(label_registry.async_load(hass, load_empty=recovery)),
+            hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
+            create_eager_task(template.async_load_custom_templates(hass)),
+            create_eager_task(restore_state.async_load(hass, load_empty=recovery)),
+            create_eager_task(hass.config_entries.async_initialize()),
+            create_eager_task(async_get_system_info(hass)),
+            create_eager_task(condition.async_setup(hass)),
+            create_eager_task(trigger.async_setup(hass)),
+        )
+    except UnsupportedStorageVersionError as err:
+        # If we're already in recovery mode, we don't want to handle the exception
+        # and activate recovery mode again, as that would lead to an infinite loop.
+        if recovery:
+            raise
+
+        _LOGGER.error(
+            "Storage file %s was created by a newer version of Home Assistant"
+            " (storage version %s > %s); activating recovery mode; on-disk data"
+            " is preserved; upgrade Home Assistant or restore from a backup",
+            err.storage_key,
+            err.found_version,
+            err.max_supported_version,
+        )
+        return False
+
+    return True
 
 
 async def async_from_config_dict(
@@ -475,7 +501,9 @@ async def async_from_config_dict(
     # Prime custom component cache early so we know if registry entries are tied
     # to a custom integration
     await loader.async_get_custom_components(hass)
-    await async_load_base_functionality(hass)
+
+    if not await async_load_base_functionality(hass):
+        return None
 
     # Set up core.
     _LOGGER.debug("Setting up %s", CORE_INTEGRATIONS)

homeassistant/brands/ubisys.json

@@ -0,0 +1,5 @@
+{
+  "domain": "ubisys",
+  "name": "Ubisys",
+  "iot_standards": ["zigbee"]
+}

homeassistant/components/accuweather/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["accuweather"],
-  "requirements": ["accuweather==5.0.0"]
+  "requirements": ["accuweather==5.1.0"]
 }

homeassistant/components/accuweather/system_health.py

@@ -30,6 +30,8 @@ async def system_health_info(hass: HomeAssistant) -> dict[str, Any]:
     )
 
     return {
-        "can_reach_server": system_health.async_check_can_reach_url(hass, ENDPOINT),
+        "can_reach_server": system_health.async_check_can_reach_url(
+            hass, str(ENDPOINT)
+        ),
         "remaining_requests": remaining_requests,
     }

homeassistant/components/accuweather/weather.py

@@ -191,7 +191,7 @@ class AccuWeatherEntity(
             {
                 ATTR_FORECAST_TIME: utc_from_timestamp(item["EpochDate"]).isoformat(),
                 ATTR_FORECAST_CLOUD_COVERAGE: item["CloudCoverDay"],
-                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"]["Average"],
+                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"].get("Average"),
                 ATTR_FORECAST_NATIVE_TEMP: item["TemperatureMax"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_TEMP_LOW: item["TemperatureMin"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_APPARENT_TEMP: item["RealFeelTemperatureMax"][

homeassistant/components/airobot/number.py

@@ -93,7 +93,6 @@ class AirobotNumber(AirobotEntity, NumberEntity):
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
                 translation_key="set_value_failed",
-                translation_placeholders={"error": str(err)},
             ) from err
         else:
             await self.coordinator.async_request_refresh()

homeassistant/components/airobot/strings.json

@@ -112,7 +112,7 @@
       "message": "Failed to set temperature to {temperature}."
     },
     "set_value_failed": {
-      "message": "Failed to set value: {error}"
+      "message": "Failed to set value."
     },
     "switch_turn_off_failed": {
       "message": "Failed to turn off {switch}."

homeassistant/components/alexa_devices/entity.py

@@ -1,6 +1,6 @@
 """Defines a base Alexa Devices entity."""
 
-from aioamazondevices.const.devices import SPEAKER_GROUP_MODEL
+from aioamazondevices.const.devices import SPEAKER_GROUP_DEVICE_TYPE
 from aioamazondevices.structures import AmazonDevice
 
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -25,19 +25,20 @@ class AmazonEntity(CoordinatorEntity[AmazonDevicesCoordinator]):
         """Initialize the entity."""
         super().__init__(coordinator)
         self._serial_num = serial_num
-        model_details = coordinator.api.get_model_details(self.device) or {}
-        model = model_details.get("model")
+        model = self.device.model
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, serial_num)},
             name=self.device.account_name,
             model=model,
             model_id=self.device.device_type,
-            manufacturer=model_details.get("manufacturer", "Amazon"),
-            hw_version=model_details.get("hw_version"),
+            manufacturer=self.device.manufacturer or "Amazon",
+            hw_version=self.device.hardware_version,
             sw_version=(
-                self.device.software_version if model != SPEAKER_GROUP_MODEL else None
+                self.device.software_version
+                if model != SPEAKER_GROUP_DEVICE_TYPE
+                else None
             ),
-            serial_number=serial_num if model != SPEAKER_GROUP_MODEL else None,
+            serial_number=serial_num if model != SPEAKER_GROUP_DEVICE_TYPE else None,
         )
         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==12.0.0"]
+  "requirements": ["aioamazondevices==13.0.0"]
 }

homeassistant/components/anthropic/entity.py

@@ -858,6 +858,11 @@ class AnthropicBaseLLMEntity(Entity):
                     ]
                 )
                 messages.extend(new_messages)
+            except anthropic.AuthenticationError as err:
+                self.entry.async_start_reauth(self.hass)
+                raise HomeAssistantError(
+                    "Authentication error with Anthropic API, reauthentication required"
+                ) from err
             except anthropic.AnthropicError as err:
                 raise HomeAssistantError(
                     f"Sorry, I had a problem talking to Anthropic: {err}"

homeassistant/components/anthropic/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "anthropic",
-  "name": "Anthropic Conversation",
+  "name": "Anthropic",
   "after_dependencies": ["assist_pipeline", "intent"],
   "codeowners": ["@Shulyaka"],
   "config_flow": true,

homeassistant/components/august/manifest.json

@@ -30,5 +30,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.4"]
+  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.7"]
 }

homeassistant/components/backup/store.py

@@ -29,12 +29,17 @@ class StoredBackupData(TypedDict):
 class _BackupStore(Store[StoredBackupData]):
     """Class to help storing backup data."""
 
+    # Maximum version we support reading for forward compatibility.
+    # This allows reading data written by a newer HA version after downgrade.
+    _MAX_READABLE_VERSION = 2
+
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize storage class."""
         super().__init__(
             hass,
             STORAGE_VERSION,
             STORAGE_KEY,
+            max_readable_version=self._MAX_READABLE_VERSION,
             minor_version=STORAGE_VERSION_MINOR,
         )
 
@@ -86,8 +91,8 @@ class _BackupStore(Store[StoredBackupData]):
         # data["config"]["schedule"]["state"] will be removed. The bump to 2 is
         # planned to happen after a 6 month quiet period with no minor version
         # changes.
-        # Reject if major version is higher than 2.
-        if old_major_version > 2:
+        # Reject if major version is higher than _MAX_READABLE_VERSION.
+        if old_major_version > self._MAX_READABLE_VERSION:
             raise NotImplementedError
         return data
 

homeassistant/components/backup/strings.json

@@ -43,11 +43,11 @@
       "title": "The backup location {agent_id} is unavailable"
     },
     "automatic_backup_failed_addons": {
-      "description": "Add-ons {failed_addons} could not be included in automatic backup. Please check the Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
-      "title": "Not all add-ons could be included in automatic backup"
+      "description": "Apps {failed_addons} could not be included in automatic backup. Please check the Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
+      "title": "Not all apps could be included in automatic backup"
     },
     "automatic_backup_failed_agents_addons_folders": {
-      "description": "The automatic backup was created with errors:\n* Locations which the backup could not be uploaded to: {failed_agents}\n* Add-ons which could not be backed up: {failed_addons}\n* Folders which could not be backed up: {failed_folders}\n\nPlease check the Core and Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
+      "description": "The automatic backup was created with errors:\n* Locations which the backup could not be uploaded to: {failed_agents}\n* Apps which could not be backed up: {failed_addons}\n* Folders which could not be backed up: {failed_folders}\n\nPlease check the Core and Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
       "title": "Automatic backup was created with errors"
     },
     "automatic_backup_failed_create": {

homeassistant/components/bsblan/sensor.py

@@ -64,6 +64,8 @@ SENSOR_TYPES: tuple[BSBLanSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         state_class=SensorStateClass.TOTAL_INCREASING,
+        suggested_display_precision=0,
+        entity_registry_enabled_default=False,
         value_fn=lambda data: (
             data.sensor.total_energy.value
             if data.sensor.total_energy is not None

homeassistant/components/cast/media_player.py

@@ -804,9 +804,24 @@ class CastMediaPlayerEntity(CastDevice, MediaPlayerEntity):
     @property
     def state(self) -> MediaPlayerState | None:
         """Return the state of the player."""
-        # The lovelace app loops media to prevent timing out, don't show that
+        if (chromecast := self._chromecast) is None or (
+            cast_status := self.cast_status
+        ) is None:
+            # Not connected to any chromecast, or not yet got any status
+            return None
+
+        if (
+            chromecast.cast_type == pychromecast.const.CAST_TYPE_CHROMECAST
+            and not chromecast.ignore_cec
+            and cast_status.is_active_input is False
+        ):
+            # The display interface for the device has been turned off or switched away
+            return MediaPlayerState.OFF
+
         if self.app_id == CAST_APP_ID_HOMEASSISTANT_LOVELACE:
+            # The lovelace app loops media to prevent timing out, don't show that
             return MediaPlayerState.PLAYING
+
         if (media_status := self._media_status()[0]) is not None:
             if media_status.player_state == MEDIA_PLAYER_STATE_PLAYING:
                 return MediaPlayerState.PLAYING
@@ -817,20 +832,16 @@ class CastMediaPlayerEntity(CastDevice, MediaPlayerEntity):
             if media_status.player_is_idle:
                 return MediaPlayerState.IDLE
 
-        if self._chromecast is not None and self._chromecast.is_idle:
-            # If library consider us idle, that is our off state
-            # it takes HDMI status into account for cast devices.
-            return MediaPlayerState.OFF
-
         if self.app_id in APP_IDS_UNRELIABLE_MEDIA_INFO:
             # Some apps don't report media status, show the player as playing
             return MediaPlayerState.PLAYING
 
-        if self.app_id is not None:
-            # We have an active app
-            return MediaPlayerState.IDLE
+        if self.app_id in (pychromecast.IDLE_APP_ID, None):
+            # We have no active app or the home screen app. This is
+            # same app as APP_BACKDROP.
+            return MediaPlayerState.OFF
 
-        return None
+        return MediaPlayerState.IDLE
 
     @property
     def media_content_id(self) -> str | None:

homeassistant/components/compit/strings.json

@@ -324,8 +324,8 @@
           "nano_nr_3": "Nano 3",
           "nano_nr_4": "Nano 4",
           "nano_nr_5": "Nano 5",
-          "off": "Off",
-          "on": "On",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]",
           "summer": "Summer",
           "winter": "Winter"
         }
@@ -363,8 +363,8 @@
       "pump_status": {
         "name": "Pump status",
         "state": {
-          "off": "Off",
-          "on": "On"
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
         }
       },
       "return_circuit_temperature": {

homeassistant/components/conversation/manifest.json

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

homeassistant/components/daikin/climate.py

@@ -115,7 +115,7 @@ def _zone_temperature_lists(device: Appliance) -> tuple[list[str], list[str]]:
     try:
         heating = device.represent(DAIKIN_ZONE_TEMP_HEAT)[1]
         cooling = device.represent(DAIKIN_ZONE_TEMP_COOL)[1]
-    except AttributeError:
+    except AttributeError, KeyError:
         return ([], [])
     return (list(heating or []), list(cooling or []))
 

homeassistant/components/dsmr/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["dsmr_parser"],
-  "requirements": ["dsmr-parser==1.4.3"]
+  "requirements": ["dsmr-parser==1.5.0"]
 }

homeassistant/components/dunehd/media_player.py

@@ -33,6 +33,8 @@ DUNEHD_PLAYER_SUPPORT: Final[MediaPlayerEntityFeature] = (
     | MediaPlayerEntityFeature.PLAY
     | MediaPlayerEntityFeature.PLAY_MEDIA
     | MediaPlayerEntityFeature.BROWSE_MEDIA
+    | MediaPlayerEntityFeature.VOLUME_STEP
+    | MediaPlayerEntityFeature.VOLUME_MUTE
 )
 
 

homeassistant/components/esphome/assist_satellite.py

@@ -524,14 +524,10 @@ class EsphomeAssistSatellite(
         self._active_pipeline_index = 0
 
         maybe_pipeline_index = 0
-        while True:
-            if not (ww_entity_id := self.get_wake_word_entity(maybe_pipeline_index)):
-                break
-
-            if not (ww_state := self.hass.states.get(ww_entity_id)):
-                continue
-
-            if ww_state.state == wake_word_phrase:
+        while ww_entity_id := self.get_wake_word_entity(maybe_pipeline_index):
+            if (
+                ww_state := self.hass.states.get(ww_entity_id)
+            ) and ww_state.state == wake_word_phrase:
                 # First match
                 self._active_pipeline_index = maybe_pipeline_index
                 break

homeassistant/components/fibaro/__init__.py

@@ -275,8 +275,11 @@ class FibaroController:
                 # otherwise add the first visible device in the group
                 # which is a hack, but solves a problem with FGT having
                 # hidden compatibility devices before the real device
-                if last_climate_parent != device.parent_fibaro_id or (
-                    device.has_endpoint_id and last_endpoint != device.endpoint_id
+                # Second hack is for quickapps which have parent id 0 and no children
+                if (
+                    last_climate_parent != device.parent_fibaro_id
+                    or (device.has_endpoint_id and last_endpoint != device.endpoint_id)
+                    or device.parent_fibaro_id == 0
                 ):
                     _LOGGER.debug("Handle separately")
                     self.fibaro_devices[platform].append(device)

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260225.0"]
+  "requirements": ["home-assistant-frontend==20260304.0"]
 }

homeassistant/components/github/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["aiogithubapi"],
-  "requirements": ["aiogithubapi==24.6.0"]
+  "requirements": ["aiogithubapi==26.0.0"]
 }

homeassistant/components/hive/manifest.json

@@ -10,5 +10,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["apyhiveapi"],
-  "requirements": ["pyhive-integration==1.0.7"]
+  "requirements": ["pyhive-integration==1.0.8"]
 }

homeassistant/components/homematicip_cloud/climate.py

@@ -88,6 +88,17 @@ class HomematicipHeatingGroup(HomematicipGenericEntity, ClimateEntity):
         if device.actualTemperature is None:
             self._simple_heating = self._first_radiator_thermostat
 
+    @property
+    def available(self) -> bool:
+        """Heating group available.
+
+        A heating group must be available, and should not be affected by the
+        individual availability of group members.
+        This allows controlling the temperature even when individual group
+        members are not available.
+        """
+        return True
+
     @property
     def device_info(self) -> DeviceInfo:
         """Return device specific attributes."""

homeassistant/components/homematicip_cloud/cover.py

@@ -312,6 +312,17 @@ class HomematicipCoverShutterGroup(HomematicipGenericEntity, CoverEntity):
         device.modelType = f"HmIP-{post}"
         super().__init__(hap, device, post, is_multi_channel=False)
 
+    @property
+    def available(self) -> bool:
+        """Cover shutter group available.
+
+        A cover shutter group must be available, and should not be affected by
+        the individual availability of group members.
+        This allows controlling the shutters even when individual group
+        members are not available.
+        """
+        return True
+
     @property
     def current_cover_position(self) -> int | None:
         """Return current position of cover."""

homeassistant/components/indevolt/strings.json

@@ -57,8 +57,8 @@
       "battery_charge_discharge_state": {
         "name": "Battery charge/discharge state",
         "state": {
-          "charging": "Charging",
-          "discharging": "Discharging",
+          "charging": "[%key:common::state::charging%]",
+          "discharging": "[%key:common::state::discharging%]",
           "static": "Static"
         }
       },

homeassistant/components/influxdb/__init__.py

@@ -43,6 +43,7 @@ from homeassistant.const import (
     STATE_UNKNOWN,
 )
 from homeassistant.core import Event, HomeAssistant, State, callback
+from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, state as state_helper
 from homeassistant.helpers.entity_values import EntityValues
@@ -61,6 +62,7 @@ from .const import (
     CLIENT_ERROR_V2,
     CODE_INVALID_INPUTS,
     COMPONENT_CONFIG_SCHEMA_CONNECTION,
+    COMPONENT_CONFIG_SCHEMA_CONNECTION_VALIDATORS,
     CONF_API_VERSION,
     CONF_BUCKET,
     CONF_COMPONENT_CONFIG,
@@ -79,7 +81,6 @@ from .const import (
     CONF_TAGS_ATTRIBUTES,
     CONNECTION_ERROR,
     DEFAULT_API_VERSION,
-    DEFAULT_HOST,
     DEFAULT_HOST_V2,
     DEFAULT_MEASUREMENT_ATTR,
     DEFAULT_SSL_V2,
@@ -104,6 +105,7 @@ from .const import (
     WRITE_ERROR,
     WROTE_MESSAGE,
 )
+from .issue import async_create_deprecated_yaml_issue
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -137,7 +139,7 @@ def create_influx_url(conf: dict) -> dict:
 
 def validate_version_specific_config(conf: dict) -> dict:
     """Ensure correct config fields are provided based on API version used."""
-    if conf[CONF_API_VERSION] == API_VERSION_2:
+    if conf.get(CONF_API_VERSION, DEFAULT_API_VERSION) == API_VERSION_2:
         if CONF_TOKEN not in conf:
             raise vol.Invalid(
                 f"{CONF_TOKEN} and {CONF_BUCKET} are required when"
@@ -193,32 +195,13 @@ _INFLUX_BASE_SCHEMA = INCLUDE_EXCLUDE_BASE_FILTER_SCHEMA.extend(
     }
 )
 
-INFLUX_SCHEMA = vol.All(
-    _INFLUX_BASE_SCHEMA.extend(COMPONENT_CONFIG_SCHEMA_CONNECTION),
-    validate_version_specific_config,
-    create_influx_url,
+INFLUX_SCHEMA = _INFLUX_BASE_SCHEMA.extend(
+    COMPONENT_CONFIG_SCHEMA_CONNECTION_VALIDATORS
 )
 
 
 CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.All(
-            cv.deprecated(CONF_API_VERSION),
-            cv.deprecated(CONF_HOST),
-            cv.deprecated(CONF_PATH),
-            cv.deprecated(CONF_PORT),
-            cv.deprecated(CONF_SSL),
-            cv.deprecated(CONF_VERIFY_SSL),
-            cv.deprecated(CONF_SSL_CA_CERT),
-            cv.deprecated(CONF_USERNAME),
-            cv.deprecated(CONF_PASSWORD),
-            cv.deprecated(CONF_DB_NAME),
-            cv.deprecated(CONF_TOKEN),
-            cv.deprecated(CONF_ORG),
-            cv.deprecated(CONF_BUCKET),
-            INFLUX_SCHEMA,
-        )
-    },
+    {DOMAIN: vol.All(INFLUX_SCHEMA, validate_version_specific_config)},
     extra=vol.ALLOW_EXTRA,
 )
 
@@ -499,23 +482,35 @@ def get_influx_connection(  # noqa: C901
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the InfluxDB component."""
-    conf = config.get(DOMAIN)
+    if DOMAIN not in config:
+        return True
 
-    if conf is not None:
-        if CONF_HOST not in conf and conf[CONF_API_VERSION] == DEFAULT_API_VERSION:
-            conf[CONF_HOST] = DEFAULT_HOST
-
-        hass.async_create_task(
-            hass.config_entries.flow.async_init(
-                DOMAIN,
-                context={"source": SOURCE_IMPORT},
-                data=conf,
-            )
-        )
+    hass.async_create_task(_async_setup(hass, config[DOMAIN]))
 
     return True
 
 
+async def _async_setup(hass: HomeAssistant, config: dict[str, Any]) -> None:
+    """Import YAML configuration into a config entry."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_IMPORT},
+        data=config,
+    )
+    if (
+        result.get("type") is FlowResultType.ABORT
+        and (reason := result["reason"]) != "single_instance_allowed"
+    ):
+        async_create_deprecated_yaml_issue(hass, error=reason)
+        return
+
+    # If we are here, the entry already exists (single instance allowed)
+    if config.keys() & (
+        {k.schema for k in COMPONENT_CONFIG_SCHEMA_CONNECTION} - {CONF_PRECISION}
+    ):
+        async_create_deprecated_yaml_issue(hass)
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: InfluxDBConfigEntry) -> bool:
     """Set up InfluxDB from a config entry."""
     data = entry.data

homeassistant/components/influxdb/config_flow.py

@@ -31,7 +31,7 @@ from homeassistant.helpers.selector import (
 )
 from homeassistant.helpers.storage import STORAGE_DIR
 
-from . import DOMAIN, get_influx_connection
+from . import DOMAIN, create_influx_url, get_influx_connection
 from .const import (
     API_VERSION_2,
     CONF_API_VERSION,
@@ -40,8 +40,11 @@ from .const import (
     CONF_ORG,
     CONF_SSL_CA_CERT,
     DEFAULT_API_VERSION,
+    DEFAULT_BUCKET,
+    DEFAULT_DATABASE,
     DEFAULT_HOST,
     DEFAULT_PORT,
+    DEFAULT_VERIFY_SSL,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -240,14 +243,17 @@ class InfluxDBConfigFlow(ConfigFlow, domain=DOMAIN):
 
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Handle the initial step."""
-        host = import_data.get(CONF_HOST)
-        database = import_data.get(CONF_DB_NAME)
-        bucket = import_data.get(CONF_BUCKET)
+        import_data = {**import_data}
+        import_data.setdefault(CONF_API_VERSION, DEFAULT_API_VERSION)
+        import_data.setdefault(CONF_VERIFY_SSL, DEFAULT_VERIFY_SSL)
+        import_data.setdefault(CONF_DB_NAME, DEFAULT_DATABASE)
+        import_data.setdefault(CONF_BUCKET, DEFAULT_BUCKET)
 
-        api_version = import_data.get(CONF_API_VERSION)
-        ssl = import_data.get(CONF_SSL)
+        api_version = import_data[CONF_API_VERSION]
 
         if api_version == DEFAULT_API_VERSION:
+            host = import_data.get(CONF_HOST, DEFAULT_HOST)
+            database = import_data[CONF_DB_NAME]
             title = f"{database} ({host})"
             data = {
                 CONF_API_VERSION: api_version,
@@ -256,21 +262,23 @@ class InfluxDBConfigFlow(ConfigFlow, domain=DOMAIN):
                 CONF_USERNAME: import_data.get(CONF_USERNAME),
                 CONF_PASSWORD: import_data.get(CONF_PASSWORD),
                 CONF_DB_NAME: database,
-                CONF_SSL: ssl,
+                CONF_SSL: import_data.get(CONF_SSL),
                 CONF_PATH: import_data.get(CONF_PATH),
-                CONF_VERIFY_SSL: import_data.get(CONF_VERIFY_SSL),
+                CONF_VERIFY_SSL: import_data[CONF_VERIFY_SSL],
                 CONF_SSL_CA_CERT: import_data.get(CONF_SSL_CA_CERT),
             }
         else:
+            create_influx_url(import_data)  # Only modifies dict for api_version == 2
+            bucket = import_data[CONF_BUCKET]
             url = import_data.get(CONF_URL)
             title = f"{bucket} ({url})"
             data = {
                 CONF_API_VERSION: api_version,
-                CONF_URL: import_data.get(CONF_URL),
+                CONF_URL: url,
                 CONF_TOKEN: import_data.get(CONF_TOKEN),
                 CONF_ORG: import_data.get(CONF_ORG),
                 CONF_BUCKET: bucket,
-                CONF_VERIFY_SSL: import_data.get(CONF_VERIFY_SSL),
+                CONF_VERIFY_SSL: import_data[CONF_VERIFY_SSL],
                 CONF_SSL_CA_CERT: import_data.get(CONF_SSL_CA_CERT),
             }
 

homeassistant/components/influxdb/const.py

@@ -154,3 +154,14 @@ COMPONENT_CONFIG_SCHEMA_CONNECTION = {
     vol.Inclusive(CONF_ORG, "v2_authentication"): cv.string,
     vol.Optional(CONF_BUCKET, default=DEFAULT_BUCKET): cv.string,
 }
+
+# Same keys without defaults, used in CONFIG_SCHEMA to validate
+# without injecting default values (so we can detect explicit keys).
+COMPONENT_CONFIG_SCHEMA_CONNECTION_VALIDATORS = {
+    (
+        vol.Optional(k.schema)
+        if isinstance(k, vol.Optional) and k.default is not vol.UNDEFINED
+        else k
+    ): v
+    for k, v in COMPONENT_CONFIG_SCHEMA_CONNECTION.items()
+}

homeassistant/components/influxdb/issue.py

@@ -0,0 +1,34 @@
+"""Issues for InfluxDB integration."""
+
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+
+from .const import DOMAIN
+
+
+@callback
+def async_create_deprecated_yaml_issue(
+    hass: HomeAssistant, *, error: str | None = None
+) -> None:
+    """Create a repair issue for deprecated YAML connection configuration."""
+    if error is None:
+        issue_id = "deprecated_yaml"
+        severity = IssueSeverity.WARNING
+    else:
+        issue_id = f"deprecated_yaml_import_issue_{error}"
+        severity = IssueSeverity.ERROR
+
+    async_create_issue(
+        hass,
+        DOMAIN,
+        issue_id,
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        breaks_in_ha_version="2026.9.0",
+        severity=severity,
+        translation_key=issue_id,
+        translation_placeholders={
+            "domain": DOMAIN,
+            "url": f"/config/integrations/dashboard/add?domain={DOMAIN}",
+        },
+    )

homeassistant/components/influxdb/manifest.json

@@ -7,7 +7,6 @@
   "documentation": "https://www.home-assistant.io/integrations/influxdb",
   "iot_class": "local_push",
   "loggers": ["influxdb", "influxdb_client"],
-  "quality_scale": "legacy",
   "requirements": ["influxdb==5.3.1", "influxdb-client==1.50.0"],
   "single_config_entry": true
 }

homeassistant/components/influxdb/strings.json

@@ -54,5 +54,31 @@
         "title": "Choose InfluxDB version"
       }
     }
+  },
+  "issues": {
+    "deprecated_yaml": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed. Your existing YAML connection configuration has been imported into the UI automatically.\n\nRemove the `{domain}` connection and authentication keys from your `configuration.yaml` file and restart Home Assistant to fix this issue. Other options like `include`, `exclude`, and `tags` remain in YAML for now. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "The InfluxDB YAML configuration is being removed"
+    },
+    "deprecated_yaml_import_issue_cannot_connect": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed because Home Assistant could not connect to the InfluxDB server.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "Failed to import InfluxDB YAML configuration"
+    },
+    "deprecated_yaml_import_issue_invalid_auth": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed because the provided credentials are invalid.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
+    },
+    "deprecated_yaml_import_issue_invalid_database": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed because the specified database was not found.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
+    },
+    "deprecated_yaml_import_issue_ssl_error": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed due to an SSL certificate error.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
+    },
+    "deprecated_yaml_import_issue_unknown": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed due to an unknown error.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
+    }
   }
 }

homeassistant/components/knx/manifest.json

@@ -13,7 +13,7 @@
   "requirements": [
     "xknx==3.15.0",
     "xknxproject==3.8.2",
-    "knx-frontend==2026.2.25.165736"
+    "knx-frontend==2026.3.2.183756"
   ],
   "single_config_entry": true
 }

homeassistant/components/matter/vacuum.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import IntEnum
+import logging
 from typing import TYPE_CHECKING, Any
 
 from chip.clusters import Objects as clusters
@@ -26,6 +27,8 @@ from .entity import MatterEntity, MatterEntityDescription
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class OperationalState(IntEnum):
     """Operational State of the vacuum cleaner.
@@ -168,8 +171,9 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
         segments: dict[str, Segment] = {}
         for area in supported_areas:
             area_name = None
-            if area.areaInfo and area.areaInfo.locationInfo:
-                area_name = area.areaInfo.locationInfo.locationName
+            location_info = area.areaInfo.locationInfo
+            if location_info not in (None, clusters.NullValue):
+                area_name = location_info.locationName
 
             if area_name:
                 segment_id = str(area.areaID)
@@ -206,10 +210,11 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
 
         if (
             response
-            and response.status != clusters.ServiceArea.Enums.SelectAreasStatus.kSuccess
+            and response["status"]
+            != clusters.ServiceArea.Enums.SelectAreasStatus.kSuccess
         ):
             raise HomeAssistantError(
-                f"Failed to select areas: {response.statusText or response.status.name}"
+                f"Failed to select areas: {response['statusText'] or response['status']}"
             )
 
         await self.send_device_command(
@@ -252,9 +257,18 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
             VacuumEntityFeature.CLEAN_AREA in self.supported_features
             and self.registry_entry is not None
             and (last_seen_segments := self.last_seen_segments) is not None
-            and self._current_segments != {s.id: s for s in last_seen_segments}
+            # Ignore empty segments; some devices transiently
+            # report an empty list before sending the real one.
+            and (current_segments := self._current_segments)
         ):
-            self.async_create_segments_issue()
+            last_seen_by_id = {s.id: s for s in last_seen_segments}
+            if current_segments != last_seen_by_id:
+                _LOGGER.debug(
+                    "Vacuum segments changed: last_seen=%s, current=%s",
+                    last_seen_by_id,
+                    current_segments,
+                )
+                self.async_create_segments_issue()
 
     @callback
     def _calculate_features(self) -> None:

homeassistant/components/mobile_app/notify.py

@@ -120,6 +120,7 @@ class MobileAppNotificationService(BaseNotificationService):
 
         local_push_channels = self.hass.data[DOMAIN][DATA_PUSH_CHANNEL]
 
+        failed_targets = []
         for target in targets:
             registration = self.hass.data[DOMAIN][DATA_CONFIG_ENTRIES][target].data
 
@@ -134,12 +135,16 @@ class MobileAppNotificationService(BaseNotificationService):
 
             # Test if local push only.
             if ATTR_PUSH_URL not in registration[ATTR_APP_DATA]:
-                raise HomeAssistantError(
-                    "Device not connected to local push notifications"
-                )
+                failed_targets.append(target)
+                continue
 
             await self._async_send_remote_message_target(target, registration, data)
 
+        if failed_targets:
+            raise HomeAssistantError(
+                f"Device(s) with webhook id(s) {', '.join(failed_targets)} not connected to local push notifications"
+            )
+
     async def _async_send_remote_message_target(self, target, registration, data):
         """Send a message to a target."""
         app_data = registration[ATTR_APP_DATA]

homeassistant/components/nest/__init__.py

@@ -7,7 +7,7 @@ import asyncio
 from http import HTTPStatus
 import logging
 
-from aiohttp import ClientError, ClientResponseError, web
+from aiohttp import ClientError, web
 from google_nest_sdm.camera_traits import CameraClipPreviewTrait
 from google_nest_sdm.device import Device
 from google_nest_sdm.device_manager import DeviceManager
@@ -43,6 +43,8 @@ from homeassistant.exceptions import (
     ConfigEntryAuthFailed,
     ConfigEntryNotReady,
     HomeAssistantError,
+    OAuth2TokenRequestError,
+    OAuth2TokenRequestReauthError,
     Unauthorized,
 )
 from homeassistant.helpers import (
@@ -253,11 +255,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: NestConfigEntry) -> bool
     auth = await api.new_auth(hass, entry)
     try:
         await auth.async_get_access_token()
-    except ClientResponseError as err:
-        if 400 <= err.status < 500:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN, translation_key="reauth_required"
-            ) from err
+    except OAuth2TokenRequestReauthError as err:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN, translation_key="reauth_required"
+        ) from err
+    except OAuth2TokenRequestError as err:
         raise ConfigEntryNotReady(
             translation_domain=DOMAIN, translation_key="auth_server_error"
         ) from err

homeassistant/components/openai_conversation/config_flow.py

@@ -512,6 +512,11 @@ class OpenAISubentryFlowHandler(ConfigSubentryFlow):
                     options.pop(CONF_WEB_SEARCH_REGION, None)
                     options.pop(CONF_WEB_SEARCH_COUNTRY, None)
                     options.pop(CONF_WEB_SEARCH_TIMEZONE, None)
+            if (
+                user_input.get(CONF_CODE_INTERPRETER)
+                and user_input.get(CONF_REASONING_EFFORT) == "minimal"
+            ):
+                errors[CONF_CODE_INTERPRETER] = "code_interpreter_minimal_reasoning"
 
             options.update(user_input)
             if not errors:
@@ -539,15 +544,15 @@ class OpenAISubentryFlowHandler(ConfigSubentryFlow):
         if not model.startswith(("o", "gpt-5")) or model.startswith("gpt-5-pro"):
             return []
 
-        MODELS_REASONING_MAP = {
+        models_reasoning_map: dict[str | tuple[str, ...], list[str]] = {
             "gpt-5.2-pro": ["medium", "high", "xhigh"],
-            "gpt-5.2": ["none", "low", "medium", "high", "xhigh"],
+            ("gpt-5.2", "gpt-5.3"): ["none", "low", "medium", "high", "xhigh"],
             "gpt-5.1": ["none", "low", "medium", "high"],
             "gpt-5": ["minimal", "low", "medium", "high"],
             "": ["low", "medium", "high"],  # The default case
         }
 
-        for prefix, options in MODELS_REASONING_MAP.items():
+        for prefix, options in models_reasoning_map.items():
             if model.startswith(prefix):
                 return options
         return []  # pragma: no cover

homeassistant/components/openai_conversation/strings.json

@@ -38,6 +38,7 @@
       },
       "entry_type": "AI task",
       "error": {
+        "code_interpreter_minimal_reasoning": "[%key:component::openai_conversation::config_subentries::conversation::error::code_interpreter_minimal_reasoning%]",
         "model_not_supported": "[%key:component::openai_conversation::config_subentries::conversation::error::model_not_supported%]",
         "web_search_minimal_reasoning": "[%key:component::openai_conversation::config_subentries::conversation::error::web_search_minimal_reasoning%]"
       },
@@ -93,6 +94,7 @@
       },
       "entry_type": "Conversation agent",
       "error": {
+        "code_interpreter_minimal_reasoning": "Code interpreter is not supported with minimal reasoning effort",
         "model_not_supported": "This model is not supported, please select a different model",
         "web_search_minimal_reasoning": "Web search is currently not supported with minimal reasoning effort"
       },

homeassistant/components/overseerr/config_flow.py

@@ -69,7 +69,7 @@ class OverseerrConfigFlow(ConfigFlow, domain=DOMAIN):
                 else:
                     if self.source == SOURCE_USER:
                         return self.async_create_entry(
-                            title="Overseerr",
+                            title="Seerr",
                             data={
                                 CONF_HOST: host,
                                 CONF_PORT: port,

homeassistant/components/overseerr/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "overseerr",
-  "name": "Overseerr",
+  "name": "Seerr",
   "after_dependencies": ["cloud"],
   "codeowners": ["@joostlek", "@AmGarera"],
   "config_flow": true,

homeassistant/components/overseerr/strings.json

@@ -25,8 +25,8 @@
           "url": "[%key:common::config_flow::data::url%]"
         },
         "data_description": {
-          "api_key": "The API key of the Overseerr instance.",
-          "url": "The URL of the Overseerr instance."
+          "api_key": "The API key of the Seerr instance.",
+          "url": "The URL of the Seerr instance."
         }
       }
     }
@@ -114,7 +114,7 @@
       "message": "[%key:common::config_flow::error::invalid_api_key%]"
     },
     "connection_error": {
-      "message": "Error connecting to the Overseerr instance: {error}"
+      "message": "Error connecting to the Seerr instance: {error}"
     }
   },
   "selector": {
@@ -137,11 +137,11 @@
   },
   "services": {
     "get_requests": {
-      "description": "Retrieves a list of media requests from Overseerr.",
+      "description": "Retrieves a list of media requests from Seerr.",
       "fields": {
         "config_entry_id": {
-          "description": "The Overseerr instance to get requests from.",
-          "name": "Overseerr instance"
+          "description": "The Seerr instance to get requests from.",
+          "name": "Seerr instance"
         },
         "requested_by": {
           "description": "Filter the requests by the user ID that requested them.",

homeassistant/components/philips_js/light.py

@@ -137,11 +137,10 @@ class PhilipsTVLightEntity(PhilipsJsEntity, LightEntity):
 
     _attr_effect: str
     _attr_translation_key = "ambilight"
+    _attr_supported_color_modes = {ColorMode.HS}
+    _attr_supported_features = LightEntityFeature.EFFECT
 
-    def __init__(
-        self,
-        coordinator: PhilipsTVDataUpdateCoordinator,
-    ) -> None:
+    def __init__(self, coordinator: PhilipsTVDataUpdateCoordinator) -> None:
         """Initialize light."""
         self._tv = coordinator.api
         self._hs = None
@@ -150,8 +149,6 @@ class PhilipsTVLightEntity(PhilipsJsEntity, LightEntity):
         self._last_selected_effect: AmbilightEffect | None = None
         super().__init__(coordinator)
 
-        self._attr_supported_color_modes = {ColorMode.HS, ColorMode.ONOFF}
-        self._attr_supported_features = LightEntityFeature.EFFECT
         self._attr_unique_id = coordinator.unique_id
 
         self._update_from_coordinator()

homeassistant/components/portainer/binary_sensor.py

@@ -16,7 +16,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import PortainerConfigEntry
 from .const import CONTAINER_STATE_RUNNING, STACK_STATUS_ACTIVE
-from .coordinator import PortainerContainerData, PortainerCoordinator
+from .coordinator import PortainerContainerData
 from .entity import (
     PortainerContainerEntity,
     PortainerCoordinatorData,
@@ -165,18 +165,6 @@ class PortainerEndpointSensor(PortainerEndpointEntity, BinarySensorEntity):
 
     entity_description: PortainerEndpointBinarySensorEntityDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerEndpointBinarySensorEntityDescription,
-        device_info: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize Portainer endpoint binary sensor entity."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{device_info.id}_{entity_description.key}"
-
     @property
     def is_on(self) -> bool | None:
         """Return true if the binary sensor is on."""
@@ -188,19 +176,6 @@ class PortainerContainerSensor(PortainerContainerEntity, BinarySensorEntity):
 
     entity_description: PortainerContainerBinarySensorEntityDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerContainerBinarySensorEntityDescription,
-        device_info: PortainerContainerData,
-        via_device: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer container sensor."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator, via_device)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_name}_{entity_description.key}"
-
     @property
     def is_on(self) -> bool | None:
         """Return true if the binary sensor is on."""
@@ -212,19 +187,6 @@ class PortainerStackSensor(PortainerStackEntity, BinarySensorEntity):
 
     entity_description: PortainerStackBinarySensorEntityDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerStackBinarySensorEntityDescription,
-        device_info: PortainerStackData,
-        via_device: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer stack sensor."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator, via_device)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{device_info.stack.id}_{entity_description.key}"
-
     @property
     def is_on(self) -> bool | None:
         """Return true if the binary sensor is on."""

homeassistant/components/portainer/button.py

@@ -167,18 +167,6 @@ class PortainerEndpointButton(PortainerEndpointEntity, PortainerBaseButton):
 
     entity_description: PortainerButtonDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerButtonDescription,
-        device_info: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer endpoint button entity."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{device_info.id}_{entity_description.key}"
-
     async def _async_press_call(self) -> None:
         """Call the endpoint button press action."""
         await self.entity_description.press_action(
@@ -191,19 +179,6 @@ class PortainerContainerButton(PortainerContainerEntity, PortainerBaseButton):
 
     entity_description: PortainerButtonDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerButtonDescription,
-        device_info: PortainerContainerData,
-        via_device: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer button entity."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator, via_device)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_name}_{entity_description.key}"
-
     async def _async_press_call(self) -> None:
         """Call the container button press action."""
         await self.entity_description.press_action(

homeassistant/components/portainer/entity.py

@@ -4,6 +4,7 @@ from yarl import URL
 
 from homeassistant.const import CONF_URL
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DEFAULT_NAME, DOMAIN
@@ -26,11 +27,13 @@ class PortainerEndpointEntity(PortainerCoordinatorEntity):
 
     def __init__(
         self,
-        device_info: PortainerCoordinatorData,
         coordinator: PortainerCoordinator,
+        entity_description: EntityDescription,
+        device_info: PortainerCoordinatorData,
     ) -> None:
         """Initialize a Portainer endpoint."""
         super().__init__(coordinator)
+        self.entity_description = entity_description
         self._device_info = device_info
         self.device_id = device_info.endpoint.id
         self._attr_device_info = DeviceInfo(
@@ -45,6 +48,7 @@ class PortainerEndpointEntity(PortainerCoordinatorEntity):
             name=device_info.endpoint.name,
             entry_type=DeviceEntryType.SERVICE,
         )
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{device_info.id}_{entity_description.key}"
 
     @property
     def available(self) -> bool:
@@ -57,12 +61,14 @@ class PortainerContainerEntity(PortainerCoordinatorEntity):
 
     def __init__(
         self,
-        device_info: PortainerContainerData,
         coordinator: PortainerCoordinator,
+        entity_description: EntityDescription,
+        device_info: PortainerContainerData,
         via_device: PortainerCoordinatorData,
     ) -> None:
         """Initialize a Portainer container."""
         super().__init__(coordinator)
+        self.entity_description = entity_description
         self._device_info = device_info
         self.device_id = self._device_info.container.id
         self.endpoint_id = via_device.endpoint.id
@@ -91,13 +97,14 @@ class PortainerContainerEntity(PortainerCoordinatorEntity):
             # else it's the endpoint
             via_device=(
                 DOMAIN,
-                f"{coordinator.config_entry.entry_id}_{self.endpoint_id}_{device_info.stack.name}"
+                f"{coordinator.config_entry.entry_id}_{self.endpoint_id}_stack_{device_info.stack.id}"
                 if device_info.stack
                 else f"{coordinator.config_entry.entry_id}_{self.endpoint_id}",
             ),
             translation_key=None if self.device_name else "unknown_container",
             entry_type=DeviceEntryType.SERVICE,
         )
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_name}_{entity_description.key}"
 
     @property
     def available(self) -> bool:
@@ -119,12 +126,14 @@ class PortainerStackEntity(PortainerCoordinatorEntity):
 
     def __init__(
         self,
-        device_info: PortainerStackData,
         coordinator: PortainerCoordinator,
+        entity_description: EntityDescription,
+        device_info: PortainerStackData,
         via_device: PortainerCoordinatorData,
     ) -> None:
         """Initialize a Portainer stack."""
         super().__init__(coordinator)
+        self.entity_description = entity_description
         self._device_info = device_info
         self.stack_id = device_info.stack.id
         self.device_name = device_info.stack.name
@@ -135,7 +144,7 @@ class PortainerStackEntity(PortainerCoordinatorEntity):
             identifiers={
                 (
                     DOMAIN,
-                    f"{coordinator.config_entry.entry_id}_{self.endpoint_id}_{self.device_name}",
+                    f"{coordinator.config_entry.entry_id}_{self.endpoint_id}_stack_{self.stack_id}",
                 )
             },
             manufacturer=DEFAULT_NAME,
@@ -149,6 +158,7 @@ class PortainerStackEntity(PortainerCoordinatorEntity):
                 f"{coordinator.config_entry.entry_id}_{self.endpoint_id}",
             ),
         )
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.stack_id}_{entity_description.key}"
 
     @property
     def available(self) -> bool:

homeassistant/components/portainer/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["pyportainer==1.0.28"]
+  "requirements": ["pyportainer==1.0.31"]
 }

homeassistant/components/portainer/sensor.py

@@ -21,7 +21,6 @@ from .const import STACK_TYPE_COMPOSE, STACK_TYPE_KUBERNETES, STACK_TYPE_SWARM
 from .coordinator import (
     PortainerConfigEntry,
     PortainerContainerData,
-    PortainerCoordinator,
     PortainerStackData,
 )
 from .entity import (
@@ -398,19 +397,6 @@ class PortainerContainerSensor(PortainerContainerEntity, SensorEntity):
 
     entity_description: PortainerContainerSensorEntityDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerContainerSensorEntityDescription,
-        device_info: PortainerContainerData,
-        via_device: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer container sensor."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator, via_device)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_name}_{entity_description.key}"
-
     @property
     def native_value(self) -> StateType:
         """Return the state of the sensor."""
@@ -422,18 +408,6 @@ class PortainerEndpointSensor(PortainerEndpointEntity, SensorEntity):
 
     entity_description: PortainerEndpointSensorEntityDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerEndpointSensorEntityDescription,
-        device_info: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer endpoint sensor."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{device_info.id}_{entity_description.key}"
-
     @property
     def native_value(self) -> StateType:
         """Return the state of the sensor."""
@@ -446,19 +420,6 @@ class PortainerStackSensor(PortainerStackEntity, SensorEntity):
 
     entity_description: PortainerStackSensorEntityDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerStackSensorEntityDescription,
-        device_info: PortainerStackData,
-        via_device: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer stack sensor."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator, via_device)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{device_info.stack.id}_{entity_description.key}"
-
     @property
     def native_value(self) -> StateType:
         """Return the state of the sensor."""

homeassistant/components/portainer/switch.py

@@ -167,19 +167,6 @@ class PortainerContainerSwitch(PortainerContainerEntity, SwitchEntity):
 
     entity_description: PortainerSwitchEntityDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerSwitchEntityDescription,
-        device_info: PortainerContainerData,
-        via_device: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer container switch."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator, via_device)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_name}_{entity_description.key}"
-
     @property
     def is_on(self) -> bool | None:
         """Return the state of the device."""
@@ -209,19 +196,6 @@ class PortainerStackSwitch(PortainerStackEntity, SwitchEntity):
 
     entity_description: PortainerStackSwitchEntityDescription
 
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerStackSwitchEntityDescription,
-        device_info: PortainerStackData,
-        via_device: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer stack switch."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator, via_device)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{device_info.stack.id}_{entity_description.key}"
-
     @property
     def is_on(self) -> bool | None:
         """Return the state of the device."""

homeassistant/components/powerfox_local/coordinator.py

@@ -49,12 +49,12 @@ class PowerfoxLocalDataUpdateCoordinator(DataUpdateCoordinator[LocalResponse]):
         except PowerfoxAuthenticationError as err:
             raise ConfigEntryAuthFailed(
                 translation_domain=DOMAIN,
-                translation_key="invalid_auth",
-                translation_placeholders={"error": str(err)},
+                translation_key="auth_failed",
+                translation_placeholders={"host": self.config_entry.data[CONF_HOST]},
             ) from err
         except PowerfoxConnectionError as err:
             raise UpdateFailed(
                 translation_domain=DOMAIN,
-                translation_key="update_failed",
-                translation_placeholders={"error": str(err)},
+                translation_key="connection_error",
+                translation_placeholders={"host": self.config_entry.data[CONF_HOST]},
             ) from err

homeassistant/components/powerfox_local/strings.json

@@ -56,11 +56,11 @@
     }
   },
   "exceptions": {
-    "invalid_auth": {
-      "message": "Error while authenticating with the device: {error}"
+    "auth_failed": {
+      "message": "Authentication with the Poweropti device at {host} failed. Please check your API key."
     },
-    "update_failed": {
-      "message": "Error while updating the device: {error}"
+    "connection_error": {
+      "message": "Could not connect to the Poweropti device at {host}. Please check if the device is online and reachable."
     }
   }
 }

homeassistant/components/proxmoxve/button.py

@@ -19,12 +19,13 @@ from homeassistant.components.button import (
 )
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import DOMAIN
 from .coordinator import ProxmoxConfigEntry, ProxmoxCoordinator, ProxmoxNodeData
 from .entity import ProxmoxContainerEntity, ProxmoxNodeEntity, ProxmoxVMEntity
+from .helpers import is_granted
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -276,6 +277,11 @@ class ProxmoxNodeButtonEntity(ProxmoxNodeEntity, ProxmoxBaseButton):
 
     async def _async_press_call(self) -> None:
         """Execute the node button action via executor."""
+        if not is_granted(self.coordinator.permissions, p_type="nodes"):
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="no_permission_node_power",
+            )
         await self.hass.async_add_executor_job(
             self.entity_description.press_action,
             self.coordinator,
@@ -303,6 +309,11 @@ class ProxmoxVMButtonEntity(ProxmoxVMEntity, ProxmoxBaseButton):
 
     async def _async_press_call(self) -> None:
         """Execute the VM button action via executor."""
+        if not is_granted(self.coordinator.permissions, p_type="vms"):
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="no_permission_vm_lxc_power",
+            )
         await self.hass.async_add_executor_job(
             self.entity_description.press_action,
             self.coordinator,
@@ -331,6 +342,12 @@ class ProxmoxContainerButtonEntity(ProxmoxContainerEntity, ProxmoxBaseButton):
 
     async def _async_press_call(self) -> None:
         """Execute the container button action via executor."""
+        # Container power actions fall under vms
+        if not is_granted(self.coordinator.permissions, p_type="vms"):
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="no_permission_vm_lxc_power",
+            )
         await self.hass.async_add_executor_job(
             self.entity_description.press_action,
             self.coordinator,

homeassistant/components/proxmoxve/const.py

@@ -17,3 +17,5 @@ DEFAULT_VERIFY_SSL = True
 TYPE_VM = 0
 TYPE_CONTAINER = 1
 UPDATE_INTERVAL = 60
+
+PERM_POWER = "VM.PowerMgmt"

homeassistant/components/proxmoxve/coordinator.py

@@ -70,6 +70,7 @@ class ProxmoxCoordinator(DataUpdateCoordinator[dict[str, ProxmoxNodeData]]):
         self.known_nodes: set[str] = set()
         self.known_vms: set[tuple[str, int]] = set()
         self.known_containers: set[tuple[str, int]] = set()
+        self.permissions: dict[str, dict[str, int]] = {}
 
         self.new_nodes_callbacks: list[Callable[[list[ProxmoxNodeData]], None]] = []
         self.new_vms_callbacks: list[
@@ -101,11 +102,21 @@ class ProxmoxCoordinator(DataUpdateCoordinator[dict[str, ProxmoxNodeData]]):
                 translation_key="timeout_connect",
                 translation_placeholders={"error": repr(err)},
             ) from err
-        except ResourceException as err:
+        except ProxmoxServerError as err:
+            raise ConfigEntryNotReady(
+                translation_domain=DOMAIN,
+                translation_key="api_error_details",
+                translation_placeholders={"error": repr(err)},
+            ) from err
+        except ProxmoxPermissionsError as err:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="permissions_error",
+            ) from err
+        except ProxmoxNodesNotFoundError as err:
             raise ConfigEntryError(
                 translation_domain=DOMAIN,
                 translation_key="no_nodes_found",
-                translation_placeholders={"error": repr(err)},
             ) from err
         except requests.exceptions.ConnectionError as err:
             raise ConfigEntryError(
@@ -143,7 +154,6 @@ class ProxmoxCoordinator(DataUpdateCoordinator[dict[str, ProxmoxNodeData]]):
             raise UpdateFailed(
                 translation_domain=DOMAIN,
                 translation_key="no_nodes_found",
-                translation_placeholders={"error": repr(err)},
             ) from err
         except requests.exceptions.ConnectionError as err:
             raise UpdateFailed(
@@ -180,7 +190,19 @@ class ProxmoxCoordinator(DataUpdateCoordinator[dict[str, ProxmoxNodeData]]):
             password=self.config_entry.data[CONF_PASSWORD],
             verify_ssl=self.config_entry.data.get(CONF_VERIFY_SSL, DEFAULT_VERIFY_SSL),
         )
-        self.proxmox.nodes.get()
+        try:
+            self.permissions = self.proxmox.access.permissions.get()
+        except ResourceException as err:
+            if 400 <= err.status_code < 500:
+                raise ProxmoxPermissionsError from err
+            raise ProxmoxServerError from err
+
+        try:
+            self.proxmox.nodes.get()
+        except ResourceException as err:
+            if 400 <= err.status_code < 500:
+                raise ProxmoxNodesNotFoundError from err
+            raise ProxmoxServerError from err
 
     def _fetch_all_nodes(
         self,
@@ -230,3 +252,19 @@ class ProxmoxCoordinator(DataUpdateCoordinator[dict[str, ProxmoxNodeData]]):
         if new_containers:
             _LOGGER.debug("New containers found: %s", new_containers)
             self.known_containers.update(new_containers)
+
+
+class ProxmoxSetupError(Exception):
+    """Base exception for Proxmox setup issues."""
+
+
+class ProxmoxNodesNotFoundError(ProxmoxSetupError):
+    """Raised when the API works but no nodes are visible."""
+
+
+class ProxmoxPermissionsError(ProxmoxSetupError):
+    """Raised when failing to retrieve permissions."""
+
+
+class ProxmoxServerError(ProxmoxSetupError):
+    """Raised when the Proxmox server returns an error."""

homeassistant/components/proxmoxve/helpers.py

@@ -0,0 +1,13 @@
+"""Helpers for Proxmox VE."""
+
+from .const import PERM_POWER
+
+
+def is_granted(
+    permissions: dict[str, dict[str, int]],
+    p_type: str = "vms",
+    permission: str = PERM_POWER,
+) -> bool:
+    """Validate user permissions for the given type and permission."""
+    path = f"/{p_type}"
+    return permissions.get(path, {}).get(permission) == 1

homeassistant/components/proxmoxve/strings.json

@@ -32,6 +32,14 @@
           "username": "[%key:common::config_flow::data::username%]",
           "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
         },
+        "data_description": {
+          "host": "[%key:component::proxmoxve::config::step::user::data_description::host%]",
+          "password": "[%key:component::proxmoxve::config::step::user::data_description::password%]",
+          "port": "[%key:component::proxmoxve::config::step::user::data_description::port%]",
+          "realm": "[%key:component::proxmoxve::config::step::user::data_description::realm%]",
+          "username": "[%key:component::proxmoxve::config::step::user::data_description::username%]",
+          "verify_ssl": "[%key:component::proxmoxve::config::step::user::data_description::verify_ssl%]"
+        },
         "description": "Use the following form to reconfigure your Proxmox VE server connection.",
         "title": "Reconfigure Proxmox VE integration"
       },
@@ -44,6 +52,14 @@
           "username": "[%key:common::config_flow::data::username%]",
           "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
         },
+        "data_description": {
+          "host": "The hostname or IP address of your Proxmox VE server",
+          "password": "The password for the Proxmox VE server",
+          "port": "The port of your Proxmox VE server (default: 8006)",
+          "realm": "The authentication realm for the Proxmox VE server (default: 'pam')",
+          "username": "The username for the Proxmox VE server",
+          "verify_ssl": "Whether to verify SSL certificates. Disable only if you have a self-signed certificate"
+        },
         "description": "Enter your Proxmox VE server details to set up the integration.",
         "title": "Connect to Proxmox VE"
       }
@@ -159,6 +175,9 @@
     }
   },
   "exceptions": {
+    "api_error_details": {
+      "message": "An error occurred while communicating with the Proxmox VE instance: {error}"
+    },
     "api_error_no_details": {
       "message": "An error occurred while communicating with the Proxmox VE instance."
     },
@@ -177,6 +196,15 @@
     "no_nodes_found": {
       "message": "No active nodes were found on the Proxmox VE server."
     },
+    "no_permission_node_power": {
+      "message": "The configured Proxmox VE user does not have permission to manage the power state of nodes. Please grant the user the 'VM.PowerMgmt' permission and try again."
+    },
+    "no_permission_vm_lxc_power": {
+      "message": "The configured Proxmox VE user does not have permission to manage the power state of VMs and containers. Please grant the user the 'VM.PowerMgmt' permission and try again."
+    },
+    "permissions_error": {
+      "message": "Failed to retrieve Proxmox VE permissions. Please check your credentials and try again."
+    },
     "ssl_error": {
       "message": "An SSL error occurred: {error}"
     },

homeassistant/components/recovery_mode/manifest.json

@@ -3,7 +3,7 @@
   "name": "Recovery Mode",
   "codeowners": ["@home-assistant/core"],
   "config_flow": false,
-  "dependencies": ["frontend", "persistent_notification", "cloud"],
+  "dependencies": ["persistent_notification"],
   "documentation": "https://www.home-assistant.io/integrations/recovery_mode",
   "integration_type": "system",
   "quality_scale": "internal"

homeassistant/components/reolink/__init__.py

@@ -543,7 +543,20 @@ def migrate_entity_ids(
                 entity.unique_id,
                 new_id,
             )
-            entity_reg.async_update_entity(entity.entity_id, new_unique_id=new_id)
+            existing_entity = entity_reg.async_get_entity_id(
+                entity.domain, entity.platform, new_id
+            )
+            if existing_entity is None:
+                entity_reg.async_update_entity(entity.entity_id, new_unique_id=new_id)
+            else:
+                _LOGGER.warning(
+                    "Reolink entity with unique_id %s already exists, "
+                    "removing entity with unique_id %s",
+                    new_id,
+                    entity.unique_id,
+                )
+                entity_reg.async_remove(entity.entity_id)
+                continue
 
         if entity.device_id in ch_device_ids:
             ch = ch_device_ids[entity.device_id]
@@ -573,7 +586,7 @@ def migrate_entity_ids(
                 else:
                     _LOGGER.warning(
                         "Reolink entity with unique_id %s already exists, "
-                        "removing device with unique_id %s",
+                        "removing entity with unique_id %s",
                         new_id,
                         entity.unique_id,
                     )

homeassistant/components/reolink/config_flow.py

@@ -159,6 +159,15 @@ class ReolinkFlowHandler(ConfigFlow, domain=DOMAIN):
         """Handle discovery via dhcp."""
         mac_address = format_mac(discovery_info.macaddress)
         existing_entry = await self.async_set_unique_id(mac_address)
+        if existing_entry and CONF_HOST not in existing_entry.data:
+            _LOGGER.debug(
+                "Reolink DHCP discovered device with MAC '%s' and IP '%s', "
+                "but existing config entry does not have host, ignoring",
+                mac_address,
+                discovery_info.ip,
+            )
+            raise AbortFlow("already_configured")
+
         if (
             existing_entry
             and CONF_PASSWORD in existing_entry.data

homeassistant/components/reolink/manifest.json

@@ -20,5 +20,5 @@
   "iot_class": "local_push",
   "loggers": ["reolink_aio"],
   "quality_scale": "platinum",
-  "requirements": ["reolink-aio==0.19.0"]
+  "requirements": ["reolink-aio==0.19.1"]
 }

homeassistant/components/ring/manifest.json

@@ -31,5 +31,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["ring_doorbell"],
   "quality_scale": "bronze",
-  "requirements": ["ring-doorbell==0.9.13"]
+  "requirements": ["ring-doorbell==0.9.14"]
 }

homeassistant/components/satel_integra/strings.json

@@ -162,6 +162,11 @@
       }
     }
   },
+  "exceptions": {
+    "missing_output_access_code": {
+      "message": "Cannot control switchable outputs because no user code is configured for this Satel Integra entry. Configure a code in the integration options to enable output control."
+    }
+  },
   "issues": {
     "deprecated_yaml_import_issue_cannot_connect": {
       "description": "Configuring {integration_title} using YAML is being removed but there was an connection error importing your existing configuration.\n\nEnsure connection to {integration_title} works and restart Home Assistant to try again or remove the `{domain}` YAML configuration from your configuration.yaml file and add the {integration_title} integration manually.",

homeassistant/components/satel_integra/switch.py

@@ -8,9 +8,14 @@ from homeassistant.components.switch import SwitchEntity
 from homeassistant.config_entries import ConfigSubentry
 from homeassistant.const import CONF_CODE
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import CONF_SWITCHABLE_OUTPUT_NUMBER, SUBENTRY_TYPE_SWITCHABLE_OUTPUT
+from .const import (
+    CONF_SWITCHABLE_OUTPUT_NUMBER,
+    DOMAIN,
+    SUBENTRY_TYPE_SWITCHABLE_OUTPUT,
+)
 from .coordinator import SatelConfigEntry, SatelIntegraOutputsCoordinator
 from .entity import SatelIntegraEntity
 
@@ -83,12 +88,24 @@ class SatelIntegraSwitch(
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the device on."""
+        if self._code is None:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="missing_output_access_code",
+            )
+
         await self._controller.set_output(self._code, self._device_number, True)
         self._attr_is_on = True
         self.async_write_ha_state()
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the device off."""
+        if self._code is None:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="missing_output_access_code",
+            )
+
         await self._controller.set_output(self._code, self._device_number, False)
         self._attr_is_on = False
         self.async_write_ha_state()

homeassistant/components/saunum/climate.py

@@ -269,7 +269,6 @@ class LeilSaunaClimate(LeilSaunaEntity, ClimateEntity):
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="start_session_failed",
-                translation_placeholders={"error": str(err)},
             ) from err
 
         await self.coordinator.async_request_refresh()

homeassistant/components/saunum/coordinator.py

@@ -47,5 +47,4 @@ class LeilSaunaCoordinator(DataUpdateCoordinator[SaunumData]):
             raise UpdateFailed(
                 translation_domain=DOMAIN,
                 translation_key="communication_error",
-                translation_placeholders={"error": str(err)},
             ) from err

homeassistant/components/saunum/strings.json

@@ -88,7 +88,7 @@
   },
   "exceptions": {
     "communication_error": {
-      "message": "Communication error: {error}"
+      "message": "Communication error with sauna control unit"
     },
     "door_open": {
       "message": "Cannot start sauna session when sauna door is open"
@@ -130,7 +130,7 @@
       "message": "Failed to set temperature to {temperature}"
     },
     "start_session_failed": {
-      "message": "Failed to start sauna session: {error}"
+      "message": "Failed to start sauna session"
     }
   },
   "options": {

homeassistant/components/sftp_storage/config_flow.py

@@ -124,6 +124,17 @@ class SFTPFlowHandler(ConfigFlow, domain=DOMAIN):
                 }
             )
 
+            if not user_input[CONF_BACKUP_LOCATION].startswith("/"):
+                errors[CONF_BACKUP_LOCATION] = "backup_location_relative"
+                return self.async_show_form(
+                    step_id=step_id,
+                    data_schema=self.add_suggested_values_to_schema(
+                        DATA_SCHEMA, user_input
+                    ),
+                    description_placeholders=placeholders,
+                    errors=errors,
+                )
+
             try:
                 # Validate auth input and save uploaded key file if provided
                 user_input = await self._validate_auth_and_save_keyfile(user_input)

homeassistant/components/sftp_storage/strings.json

@@ -4,6 +4,7 @@
       "already_configured": "Integration already configured. Host with same address, port and backup location already exists."
     },
     "error": {
+      "backup_location_relative": "The remote path must be an absolute path (starting with `/`).",
       "invalid_key": "Invalid key uploaded. Please make sure key corresponds to valid SSH key algorithm.",
       "key_or_password_needed": "Please configure password or private key file location for SFTP Storage.",
       "os_error": "{error_message}. Please check if host and/or port are correct.",

homeassistant/components/shelly/__init__.py

@@ -66,6 +66,7 @@ from .repairs import (
 from .services import async_setup_services
 from .utils import (
     async_create_issue_unsupported_firmware,
+    async_migrate_rpc_sensor_description_unique_ids,
     async_migrate_rpc_virtual_components_unique_ids,
     get_coap_context,
     get_device_entry_gen,
@@ -296,6 +297,12 @@ async def _async_setup_rpc_entry(hass: HomeAssistant, entry: ShellyConfigEntry)
     runtime_data = entry.runtime_data
     runtime_data.platforms = RPC_SLEEPING_PLATFORMS
 
+    await er.async_migrate_entries(
+        hass,
+        entry.entry_id,
+        async_migrate_rpc_sensor_description_unique_ids,
+    )
+
     if sleep_period == 0:
         # Not a sleeping device, finish setup
         LOGGER.debug("Setting up online RPC device %s", entry.title)

homeassistant/components/shelly/sensor.py

@@ -1220,7 +1220,7 @@ RPC_SENSORS: Final = {
         entity_category=EntityCategory.DIAGNOSTIC,
         use_polling_coordinator=True,
     ),
-    "temperature_0": RpcSensorDescription(
+    "temperature_tc": RpcSensorDescription(
         key="temperature",
         sub_key="tC",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
@@ -1249,7 +1249,7 @@ RPC_SENSORS: Final = {
         entity_category=EntityCategory.DIAGNOSTIC,
         use_polling_coordinator=True,
     ),
-    "humidity_0": RpcSensorDescription(
+    "humidity_rh": RpcSensorDescription(
         key="humidity",
         sub_key="rh",
         native_unit_of_measurement=PERCENTAGE,

homeassistant/components/shelly/utils.py

@@ -969,6 +969,30 @@ def format_ble_addr(ble_addr: str) -> str:
     return ble_addr.replace(":", "").upper()
 
 
+@callback
+def async_migrate_rpc_sensor_description_unique_ids(
+    entity_entry: er.RegistryEntry,
+) -> dict[str, Any] | None:
+    """Migrate RPC sensor unique_ids after sensor description key rename."""
+    unique_id_map = {
+        "-temperature_0": "-temperature_tc",
+        "-humidity_0": "-humidity_rh",
+    }
+
+    for old_suffix, new_suffix in unique_id_map.items():
+        if entity_entry.unique_id.endswith(old_suffix):
+            new_unique_id = entity_entry.unique_id.removesuffix(old_suffix) + new_suffix
+            LOGGER.debug(
+                "Migrating unique_id for %s entity from [%s] to [%s]",
+                entity_entry.entity_id,
+                entity_entry.unique_id,
+                new_unique_id,
+            )
+            return {"new_unique_id": new_unique_id}
+
+    return None
+
+
 @callback
 def async_migrate_rpc_virtual_components_unique_ids(
     config: dict[str, Any], entity_entry: er.RegistryEntry

homeassistant/components/smartthings/manifest.json

@@ -34,5 +34,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pysmartthings"],
   "quality_scale": "bronze",
-  "requirements": ["pysmartthings==3.5.3"]
+  "requirements": ["pysmartthings==3.6.0"]
 }

homeassistant/components/smartthings/sensor.py

@@ -95,6 +95,7 @@ ROBOT_CLEANER_TURBO_MODE_STATE_MAP = {
 
 ROBOT_CLEANER_MOVEMENT_MAP = {
     "powerOff": "off",
+    "washingMop": "washing_mop",
 }
 
 OVEN_MODE = {
@@ -161,6 +162,13 @@ class SmartThingsSensorEntityDescription(SensorEntityDescription):
     use_temperature_unit: bool = False
     deprecated: Callable[[ComponentStatus], tuple[str, str] | None] | None = None
     component_translation_key: dict[str, str] | None = None
+    presentation_fn: (
+        Callable[
+            [str | None, str | float | int | datetime | None],
+            str | float | int | datetime | None,
+        ]
+        | None
+    ) = None
 
 
 CAPABILITY_TO_SENSORS: dict[
@@ -762,6 +770,13 @@ CAPABILITY_TO_SENSORS: dict[
                     (value := cast(dict | None, status.value)) is not None
                     and "power" in value
                 ),
+                presentation_fn=lambda presentation_id, value: (
+                    value * 1000
+                    if presentation_id is not None
+                    and "EHS" in presentation_id
+                    and isinstance(value, (int, float))
+                    else value
+                ),
             ),
             SmartThingsSensorEntityDescription(
                 key="deltaEnergy_meter",
@@ -880,6 +895,7 @@ CAPABILITY_TO_SENSORS: dict[
                     "after",
                     "cleaning",
                     "pause",
+                    "washing_mop",
                 ],
                 device_class=SensorDeviceClass.ENUM,
                 value_fn=lambda value: ROBOT_CLEANER_MOVEMENT_MAP.get(value, value),
@@ -1345,7 +1361,12 @@ class SmartThingsSensor(SmartThingsEntity, SensorEntity):
         res = self.get_attribute_value(self.capability, self._attribute)
         if options_map := self.entity_description.options_map:
             return options_map.get(res)
-        return self.entity_description.value_fn(res)
+        value = self.entity_description.value_fn(res)
+        if self.entity_description.presentation_fn:
+            value = self.entity_description.presentation_fn(
+                self.device.device.presentation_id, value
+            )
+        return value
 
     @property
     def native_unit_of_measurement(self) -> str | None:

homeassistant/components/smartthings/strings.json

@@ -718,7 +718,8 @@
           "off": "[%key:common::state::off%]",
           "pause": "[%key:common::state::paused%]",
           "point": "Point",
-          "reserve": "Reserve"
+          "reserve": "Reserve",
+          "washing_mop": "Washing mop"
         }
       },
       "robot_cleaner_turbo_mode": {

homeassistant/components/smlight/manifest.json

@@ -12,7 +12,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "quality_scale": "silver",
-  "requirements": ["pysmlight==0.2.14"],
+  "requirements": ["pysmlight==0.2.16"],
   "zeroconf": [
     {
       "type": "_slzb-06._tcp.local."

homeassistant/components/sonarr/__init__.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from dataclasses import fields
+
 from aiopyarr.models.host_configuration import PyArrHostConfiguration
 from aiopyarr.sonarr_client import SonarrClient
 
@@ -37,7 +39,6 @@ from .coordinator import (
     SeriesDataUpdateCoordinator,
     SonarrConfigEntry,
     SonarrData,
-    SonarrDataUpdateCoordinator,
     StatusDataUpdateCoordinator,
     WantedDataUpdateCoordinator,
 )
@@ -89,16 +90,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: SonarrConfigEntry) -> bo
     )
     # Temporary, until we add diagnostic entities
     _version = None
-    coordinators: list[SonarrDataUpdateCoordinator] = [
-        data.upcoming,
-        data.commands,
-        data.diskspace,
-        data.queue,
-        data.series,
-        data.status,
-        data.wanted,
-    ]
-    for coordinator in coordinators:
+    for field in fields(data):
+        coordinator = getattr(data, field.name)
         await coordinator.async_config_entry_first_refresh()
         if isinstance(coordinator, StatusDataUpdateCoordinator):
             _version = coordinator.data.version

homeassistant/components/sonarr/helpers.py

@@ -128,35 +128,6 @@ def format_queue(
     return shows
 
 
-def format_episode_item(
-    series: SonarrSeries, episode_data: dict[str, Any], base_url: str | None = None
-) -> dict[str, Any]:
-    """Format a single episode item."""
-    result: dict[str, Any] = {
-        "id": episode_data.get("id"),
-        "episode_number": episode_data.get("episodeNumber"),
-        "season_number": episode_data.get("seasonNumber"),
-        "title": episode_data.get("title"),
-        "air_date": str(episode_data.get("airDate", "")),
-        "overview": episode_data.get("overview"),
-        "has_file": episode_data.get("hasFile", False),
-        "monitored": episode_data.get("monitored", False),
-    }
-
-    # Add episode images if available
-    if images := episode_data.get("images"):
-        result["images"] = {}
-        for image in images:
-            cover_type = image.coverType
-            # Prefer remoteUrl (public TVDB URL) over local path
-            if remote_url := getattr(image, "remoteUrl", None):
-                result["images"][cover_type] = remote_url
-            elif base_url and (url := getattr(image, "url", None)):
-                result["images"][cover_type] = f"{base_url.rstrip('/')}{url}"
-
-    return result
-
-
 def format_series(
     series_list: list[SonarrSeries], base_url: str | None = None
 ) -> dict[str, dict[str, Any]]:

homeassistant/components/sonarr/services.py

@@ -46,7 +46,7 @@ CONF_SEASON_NUMBER = "season_number"
 CONF_SPACE_UNIT = "space_unit"
 
 # Valid space units
-SPACE_UNITS = ["bytes", "kb", "kib", "mb", "mib", "gb", "gib", "tb", "tib", "pb", "pib"]
+SPACE_UNITS = ["bytes", "KB", "KiB", "MB", "MiB", "GB", "GiB", "TB", "TiB", "PB", "PiB"]
 DEFAULT_SPACE_UNIT = "bytes"
 
 # Default values - 0 means no limit

homeassistant/components/sonarr/strings.json

@@ -78,7 +78,7 @@
           "name": "Sonarr entry"
         },
         "space_unit": {
-          "description": "Unit for space values. Use binary units (kib, mib, gib, tib, pib) for 1024-based values or decimal units (kb, mb, gb, tb, pb) for 1000-based values.",
+          "description": "Unit for space values. Use binary units (KiB, MiB, GiB, TiB, PiB) for 1024-based values or decimal units (KB, MB, GB, TB, PB) for 1000-based values. The default is bytes.",
           "name": "Space unit"
         }
       },

homeassistant/components/tankerkoenig/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aiotankerkoenig"],
   "quality_scale": "platinum",
-  "requirements": ["aiotankerkoenig==0.4.2"]
+  "requirements": ["aiotankerkoenig==0.5.1"]
 }

homeassistant/components/telegram_bot/config_flow.py

@@ -62,8 +62,8 @@ _LOGGER = logging.getLogger(__name__)
 DESCRIPTION_PLACEHOLDERS: dict[str, str] = {
     "botfather_username": "@BotFather",
     "botfather_url": "https://t.me/botfather",
-    "getidsbot_username": "@GetIDs Bot",
-    "getidsbot_url": "https://t.me/getidsbot",
+    "id_bot_username": "@id_bot",
+    "id_bot_url": "https://t.me/id_bot",
     "socks_url": "socks5://username:password@proxy_ip:proxy_port",
     # used in advanced settings section
     "default_api_endpoint": DEFAULT_API_ENDPOINT,
@@ -611,10 +611,15 @@ class AllowedChatIdsSubEntryFlowHandler(ConfigSubentryFlow):
 
             errors["base"] = "chat_not_found"
 
+        service: TelegramNotificationService = self._get_entry().runtime_data
+        description_placeholders = DESCRIPTION_PLACEHOLDERS.copy()
+        description_placeholders["bot_username"] = f"@{service.bot.username}"
+        description_placeholders["bot_url"] = f"https://t.me/{service.bot.username}"
+
         return self.async_show_form(
             step_id="user",
             data_schema=vol.Schema({vol.Required(CONF_CHAT_ID): vol.Coerce(int)}),
-            description_placeholders=DESCRIPTION_PLACEHOLDERS,
+            description_placeholders=description_placeholders,
             errors=errors,
         )
 

homeassistant/components/telegram_bot/strings.json

@@ -105,7 +105,7 @@
           "data_description": {
             "chat_id": "ID representing the user or group chat to which messages can be sent."
           },
-          "description": "To get your chat ID, follow these steps:\n\n1. Open Telegram and start a chat with [{getidsbot_username}]({getidsbot_url}).\n1. Send any message to the bot.\n1. Your chat ID is in the `id` field of the bot's response.",
+          "description": "Before you proceed, send any message to your bot: [{bot_username}]({bot_url}). This is required because Telegram prevents bots from initiating chats with users.\n\nThen follow these steps to get your chat ID:\n\n1. Open Telegram and start a chat with [{id_bot_username}]({id_bot_url}).\n1. Send any message to the bot.\n1. Your chat ID is in the `ID` field of the bot's response.",
           "title": "Add chat"
         }
       }

homeassistant/components/template/sensor.py

@@ -257,6 +257,9 @@ class AbstractTemplateSensor(AbstractTemplateEntity, RestoreSensor):
     ) -> StateType | date | datetime | Decimal | None:
         """Validate the state."""
         if self._numeric_state_expected:
+            if not isinstance(result, bool) and isinstance(result, (int, float)):
+                return result
+
             return template_validators.number(self, CONF_STATE)(result)
 
         if result is None or self.device_class not in (

homeassistant/components/template/template_entity.py

@@ -29,7 +29,7 @@ from homeassistant.core import (
 )
 from homeassistant.exceptions import TemplateError
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.entity import Entity, async_generate_entity_id
 from homeassistant.helpers.event import (
     TrackTemplate,
     TrackTemplateResult,
@@ -264,16 +264,23 @@ class TemplateEntity(AbstractTemplateEntity):
             return None
         return cast(str, self._blueprint_inputs[CONF_USE_BLUEPRINT][CONF_PATH])
 
+    def _get_this_variable(self) -> TemplateStateFromEntityId:
+        """Create a this variable for the entity."""
+        if self._preview_callback:
+            preview_entity_id = async_generate_entity_id(
+                self._entity_id_format, self._attr_name or "preview", hass=self.hass
+            )
+            return TemplateStateFromEntityId(self.hass, preview_entity_id)
+
+        return TemplateStateFromEntityId(self.hass, self.entity_id)
+
     def _render_script_variables(self) -> dict[str, Any]:
         """Render configured variables."""
         if isinstance(self._run_variables, dict):
             return self._run_variables
 
         return self._run_variables.async_render(
-            self.hass,
-            {
-                "this": TemplateStateFromEntityId(self.hass, self.entity_id),
-            },
+            self.hass, {"this": self._get_this_variable()}
         )
 
     def setup_state_template(
@@ -451,7 +458,7 @@ class TemplateEntity(AbstractTemplateEntity):
         has_availability_template = False
 
         variables = {
-            "this": TemplateStateFromEntityId(self.hass, self.entity_id),
+            "this": self._get_this_variable(),
             **self._render_script_variables(),
         }
 

homeassistant/components/unifiprotect/manifest.json

@@ -41,7 +41,7 @@
   "iot_class": "local_push",
   "loggers": ["uiprotect", "unifi_discovery"],
   "quality_scale": "platinum",
-  "requirements": ["uiprotect==10.2.1", "unifi-discovery==1.2.0"],
+  "requirements": ["uiprotect==10.2.2", "unifi-discovery==1.2.0"],
   "ssdp": [
     {
       "manufacturer": "Ubiquiti Networks",

homeassistant/components/vacuum/__init__.py

@@ -23,6 +23,7 @@ from homeassistant.const import (  # noqa: F401 # STATE_PAUSED/IDLE are API
     STATE_ON,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv, issue_registry as ir
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
@@ -63,7 +64,6 @@ SERVICE_STOP = "stop"
 DEFAULT_NAME = "Vacuum cleaner robot"
 
 ISSUE_SEGMENTS_CHANGED = "segments_changed"
-ISSUE_SEGMENTS_MAPPING_NOT_CONFIGURED = "segments_mapping_not_configured"
 
 _BATTERY_DEPRECATION_IGNORED_PLATFORMS = ("template",)
 
@@ -236,12 +236,6 @@ class StateVacuumEntity(
         if self.__vacuum_legacy_battery_icon:
             self._report_deprecated_battery_properties("battery_icon")
 
-    @callback
-    def async_write_ha_state(self) -> None:
-        """Write the state to the state machine."""
-        super().async_write_ha_state()
-        self._async_check_segments_issues()
-
     @callback
     def async_registry_entry_updated(self) -> None:
         """Run when the entity registry entry has been updated."""
@@ -444,7 +438,14 @@ class StateVacuumEntity(
             )
 
         options: Mapping[str, Any] = self.registry_entry.options.get(DOMAIN, {})
-        area_mapping: dict[str, list[str]] = options.get("area_mapping", {})
+        area_mapping: dict[str, list[str]] | None = options.get("area_mapping")
+
+        if area_mapping is None:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="area_mapping_not_configured",
+                translation_placeholders={"entity_id": self.entity_id},
+            )
 
         # We use a dict to preserve the order of segments.
         segment_ids: dict[str, None] = {}
@@ -514,43 +515,6 @@ class StateVacuumEntity(
             return
 
         options: Mapping[str, Any] = self.registry_entry.options.get(DOMAIN, {})
-        should_have_not_configured_issue = (
-            VacuumEntityFeature.CLEAN_AREA in self.supported_features
-            and options.get("area_mapping") is None
-        )
-
-        if (
-            should_have_not_configured_issue
-            and not self._segments_not_configured_issue_created
-        ):
-            issue_id = (
-                f"{ISSUE_SEGMENTS_MAPPING_NOT_CONFIGURED}_{self.registry_entry.id}"
-            )
-            ir.async_create_issue(
-                self.hass,
-                DOMAIN,
-                issue_id,
-                data={
-                    "entry_id": self.registry_entry.id,
-                    "entity_id": self.entity_id,
-                },
-                is_fixable=False,
-                severity=ir.IssueSeverity.WARNING,
-                translation_key=ISSUE_SEGMENTS_MAPPING_NOT_CONFIGURED,
-                translation_placeholders={
-                    "entity_id": self.entity_id,
-                },
-            )
-            self._segments_not_configured_issue_created = True
-        elif (
-            not should_have_not_configured_issue
-            and self._segments_not_configured_issue_created
-        ):
-            issue_id = (
-                f"{ISSUE_SEGMENTS_MAPPING_NOT_CONFIGURED}_{self.registry_entry.id}"
-            )
-            ir.async_delete_issue(self.hass, DOMAIN, issue_id)
-            self._segments_not_configured_issue_created = False
 
         if self._segments_changed_last_seen is not None and (
             VacuumEntityFeature.CLEAN_AREA not in self.supported_features

homeassistant/components/vacuum/strings.json

@@ -89,14 +89,15 @@
       }
     }
   },
+  "exceptions": {
+    "area_mapping_not_configured": {
+      "message": "Area mapping is not configured for `{entity_id}`. Configure the segment-to-area mapping before using this action."
+    }
+  },
   "issues": {
     "segments_changed": {
       "description": "",
       "title": "Vacuum segments have changed for {entity_id}"
-    },
-    "segments_mapping_not_configured": {
-      "description": "",
-      "title": "Vacuum segment mapping not configured for {entity_id}"
     }
   },
   "selector": {

homeassistant/components/webdav/backup.py

@@ -222,8 +222,10 @@ class WebDavBackupAgent(BackupAgent):
         async def _download_metadata(path: str) -> AgentBackup:
             """Download metadata file."""
             iterator = await self._client.download_iter(path)
-            metadata = await anext(iterator)
-            return AgentBackup.from_dict(json_loads_object(metadata))
+            metadata_bytes = bytearray()
+            async for chunk in iterator:
+                metadata_bytes.extend(chunk)
+            return AgentBackup.from_dict(json_loads_object(metadata_bytes))
 
         async def _list_metadata_files() -> dict[str, AgentBackup]:
             """List metadata files."""

homeassistant/components/webdav/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aiowebdav2"],
   "quality_scale": "bronze",
-  "requirements": ["aiowebdav2==0.5.0"]
+  "requirements": ["aiowebdav2==0.6.1"]
 }

homeassistant/components/weheat/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/weheat",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "requirements": ["weheat==2026.1.25"]
+  "requirements": ["weheat==2026.2.28"]
 }

homeassistant/components/yale/manifest.json

@@ -14,5 +14,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["socketio", "engineio", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.4"]
+  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.7"]
 }

homeassistant/components/yalexs_ble/manifest.json

@@ -13,5 +13,5 @@
   "documentation": "https://www.home-assistant.io/integrations/yalexs_ble",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["yalexs-ble==3.2.4"]
+  "requirements": ["yalexs-ble==3.2.7"]
 }

homeassistant/components/zha/__init__.py

@@ -274,6 +274,9 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> b
 
 async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
     """Unload ZHA config entry."""
+    if not await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS):
+        return False
+
     ha_zha_data = get_zha_data(hass)
     ha_zha_data.config_entry = None
 
@@ -281,6 +284,8 @@ async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
         await ha_zha_data.gateway_proxy.shutdown()
         ha_zha_data.gateway_proxy = None
 
+    ha_zha_data.update_coordinator = None
+
     # clean up any remaining entity metadata
     # (entities that have been discovered but not yet added to HA)
     # suppress KeyError because we don't know what state we may
@@ -291,7 +296,7 @@ async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
 
     websocket_api.async_unload_api(hass)
 
-    return await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS)
+    return True
 
 
 async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:

homeassistant/components/zha/cover.py

@@ -67,8 +67,12 @@ class ZhaCover(ZHAEntity, CoverEntity):
                 self.entity_data.entity.info_object.device_class
             )
 
+    @staticmethod
+    def _convert_supported_features(
+        zha_features: ZHACoverEntityFeature,
+    ) -> CoverEntityFeature:
+        """Convert ZHA cover features to HA cover features."""
         features = CoverEntityFeature(0)
-        zha_features: ZHACoverEntityFeature = self.entity_data.entity.supported_features
 
         if ZHACoverEntityFeature.OPEN in zha_features:
             features |= CoverEntityFeature.OPEN
@@ -87,7 +91,13 @@ class ZhaCover(ZHAEntity, CoverEntity):
         if ZHACoverEntityFeature.SET_TILT_POSITION in zha_features:
             features |= CoverEntityFeature.SET_TILT_POSITION
 
-        self._attr_supported_features = features
+        return features
+
+    @property
+    def supported_features(self) -> CoverEntityFeature:
+        """Return the supported features."""
+        zha_features: ZHACoverEntityFeature = self.entity_data.entity.supported_features
+        return self._convert_supported_features(zha_features)
 
     @property
     def is_closed(self) -> bool | None:

homeassistant/components/zha/manifest.json

@@ -23,7 +23,7 @@
     "universal_silabs_flasher",
     "serialx"
   ],
-  "requirements": ["zha==1.0.0", "serialx==0.6.2"],
+  "requirements": ["zha==1.0.1", "serialx==0.6.2"],
   "usb": [
     {
       "description": "*2652*",

homeassistant/components/zwave_js/strings.json

@@ -1,13 +1,13 @@
 {
   "config": {
     "abort": {
-      "addon_get_discovery_info_failed": "Failed to get Z-Wave app discovery info.",
-      "addon_info_failed": "Failed to get Z-Wave app info.",
-      "addon_install_failed": "Failed to install the Z-Wave app.",
-      "addon_required": "The Z-Wave migration flow requires the integration to be configured using the Z-Wave Supervisor app. If you are using Z-Wave JS UI, please follow our [migration instructions]({zwave_js_ui_migration}).",
-      "addon_set_config_failed": "Failed to set Z-Wave configuration.",
-      "addon_start_failed": "Failed to start the Z-Wave app.",
-      "addon_stop_failed": "Failed to stop the Z-Wave app.",
+      "addon_get_discovery_info_failed": "Failed to get Z-Wave JS app discovery info.",
+      "addon_info_failed": "Failed to get Z-Wave JS app info.",
+      "addon_install_failed": "Failed to install the Z-Wave JS app.",
+      "addon_required": "The Z-Wave migration flow requires the integration to be configured using the Z-Wave JS app. If you are using Z-Wave JS UI, please follow our [migration instructions]({zwave_js_ui_migration}).",
+      "addon_set_config_failed": "Failed to set Z-Wave JS app configuration.",
+      "addon_start_failed": "Failed to start the Z-Wave JS app.",
+      "addon_stop_failed": "Failed to stop the Z-Wave JS app.",
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
       "backup_failed": "Failed to back up network.",
@@ -17,15 +17,15 @@
       "discovery_requires_supervisor": "Discovery requires the Home Assistant Supervisor.",
       "migration_low_sdk_version": "The SDK version of the old adapter is lower than {ok_sdk_version}. This means it's not possible to migrate the non-volatile memory (NVM) of the old adapter to another adapter.\n\nCheck the documentation on the manufacturer support pages of the old adapter, if it's possible to upgrade the firmware of the old adapter to a version that is built with SDK version {ok_sdk_version} or higher.",
       "migration_successful": "Migration successful.",
-      "not_hassio": "ESPHome discovery requires Home Assistant to configure the Z-Wave app.",
+      "not_hassio": "ESPHome discovery requires Home Assistant to configure the Z-Wave JS app.",
       "not_zwave_device": "Discovered device is not a Z-Wave device.",
-      "not_zwave_js_addon": "Discovered app is not the official Z-Wave app.",
+      "not_zwave_js_addon": "Discovered app is not the official Z-Wave JS app.",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "reset_failed": "Failed to reset adapter.",
       "usb_ports_failed": "Failed to get USB devices."
     },
     "error": {
-      "addon_start_failed": "Failed to start the Z-Wave app. Check the configuration.",
+      "addon_start_failed": "Failed to start the Z-Wave JS app. Check the configuration.",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_ws_url": "Invalid websocket URL",
       "unknown": "[%key:common::config_flow::error::unknown%]"
@@ -65,7 +65,7 @@
           "usb_path": "[%key:common::config_flow::data::usb_path%]"
         },
         "description": "Select your Z-Wave adapter",
-        "title": "Enter the Z-Wave app configuration"
+        "title": "Enter the Z-Wave JS app configuration"
       },
       "configure_security_keys": {
         "data": {
@@ -84,7 +84,7 @@
         "title": "Migrate to a new adapter"
       },
       "hassio_confirm": {
-        "description": "Do you want to set up the Z-Wave integration with the Z-Wave app?"
+        "description": "Do you want to set up the Z-Wave integration with the Z-Wave JS app?"
       },
       "install_addon": {
         "title": "Installing app"
@@ -127,9 +127,9 @@
       },
       "on_supervisor": {
         "data": {
-          "use_addon": "Use the Z-Wave Supervisor app"
+          "use_addon": "Use the Z-Wave JS app"
         },
-        "description": "Do you want to use the Z-Wave Supervisor app?",
+        "description": "Do you want to use the Z-Wave JS app?",
         "title": "Select connection method"
       },
       "on_supervisor_reconfigure": {

homeassistant/const.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 APPLICATION_NAME: Final = "HomeAssistant"
 MAJOR_VERSION: Final = 2026
 MINOR_VERSION: Final = 3
-PATCH_VERSION: Final = "0.dev0"
+PATCH_VERSION: Final = "0"
 __short_version__: Final = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__: Final = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER: Final[tuple[int, int, int]] = (3, 14, 2)