Merge pull request #70155 from home-assistant/rc

Co-authored-by: Paulus Schoutsen <balloob@gmail.com>

homeassistant/components/airzone/manifest.json

@@ -3,7 +3,7 @@
   "name": "Airzone",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/airzone",
-  "requirements": ["aioairzone==0.2.3"],
+  "requirements": ["aioairzone==0.3.3"],
   "codeowners": ["@Noltari"],
   "iot_class": "local_polling",
   "loggers": ["aioairzone"]

homeassistant/components/ambient_station/binary_sensor.py

@@ -28,6 +28,7 @@ TYPE_BATT6 = "batt6"
 TYPE_BATT7 = "batt7"
 TYPE_BATT8 = "batt8"
 TYPE_BATT9 = "batt9"
+TYPE_BATTIN = "battin"
 TYPE_BATTOUT = "battout"
 TYPE_BATT_CO2 = "batt_co2"
 TYPE_BATT_LIGHTNING = "batt_lightning"
@@ -140,6 +141,13 @@ BINARY_SENSOR_DESCRIPTIONS = (
         entity_category=EntityCategory.DIAGNOSTIC,
         on_state=0,
     ),
+    AmbientBinarySensorDescription(
+        key=TYPE_BATTIN,
+        name="Interior Battery",
+        device_class=BinarySensorDeviceClass.BATTERY,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        on_state=0,
+    ),
     AmbientBinarySensorDescription(
         key=TYPE_BATT10,
         name="Soil Monitor Battery 10",

homeassistant/components/backup/manager.py

@@ -108,7 +108,7 @@ class BackupManager:
                             size=round(backup_path.stat().st_size / 1_048_576, 2),
                         )
                         backups[backup.slug] = backup
-            except (OSError, TarError, json.JSONDecodeError) as err:
+            except (OSError, TarError, json.JSONDecodeError, KeyError) as err:
                 LOGGER.warning("Unable to read backup %s: %s", backup_path, err)
         return backups
 

homeassistant/components/bmw_connected_drive/sensor.py

@@ -46,6 +46,17 @@ class BMWSensorEntityDescription(SensorEntityDescription):
     value: Callable = lambda x, y: x
 
 
+def convert_and_round(
+    state: tuple,
+    converter: Callable[[float | None, str], float],
+    precision: int,
+) -> float | None:
+    """Safely convert and round a value from a Tuple[value, unit]."""
+    if state[0] is None:
+        return None
+    return round(converter(state[0], UNIT_MAP.get(state[1], state[1])), precision)
+
+
 SENSOR_TYPES: dict[str, BMWSensorEntityDescription] = {
     # --- Generic ---
     "charging_start_time": BMWSensorEntityDescription(
@@ -78,45 +89,35 @@ SENSOR_TYPES: dict[str, BMWSensorEntityDescription] = {
         icon="mdi:speedometer",
         unit_metric=LENGTH_KILOMETERS,
         unit_imperial=LENGTH_MILES,
-        value=lambda x, hass: round(
-            hass.config.units.length(x[0], UNIT_MAP.get(x[1], x[1])), 2
-        ),
+        value=lambda x, hass: convert_and_round(x, hass.config.units.length, 2),
     ),
     "remaining_range_total": BMWSensorEntityDescription(
         key="remaining_range_total",
         icon="mdi:map-marker-distance",
         unit_metric=LENGTH_KILOMETERS,
         unit_imperial=LENGTH_MILES,
-        value=lambda x, hass: round(
-            hass.config.units.length(x[0], UNIT_MAP.get(x[1], x[1])), 2
-        ),
+        value=lambda x, hass: convert_and_round(x, hass.config.units.length, 2),
     ),
     "remaining_range_electric": BMWSensorEntityDescription(
         key="remaining_range_electric",
         icon="mdi:map-marker-distance",
         unit_metric=LENGTH_KILOMETERS,
         unit_imperial=LENGTH_MILES,
-        value=lambda x, hass: round(
-            hass.config.units.length(x[0], UNIT_MAP.get(x[1], x[1])), 2
-        ),
+        value=lambda x, hass: convert_and_round(x, hass.config.units.length, 2),
     ),
     "remaining_range_fuel": BMWSensorEntityDescription(
         key="remaining_range_fuel",
         icon="mdi:map-marker-distance",
         unit_metric=LENGTH_KILOMETERS,
         unit_imperial=LENGTH_MILES,
-        value=lambda x, hass: round(
-            hass.config.units.length(x[0], UNIT_MAP.get(x[1], x[1])), 2
-        ),
+        value=lambda x, hass: convert_and_round(x, hass.config.units.length, 2),
     ),
     "remaining_fuel": BMWSensorEntityDescription(
         key="remaining_fuel",
         icon="mdi:gas-station",
         unit_metric=VOLUME_LITERS,
         unit_imperial=VOLUME_GALLONS,
-        value=lambda x, hass: round(
-            hass.config.units.volume(x[0], UNIT_MAP.get(x[1], x[1])), 2
-        ),
+        value=lambda x, hass: convert_and_round(x, hass.config.units.volume, 2),
     ),
     "fuel_percent": BMWSensorEntityDescription(
         key="fuel_percent",

homeassistant/components/cast/media_player.py

@@ -469,7 +469,8 @@ class CastMediaPlayerEntity(CastDevice, MediaPlayerEntity):
 
         # The only way we can turn the Chromecast is on is by launching an app
         if self._chromecast.cast_type == pychromecast.const.CAST_TYPE_CHROMECAST:
-            self._chromecast.play_media(CAST_SPLASH, "image/png")
+            app_data = {"media_id": CAST_SPLASH, "media_type": "image/png"}
+            quick_play(self._chromecast, "default_media_receiver", app_data)
         else:
             self._chromecast.start_app(pychromecast.config.APP_MEDIA_RECEIVER)
 

homeassistant/components/climate/device_condition.py

@@ -75,15 +75,19 @@ def async_condition_from_config(
     hass: HomeAssistant, config: ConfigType
 ) -> condition.ConditionCheckerType:
     """Create a function to test a device condition."""
-    if config[CONF_TYPE] == "is_hvac_mode":
-        attribute = const.ATTR_HVAC_MODE
-    else:
-        attribute = const.ATTR_PRESET_MODE
 
     def test_is_state(hass: HomeAssistant, variables: TemplateVarsType) -> bool:
         """Test if an entity is a certain state."""
-        state = hass.states.get(config[ATTR_ENTITY_ID])
-        return state.attributes.get(attribute) == config[attribute] if state else False
+        if (state := hass.states.get(config[ATTR_ENTITY_ID])) is None:
+            return False
+
+        if config[CONF_TYPE] == "is_hvac_mode":
+            return state.state == config[const.ATTR_HVAC_MODE]
+
+        return (
+            state.attributes.get(const.ATTR_PRESET_MODE)
+            == config[const.ATTR_PRESET_MODE]
+        )
 
     return test_is_state
 

homeassistant/components/climate/recorder.py

@@ -0,0 +1,32 @@
+"""Integration platform for recorder."""
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant, callback
+
+from .const import (
+    ATTR_FAN_MODES,
+    ATTR_HVAC_MODES,
+    ATTR_MAX_HUMIDITY,
+    ATTR_MAX_TEMP,
+    ATTR_MIN_HUMIDITY,
+    ATTR_MIN_TEMP,
+    ATTR_PRESET_MODES,
+    ATTR_SWING_MODES,
+    ATTR_TARGET_TEMP_STEP,
+)
+
+
+@callback
+def exclude_attributes(hass: HomeAssistant) -> set[str]:
+    """Exclude static attributes from being recorded in the database."""
+    return {
+        ATTR_HVAC_MODES,
+        ATTR_FAN_MODES,
+        ATTR_SWING_MODES,
+        ATTR_MIN_TEMP,
+        ATTR_MAX_TEMP,
+        ATTR_MIN_HUMIDITY,
+        ATTR_MAX_HUMIDITY,
+        ATTR_TARGET_TEMP_STEP,
+        ATTR_PRESET_MODES,
+    }

homeassistant/components/demo/__init__.py

@@ -5,6 +5,7 @@ from random import random
 
 from homeassistant import config_entries, setup
 from homeassistant.components import persistent_notification
+from homeassistant.components.recorder import get_instance
 from homeassistant.components.recorder.statistics import (
     async_add_external_statistics,
     get_last_statistics,
@@ -245,7 +246,7 @@ async def _insert_statistics(hass):
     }
     statistic_id = f"{DOMAIN}:energy_consumption"
     sum_ = 0
-    last_stats = await hass.async_add_executor_job(
+    last_stats = await get_instance(hass).async_add_executor_job(
         get_last_statistics, hass, 1, statistic_id, True
     )
     if "domain:energy_consumption" in last_stats:

homeassistant/components/derivative/sensor.py

@@ -250,8 +250,10 @@ class DerivativeSensor(RestoreEntity, SensorEntity):
             self._state = derivative
             self.async_write_ha_state()
 
-        async_track_state_change_event(
-            self.hass, self._sensor_source_id, calc_derivative
+        self.async_on_remove(
+            async_track_state_change_event(
+                self.hass, self._sensor_source_id, calc_derivative
+            )
         )
 
     @property

homeassistant/components/derivative/strings.json

@@ -1,8 +1,9 @@
 {
+  "title": "Derivative sensor",
   "config": {
     "step": {
       "user": {
-        "title": "New Derivative sensor",
+        "title": "Add Derivative sensor",
         "description": "Create a sensor that estimates the derivative of a sensor.",
         "data": {
           "name": "Name",
@@ -15,14 +16,14 @@
         "data_description": {
           "round": "Controls the number of decimal digits in the output.",
           "time_window": "If set, the sensor's value is a time weighted moving average of derivatives within this window.",
-          "unit_prefix": "The derivative will be scaled according to the selected metric prefix and time unit of the derivative."
+          "unit_prefix": "The output will be scaled according to the selected metric prefix and time unit of the derivative."
         }
       }
     }
   },
   "options": {
     "step": {
-      "options": {
+      "init": {
         "data": {
           "name": "[%key:component::derivative::config::step::user::data::name%]",
           "round": "[%key:component::derivative::config::step::user::data::round%]",

homeassistant/components/derivative/translations/en.json

@@ -13,15 +13,16 @@
                 "data_description": {
                     "round": "Controls the number of decimal digits in the output.",
                     "time_window": "If set, the sensor's value is a time weighted moving average of derivatives within this window.",
-                    "unit_prefix": "The derivative will be scaled according to the selected metric prefix and time unit of the derivative."
+                    "unit_prefix": "The output will be scaled according to the selected metric prefix and time unit of the derivative."
                 },
-                "title": "New Derivative sensor"
+                "description": "Create a sensor that estimates the derivative of a sensor.",
+                "title": "Add Derivative sensor"
             }
         }
     },
     "options": {
         "step": {
-            "options": {
+            "init": {
                 "data": {
                     "name": "Name",
                     "round": "Precision",
@@ -33,9 +34,10 @@
                 "data_description": {
                     "round": "Controls the number of decimal digits in the output.",
                     "time_window": "If set, the sensor's value is a time weighted moving average of derivatives within this window.",
-                    "unit_prefix": "The derivative will be scaled according to the selected metric prefix and time unit of the derivative.."
+                    "unit_prefix": "The output will be scaled according to the selected metric prefix and time unit of the derivative.."
                 }
             }
         }
-    }
+    },
+    "title": "Derivative sensor"
 }

homeassistant/components/devolo_home_control/binary_sensor.py

@@ -66,9 +66,9 @@ class DevoloBinaryDeviceEntity(DevoloDeviceEntity, BinarySensorEntity):
         self, homecontrol: HomeControl, device_instance: Zwave, element_uid: str
     ) -> None:
         """Initialize a devolo binary sensor."""
-        self._binary_sensor_property = device_instance.binary_sensor_property.get(
+        self._binary_sensor_property = device_instance.binary_sensor_property[
             element_uid
-        )
+        ]
 
         super().__init__(
             homecontrol=homecontrol,
@@ -82,10 +82,12 @@ class DevoloBinaryDeviceEntity(DevoloDeviceEntity, BinarySensorEntity):
         )
 
         if self._attr_device_class is None:
-            if device_instance.binary_sensor_property.get(element_uid).sub_type != "":
-                self._attr_name += f" {device_instance.binary_sensor_property.get(element_uid).sub_type}"
+            if device_instance.binary_sensor_property[element_uid].sub_type != "":
+                self._attr_name += (
+                    f" {device_instance.binary_sensor_property[element_uid].sub_type}"
+                )
             else:
-                self._attr_name += f" {device_instance.binary_sensor_property.get(element_uid).sensor_type}"
+                self._attr_name += f" {device_instance.binary_sensor_property[element_uid].sensor_type}"
 
         self._value = self._binary_sensor_property.state
 
@@ -114,9 +116,9 @@ class DevoloRemoteControl(DevoloDeviceEntity, BinarySensorEntity):
         key: int,
     ) -> None:
         """Initialize a devolo remote control."""
-        self._remote_control_property = device_instance.remote_control_property.get(
+        self._remote_control_property = device_instance.remote_control_property[
             element_uid
-        )
+        ]
 
         super().__init__(
             homecontrol=homecontrol,

homeassistant/components/devolo_home_control/cover.py

@@ -63,7 +63,7 @@ class DevoloCoverDeviceEntity(DevoloMultiLevelSwitchDeviceEntity, CoverEntity):
     @property
     def current_cover_position(self) -> int:
         """Return the current position. 0 is closed. 100 is open."""
-        return self._value
+        return int(self._value)
 
     @property
     def is_closed(self) -> bool:

homeassistant/components/devolo_home_control/devolo_device.py

@@ -46,7 +46,7 @@ class DevoloDeviceEntity(Entity):
 
         self.subscriber: Subscriber | None = None
         self.sync_callback = self._sync
-        self._value: int
+        self._value: float
 
     async def async_added_to_hass(self) -> None:
         """Call when entity is added to hass."""

homeassistant/components/devolo_home_control/manifest.json

@@ -2,7 +2,7 @@
   "domain": "devolo_home_control",
   "name": "devolo Home Control",
   "documentation": "https://www.home-assistant.io/integrations/devolo_home_control",
-  "requirements": ["devolo-home-control-api==0.17.4"],
+  "requirements": ["devolo-home-control-api==0.18.1"],
   "after_dependencies": ["zeroconf"],
   "config_flow": true,
   "codeowners": ["@2Fake", "@Shutgun"],

homeassistant/components/devolo_home_control/sensor.py

@@ -83,7 +83,7 @@ class DevoloMultiLevelDeviceEntity(DevoloDeviceEntity, SensorEntity):
     """Abstract representation of a multi level sensor within devolo Home Control."""
 
     @property
-    def native_value(self) -> int:
+    def native_value(self) -> float:
         """Return the state of the sensor."""
         return self._value
 

homeassistant/components/devolo_home_control/siren.py

@@ -54,8 +54,8 @@ class DevoloSirenDeviceEntity(DevoloMultiLevelSwitchDeviceEntity, SirenEntity):
         )
         self._attr_available_tones = [
             *range(
-                self._multi_level_switch_property.min,
-                self._multi_level_switch_property.max + 1,
+                int(self._multi_level_switch_property.min),
+                int(self._multi_level_switch_property.max) + 1,
             )
         ]
         self._attr_supported_features = (

homeassistant/components/devolo_home_control/switch.py

@@ -50,9 +50,9 @@ class DevoloSwitch(DevoloDeviceEntity, SwitchEntity):
             device_instance=device_instance,
             element_uid=element_uid,
         )
-        self._binary_switch_property = self._device_instance.binary_switch_property.get(
-            self._attr_unique_id
-        )
+        self._binary_switch_property = self._device_instance.binary_switch_property[
+            self._attr_unique_id  # type: ignore[index]
+        ]
         self._attr_is_on = self._binary_switch_property.state
 
     def turn_on(self, **kwargs: Any) -> None:

homeassistant/components/dlna_dmr/config_flow.py

@@ -134,10 +134,16 @@ class DlnaDmrFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
         discovery_service_list = discovery_info.upnp.get(ssdp.ATTR_UPNP_SERVICE_LIST)
         if not discovery_service_list:
             return self.async_abort(reason="not_dmr")
-        discovery_service_ids = {
-            service.get("serviceId")
-            for service in discovery_service_list.get("service") or []
-        }
+
+        services = discovery_service_list.get("service")
+        if not services:
+            discovery_service_ids: set[str] = set()
+        elif isinstance(services, list):
+            discovery_service_ids = {service.get("serviceId") for service in services}
+        else:
+            # Only one service defined (etree_to_dict failed to make a list)
+            discovery_service_ids = {services.get("serviceId")}
+
         if not DmrDevice.SERVICE_IDS.issubset(discovery_service_ids):
             return self.async_abort(reason="not_dmr")
 

homeassistant/components/dlna_dms/config_flow.py

@@ -77,10 +77,16 @@ class DlnaDmsFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
         discovery_service_list = discovery_info.upnp.get(ssdp.ATTR_UPNP_SERVICE_LIST)
         if not discovery_service_list:
             return self.async_abort(reason="not_dms")
-        discovery_service_ids = {
-            service.get("serviceId")
-            for service in discovery_service_list.get("service") or []
-        }
+
+        services = discovery_service_list.get("service")
+        if not services:
+            discovery_service_ids: set[str] = set()
+        elif isinstance(services, list):
+            discovery_service_ids = {service.get("serviceId") for service in services}
+        else:
+            # Only one service defined (etree_to_dict failed to make a list)
+            discovery_service_ids = {services.get("serviceId")}
+
         if not DmsDevice.SERVICE_IDS.issubset(discovery_service_ids):
             return self.async_abort(reason="not_dms")
 

homeassistant/components/elkm1/__init__.py

@@ -363,6 +363,9 @@ async def async_wait_for_elk_to_sync(
     # VN is the first command sent for panel, when we get
     # it back we now we are logged in either with or without a password
     elk.add_handler("VN", first_response)
+    # Some panels do not respond to the vn request so we
+    # check for lw as well
+    elk.add_handler("LW", first_response)
     elk.add_handler("sync_complete", sync_complete)
     for name, event, timeout in (
         ("login", login_event, login_timeout),

homeassistant/components/energy/validate.py

@@ -489,7 +489,7 @@ async def async_validate(hass: HomeAssistant) -> EnergyPreferencesValidation:
 
     # Fetch the needed statistics metadata
     statistics_metadata.update(
-        await hass.async_add_executor_job(
+        await recorder.get_instance(hass).async_add_executor_job(
             functools.partial(
                 recorder.statistics.get_metadata,
                 hass,

homeassistant/components/energy/websocket_api.py

@@ -260,7 +260,7 @@ async def ws_get_fossil_energy_consumption(
     statistic_ids.append(msg["co2_statistic_id"])
 
     # Fetch energy + CO2 statistics
-    statistics = await hass.async_add_executor_job(
+    statistics = await recorder.get_instance(hass).async_add_executor_job(
         recorder.statistics.statistics_during_period,
         hass,
         start_time,

homeassistant/components/environment_canada/manifest.json

@@ -2,7 +2,7 @@
   "domain": "environment_canada",
   "name": "Environment Canada",
   "documentation": "https://www.home-assistant.io/integrations/environment_canada",
-  "requirements": ["env_canada==0.5.20"],
+  "requirements": ["env_canada==0.5.21"],
   "codeowners": ["@gwww", "@michaeldavie"],
   "config_flow": true,
   "iot_class": "cloud_polling",

homeassistant/components/environment_canada/sensor.py

@@ -209,13 +209,23 @@ SENSOR_TYPES: tuple[ECSensorEntityDescription, ...] = (
     ),
 )
 
+
+def _get_aqhi_value(data):
+    if (aqhi := data.current) is not None:
+        return aqhi
+    if data.forecasts and (hourly := data.forecasts.get("hourly")) is not None:
+        if values := list(hourly.values()):
+            return values[0]
+    return None
+
+
 AQHI_SENSOR = ECSensorEntityDescription(
     key="aqhi",
     name="AQHI",
     device_class=SensorDeviceClass.AQI,
     native_unit_of_measurement="AQI",
     state_class=SensorStateClass.MEASUREMENT,
-    value_fn=lambda data: data.current,
+    value_fn=_get_aqhi_value,
 )
 
 ALERT_TYPES: tuple[ECSensorEntityDescription, ...] = (

homeassistant/components/esphome/__init__.py

@@ -520,6 +520,7 @@ async def _cleanup_instance(
     data = domain_data.pop_entry_data(entry)
     for disconnect_cb in data.disconnect_callbacks:
         disconnect_cb()
+    data.disconnect_callbacks = []
     for cleanup_callback in data.cleanup_callbacks:
         cleanup_callback()
     await data.client.disconnect()

homeassistant/components/fan/recorder.py

@@ -0,0 +1,12 @@
+"""Integration platform for recorder."""
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant, callback
+
+from . import ATTR_PRESET_MODES
+
+
+@callback
+def exclude_attributes(hass: HomeAssistant) -> set[str]:
+    """Exclude static attributes from being recorded in the database."""
+    return {ATTR_PRESET_MODES}

homeassistant/components/fibaro/light.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import asyncio
+from contextlib import suppress
 from functools import partial
 
 from homeassistant.components.light import (
@@ -198,16 +199,21 @@ class FibaroLight(FibaroDevice, LightEntity):
 
         Dimmable and RGB lights can be on based on different
         properties, so we need to check here several values.
+
+        JSON for HC2 uses always string, HC3 uses int for integers.
         """
         props = self.fibaro_device.properties
         if self.current_binary_state:
             return True
-        if "brightness" in props and props.brightness != "0":
-            return True
-        if "currentProgram" in props and props.currentProgram != "0":
-            return True
-        if "currentProgramID" in props and props.currentProgramID != "0":
-            return True
+        with suppress(ValueError, TypeError):
+            if "brightness" in props and int(props.brightness) != 0:
+                return True
+        with suppress(ValueError, TypeError):
+            if "currentProgram" in props and int(props.currentProgram) != 0:
+                return True
+        with suppress(ValueError, TypeError):
+            if "currentProgramID" in props and int(props.currentProgramID) != 0:
+                return True
 
         return False
 

homeassistant/components/fritz/common.py

@@ -91,6 +91,11 @@ def _cleanup_entity_filter(device: er.RegistryEntry) -> bool:
     )
 
 
+def _ha_is_stopping(activity: str) -> None:
+    """Inform that HA is stopping."""
+    _LOGGER.info("Cannot execute %s: HomeAssistant is shutting down", activity)
+
+
 class ClassSetupMissing(Exception):
     """Raised when a Class func is called before setup."""
 
@@ -351,6 +356,10 @@ class FritzBoxTools(update_coordinator.DataUpdateCoordinator):
     def scan_devices(self, now: datetime | None = None) -> None:
         """Scan for new devices and return a list of found device ids."""
 
+        if self.hass.is_stopping:
+            _ha_is_stopping("scan devices")
+            return
+
         _LOGGER.debug("Checking host info for FRITZ!Box device %s", self.host)
         self._update_available, self._latest_firmware = self._update_device_info()
 
@@ -603,6 +612,10 @@ class AvmWrapper(FritzBoxTools):
     ) -> dict:
         """Return service details."""
 
+        if self.hass.is_stopping:
+            _ha_is_stopping(f"{service_name}/{action_name}")
+            return {}
+
         if f"{service_name}{service_suffix}" not in self.connection.services:
             return {}
 

homeassistant/components/fritz/config_flow.py

@@ -1,6 +1,7 @@
 """Config flow to configure the FRITZ!Box Tools integration."""
 from __future__ import annotations
 
+import ipaddress
 import logging
 import socket
 from typing import Any
@@ -129,6 +130,9 @@ class FritzBoxToolsFlowHandler(ConfigFlow, domain=DOMAIN):
         )
         self.context[CONF_HOST] = self._host
 
+        if ipaddress.ip_address(self._host).is_link_local:
+            return self.async_abort(reason="ignore_ip6_link_local")
+
         if uuid := discovery_info.upnp.get(ssdp.ATTR_UPNP_UDN):
             if uuid.startswith("uuid:"):
                 uuid = uuid[5:]

homeassistant/components/fritz/strings.json

@@ -32,6 +32,7 @@
     "abort": {
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "ignore_ip6_link_local": "IPv6 link local address is not supported.",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {

homeassistant/components/fritz/translations/en.json

@@ -3,13 +3,13 @@
         "abort": {
             "already_configured": "Device is already configured",
             "already_in_progress": "Configuration flow is already in progress",
+            "ignore_ip6_link_local": "IPv6 link local address is not supported.",
             "reauth_successful": "Re-authentication was successful"
         },
         "error": {
             "already_configured": "Device is already configured",
             "already_in_progress": "Configuration flow is already in progress",
             "cannot_connect": "Failed to connect",
-            "connection_error": "Failed to connect",
             "invalid_auth": "Invalid authentication",
             "upnp_not_configured": "Missing UPnP settings on device."
         },
@@ -31,16 +31,6 @@
                 "description": "Update FRITZ!Box Tools credentials for: {host}.\n\nFRITZ!Box Tools is unable to log in to your FRITZ!Box.",
                 "title": "Updating FRITZ!Box Tools - credentials"
             },
-            "start_config": {
-                "data": {
-                    "host": "Host",
-                    "password": "Password",
-                    "port": "Port",
-                    "username": "Username"
-                },
-                "description": "Setup FRITZ!Box Tools to control your FRITZ!Box.\nMinimum needed: username, password.",
-                "title": "Setup FRITZ!Box Tools - mandatory"
-            },
             "user": {
                 "data": {
                     "host": "Host",

homeassistant/components/fritzbox/config_flow.py

@@ -1,6 +1,7 @@
 """Config flow for AVM FRITZ!SmartHome."""
 from __future__ import annotations
 
+import ipaddress
 from typing import Any
 from urllib.parse import urlparse
 
@@ -120,6 +121,12 @@ class FritzboxConfigFlow(ConfigFlow, domain=DOMAIN):
         assert isinstance(host, str)
         self.context[CONF_HOST] = host
 
+        if (
+            ipaddress.ip_address(host).version == 6
+            and ipaddress.ip_address(host).is_link_local
+        ):
+            return self.async_abort(reason="ignore_ip6_link_local")
+
         if uuid := discovery_info.upnp.get(ssdp.ATTR_UPNP_UDN):
             if uuid.startswith("uuid:"):
                 uuid = uuid[5:]

homeassistant/components/fritzbox/strings.json

@@ -28,6 +28,7 @@
     "abort": {
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "ignore_ip6_link_local": "IPv6 link local address is not supported.",
       "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
       "not_supported": "Connected to AVM FRITZ!Box but it's unable to control Smart Home devices.",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"

homeassistant/components/fritzbox/translations/en.json

@@ -3,6 +3,7 @@
         "abort": {
             "already_configured": "Device is already configured",
             "already_in_progress": "Configuration flow is already in progress",
+            "ignore_ip6_link_local": "IPv6 link local address is not supported.",
             "no_devices_found": "No devices found on the network",
             "not_supported": "Connected to AVM FRITZ!Box but it's unable to control Smart Home devices.",
             "reauth_successful": "Re-authentication was successful"

homeassistant/components/frontend/manifest.json

@@ -2,7 +2,7 @@
   "domain": "frontend",
   "name": "Home Assistant Frontend",
   "documentation": "https://www.home-assistant.io/integrations/frontend",
-  "requirements": ["home-assistant-frontend==20220401.0"],
+  "requirements": ["home-assistant-frontend==20220405.0"],
   "dependencies": [
     "api",
     "auth",

homeassistant/components/gdacs/manifest.json

@@ -3,7 +3,7 @@
   "name": "Global Disaster Alert and Coordination System (GDACS)",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/gdacs",
-  "requirements": ["aio_georss_gdacs==0.5"],
+  "requirements": ["aio_georss_gdacs==0.7"],
   "codeowners": ["@exxamalte"],
   "quality_scale": "platinum",
   "iot_class": "cloud_polling"

homeassistant/components/generic/config_flow.py

@@ -58,7 +58,7 @@ DEFAULT_DATA = {
     CONF_VERIFY_SSL: True,
 }
 
-SUPPORTED_IMAGE_TYPES = {"png", "jpeg", "gif", "svg+xml"}
+SUPPORTED_IMAGE_TYPES = {"png", "jpeg", "gif", "svg+xml", "webp"}
 
 
 def build_schema(
@@ -109,6 +109,20 @@ def build_schema(
     return vol.Schema(spec)
 
 
+def build_schema_content_type(user_input: dict[str, Any] | MappingProxyType[str, Any]):
+    """Create schema for conditional 2nd page specifying stream content_type."""
+    return vol.Schema(
+        {
+            vol.Required(
+                CONF_CONTENT_TYPE,
+                description={
+                    "suggested_value": user_input.get(CONF_CONTENT_TYPE, "image/jpeg")
+                },
+            ): str,
+        }
+    )
+
+
 def get_image_type(image):
     """Get the format of downloaded bytes that could be an image."""
     fmt = None
@@ -129,14 +143,14 @@ async def async_test_still(hass, info) -> tuple[dict[str, str], str | None]:
     """Verify that the still image is valid before we create an entity."""
     fmt = None
     if not (url := info.get(CONF_STILL_IMAGE_URL)):
-        return {}, None
+        return {}, info.get(CONF_CONTENT_TYPE, "image/jpeg")
     if not isinstance(url, template_helper.Template) and url:
         url = cv.template(url)
         url.hass = hass
     try:
         url = url.async_render(parse_result=False)
     except TemplateError as err:
-        _LOGGER.error("Error parsing template %s: %s", url, err)
+        _LOGGER.warning("Problem rendering template %s: %s", url, err)
         return {CONF_STILL_IMAGE_URL: "template_error"}, None
     verify_ssl = info.get(CONF_VERIFY_SSL)
     auth = generate_auth(info)
@@ -228,6 +242,11 @@ class GenericIPCamConfigFlow(ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
+    def __init__(self):
+        """Initialize Generic ConfigFlow."""
+        self.cached_user_input: dict[str, Any] = {}
+        self.cached_title = ""
+
     @staticmethod
     def async_get_options_flow(
         config_entry: ConfigEntry,
@@ -238,8 +257,8 @@ class GenericIPCamConfigFlow(ConfigFlow, domain=DOMAIN):
     def check_for_existing(self, options):
         """Check whether an existing entry is using the same URLs."""
         return any(
-            entry.options[CONF_STILL_IMAGE_URL] == options[CONF_STILL_IMAGE_URL]
-            and entry.options[CONF_STREAM_SOURCE] == options[CONF_STREAM_SOURCE]
+            entry.options.get(CONF_STILL_IMAGE_URL) == options.get(CONF_STILL_IMAGE_URL)
+            and entry.options.get(CONF_STREAM_SOURCE) == options.get(CONF_STREAM_SOURCE)
             for entry in self._async_current_entries()
         )
 
@@ -264,10 +283,17 @@ class GenericIPCamConfigFlow(ConfigFlow, domain=DOMAIN):
                 if not errors:
                     user_input[CONF_CONTENT_TYPE] = still_format
                     user_input[CONF_LIMIT_REFETCH_TO_URL_CHANGE] = False
-                    await self.async_set_unique_id(self.flow_id)
-                    return self.async_create_entry(
-                        title=name, data={}, options=user_input
-                    )
+                    if user_input.get(CONF_STILL_IMAGE_URL):
+                        await self.async_set_unique_id(self.flow_id)
+                        return self.async_create_entry(
+                            title=name, data={}, options=user_input
+                        )
+                    # If user didn't specify a still image URL,
+                    # we can't (yet) autodetect it from the stream.
+                    # Show a conditional 2nd page to ask them the content type.
+                    self.cached_user_input = user_input
+                    self.cached_title = name
+                    return await self.async_step_content_type()
         else:
             user_input = DEFAULT_DATA.copy()
 
@@ -277,13 +303,28 @@ class GenericIPCamConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
+    async def async_step_content_type(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
+        """Handle the user's choice for stream content_type."""
+        if user_input is not None:
+            user_input = self.cached_user_input | user_input
+            await self.async_set_unique_id(self.flow_id)
+            return self.async_create_entry(
+                title=self.cached_title, data={}, options=user_input
+            )
+        return self.async_show_form(
+            step_id="content_type",
+            data_schema=build_schema_content_type({}),
+            errors={},
+        )
+
     async def async_step_import(self, import_config) -> FlowResult:
         """Handle config import from yaml."""
         # abort if we've already got this one.
         if self.check_for_existing(import_config):
             return self.async_abort(reason="already_exists")
-        errors, still_format = await async_test_still(self.hass, import_config)
-        errors = errors | await async_test_stream(self.hass, import_config)
+        # Don't bother testing the still or stream details on yaml import.
         still_url = import_config.get(CONF_STILL_IMAGE_URL)
         stream_url = import_config.get(CONF_STREAM_SOURCE)
         name = import_config.get(
@@ -291,15 +332,10 @@ class GenericIPCamConfigFlow(ConfigFlow, domain=DOMAIN):
         )
         if CONF_LIMIT_REFETCH_TO_URL_CHANGE not in import_config:
             import_config[CONF_LIMIT_REFETCH_TO_URL_CHANGE] = False
-        if not errors:
-            import_config[CONF_CONTENT_TYPE] = still_format
-            await self.async_set_unique_id(self.flow_id)
-            return self.async_create_entry(title=name, data={}, options=import_config)
-        _LOGGER.error(
-            "Error importing generic IP camera platform config: unexpected error '%s'",
-            list(errors.values()),
-        )
-        return self.async_abort(reason="unknown")
+        still_format = import_config.get(CONF_CONTENT_TYPE, "image/jpeg")
+        import_config[CONF_CONTENT_TYPE] = still_format
+        await self.async_set_unique_id(self.flow_id)
+        return self.async_create_entry(title=name, data={}, options=import_config)
 
 
 class GenericOptionsFlowHandler(OptionsFlow):
@@ -308,6 +344,8 @@ class GenericOptionsFlowHandler(OptionsFlow):
     def __init__(self, config_entry: ConfigEntry) -> None:
         """Initialize Generic IP Camera options flow."""
         self.config_entry = config_entry
+        self.cached_user_input: dict[str, Any] = {}
+        self.cached_title = ""
 
     async def async_step_init(
         self, user_input: dict[str, Any] | None = None
@@ -316,29 +354,52 @@ class GenericOptionsFlowHandler(OptionsFlow):
         errors: dict[str, str] = {}
 
         if user_input is not None:
-            errors, still_format = await async_test_still(self.hass, user_input)
+            errors, still_format = await async_test_still(
+                self.hass, self.config_entry.options | user_input
+            )
             errors = errors | await async_test_stream(self.hass, user_input)
             still_url = user_input.get(CONF_STILL_IMAGE_URL)
             stream_url = user_input.get(CONF_STREAM_SOURCE)
             if not errors:
-                return self.async_create_entry(
-                    title=slug_url(still_url) or slug_url(stream_url) or DEFAULT_NAME,
-                    data={
-                        CONF_AUTHENTICATION: user_input.get(CONF_AUTHENTICATION),
-                        CONF_STREAM_SOURCE: user_input.get(CONF_STREAM_SOURCE),
-                        CONF_PASSWORD: user_input.get(CONF_PASSWORD),
-                        CONF_STILL_IMAGE_URL: user_input.get(CONF_STILL_IMAGE_URL),
-                        CONF_CONTENT_TYPE: still_format,
-                        CONF_USERNAME: user_input.get(CONF_USERNAME),
-                        CONF_LIMIT_REFETCH_TO_URL_CHANGE: user_input[
-                            CONF_LIMIT_REFETCH_TO_URL_CHANGE
-                        ],
-                        CONF_FRAMERATE: user_input[CONF_FRAMERATE],
-                        CONF_VERIFY_SSL: user_input[CONF_VERIFY_SSL],
-                    },
-                )
+                title = slug_url(still_url) or slug_url(stream_url) or DEFAULT_NAME
+                data = {
+                    CONF_AUTHENTICATION: user_input.get(CONF_AUTHENTICATION),
+                    CONF_STREAM_SOURCE: user_input.get(CONF_STREAM_SOURCE),
+                    CONF_PASSWORD: user_input.get(CONF_PASSWORD),
+                    CONF_STILL_IMAGE_URL: user_input.get(CONF_STILL_IMAGE_URL),
+                    CONF_CONTENT_TYPE: still_format
+                    or self.config_entry.options.get(CONF_CONTENT_TYPE),
+                    CONF_USERNAME: user_input.get(CONF_USERNAME),
+                    CONF_LIMIT_REFETCH_TO_URL_CHANGE: user_input[
+                        CONF_LIMIT_REFETCH_TO_URL_CHANGE
+                    ],
+                    CONF_FRAMERATE: user_input[CONF_FRAMERATE],
+                    CONF_VERIFY_SSL: user_input[CONF_VERIFY_SSL],
+                }
+                if still_url:
+                    return self.async_create_entry(
+                        title=title,
+                        data=data,
+                    )
+                self.cached_title = title
+                self.cached_user_input = data
+                return await self.async_step_content_type()
+
         return self.async_show_form(
             step_id="init",
             data_schema=build_schema(user_input or self.config_entry.options, True),
             errors=errors,
         )
+
+    async def async_step_content_type(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
+        """Handle the user's choice for stream content_type."""
+        if user_input is not None:
+            user_input = self.cached_user_input | user_input
+            return self.async_create_entry(title=self.cached_title, data=user_input)
+        return self.async_show_form(
+            step_id="content_type",
+            data_schema=build_schema_content_type(self.cached_user_input),
+            errors={},
+        )

homeassistant/components/generic/manifest.json

@@ -2,7 +2,7 @@
   "domain": "generic",
   "name": "Generic Camera",
   "config_flow": true,
-  "requirements": ["av==9.0.0", "pillow==9.0.1"],
+  "requirements": ["ha-av==9.1.1-3", "pillow==9.0.1"],
   "documentation": "https://www.home-assistant.io/integrations/generic",
   "codeowners": ["@davet2001"],
   "iot_class": "local_push"

homeassistant/components/generic/strings.json

@@ -30,11 +30,16 @@
           "limit_refetch_to_url_change": "Limit refetch to url change",
           "password": "[%key:common::config_flow::data::password%]",
           "username": "[%key:common::config_flow::data::username%]",
-          "content_type": "Content Type",
           "framerate": "Frame Rate (Hz)",
           "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
         }
       },
+      "content_type": {
+        "description": "Specify the content type for the stream.",
+        "data": {
+          "content_type": "Content Type"
+        }
+      },
       "confirm": {
         "description": "[%key:common::config_flow::description::confirm_setup%]"
       }
@@ -51,10 +56,15 @@
           "limit_refetch_to_url_change": "[%key:component::generic::config::step::user::data::limit_refetch_to_url_change%]",
           "password": "[%key:common::config_flow::data::password%]",
           "username": "[%key:common::config_flow::data::username%]",
-          "content_type": "[%key:component::generic::config::step::user::data::content_type%]",
           "framerate": "[%key:component::generic::config::step::user::data::framerate%]",
           "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
         }
+      },
+      "content_type": {
+        "description": "[%key:component::generic::config::step::content_type::description%]",
+        "data": {
+          "content_type": "[%key:component::generic::config::step::content_type::data::content_type%]"
+        }
       }
     },
     "error": {

homeassistant/components/generic/translations/en.json

@@ -23,10 +23,15 @@
             "confirm": {
                 "description": "Do you want to start set up?"
             },
+            "content_type": {
+                "data": {
+                    "content_type": "Content Type"
+                },
+                "description": "Specify the content type for the stream."
+            },
             "user": {
                 "data": {
                     "authentication": "Authentication",
-                    "content_type": "Content Type",
                     "framerate": "Frame Rate (Hz)",
                     "limit_refetch_to_url_change": "Limit refetch to url change",
                     "password": "Password",
@@ -57,10 +62,15 @@
             "unknown": "Unexpected error"
         },
         "step": {
+            "content_type": {
+                "data": {
+                    "content_type": "Content Type"
+                },
+                "description": "Specify the content type for the stream."
+            },
             "init": {
                 "data": {
                     "authentication": "Authentication",
-                    "content_type": "Content Type",
                     "framerate": "Frame Rate (Hz)",
                     "limit_refetch_to_url_change": "Limit refetch to url change",
                     "password": "Password",

homeassistant/components/google/__init__.py

@@ -7,6 +7,7 @@ from datetime import datetime, timedelta
 import logging
 from typing import Any
 
+import aiohttp
 from httplib2.error import ServerNotFoundError
 from oauth2client.file import Storage
 import voluptuous as vol
@@ -24,7 +25,11 @@ from homeassistant.const import (
     CONF_OFFSET,
 )
 from homeassistant.core import HomeAssistant, ServiceCall
-from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
+from homeassistant.exceptions import (
+    ConfigEntryAuthFailed,
+    ConfigEntryNotReady,
+    HomeAssistantError,
+)
 from homeassistant.helpers import config_entry_oauth2_flow
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.dispatcher import async_dispatcher_send
@@ -185,8 +190,23 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             hass, entry
         )
     )
-    assert isinstance(implementation, DeviceAuth)
     session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
+    # Force a token refresh to fix a bug where tokens were persisted with
+    # expires_in (relative time delta) and expires_at (absolute time) swapped.
+    # A google session token typically only lasts a few days between refresh.
+    now = datetime.now()
+    if session.token["expires_at"] >= (now + timedelta(days=365)).timestamp():
+        session.token["expires_in"] = 0
+        session.token["expires_at"] = now.timestamp()
+    try:
+        await session.async_ensure_token_valid()
+    except aiohttp.ClientResponseError as err:
+        if 400 <= err.status < 500:
+            raise ConfigEntryAuthFailed from err
+        raise ConfigEntryNotReady from err
+    except aiohttp.ClientError as err:
+        raise ConfigEntryNotReady from err
+
     required_scope = hass.data[DOMAIN][DATA_CONFIG][CONF_CALENDAR_ACCESS].scope
     if required_scope not in session.token.get("scope", []):
         raise ConfigEntryAuthFailed(

homeassistant/components/google/api.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from collections.abc import Awaitable, Callable
 import datetime
 import logging
+import time
 from typing import Any
 
 from googleapiclient import discovery as google_discovery
@@ -58,7 +59,7 @@ class DeviceAuth(config_entry_oauth2_flow.LocalOAuth2Implementation):
             "refresh_token": creds.refresh_token,
             "scope": " ".join(creds.scopes),
             "token_type": "Bearer",
-            "expires_in": creds.token_expiry.timestamp(),
+            "expires_in": creds.token_expiry.timestamp() - time.time(),
         }
 
 
@@ -157,16 +158,16 @@ def _async_google_creds(hass: HomeAssistant, token: dict[str, Any]) -> Credentia
         client_id=conf[CONF_CLIENT_ID],
         client_secret=conf[CONF_CLIENT_SECRET],
         refresh_token=token["refresh_token"],
-        token_expiry=token["expires_at"],
+        token_expiry=datetime.datetime.fromtimestamp(token["expires_at"]),
         token_uri=oauth2client.GOOGLE_TOKEN_URI,
         scopes=[conf[CONF_CALENDAR_ACCESS].scope],
         user_agent=None,
     )
 
 
-def _api_time_format(time: datetime.datetime | None) -> str | None:
+def _api_time_format(date_time: datetime.datetime | None) -> str | None:
     """Convert a datetime to the api string format."""
-    return time.isoformat("T") if time else None
+    return date_time.isoformat("T") if date_time else None
 
 
 class GoogleCalendarService:

homeassistant/components/google/calendar.py

@@ -183,7 +183,9 @@ class GoogleCalendarEventDevice(CalendarEventDevice):
         valid_items = filter(self._event_filter, items)
         self._event = copy.deepcopy(next(valid_items, None))
         if self._event:
-            (summary, offset) = extract_offset(self._event["summary"], self._offset)
+            (summary, offset) = extract_offset(
+                self._event.get("summary", ""), self._offset
+            )
             self._event["summary"] = summary
             self._offset_reached = is_offset_reached(
                 get_date(self._event["start"]), offset

homeassistant/components/google/config_flow.py

@@ -34,7 +34,7 @@ class OAuth2FlowHandler(
         return logging.getLogger(__name__)
 
     async def async_step_import(self, info: dict[str, Any]) -> FlowResult:
-        """Import existing auth from Nest."""
+        """Import existing auth into a new config entry."""
         if self._async_current_entries():
             return self.async_abort(reason="single_instance_allowed")
         implementations = await config_entry_oauth2_flow.async_get_implementations(

homeassistant/components/google/strings.json

@@ -6,7 +6,7 @@
       },
       "reauth_confirm": {
         "title": "[%key:common::config_flow::title::reauth%]",
-        "description": "The Nest integration needs to re-authenticate your account"
+        "description": "The Google Calendar integration needs to re-authenticate your account"
       },
       "auth": {
         "title": "Link Google Account"

homeassistant/components/google/translations/en.json

@@ -3,7 +3,7 @@
         "abort": {
             "already_configured": "Account is already configured",
             "already_in_progress": "Configuration flow is already in progress",
-            "code_expired": "Authentication code expired, please try again.",
+            "code_expired": "Authentication code expired or credential setup is invalid, please try again.",
             "invalid_access_token": "Invalid access token",
             "missing_configuration": "The component is not configured. Please follow the documentation.",
             "oauth_error": "Received invalid token data.",
@@ -23,7 +23,7 @@
                 "title": "Pick Authentication Method"
             },
             "reauth_confirm": {
-                "description": "The Nest integration needs to re-authenticate your account",
+                "description": "The Google Calendar integration needs to re-authenticate your account",
                 "title": "Reauthenticate Integration"
             }
         }

homeassistant/components/group/__init__.py

@@ -454,7 +454,7 @@ class GroupEntity(Entity):
             self.async_update_group_state()
             self.async_write_ha_state()
 
-        start.async_at_start(self.hass, _update_at_start)
+        self.async_on_remove(start.async_at_start(self.hass, _update_at_start))
 
     @callback
     def async_defer_or_update_ha_state(self) -> None:
@@ -689,7 +689,7 @@ class Group(Entity):
 
     async def async_added_to_hass(self):
         """Handle addition to Home Assistant."""
-        start.async_at_start(self.hass, self._async_start)
+        self.async_on_remove(start.async_at_start(self.hass, self._async_start))
 
     async def async_will_remove_from_hass(self):
         """Handle removal from Home Assistant."""

homeassistant/components/hangouts/manifest.json

@@ -3,7 +3,7 @@
   "name": "Google Chat",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/hangouts",
-  "requirements": ["hangups==0.4.17"],
+  "requirements": ["hangups==0.4.18"],
   "codeowners": [],
   "iot_class": "cloud_push",
   "loggers": ["hangups", "urwid"]

homeassistant/components/hassio/__init__.py

@@ -42,7 +42,7 @@ from homeassistant.helpers.device_registry import (
 )
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.loader import bind_hass
 from homeassistant.util.dt import utcnow
 
@@ -609,21 +609,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
             DOMAIN, service, async_service_handler, schema=settings.schema
         )
 
-    async def update_addon_stats(slug):
-        """Update single addon stats."""
-        stats = await hassio.get_addon_stats(slug)
-        return (slug, stats)
-
-    async def update_addon_changelog(slug):
-        """Return the changelog for an add-on."""
-        changelog = await hassio.get_addon_changelog(slug)
-        return (slug, changelog)
-
-    async def update_addon_info(slug):
-        """Return the info for an add-on."""
-        info = await hassio.get_addon_info(slug)
-        return (slug, info)
-
     async def update_info_data(now):
         """Update last available supervisor information."""
 
@@ -644,28 +629,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
                 hassio.get_os_info(),
             )
 
-            addons = [
-                addon
-                for addon in hass.data[DATA_SUPERVISOR_INFO].get("addons", [])
-                if addon[ATTR_STATE] == ATTR_STARTED
-            ]
-            stats_data = await asyncio.gather(
-                *[update_addon_stats(addon[ATTR_SLUG]) for addon in addons]
-            )
-            hass.data[DATA_ADDONS_STATS] = dict(stats_data)
-            hass.data[DATA_ADDONS_CHANGELOGS] = dict(
-                await asyncio.gather(
-                    *[update_addon_changelog(addon[ATTR_SLUG]) for addon in addons]
-                )
-            )
-            hass.data[DATA_ADDONS_INFO] = dict(
-                await asyncio.gather(
-                    *[update_addon_info(addon[ATTR_SLUG]) for addon in addons]
-                )
-            )
-
-            if ADDONS_COORDINATOR in hass.data:
-                await hass.data[ADDONS_COORDINATOR].async_refresh()
         except HassioAPIError as err:
             _LOGGER.warning("Can't read Supervisor data: %s", err)
 
@@ -748,7 +711,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     dev_reg = await async_get_registry(hass)
     coordinator = HassioDataUpdateCoordinator(hass, entry, dev_reg)
     hass.data[ADDONS_COORDINATOR] = coordinator
-    await coordinator.async_refresh()
+    await coordinator.async_config_entry_first_refresh()
 
     hass.config_entries.async_setup_platforms(entry, PLATFORMS)
 
@@ -855,16 +818,21 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
             hass,
             _LOGGER,
             name=DOMAIN,
-            update_method=self._async_update_data,
+            update_interval=HASSIO_UPDATE_INTERVAL,
         )
         self.hassio: HassIO = hass.data[DOMAIN]
         self.data = {}
         self.entry_id = config_entry.entry_id
         self.dev_reg = dev_reg
-        self.is_hass_os = "hassos" in get_info(self.hass)
+        self.is_hass_os = (get_info(self.hass) or {}).get("hassos") is not None
 
     async def _async_update_data(self) -> dict[str, Any]:
         """Update data via library."""
+        try:
+            await self.force_data_refresh()
+        except HassioAPIError as err:
+            raise UpdateFailed(f"Error on Supervisor API: {err}") from err
+
         new_data = {}
         supervisor_info = get_supervisor_info(self.hass)
         addons_info = get_addons_info(self.hass)
@@ -880,8 +848,8 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
         new_data[DATA_KEY_ADDONS] = {
             addon[ATTR_SLUG]: {
                 **addon,
-                **((addons_stats or {}).get(addon[ATTR_SLUG], {})),
-                ATTR_AUTO_UPDATE: addons_info.get(addon[ATTR_SLUG], {}).get(
+                **((addons_stats or {}).get(addon[ATTR_SLUG]) or {}),
+                ATTR_AUTO_UPDATE: (addons_info.get(addon[ATTR_SLUG]) or {}).get(
                     ATTR_AUTO_UPDATE, False
                 ),
                 ATTR_CHANGELOG: (addons_changelogs or {}).get(addon[ATTR_SLUG]),
@@ -923,6 +891,12 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
         if stale_addons := supervisor_addon_devices - set(new_data[DATA_KEY_ADDONS]):
             async_remove_addons_from_dev_reg(self.dev_reg, stale_addons)
 
+        if not self.is_hass_os and (
+            dev := self.dev_reg.async_get_device({(DOMAIN, "OS")})
+        ):
+            # Remove the OS device if it exists and the installation is not hassos
+            self.dev_reg.async_remove_device(dev.id)
+
         # If there are new add-ons, we should reload the config entry so we can
         # create new devices and entities. We can return an empty dict because
         # coordinator will be recreated.
@@ -940,3 +914,79 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
         """Force update of the supervisor info."""
         self.hass.data[DATA_SUPERVISOR_INFO] = await self.hassio.get_supervisor_info()
         await self.async_refresh()
+
+    async def force_data_refresh(self) -> None:
+        """Force update of the addon info."""
+        (
+            self.hass.data[DATA_INFO],
+            self.hass.data[DATA_CORE_INFO],
+            self.hass.data[DATA_SUPERVISOR_INFO],
+            self.hass.data[DATA_OS_INFO],
+        ) = await asyncio.gather(
+            self.hassio.get_info(),
+            self.hassio.get_core_info(),
+            self.hassio.get_supervisor_info(),
+            self.hassio.get_os_info(),
+        )
+
+        addons = [
+            addon
+            for addon in self.hass.data[DATA_SUPERVISOR_INFO].get("addons", [])
+            if addon[ATTR_STATE] == ATTR_STARTED
+        ]
+        stats_data = await asyncio.gather(
+            *[self._update_addon_stats(addon[ATTR_SLUG]) for addon in addons]
+        )
+        self.hass.data[DATA_ADDONS_STATS] = dict(stats_data)
+        self.hass.data[DATA_ADDONS_CHANGELOGS] = dict(
+            await asyncio.gather(
+                *[self._update_addon_changelog(addon[ATTR_SLUG]) for addon in addons]
+            )
+        )
+        self.hass.data[DATA_ADDONS_INFO] = dict(
+            await asyncio.gather(
+                *[self._update_addon_info(addon[ATTR_SLUG]) for addon in addons]
+            )
+        )
+
+    async def _update_addon_stats(self, slug):
+        """Update single addon stats."""
+        try:
+            stats = await self.hassio.get_addon_stats(slug)
+            return (slug, stats)
+        except HassioAPIError as err:
+            _LOGGER.warning("Could not fetch stats for %s: %s", slug, err)
+        return (slug, None)
+
+    async def _update_addon_changelog(self, slug):
+        """Return the changelog for an add-on."""
+        try:
+            changelog = await self.hassio.get_addon_changelog(slug)
+            return (slug, changelog)
+        except HassioAPIError as err:
+            _LOGGER.warning("Could not fetch changelog for %s: %s", slug, err)
+        return (slug, None)
+
+    async def _update_addon_info(self, slug):
+        """Return the info for an add-on."""
+        try:
+            info = await self.hassio.get_addon_info(slug)
+            return (slug, info)
+        except HassioAPIError as err:
+            _LOGGER.warning("Could not fetch info for %s: %s", slug, err)
+        return (slug, None)
+
+    async def _async_refresh(
+        self,
+        log_failures: bool = True,
+        raise_on_auth_failed: bool = False,
+        scheduled: bool = False,
+    ) -> None:
+        """Refresh data."""
+        if not scheduled:
+            # Force refreshing updates for non-scheduled updates
+            try:
+                await self.hassio.refresh_updates()
+            except HassioAPIError as err:
+                _LOGGER.warning("Error on Supervisor API: %s", err)
+        await super()._async_refresh(log_failures, raise_on_auth_failed, scheduled)

homeassistant/components/hassio/entity.py

@@ -90,7 +90,7 @@ class HassioSupervisorEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
         """Return True if entity is available."""
         return (
             super().available
-            and DATA_KEY_OS in self.coordinator.data
+            and DATA_KEY_SUPERVISOR in self.coordinator.data
             and self.entity_description.key
             in self.coordinator.data[DATA_KEY_SUPERVISOR]
         )

homeassistant/components/hassio/handler.py

@@ -168,6 +168,14 @@ class HassIO:
         """
         return self.send_command("/homeassistant/stop")
 
+    @_api_bool
+    def refresh_updates(self):
+        """Refresh available updates.
+
+        This method return a coroutine.
+        """
+        return self.send_command("/refresh_updates", timeout=None)
+
     @api_data
     def retrieve_discovery_messages(self):
         """Return all discovery data from Hass.io API.

homeassistant/components/here_travel_time/sensor.py

@@ -247,7 +247,7 @@ class HERETravelTimeSensor(SensorEntity, CoordinatorEntity):
         async def _update_at_start(_):
             await self.async_update()
 
-        async_at_start(self.hass, _update_at_start)
+        self.async_on_remove(async_at_start(self.hass, _update_at_start))
 
     @property
     def native_value(self) -> str | None:

homeassistant/components/home_connect/api.py

@@ -312,7 +312,6 @@ class Dishwasher(
     """Dishwasher class."""
 
     PROGRAMS = [
-        {"name": "Dishcare.Dishwasher.Program.PreRinse"},
         {"name": "Dishcare.Dishwasher.Program.Auto1"},
         {"name": "Dishcare.Dishwasher.Program.Auto2"},
         {"name": "Dishcare.Dishwasher.Program.Auto3"},

homeassistant/components/homekit/config_flow.py

@@ -652,7 +652,7 @@ def _exclude_by_entity_registry(
         (entry := ent_reg.async_get(entity_id))
         and (
             entry.hidden_by is not None
-            or (not include_entity_category or entry.entity_category is not None)
+            or (not include_entity_category and entry.entity_category is not None)
         )
     )
 

homeassistant/components/homekit_controller/binary_sensor.py

@@ -63,7 +63,7 @@ class HomeKitSmokeSensor(HomeKitEntity, BinarySensorEntity):
 class HomeKitCarbonMonoxideSensor(HomeKitEntity, BinarySensorEntity):
     """Representation of a Homekit BO sensor."""
 
-    _attr_device_class = BinarySensorDeviceClass.GAS
+    _attr_device_class = BinarySensorDeviceClass.CO
 
     def get_characteristic_types(self) -> list[str]:
         """Define the homekit characteristics the entity is tracking."""

homeassistant/components/homekit_controller/config_flow.py

@@ -293,7 +293,10 @@ class HomekitControllerFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
         self._abort_if_unique_id_configured(updates=updated_ip_port)
 
         for progress in self._async_in_progress(include_uninitialized=True):
-            if progress["context"].get("unique_id") == normalized_hkid:
+            context = progress["context"]
+            if context.get("unique_id") == normalized_hkid and not context.get(
+                "pairing"
+            ):
                 if paired:
                     # If the device gets paired, we want to dismiss
                     # an existing discovery since we can no longer
@@ -350,6 +353,7 @@ class HomekitControllerFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
             await self._async_setup_controller()
 
         if pair_info and self.finish_pairing:
+            self.context["pairing"] = True
             code = pair_info["pairing_code"]
             try:
                 code = ensure_pin_format(

homeassistant/components/humidifier/recorder.py

@@ -0,0 +1,16 @@
+"""Integration platform for recorder."""
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant, callback
+
+from . import ATTR_AVAILABLE_MODES, ATTR_MAX_HUMIDITY, ATTR_MIN_HUMIDITY
+
+
+@callback
+def exclude_attributes(hass: HomeAssistant) -> set[str]:
+    """Exclude static attributes from being recorded in the database."""
+    return {
+        ATTR_MIN_HUMIDITY,
+        ATTR_MAX_HUMIDITY,
+        ATTR_AVAILABLE_MODES,
+    }

homeassistant/components/integration/config_flow.py

@@ -39,7 +39,6 @@ UNIT_PREFIXES = [
     {"value": "M", "label": "M (mega)"},
     {"value": "G", "label": "G (giga)"},
     {"value": "T", "label": "T (tera)"},
-    {"value": "P", "label": "P (peta)"},
 ]
 TIME_UNITS = [
     {"value": TIME_SECONDS, "label": "s (seconds)"},
@@ -84,7 +83,7 @@ CONFIG_SCHEMA = vol.Schema(
             {"select": {"options": UNIT_PREFIXES}}
         ),
         vol.Required(CONF_UNIT_TIME, default=TIME_HOURS): selector.selector(
-            {"select": {"options": TIME_UNITS}}
+            {"select": {"options": TIME_UNITS, "mode": "dropdown"}}
         ),
     }
 )

homeassistant/components/integration/sensor.py

@@ -253,8 +253,10 @@ class IntegrationSensor(RestoreEntity, SensorEntity):
                     self._state = integral
                 self.async_write_ha_state()
 
-        async_track_state_change_event(
-            self.hass, [self._sensor_source_id], calc_integration
+        self.async_on_remove(
+            async_track_state_change_event(
+                self.hass, [self._sensor_source_id], calc_integration
+            )
         )
 
     @property

homeassistant/components/integration/strings.json

@@ -1,26 +1,34 @@
 {
+  "title": "Integration - Riemann sum integral sensor",
   "config": {
     "step": {
       "user": {
-        "title": "New Integration sensor",
-        "description": "Precision controls the number of decimal digits in the output.\nThe sum will be scaled according to the selected metric prefix and integration time.",
+        "title": "Add Riemann sum integral sensor",
+        "description": "Create a sensor that calculates a Riemann sum to estimate the integral of a sensor.",
         "data": {
           "method": "Integration method",
           "name": "Name",
           "round": "Precision",
           "source": "Input sensor",
           "unit_prefix": "Metric prefix",
-          "unit_time": "Integration time"
+          "unit_time": "Time unit"
+        },
+        "data_description": {
+          "round": "Controls the number of decimal digits in the output.",
+          "unit_prefix": "The output will be scaled according to the selected metric prefix.",
+          "unit_time": "The output will be scaled according to the selected time unit."
         }
       }
     }
   },
   "options": {
     "step": {
-      "options": {
-        "description": "Precision controls the number of decimal digits in the output.",
+      "init": {
         "data": {
           "round": "[%key:component::integration::config::step::user::data::round%]"
+        },
+        "data_description": {
+          "round": "[%key:component::integration::config::step::user::data_description::round%]"
         }
       }
     }

homeassistant/components/integration/translations/en.json

@@ -8,21 +8,29 @@
                     "round": "Precision",
                     "source": "Input sensor",
                     "unit_prefix": "Metric prefix",
-                    "unit_time": "Integration time"
+                    "unit_time": "Time unit"
                 },
-                "description": "Precision controls the number of decimal digits in the output.\nThe sum will be scaled according to the selected metric prefix and integration time.",
-                "title": "New Integration sensor"
+                "data_description": {
+                    "round": "Controls the number of decimal digits in the output.",
+                    "unit_prefix": "The output will be scaled according to the selected metric prefix.",
+                    "unit_time": "The output will be scaled according to the selected time unit."
+                },
+                "description": "Create a sensor that calculates a Riemann sum to estimate the integral of a sensor.",
+                "title": "Add Riemann sum integral sensor"
             }
         }
     },
     "options": {
         "step": {
-            "options": {
+            "init": {
                 "data": {
                     "round": "Precision"
                 },
-                "description": "Precision controls the number of decimal digits in the output."
+                "data_description": {
+                    "round": "Controls the number of decimal digits in the output."
+                }
             }
         }
-    }
+    },
+    "title": "Integration - Riemann sum integral sensor"
 }

homeassistant/components/isy994/manifest.json

@@ -2,7 +2,7 @@
   "domain": "isy994",
   "name": "Universal Devices ISY994",
   "documentation": "https://www.home-assistant.io/integrations/isy994",
-  "requirements": ["pyisy==3.0.5"],
+  "requirements": ["pyisy==3.0.6"],
   "codeowners": ["@bdraco", "@shbatm"],
   "config_flow": true,
   "ssdp": [

homeassistant/components/knx/climate.py

@@ -296,9 +296,3 @@ class KNXClimate(KnxEntity, ClimateEntity):
         await super().async_added_to_hass()
         if self._device.mode is not None:
             self._device.mode.register_device_updated_cb(self.after_update_callback)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Disconnect device object when removed."""
-        await super().async_will_remove_from_hass()
-        if self._device.mode is not None:
-            self._device.mode.unregister_device_updated_cb(self.after_update_callback)

homeassistant/components/knx/knx_entity.py

@@ -45,4 +45,5 @@ class KnxEntity(Entity):
 
     async def async_will_remove_from_hass(self) -> None:
         """Disconnect device object when removed."""
-        self._device.unregister_device_updated_cb(self.after_update_callback)
+        # will also remove callbacks
+        self._device.shutdown()

homeassistant/components/knx/manifest.json

@@ -3,7 +3,7 @@
   "name": "KNX",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/knx",
-  "requirements": ["xknx==0.20.0"],
+  "requirements": ["xknx==0.20.3"],
   "codeowners": ["@Julius2342", "@farmio", "@marvin-w"],
   "quality_scale": "silver",
   "iot_class": "local_push",

homeassistant/components/kodi/media_player.py

@@ -448,7 +448,8 @@ class KodiEntity(MediaPlayerEntity):
                 self._connect_error = True
                 _LOGGER.warning("Unable to connect to Kodi via websocket")
             await self._clear_connection(False)
-        self._connect_error = False
+        else:
+            self._connect_error = False
 
     async def _ping(self):
         try:
@@ -458,7 +459,8 @@ class KodiEntity(MediaPlayerEntity):
                 self._connect_error = True
                 _LOGGER.warning("Unable to ping Kodi via websocket")
             await self._clear_connection()
-        self._connect_error = False
+        else:
+            self._connect_error = False
 
     async def _async_connect_websocket_if_disconnected(self, *_):
         """Reconnect the websocket if it fails."""

homeassistant/components/light/recorder.py

@@ -0,0 +1,22 @@
+"""Integration platform for recorder."""
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant, callback
+
+from . import (
+    ATTR_EFFECT_LIST,
+    ATTR_MAX_MIREDS,
+    ATTR_MIN_MIREDS,
+    ATTR_SUPPORTED_COLOR_MODES,
+)
+
+
+@callback
+def exclude_attributes(hass: HomeAssistant) -> set[str]:
+    """Exclude static attributes from being recorded in the database."""
+    return {
+        ATTR_SUPPORTED_COLOR_MODES,
+        ATTR_EFFECT_LIST,
+        ATTR_MIN_MIREDS,
+        ATTR_MAX_MIREDS,
+    }

homeassistant/components/mazda/manifest.json

@@ -3,7 +3,7 @@
   "name": "Mazda Connected Services",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/mazda",
-  "requirements": ["pymazda==0.3.2"],
+  "requirements": ["pymazda==0.3.3"],
   "codeowners": ["@bdr99"],
   "quality_scale": "platinum",
   "iot_class": "cloud_polling",

homeassistant/components/media_player/__init__.py

@@ -70,6 +70,7 @@ from .browse_media import BrowseMedia, async_process_play_media_url  # noqa: F40
 from .const import (  # noqa: F401
     ATTR_APP_ID,
     ATTR_APP_NAME,
+    ATTR_ENTITY_PICTURE_LOCAL,
     ATTR_GROUP_MEMBERS,
     ATTR_INPUT_SOURCE,
     ATTR_INPUT_SOURCE_LIST,
@@ -936,7 +937,7 @@ class MediaPlayerEntity(Entity):
                 state_attr[attr] = value
 
         if self.media_image_remotely_accessible:
-            state_attr["entity_picture_local"] = self.media_image_local
+            state_attr[ATTR_ENTITY_PICTURE_LOCAL] = self.media_image_local
 
         return state_attr
 

homeassistant/components/media_player/browse_media.py

@@ -32,6 +32,9 @@ def async_process_play_media_url(
     """Update a media URL with authentication if it points at Home Assistant."""
     parsed = yarl.URL(media_content_id)
 
+    if parsed.scheme and parsed.scheme not in ("http", "https"):
+        return media_content_id
+
     if parsed.is_absolute():
         if not is_hass_url(hass, media_content_id):
             return media_content_id

homeassistant/components/media_player/const.py

@@ -1,9 +1,12 @@
 """Provides the constants needed for component."""
+from enum import IntEnum
+
 # How long our auth signature on the content should be valid for
 CONTENT_AUTH_EXPIRY_TIME = 3600 * 24
 
 ATTR_APP_ID = "app_id"
 ATTR_APP_NAME = "app_name"
+ATTR_ENTITY_PICTURE_LOCAL = "entity_picture_local"
 ATTR_GROUP_MEMBERS = "group_members"
 ATTR_INPUT_SOURCE = "source"
 ATTR_INPUT_SOURCE_LIST = "source_list"
@@ -89,6 +92,32 @@ REPEAT_MODE_OFF = "off"
 REPEAT_MODE_ONE = "one"
 REPEAT_MODES = [REPEAT_MODE_OFF, REPEAT_MODE_ALL, REPEAT_MODE_ONE]
 
+
+class MediaPlayerEntityFeature(IntEnum):
+    """Supported features of the media player entity."""
+
+    PAUSE = 1
+    SEEK = 2
+    VOLUME_SET = 4
+    VOLUME_MUTE = 8
+    PREVIOUS_TRACK = 16
+    NEXT_TRACK = 32
+
+    TURN_ON = 128
+    TURN_OFF = 256
+    PLAY_MEDIA = 512
+    VOLUME_STEP = 1024
+    SELECT_SOURCE = 2048
+    STOP = 4096
+    CLEAR_PLAYLIST = 8192
+    PLAY = 16384
+    SHUFFLE_SET = 32768
+    SELECT_SOUND_MODE = 65536
+    BROWSE_MEDIA = 131072
+    REPEAT_SET = 262144
+    GROUPING = 524288
+
+
 SUPPORT_PAUSE = 1
 SUPPORT_SEEK = 2
 SUPPORT_VOLUME_SET = 4

homeassistant/components/media_player/recorder.py

@@ -0,0 +1,26 @@
+"""Integration platform for recorder."""
+from __future__ import annotations
+
+from homeassistant.const import ATTR_ENTITY_PICTURE
+from homeassistant.core import HomeAssistant, callback
+
+from . import (
+    ATTR_ENTITY_PICTURE_LOCAL,
+    ATTR_INPUT_SOURCE_LIST,
+    ATTR_MEDIA_POSITION,
+    ATTR_MEDIA_POSITION_UPDATED_AT,
+    ATTR_SOUND_MODE_LIST,
+)
+
+
+@callback
+def exclude_attributes(hass: HomeAssistant) -> set[str]:
+    """Exclude static and token attributes from being recorded in the database."""
+    return {
+        ATTR_ENTITY_PICTURE_LOCAL,
+        ATTR_ENTITY_PICTURE,
+        ATTR_INPUT_SOURCE_LIST,
+        ATTR_MEDIA_POSITION_UPDATED_AT,
+        ATTR_MEDIA_POSITION,
+        ATTR_SOUND_MODE_LIST,
+    }

homeassistant/components/media_player/reproduce_state.py

@@ -6,6 +6,7 @@ from collections.abc import Iterable
 from typing import Any
 
 from homeassistant.const import (
+    ATTR_SUPPORTED_FEATURES,
     SERVICE_MEDIA_PAUSE,
     SERVICE_MEDIA_PLAY,
     SERVICE_MEDIA_STOP,
@@ -33,6 +34,7 @@ from .const import (
     SERVICE_PLAY_MEDIA,
     SERVICE_SELECT_SOUND_MODE,
     SERVICE_SELECT_SOURCE,
+    MediaPlayerEntityFeature,
 )
 
 # mypy: allow-untyped-defs
@@ -46,6 +48,8 @@ async def _async_reproduce_states(
     reproduce_options: dict[str, Any] | None = None,
 ) -> None:
     """Reproduce component states."""
+    cur_state = hass.states.get(state.entity_id)
+    features = cur_state.attributes[ATTR_SUPPORTED_FEATURES] if cur_state else 0
 
     async def call_service(service: str, keys: Iterable) -> None:
         """Call service with set of attributes given."""
@@ -59,47 +63,75 @@ async def _async_reproduce_states(
         )
 
     if state.state == STATE_OFF:
-        await call_service(SERVICE_TURN_OFF, [])
+        if features & MediaPlayerEntityFeature.TURN_OFF:
+            await call_service(SERVICE_TURN_OFF, [])
         # entities that are off have no other attributes to restore
         return
 
-    if state.state in (
-        STATE_ON,
-        STATE_PLAYING,
-        STATE_IDLE,
-        STATE_PAUSED,
+    if (
+        state.state
+        in (
+            STATE_ON,
+            STATE_PLAYING,
+            STATE_IDLE,
+            STATE_PAUSED,
+        )
+        and features & MediaPlayerEntityFeature.TURN_ON
     ):
         await call_service(SERVICE_TURN_ON, [])
 
-    if ATTR_MEDIA_VOLUME_LEVEL in state.attributes:
-        await call_service(SERVICE_VOLUME_SET, [ATTR_MEDIA_VOLUME_LEVEL])
+    cur_state = hass.states.get(state.entity_id)
+    features = cur_state.attributes[ATTR_SUPPORTED_FEATURES] if cur_state else 0
 
-    if ATTR_MEDIA_VOLUME_MUTED in state.attributes:
-        await call_service(SERVICE_VOLUME_MUTE, [ATTR_MEDIA_VOLUME_MUTED])
-
-    if ATTR_INPUT_SOURCE in state.attributes:
+    # First set source & sound mode to match the saved supported features
+    if (
+        ATTR_INPUT_SOURCE in state.attributes
+        and features & MediaPlayerEntityFeature.SELECT_SOURCE
+    ):
         await call_service(SERVICE_SELECT_SOURCE, [ATTR_INPUT_SOURCE])
 
-    if ATTR_SOUND_MODE in state.attributes:
+    if (
+        ATTR_SOUND_MODE in state.attributes
+        and features & MediaPlayerEntityFeature.SELECT_SOUND_MODE
+    ):
         await call_service(SERVICE_SELECT_SOUND_MODE, [ATTR_SOUND_MODE])
 
+    if (
+        ATTR_MEDIA_VOLUME_LEVEL in state.attributes
+        and features & MediaPlayerEntityFeature.VOLUME_SET
+    ):
+        await call_service(SERVICE_VOLUME_SET, [ATTR_MEDIA_VOLUME_LEVEL])
+
+    if (
+        ATTR_MEDIA_VOLUME_MUTED in state.attributes
+        and features & MediaPlayerEntityFeature.VOLUME_MUTE
+    ):
+        await call_service(SERVICE_VOLUME_MUTE, [ATTR_MEDIA_VOLUME_MUTED])
+
     already_playing = False
 
     if (ATTR_MEDIA_CONTENT_TYPE in state.attributes) and (
         ATTR_MEDIA_CONTENT_ID in state.attributes
     ):
-        await call_service(
-            SERVICE_PLAY_MEDIA,
-            [ATTR_MEDIA_CONTENT_TYPE, ATTR_MEDIA_CONTENT_ID, ATTR_MEDIA_ENQUEUE],
-        )
+        if features & MediaPlayerEntityFeature.PLAY_MEDIA:
+            await call_service(
+                SERVICE_PLAY_MEDIA,
+                [ATTR_MEDIA_CONTENT_TYPE, ATTR_MEDIA_CONTENT_ID, ATTR_MEDIA_ENQUEUE],
+            )
         already_playing = True
 
-    if state.state == STATE_PLAYING and not already_playing:
+    if (
+        not already_playing
+        and state.state == STATE_PLAYING
+        and features & MediaPlayerEntityFeature.PLAY
+    ):
         await call_service(SERVICE_MEDIA_PLAY, [])
     elif state.state == STATE_IDLE:
-        await call_service(SERVICE_MEDIA_STOP, [])
+        if features & MediaPlayerEntityFeature.STOP:
+            await call_service(SERVICE_MEDIA_STOP, [])
     elif state.state == STATE_PAUSED:
-        await call_service(SERVICE_MEDIA_PAUSE, [])
+        if features & MediaPlayerEntityFeature.PAUSE:
+            await call_service(SERVICE_MEDIA_PAUSE, [])
 
 
 async def async_reproduce_states(

homeassistant/components/met/__init__.py

@@ -21,6 +21,7 @@ from homeassistant.const import (
     Platform,
 )
 from homeassistant.core import Event, HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util.distance import convert as convert_distance
@@ -33,6 +34,7 @@ from .const import (
     DOMAIN,
 )
 
+# Dedicated Home Assistant endpoint - do not change!
 URL = "https://aa015h6buqvih86i1.api.met.no/weatherapi/locationforecast/2.0/complete"
 
 PLATFORMS = [Platform.WEATHER]
@@ -82,6 +84,10 @@ async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
     return unload_ok
 
 
+class CannotConnect(HomeAssistantError):
+    """Unable to connect to the web site."""
+
+
 class MetDataUpdateCoordinator(DataUpdateCoordinator["MetWeatherData"]):
     """Class to manage fetching Met data."""
 
@@ -173,7 +179,9 @@ class MetWeatherData:
 
     async def fetch_data(self) -> MetWeatherData:
         """Fetch data from API - (current weather and forecast)."""
-        await self._weather_data.fetching_data()
+        resp = await self._weather_data.fetching_data()
+        if not resp:
+            raise CannotConnect()
         self.current_weather_data = self._weather_data.get_current_weather()
         time_zone = dt_util.DEFAULT_TIME_ZONE
         self.daily_forecast = self._weather_data.get_forecast(time_zone, False)

homeassistant/components/microsoft_face/__init__.py

@@ -10,6 +10,7 @@ from aiohttp.hdrs import CONTENT_TYPE
 import async_timeout
 import voluptuous as vol
 
+from homeassistant.components import camera
 from homeassistant.const import ATTR_NAME, CONF_API_KEY, CONF_TIMEOUT, CONTENT_TYPE_JSON
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import HomeAssistantError
@@ -181,7 +182,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         p_id = face.store[g_id].get(service.data[ATTR_PERSON])
 
         camera_entity = service.data[ATTR_CAMERA_ENTITY]
-        camera = hass.components.camera
 
         try:
             image = await camera.async_get_image(hass, camera_entity)

homeassistant/components/min_max/config_flow.py

@@ -16,7 +16,14 @@ from homeassistant.helpers.schema_config_entry_flow import (
 
 from .const import CONF_ENTITY_IDS, CONF_ROUND_DIGITS, DOMAIN
 
-_STATISTIC_MEASURES = ["last", "max", "mean", "min", "median"]
+_STATISTIC_MEASURES = [
+    {"value": "min", "label": "Minimum"},
+    {"value": "max", "label": "Maximum"},
+    {"value": "mean", "label": "Arithmetic mean"},
+    {"value": "median", "label": "Median"},
+    {"value": "last", "label": "Most recently updated"},
+]
+
 
 OPTIONS_SCHEMA = vol.Schema(
     {

homeassistant/components/min_max/strings.json

@@ -3,24 +3,30 @@
   "config": {
     "step": {
       "user": {
-        "description": "Precision controls the number of decimal digits when the statistics characteristic is mean or median.",
+        "title": "Add min / max / mean / median sensor",
+        "description": "Create a sensor that calculates a min, max, mean or median value from a list of input sensors.",
         "data": {
           "entity_ids": "Input entities",
           "name": "Name",
           "round_digits": "Precision",
           "type": "Statistic characteristic"
+        },
+        "data_description": {
+          "round_digits": "Controls the number of decimal digits in the output when the statistics characteristic is mean or median."
         }
       }
     }
   },
   "options": {
     "step": {
-      "options": {
-        "description": "[%key:component::min_max::config::step::user::description%]",
+      "init": {
         "data": {
           "entity_ids": "[%key:component::min_max::config::step::user::data::entity_ids%]",
           "round_digits": "[%key:component::min_max::config::step::user::data::round_digits%]",
           "type": "[%key:component::min_max::config::step::user::data::type%]"
+        },
+        "data_description": {
+          "round_digits": "[%key:component::min_max::config::step::user::data_description::round_digits%]"
         }
       }
     }

homeassistant/components/min_max/translations/en.json

@@ -8,19 +8,25 @@
                     "round_digits": "Precision",
                     "type": "Statistic characteristic"
                 },
-                "description": "Precision controls the number of decimal digits when the statistics characteristic is mean or median."
+                "data_description": {
+                    "round_digits": "Controls the number of decimal digits in the output when the statistics characteristic is mean or median."
+                },
+                "description": "Create a sensor that calculates a min, max, mean or median value from a list of input sensors.",
+                "title": "Add min / max / mean / median sensor"
             }
         }
     },
     "options": {
         "step": {
-            "options": {
+            "init": {
                 "data": {
                     "entity_ids": "Input entities",
                     "round_digits": "Precision",
                     "type": "Statistic characteristic"
                 },
-                "description": "Precision controls the number of decimal digits when the statistics characteristic is mean or median."
+                "data_description": {
+                    "round_digits": "Controls the number of decimal digits in the output when the statistics characteristic is mean or median."
+                }
             }
         }
     },

homeassistant/components/motion_blinds/cover.py

@@ -155,7 +155,7 @@ async def async_setup_entry(
     platform.async_register_entity_service(
         SERVICE_SET_ABSOLUTE_POSITION,
         SET_ABSOLUTE_POSITION_SCHEMA,
-        SERVICE_SET_ABSOLUTE_POSITION,
+        "async_set_absolute_position",
     )
 
 

homeassistant/components/mpd/manifest.json

@@ -2,7 +2,7 @@
   "domain": "mpd",
   "name": "Music Player Daemon (MPD)",
   "documentation": "https://www.home-assistant.io/integrations/mpd",
-  "requirements": ["python-mpd2==3.0.4"],
+  "requirements": ["python-mpd2==3.0.5"],
   "codeowners": ["@fabaff"],
   "iot_class": "local_polling",
   "loggers": ["mpd"]

homeassistant/components/mpd/media_player.py

@@ -463,7 +463,7 @@ class MpdDevice(MediaPlayerEntity):
         if media_source.is_media_source_id(media_id):
             media_type = MEDIA_TYPE_MUSIC
             play_item = await media_source.async_resolve_media(self.hass, media_id)
-            media_id = play_item.url
+            media_id = async_process_play_media_url(self.hass, play_item.url)
 
         if media_type == MEDIA_TYPE_PLAYLIST:
             _LOGGER.debug("Playing playlist: %s", media_id)
@@ -476,8 +476,6 @@ class MpdDevice(MediaPlayerEntity):
             await self._client.load(media_id)
             await self._client.play()
         else:
-            media_id = async_process_play_media_url(self.hass, media_id)
-
             await self._client.clear()
             self._currentplaylist = None
             await self._client.add(media_id)

homeassistant/components/netgear/manifest.json

@@ -2,7 +2,7 @@
   "domain": "netgear",
   "name": "NETGEAR",
   "documentation": "https://www.home-assistant.io/integrations/netgear",
-  "requirements": ["pynetgear==0.9.2"],
+  "requirements": ["pynetgear==0.9.4"],
   "codeowners": ["@hacf-fr", "@Quentame", "@starkillerOG"],
   "iot_class": "local_polling",
   "config_flow": true,

homeassistant/components/netgear/switch.py

@@ -90,10 +90,12 @@ class NetgearAllowBlock(NetgearDeviceEntity, SwitchEntity):
     async def async_turn_on(self, **kwargs):
         """Turn the switch on."""
         await self._router.async_allow_block_device(self._mac, ALLOW)
+        await self.coordinator.async_request_refresh()
 
     async def async_turn_off(self, **kwargs):
         """Turn the switch off."""
         await self._router.async_allow_block_device(self._mac, BLOCK)
+        await self.coordinator.async_request_refresh()
 
     @callback
     def async_update_device(self) -> None:

homeassistant/components/network/__init__.py

@@ -6,11 +6,16 @@ import logging
 
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.typing import ConfigType
+from homeassistant.helpers.typing import UNDEFINED, ConfigType, UndefinedType
 from homeassistant.loader import bind_hass
 
 from . import util
-from .const import IPV4_BROADCAST_ADDR, PUBLIC_TARGET_IP
+from .const import (
+    IPV4_BROADCAST_ADDR,
+    LOOPBACK_TARGET_IP,
+    MDNS_TARGET_IP,
+    PUBLIC_TARGET_IP,
+)
 from .models import Adapter
 from .network import Network, async_get_network
 
@@ -26,7 +31,7 @@ async def async_get_adapters(hass: HomeAssistant) -> list[Adapter]:
 
 @bind_hass
 async def async_get_source_ip(
-    hass: HomeAssistant, target_ip: str = PUBLIC_TARGET_IP
+    hass: HomeAssistant, target_ip: str | UndefinedType = UNDEFINED
 ) -> str:
     """Get the source ip for a target ip."""
     adapters = await async_get_adapters(hass)
@@ -35,7 +40,15 @@ async def async_get_source_ip(
         if adapter["enabled"] and (ipv4s := adapter["ipv4"]):
             all_ipv4s.extend([ipv4["address"] for ipv4 in ipv4s])
 
-    source_ip = util.async_get_source_ip(target_ip)
+    if target_ip is UNDEFINED:
+        source_ip = (
+            util.async_get_source_ip(PUBLIC_TARGET_IP)
+            or util.async_get_source_ip(MDNS_TARGET_IP)
+            or util.async_get_source_ip(LOOPBACK_TARGET_IP)
+        )
+    else:
+        source_ip = util.async_get_source_ip(target_ip)
+
     if not all_ipv4s:
         _LOGGER.warning(
             "Because the system does not have any enabled IPv4 addresses, source address detection may be inaccurate"

homeassistant/components/network/const.py

@@ -17,6 +17,7 @@ ATTR_ADAPTERS: Final = "adapters"
 ATTR_CONFIGURED_ADAPTERS: Final = "configured_adapters"
 DEFAULT_CONFIGURED_ADAPTERS: list[str] = []
 
+LOOPBACK_TARGET_IP: Final = "127.0.0.1"
 MDNS_TARGET_IP: Final = "224.0.0.251"
 PUBLIC_TARGET_IP: Final = "8.8.8.8"
 IPV4_BROADCAST_ADDR: Final = "255.255.255.255"

homeassistant/components/nina/manifest.json

@@ -3,7 +3,7 @@
   "name": "NINA",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/nina",
-  "requirements": ["pynina==0.1.7"],
+  "requirements": ["pynina==0.1.8"],
   "dependencies": [],
   "codeowners": ["@DeerMaximum"],
   "iot_class": "cloud_polling",

homeassistant/components/number/recorder.py

@@ -0,0 +1,17 @@
+"""Integration platform for recorder."""
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant, callback
+
+from . import ATTR_MAX, ATTR_MIN, ATTR_MODE, ATTR_STEP
+
+
+@callback
+def exclude_attributes(hass: HomeAssistant) -> set[str]:
+    """Exclude static attributes from being recorded in the database."""
+    return {
+        ATTR_MIN,
+        ATTR_MAX,
+        ATTR_STEP,
+        ATTR_MODE,
+    }

homeassistant/components/onvif/device.py

@@ -204,9 +204,10 @@ class ONVIFDevice:
 
                 if self._dt_diff_seconds > 5:
                     LOGGER.warning(
-                        "The date/time on the device (UTC) is '%s', "
+                        "The date/time on %s (UTC) is '%s', "
                         "which is different from the system '%s', "
                         "this could lead to authentication issues",
+                        self.name,
                         cam_date_utc,
                         system_date,
                     )

homeassistant/components/openhome/manifest.json

@@ -2,7 +2,7 @@
   "domain": "openhome",
   "name": "Linn / OpenHome",
   "documentation": "https://www.home-assistant.io/integrations/openhome",
-  "requirements": ["openhomedevice==2.0.1"],
+  "requirements": ["openhomedevice==2.0.2"],
   "codeowners": ["@bazwilliams"],
   "iot_class": "local_polling",
   "loggers": ["async_upnp_client", "openhomedevice"]

homeassistant/components/overkiz/alarm_control_panel.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import cast
+from typing import Any, cast
 
 from pyoverkiz.enums import OverkizCommand, OverkizCommandParam, OverkizState
 from pyoverkiz.enums.ui import UIWidget
@@ -55,15 +55,15 @@ class OverkizAlarmDescription(
     """Class to describe an Overkiz alarm control panel."""
 
     alarm_disarm: str | None = None
-    alarm_disarm_args: OverkizStateType | list[OverkizStateType] = []
+    alarm_disarm_args: OverkizStateType | list[OverkizStateType] = None
     alarm_arm_home: str | None = None
-    alarm_arm_home_args: OverkizStateType | list[OverkizStateType] = []
+    alarm_arm_home_args: OverkizStateType | list[OverkizStateType] = None
     alarm_arm_night: str | None = None
-    alarm_arm_night_args: OverkizStateType | list[OverkizStateType] = []
+    alarm_arm_night_args: OverkizStateType | list[OverkizStateType] = None
     alarm_arm_away: str | None = None
-    alarm_arm_away_args: OverkizStateType | list[OverkizStateType] = []
+    alarm_arm_away_args: OverkizStateType | list[OverkizStateType] = None
     alarm_trigger: str | None = None
-    alarm_trigger_args: OverkizStateType | list[OverkizStateType] = []
+    alarm_trigger_args: OverkizStateType | list[OverkizStateType] = None
 
 
 MAP_INTERNAL_STATUS_STATE: dict[str, str] = {
@@ -266,7 +266,7 @@ class OverkizAlarmControlPanel(OverkizDescriptiveEntity, AlarmControlPanelEntity
     async def async_alarm_disarm(self, code: str | None = None) -> None:
         """Send disarm command."""
         assert self.entity_description.alarm_disarm
-        await self.executor.async_execute_command(
+        await self.async_execute_command(
             self.entity_description.alarm_disarm,
             self.entity_description.alarm_disarm_args,
         )
@@ -274,7 +274,7 @@ class OverkizAlarmControlPanel(OverkizDescriptiveEntity, AlarmControlPanelEntity
     async def async_alarm_arm_home(self, code: str | None = None) -> None:
         """Send arm home command."""
         assert self.entity_description.alarm_arm_home
-        await self.executor.async_execute_command(
+        await self.async_execute_command(
             self.entity_description.alarm_arm_home,
             self.entity_description.alarm_arm_home_args,
         )
@@ -282,7 +282,7 @@ class OverkizAlarmControlPanel(OverkizDescriptiveEntity, AlarmControlPanelEntity
     async def async_alarm_arm_night(self, code: str | None = None) -> None:
         """Send arm night command."""
         assert self.entity_description.alarm_arm_night
-        await self.executor.async_execute_command(
+        await self.async_execute_command(
             self.entity_description.alarm_arm_night,
             self.entity_description.alarm_arm_night_args,
         )
@@ -290,7 +290,7 @@ class OverkizAlarmControlPanel(OverkizDescriptiveEntity, AlarmControlPanelEntity
     async def async_alarm_arm_away(self, code: str | None = None) -> None:
         """Send arm away command."""
         assert self.entity_description.alarm_arm_away
-        await self.executor.async_execute_command(
+        await self.async_execute_command(
             self.entity_description.alarm_arm_away,
             self.entity_description.alarm_arm_away_args,
         )
@@ -298,7 +298,14 @@ class OverkizAlarmControlPanel(OverkizDescriptiveEntity, AlarmControlPanelEntity
     async def async_alarm_trigger(self, code: str | None = None) -> None:
         """Send alarm trigger command."""
         assert self.entity_description.alarm_trigger
-        await self.executor.async_execute_command(
+        await self.async_execute_command(
             self.entity_description.alarm_trigger,
             self.entity_description.alarm_trigger_args,
         )
+
+    async def async_execute_command(self, command_name: str, args: Any) -> None:
+        """Execute device command in async context."""
+        if args:
+            await self.executor.async_execute_command(command_name, args)
+        else:
+            await self.executor.async_execute_command(command_name)

homeassistant/components/overkiz/select.py

@@ -39,8 +39,7 @@ def _select_option_open_closed_pedestrian(
             OverkizCommandParam.CLOSED: OverkizCommand.CLOSE,
             OverkizCommandParam.OPEN: OverkizCommand.OPEN,
             OverkizCommandParam.PEDESTRIAN: OverkizCommand.SET_PEDESTRIAN_POSITION,
-        }[OverkizCommandParam(option)],
-        None,
+        }[OverkizCommandParam(option)]
     )
 
 

homeassistant/components/plaato/manifest.json

@@ -6,7 +6,7 @@
   "dependencies": ["webhook"],
   "after_dependencies": ["cloud"],
   "codeowners": ["@JohNan"],
-  "requirements": ["pyplaato==0.0.15"],
+  "requirements": ["pyplaato==0.0.16"],
   "iot_class": "cloud_push",
   "loggers": ["pyplaato"]
 }

homeassistant/components/plex/__init__.py

@@ -159,7 +159,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             entry.data[CONF_SERVER],
             error,
         )
-        return False
+        # Retry as setups behind a proxy can return transient 404 or 502 errors
+        raise ConfigEntryNotReady from error
 
     _LOGGER.debug(
         "Connected to: %s (%s)", plex_server.friendly_name, plex_server.url_in_use

homeassistant/components/plex/services.py

@@ -173,7 +173,9 @@ def process_plex_payload(
     media = plex_server.lookup_media(content_type, **search_query)
 
     if supports_playqueues and (isinstance(media, list) or shuffle):
-        playqueue = plex_server.create_playqueue(media, shuffle=shuffle)
+        playqueue = plex_server.create_playqueue(
+            media, includeRelated=0, shuffle=shuffle
+        )
         return PlexMediaSearchResult(playqueue, content)
 
     return PlexMediaSearchResult(media, content)

homeassistant/components/plugwise/manifest.json

@@ -2,7 +2,7 @@
   "domain": "plugwise",
   "name": "Plugwise",
   "documentation": "https://www.home-assistant.io/integrations/plugwise",
-  "requirements": ["plugwise==0.17.2"],
+  "requirements": ["plugwise==0.17.3"],
   "codeowners": ["@CoMPaTech", "@bouwew", "@brefra", "@frenck"],
   "zeroconf": ["_plugwise._tcp.local."],
   "config_flow": true,

homeassistant/components/powerwall/__init__.py

@@ -162,6 +162,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         _LOGGER.debug("Authentication failed", exc_info=err)
         http_session.close()
         raise ConfigEntryAuthFailed from err
+    except APIError as err:
+        http_session.close()
+        raise ConfigEntryNotReady from err
 
     gateway_din = base_info.gateway_din
     if gateway_din and entry.unique_id is not None and is_ip_address(entry.unique_id):
@@ -223,13 +226,18 @@ def call_base_info(power_wall: Powerwall, host: str) -> PowerwallBaseInfo:
 
 def _fetch_powerwall_data(power_wall: Powerwall) -> PowerwallData:
     """Process and update powerwall data."""
+    try:
+        backup_reserve = power_wall.get_backup_reserve_percentage()
+    except MissingAttributeError:
+        backup_reserve = None
+
     return PowerwallData(
         charge=power_wall.get_charge(),
         site_master=power_wall.get_sitemaster(),
         meters=power_wall.get_meters(),
         grid_services_active=power_wall.is_grid_services_active(),
         grid_status=power_wall.get_grid_status(),
-        backup_reserve=power_wall.get_backup_reserve_percentage(),
+        backup_reserve=backup_reserve,
     )
 
 

homeassistant/components/powerwall/models.py

@@ -38,7 +38,7 @@ class PowerwallData:
     meters: MetersAggregates
     grid_services_active: bool
     grid_status: GridStatus
-    backup_reserve: float
+    backup_reserve: float | None
 
 
 class PowerwallRuntimeData(TypedDict):

homeassistant/components/powerwall/sensor.py

@@ -117,9 +117,11 @@ async def async_setup_entry(
     data: PowerwallData = coordinator.data
     entities: list[PowerWallEntity] = [
         PowerWallChargeSensor(powerwall_data),
-        PowerWallBackupReserveSensor(powerwall_data),
     ]
 
+    if data.backup_reserve is not None:
+        entities.append(PowerWallBackupReserveSensor(powerwall_data))
+
     for meter in data.meters.meters:
         entities.append(PowerWallExportSensor(powerwall_data, meter))
         entities.append(PowerWallImportSensor(powerwall_data, meter))
@@ -190,8 +192,10 @@ class PowerWallBackupReserveSensor(PowerWallEntity, SensorEntity):
         return f"{self.base_unique_id}_backup_reserve"
 
     @property
-    def native_value(self) -> int:
+    def native_value(self) -> int | None:
         """Get the current value in percentage."""
+        if self.data.backup_reserve is None:
+            return None
         return round(self.data.backup_reserve)
 
 

homeassistant/components/prosegur/alarm_control_panel.py

@@ -51,6 +51,7 @@ class ProsegurAlarm(alarm.AlarmControlPanelEntity):
         self.contract = contract
         self._auth = auth
 
+        self._attr_code_arm_required = False
         self._attr_name = f"contract {self.contract}"
         self._attr_unique_id = self.contract
         self._attr_supported_features = SUPPORT_ALARM_ARM_AWAY | SUPPORT_ALARM_ARM_HOME