Update comment

Co-authored-by: Joostlek <joostlek@outlook.com>

.devcontainer/devcontainer.json

@@ -40,7 +40,8 @@
         "python.terminal.activateEnvInCurrentTerminal": true,
         "python.testing.pytestArgs": ["--no-cov"],
         "pylint.importStrategy": "fromEnvironment",
-        "python.analysis.typeCheckingMode": "basic",
+        // Pyright type checking is too not compatible with mypy which Home Assistant uses for type checking
+        "python.analysis.typeCheckingMode": "off",
         "editor.formatOnPaste": false,
         "editor.formatOnSave": true,
         "editor.formatOnType": true,

.vscode/settings.default.jsonc

@@ -7,8 +7,8 @@
   "python.testing.pytestEnabled": false,
   // https://code.visualstudio.com/docs/python/linting#_general-settings
   "pylint.importStrategy": "fromEnvironment",
-  // Pyright is too pedantic for Home Assistant
-  "python.analysis.typeCheckingMode": "basic",
+  // Pyright type checking is too not compatible with mypy which Home Assistant uses for type checking
+  "python.analysis.typeCheckingMode": "off",
   "[python]": {
     "editor.defaultFormatter": "charliermarsh.ruff",
   },

CODEOWNERS

@@ -661,6 +661,8 @@ build.json @home-assistant/supervisor
 /tests/components/harmony/ @ehendrix23 @bdraco @mkeesey @Aohzan
 /homeassistant/components/hassio/ @home-assistant/supervisor
 /tests/components/hassio/ @home-assistant/supervisor
+/homeassistant/components/hdfury/ @glenndehaan
+/tests/components/hdfury/ @glenndehaan
 /homeassistant/components/hdmi_cec/ @inytar
 /tests/components/hdmi_cec/ @inytar
 /homeassistant/components/heatmiser/ @andylockran
@@ -1170,8 +1172,8 @@ build.json @home-assistant/supervisor
 /tests/components/open_router/ @joostlek
 /homeassistant/components/openerz/ @misialq
 /tests/components/openerz/ @misialq
-/homeassistant/components/openevse/ @c00w
-/tests/components/openevse/ @c00w
+/homeassistant/components/openevse/ @c00w @firstof9
+/tests/components/openevse/ @c00w @firstof9
 /homeassistant/components/openexchangerates/ @MartinHjelmare
 /tests/components/openexchangerates/ @MartinHjelmare
 /homeassistant/components/opengarage/ @danielhiversen
@@ -1803,6 +1805,7 @@ build.json @home-assistant/supervisor
 /tests/components/waqi/ @joostlek
 /homeassistant/components/water_heater/ @home-assistant/core
 /tests/components/water_heater/ @home-assistant/core
+/homeassistant/components/waterfurnace/ @sdague @masterkoppa
 /homeassistant/components/watergate/ @adam-the-hero
 /tests/components/watergate/ @adam-the-hero
 /homeassistant/components/watson_tts/ @rutkai

homeassistant/components/automation/__init__.py

@@ -7,7 +7,7 @@ import asyncio
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 import logging
-from typing import Any, Protocol, cast
+from typing import Any, Literal, Protocol, cast
 
 from propcache.api import cached_property
 import voluptuous as vol
@@ -16,7 +16,10 @@ from homeassistant.components import labs, websocket_api
 from homeassistant.components.blueprint import CONF_USE_BLUEPRINT
 from homeassistant.components.labs import async_listen as async_labs_listen
 from homeassistant.const import (
+    ATTR_AREA_ID,
     ATTR_ENTITY_ID,
+    ATTR_FLOOR_ID,
+    ATTR_LABEL_ID,
     ATTR_MODE,
     ATTR_NAME,
     CONF_ACTIONS,
@@ -30,6 +33,7 @@ from homeassistant.const import (
     CONF_OPTIONS,
     CONF_PATH,
     CONF_PLATFORM,
+    CONF_TARGET,
     CONF_TRIGGERS,
     CONF_VARIABLES,
     CONF_ZONE,
@@ -589,20 +593,32 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
         """Return True if entity is on."""
         return self._async_detach_triggers is not None or self._is_enabled
 
-    @property
+    @cached_property
     def referenced_labels(self) -> set[str]:
         """Return a set of referenced labels."""
-        return self.action_script.referenced_labels
+        referenced = self.action_script.referenced_labels
 
-    @property
+        for conf in self._trigger_config:
+            referenced |= set(_get_targets_from_trigger_config(conf, ATTR_LABEL_ID))
+        return referenced
+
+    @cached_property
     def referenced_floors(self) -> set[str]:
         """Return a set of referenced floors."""
-        return self.action_script.referenced_floors
+        referenced = self.action_script.referenced_floors
+
+        for conf in self._trigger_config:
+            referenced |= set(_get_targets_from_trigger_config(conf, ATTR_FLOOR_ID))
+        return referenced
 
     @cached_property
     def referenced_areas(self) -> set[str]:
         """Return a set of referenced areas."""
-        return self.action_script.referenced_areas
+        referenced = self.action_script.referenced_areas
+
+        for conf in self._trigger_config:
+            referenced |= set(_get_targets_from_trigger_config(conf, ATTR_AREA_ID))
+        return referenced
 
     @property
     def referenced_blueprint(self) -> str | None:
@@ -1210,6 +1226,9 @@ def _trigger_extract_devices(trigger_conf: dict) -> list[str]:
     if trigger_conf[CONF_PLATFORM] == "tag" and CONF_DEVICE_ID in trigger_conf:
         return trigger_conf[CONF_DEVICE_ID]  # type: ignore[no-any-return]
 
+    if target_devices := _get_targets_from_trigger_config(trigger_conf, CONF_DEVICE_ID):
+        return target_devices
+
     return []
 
 
@@ -1240,9 +1259,28 @@ def _trigger_extract_entities(trigger_conf: dict) -> list[str]:
     ):
         return [trigger_conf[CONF_EVENT_DATA][CONF_ENTITY_ID]]
 
+    if target_entities := _get_targets_from_trigger_config(
+        trigger_conf, CONF_ENTITY_ID
+    ):
+        return target_entities
+
     return []
 
 
+@callback
+def _get_targets_from_trigger_config(
+    config: dict,
+    target: Literal["entity_id", "device_id", "area_id", "floor_id", "label_id"],
+) -> list[str]:
+    """Extract targets from a target config."""
+    if not (target_conf := config.get(CONF_TARGET)):
+        return []
+    if not (targets := target_conf.get(target)):
+        return []
+
+    return [targets] if isinstance(targets, str) else targets
+
+
 @websocket_api.websocket_command({"type": "automation/config", "entity_id": str})
 def websocket_config(
     hass: HomeAssistant,

homeassistant/components/bang_olufsen/__init__.py

@@ -34,7 +34,7 @@ class BeoData:
 
 type BeoConfigEntry = ConfigEntry[BeoData]
 
-PLATFORMS = [Platform.EVENT, Platform.MEDIA_PLAYER]
+PLATFORMS = [Platform.EVENT, Platform.MEDIA_PLAYER, Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: BeoConfigEntry) -> bool:

homeassistant/components/bang_olufsen/const.py

@@ -115,6 +115,7 @@ class WebsocketNotification(StrEnum):
     """Enum for WebSocket notification types."""
 
     ACTIVE_LISTENING_MODE = "active_listening_mode"
+    BATTERY = "battery"
     BEO_REMOTE_BUTTON = "beo_remote_button"
     BUTTON = "button"
     PLAYBACK_ERROR = "playback_error"

homeassistant/components/bang_olufsen/diagnostics.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Any
 
 from homeassistant.components.event import DOMAIN as EVENT_DOMAIN
 from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.const import CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
@@ -55,6 +56,19 @@ async def async_get_config_entry_diagnostics(
 
     # Get remotes
     for remote in await get_remotes(config_entry.runtime_data.client):
+        # Get Battery Sensor states
+        if entity_id := entity_registry.async_get_entity_id(
+            SENSOR_DOMAIN,
+            DOMAIN,
+            f"{remote.serial_number}_{config_entry.unique_id}_remote_battery_level",
+        ):
+            if state := hass.states.get(entity_id):
+                state_dict = dict(state.as_dict())
+
+                # Remove context as it is not relevant
+                state_dict.pop("context")
+                data[f"remote_{remote.serial_number}_battery_level"] = state_dict
+
         # Get key Event entity states (if enabled)
         for key_type in get_remote_keys():
             if entity_id := entity_registry.async_get_entity_id(
@@ -72,4 +86,15 @@ async def async_get_config_entry_diagnostics(
         # Add remote Mozart model
         data[f"remote_{remote.serial_number}"] = dict(remote)
 
+    # Get Mozart battery entity
+    if entity_id := entity_registry.async_get_entity_id(
+        SENSOR_DOMAIN, DOMAIN, f"{config_entry.unique_id}_battery_level"
+    ):
+        if state := hass.states.get(entity_id):
+            state_dict = dict(state.as_dict())
+
+            # Remove context as it is not relevant
+            state_dict.pop("context")
+            data["battery_level"] = state_dict
+
     return data

homeassistant/components/bang_olufsen/sensor.py

@@ -0,0 +1,139 @@
+"""Sensor entities for the Bang & Olufsen integration."""
+
+from __future__ import annotations
+
+import contextlib
+from datetime import timedelta
+
+from aiohttp import ClientConnectorError
+from mozart_api.exceptions import ApiException
+from mozart_api.models import BatteryState, PairedRemote
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorStateClass,
+)
+from homeassistant.const import PERCENTAGE
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import BeoConfigEntry
+from .const import CONNECTION_STATUS, DOMAIN, WebsocketNotification
+from .entity import BeoEntity
+from .util import get_remotes, supports_battery
+
+SCAN_INTERVAL = timedelta(minutes=15)
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BeoConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Sensor entities from config entry."""
+    entities: list[BeoSensor] = []
+
+    # Check for Mozart device with battery
+    if await supports_battery(config_entry.runtime_data.client):
+        entities.append(BeoSensorBatteryLevel(config_entry))
+
+    # Add any Beoremote One remotes
+    entities.extend(
+        [
+            BeoSensorRemoteBatteryLevel(config_entry, remote)
+            for remote in (await get_remotes(config_entry.runtime_data.client))
+        ]
+    )
+
+    async_add_entities(entities, update_before_add=True)
+
+
+class BeoSensor(SensorEntity, BeoEntity):
+    """Base Bang & Olufsen Sensor."""
+
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
+        """Initialize Sensor."""
+        super().__init__(config_entry, config_entry.runtime_data.client)
+
+
+class BeoSensorBatteryLevel(BeoSensor):
+    """Battery level Sensor for Mozart devices."""
+
+    _attr_device_class = SensorDeviceClass.BATTERY
+    _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_state_class = SensorStateClass.MEASUREMENT
+
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
+        """Init the battery level Sensor."""
+        super().__init__(config_entry)
+
+        self._attr_unique_id = f"{self._unique_id}_battery_level"
+
+    async def async_added_to_hass(self) -> None:
+        """Turn on the dispatchers."""
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+                self._async_update_connection_state,
+            )
+        )
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BATTERY}",
+                self._update_battery,
+            )
+        )
+
+    async def _update_battery(self, data: BatteryState) -> None:
+        """Update sensor value."""
+        self._attr_native_value = data.battery_level
+        self.async_write_ha_state()
+
+
+class BeoSensorRemoteBatteryLevel(BeoSensor):
+    """Battery level Sensor for the Beoremote One."""
+
+    _attr_device_class = SensorDeviceClass.BATTERY
+    _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_should_poll = True
+    _attr_state_class = SensorStateClass.MEASUREMENT
+
+    def __init__(self, config_entry: BeoConfigEntry, remote: PairedRemote) -> None:
+        """Init the battery level Sensor."""
+        super().__init__(config_entry)
+        # Serial number is not None, as the remote object is provided by get_remotes
+        assert remote.serial_number
+
+        self._attr_unique_id = (
+            f"{remote.serial_number}_{self._unique_id}_remote_battery_level"
+        )
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, f"{remote.serial_number}_{self._unique_id}")}
+        )
+        self._attr_native_value = remote.battery_level
+        self._remote = remote
+
+    async def async_added_to_hass(self) -> None:
+        """Turn on the dispatchers."""
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+                self._async_update_connection_state,
+            )
+        )
+
+    async def async_update(self) -> None:
+        """Poll battery status."""
+        with contextlib.suppress(ApiException, ClientConnectorError, TimeoutError):
+            for remote in await get_remotes(self._client):
+                if remote.serial_number == self._remote.serial_number:
+                    self._attr_native_value = remote.battery_level
+                    break

homeassistant/components/bang_olufsen/util.py

@@ -84,3 +84,10 @@ def get_remote_keys() -> list[str]:
             for key_type in (*BEO_REMOTE_KEYS, *BEO_REMOTE_CONTROL_KEYS)
         ],
     ]
+
+
+async def supports_battery(client: MozartClient) -> bool:
+    """Get if a Mozart device has a battery."""
+    battery_state = await client.get_battery_state()
+
+    return battery_state.state != "BatteryNotPresent"

homeassistant/components/bang_olufsen/websocket.py

@@ -6,6 +6,7 @@ import logging
 from typing import TYPE_CHECKING
 
 from mozart_api.models import (
+    BatteryState,
     BeoRemoteButton,
     ButtonEvent,
     ListeningModeProps,
@@ -60,6 +61,7 @@ class BeoWebsocket(BeoBase):
         self._client.get_active_listening_mode_notifications(
             self.on_active_listening_mode
         )
+        self._client.get_battery_notifications(self.on_battery_notification)
         self._client.get_beo_remote_button_notifications(
             self.on_beo_remote_button_notification
         )
@@ -115,6 +117,14 @@ class BeoWebsocket(BeoBase):
             notification,
         )
 
+    def on_battery_notification(self, notification: BatteryState) -> None:
+        """Send battery dispatch."""
+        async_dispatcher_send(
+            self.hass,
+            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BATTERY}",
+            notification,
+        )
+
     def on_beo_remote_button_notification(self, notification: BeoRemoteButton) -> None:
         """Send beo_remote_button dispatch."""
         if TYPE_CHECKING:

homeassistant/components/braviatv/__init__.py

@@ -11,6 +11,7 @@ from homeassistant.const import CONF_HOST, CONF_MAC, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_create_clientsession
 
+from .const import CONF_USE_SSL
 from .coordinator import BraviaTVConfigEntry, BraviaTVCoordinator
 
 PLATFORMS: Final[list[Platform]] = [
@@ -26,11 +27,12 @@ async def async_setup_entry(
     """Set up a config entry."""
     host = config_entry.data[CONF_HOST]
     mac = config_entry.data[CONF_MAC]
+    ssl = config_entry.data.get(CONF_USE_SSL, False)
 
     session = async_create_clientsession(
         hass, cookie_jar=CookieJar(unsafe=True, quote_cookie=False)
     )
-    client = BraviaClient(host, mac, session=session)
+    client = BraviaClient(host, mac, session=session, ssl=ssl)
     coordinator = BraviaTVCoordinator(
         hass=hass,
         config_entry=config_entry,

homeassistant/components/braviatv/config_flow.py

@@ -28,6 +28,7 @@ from .const import (
     ATTR_MODEL,
     CONF_NICKNAME,
     CONF_USE_PSK,
+    CONF_USE_SSL,
     DOMAIN,
     NICKNAME_PREFIX,
 )
@@ -46,11 +47,12 @@ class BraviaTVConfigFlow(ConfigFlow, domain=DOMAIN):
     def create_client(self) -> None:
         """Create Bravia TV client from config."""
         host = self.device_config[CONF_HOST]
+        ssl = self.device_config[CONF_USE_SSL]
         session = async_create_clientsession(
             self.hass,
             cookie_jar=CookieJar(unsafe=True, quote_cookie=False),
         )
-        self.client = BraviaClient(host=host, session=session)
+        self.client = BraviaClient(host=host, session=session, ssl=ssl)
 
     async def gen_instance_ids(self) -> tuple[str, str]:
         """Generate client_id and nickname."""
@@ -123,10 +125,10 @@ class BraviaTVConfigFlow(ConfigFlow, domain=DOMAIN):
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle authorize step."""
-        self.create_client()
-
         if user_input is not None:
             self.device_config[CONF_USE_PSK] = user_input[CONF_USE_PSK]
+            self.device_config[CONF_USE_SSL] = user_input[CONF_USE_SSL]
+            self.create_client()
             if user_input[CONF_USE_PSK]:
                 return await self.async_step_psk()
             return await self.async_step_pin()
@@ -136,6 +138,7 @@ class BraviaTVConfigFlow(ConfigFlow, domain=DOMAIN):
             data_schema=vol.Schema(
                 {
                     vol.Required(CONF_USE_PSK, default=False): bool,
+                    vol.Required(CONF_USE_SSL, default=False): bool,
                 }
             ),
         )

homeassistant/components/braviatv/const.py

@@ -12,6 +12,7 @@ ATTR_MODEL: Final = "model"
 
 CONF_NICKNAME: Final = "nickname"
 CONF_USE_PSK: Final = "use_psk"
+CONF_USE_SSL: Final = "use_ssl"
 
 DOMAIN: Final = "braviatv"
 LEGACY_CLIENT_ID: Final = "HomeAssistant"

homeassistant/components/braviatv/coordinator.py

@@ -22,7 +22,7 @@ from homeassistant.components.media_player import MediaType
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_CLIENT_ID, CONF_PIN
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -56,8 +56,31 @@ def catch_braviatv_errors[_BraviaTVCoordinatorT: BraviaTVCoordinator, **_P](
         """Catch Bravia errors and log message."""
         try:
             await func(self, *args, **kwargs)
+        except BraviaNotFound as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_error_not_found",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                },
+            ) from err
+        except (BraviaConnectionError, BraviaConnectionTimeout, BraviaTurnedOff) as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_error_offline",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                },
+            ) from err
         except BraviaError as err:
-            _LOGGER.error("Command error: %s", err)
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_error",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                    "error": repr(err),
+                },
+            ) from err
         await self.async_request_refresh()
 
     return wrapper
@@ -165,17 +188,35 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
             if self.skipped_updates < 10:
                 self.connected = False
                 self.skipped_updates += 1
-                _LOGGER.debug("Update skipped, Bravia API service is reloading")
+                _LOGGER.debug(
+                    "Update for %s skipped: the Bravia API service is reloading",
+                    self.config_entry.title,
+                )
                 return
-            raise UpdateFailed("Error communicating with device") from err
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error_not_found",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                },
+            ) from err
         except (BraviaConnectionError, BraviaConnectionTimeout, BraviaTurnedOff):
             self.is_on = False
             self.connected = False
-            _LOGGER.debug("Update skipped, Bravia TV is off")
+            _LOGGER.debug(
+                "Update for %s skipped: the TV is turned off", self.config_entry.title
+            )
         except BraviaError as err:
             self.is_on = False
             self.connected = False
-            raise UpdateFailed("Error communicating with device") from err
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                    "error": repr(err),
+                },
+            ) from err
 
     async def async_update_volume(self) -> None:
         """Update volume information."""

homeassistant/components/braviatv/strings.json

@@ -15,9 +15,10 @@
     "step": {
       "authorize": {
         "data": {
-          "use_psk": "Use PSK authentication"
+          "use_psk": "Use PSK authentication",
+          "use_ssl": "Use SSL connection"
         },
-        "description": "Make sure that «Control remotely» is enabled on your TV, go to: \nSettings -> Network -> Remote device settings -> Control remotely. \n\nThere are two authorization methods: PIN code or PSK (Pre-Shared Key). \nAuthorization via PSK is recommended as more stable.",
+        "description": "Make sure that «Control remotely» is enabled on your TV. Go to: \nSettings -> Network -> Remote device settings -> Control remotely. \n\nThere are two authorization methods: PIN code or PSK (Pre-Shared Key). \nAuthorization via PSK is recommended, as it is more stable. \n\nUse an SSL connection only if your TV supports this connection type.",
         "title": "Authorize Sony Bravia TV"
       },
       "confirm": {
@@ -54,5 +55,22 @@
         "name": "Terminate apps"
       }
     }
+  },
+  "exceptions": {
+    "command_error": {
+      "message": "Error sending command to {device}: {error}"
+    },
+    "command_error_not_found": {
+      "message": "Error sending command to {device}: the Bravia API service is reloading"
+    },
+    "command_error_offline": {
+      "message": "Error sending command to {device}: the TV is turned off"
+    },
+    "update_error": {
+      "message": "Error updating data for {device}: {error}"
+    },
+    "update_error_not_found": {
+      "message": "Error updating data for {device}: the Bravia API service is stuck"
+    }
   }
 }

homeassistant/components/climate/trigger.py

@@ -33,7 +33,7 @@ HVAC_MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend
     {
         vol.Required(CONF_OPTIONS): {
             vol.Required(CONF_HVAC_MODE): vol.All(
-                cv.ensure_list, vol.Length(min=1), [HVACMode]
+                cv.ensure_list, vol.Length(min=1), [vol.Coerce(HVACMode)]
             ),
         },
     }

homeassistant/components/conversation/manifest.json

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

homeassistant/components/ecovacs/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.11", "deebot-client==17.0.0"]
+  "requirements": ["py-sucks==0.9.11", "deebot-client==17.0.1"]
 }

homeassistant/components/enphase_envoy/sensor.py

@@ -206,7 +206,7 @@ class EnvoyProductionSensorEntityDescription(SensorEntityDescription):
     """Describes an Envoy production sensor entity."""
 
     value_fn: Callable[[EnvoySystemProduction], int]
-    on_phase: str | None
+    on_phase: str | None = None
 
 
 PRODUCTION_SENSORS = (
@@ -219,7 +219,6 @@ PRODUCTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
         suggested_display_precision=3,
         value_fn=attrgetter("watts_now"),
-        on_phase=None,
     ),
     EnvoyProductionSensorEntityDescription(
         key="daily_production",
@@ -230,7 +229,6 @@ PRODUCTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=2,
         value_fn=attrgetter("watt_hours_today"),
-        on_phase=None,
     ),
     EnvoyProductionSensorEntityDescription(
         key="seven_days_production",
@@ -240,7 +238,6 @@ PRODUCTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=1,
         value_fn=attrgetter("watt_hours_last_7_days"),
-        on_phase=None,
     ),
     EnvoyProductionSensorEntityDescription(
         key="lifetime_production",
@@ -251,7 +248,6 @@ PRODUCTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
         suggested_display_precision=3,
         value_fn=attrgetter("watt_hours_lifetime"),
-        on_phase=None,
     ),
 )
 
@@ -277,7 +273,7 @@ class EnvoyConsumptionSensorEntityDescription(SensorEntityDescription):
     """Describes an Envoy consumption sensor entity."""
 
     value_fn: Callable[[EnvoySystemConsumption], int]
-    on_phase: str | None
+    on_phase: str | None = None
 
 
 CONSUMPTION_SENSORS = (
@@ -290,7 +286,6 @@ CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
         suggested_display_precision=3,
         value_fn=attrgetter("watts_now"),
-        on_phase=None,
     ),
     EnvoyConsumptionSensorEntityDescription(
         key="daily_consumption",
@@ -301,7 +296,6 @@ CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=2,
         value_fn=attrgetter("watt_hours_today"),
-        on_phase=None,
     ),
     EnvoyConsumptionSensorEntityDescription(
         key="seven_days_consumption",
@@ -311,7 +305,6 @@ CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=1,
         value_fn=attrgetter("watt_hours_last_7_days"),
-        on_phase=None,
     ),
     EnvoyConsumptionSensorEntityDescription(
         key="lifetime_consumption",
@@ -322,7 +315,6 @@ CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
         suggested_display_precision=3,
         value_fn=attrgetter("watt_hours_lifetime"),
-        on_phase=None,
     ),
 )
 
@@ -354,7 +346,6 @@ NET_CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
         suggested_display_precision=3,
         value_fn=attrgetter("watts_now"),
-        on_phase=None,
     ),
     EnvoyConsumptionSensorEntityDescription(
         key="lifetime_balanced_net_consumption",
@@ -366,7 +357,6 @@ NET_CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=3,
         value_fn=attrgetter("watt_hours_lifetime"),
-        on_phase=None,
     ),
 )
 
@@ -395,7 +385,7 @@ class EnvoyCTSensorEntityDescription(SensorEntityDescription):
         [EnvoyMeterData],
         int | float | str | CtType | CtMeterStatus | CtStatusFlags | CtState | None,
     ]
-    on_phase: str | None
+    on_phase: str | None = None
     cttype: str | None = None
 
 
@@ -411,7 +401,6 @@ CT_SENSORS = (
             suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
             suggested_display_precision=3,
             value_fn=attrgetter("energy_delivered"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -430,7 +419,6 @@ CT_SENSORS = (
             suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
             suggested_display_precision=3,
             value_fn=attrgetter("energy_received"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -449,7 +437,6 @@ CT_SENSORS = (
             suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
             suggested_display_precision=3,
             value_fn=attrgetter("active_power"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -468,7 +455,6 @@ CT_SENSORS = (
             suggested_display_precision=1,
             entity_registry_enabled_default=False,
             value_fn=attrgetter("frequency"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key, translation_key in (
@@ -488,7 +474,6 @@ CT_SENSORS = (
             suggested_display_precision=1,
             entity_registry_enabled_default=False,
             value_fn=attrgetter("voltage"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key, translation_key in (
@@ -508,7 +493,6 @@ CT_SENSORS = (
             suggested_display_precision=3,
             entity_registry_enabled_default=False,
             value_fn=attrgetter("current"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -526,7 +510,6 @@ CT_SENSORS = (
             suggested_display_precision=2,
             entity_registry_enabled_default=False,
             value_fn=attrgetter("power_factor"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -544,7 +527,6 @@ CT_SENSORS = (
             options=list(CtMeterStatus),
             entity_registry_enabled_default=False,
             value_fn=attrgetter("metering_status"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key, translation_key in (
@@ -565,7 +547,6 @@ CT_SENSORS = (
             entity_category=EntityCategory.DIAGNOSTIC,
             entity_registry_enabled_default=False,
             value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key, translation_key in (

homeassistant/components/frontend/manifest.json

@@ -23,5 +23,5 @@
     "winter_mode": {}
   },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20251229.1"]
+  "requirements": ["home-assistant-frontend==20260107.0"]
 }

homeassistant/components/hdfury/__init__.py

@@ -0,0 +1,29 @@
+"""The HDFury Integration."""
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import HDFuryConfigEntry, HDFuryCoordinator
+
+PLATFORMS = [
+    Platform.SELECT,
+]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: HDFuryConfigEntry) -> bool:
+    """Set up HDFury as config entry."""
+
+    coordinator = HDFuryCoordinator(hass, entry)
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: HDFuryConfigEntry) -> bool:
+    """Unload a HDFury config entry."""
+
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/hdfury/config_flow.py

@@ -0,0 +1,54 @@
+"""Config flow for HDFury Integration."""
+
+from typing import Any
+
+from hdfury import HDFuryAPI, HDFuryError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_HOST
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+
+class HDFuryConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle Config Flow for HDFury."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle Initial Setup."""
+
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            host = user_input[CONF_HOST]
+
+            serial = await self._validate_connection(host)
+            if serial is not None:
+                await self.async_set_unique_id(serial)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(
+                    title=f"HDFury ({host})", data=user_input
+                )
+
+            errors["base"] = "cannot_connect"
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema({vol.Required(CONF_HOST): str}),
+            errors=errors,
+        )
+
+    async def _validate_connection(self, host: str) -> str | None:
+        """Try to fetch serial number to confirm it's a valid HDFury device."""
+
+        client = HDFuryAPI(host, async_get_clientsession(self.hass))
+
+        try:
+            data = await client.get_board()
+        except HDFuryError:
+            return None
+
+        return data["serial"]

homeassistant/components/hdfury/const.py

@@ -0,0 +1,3 @@
+"""Constants for HDFury Integration."""
+
+DOMAIN = "hdfury"

homeassistant/components/hdfury/coordinator.py

@@ -0,0 +1,67 @@
+"""DataUpdateCoordinator for HDFury Integration."""
+
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+from typing import Final
+
+from hdfury import HDFuryAPI, HDFuryError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL: Final = timedelta(seconds=60)
+
+type HDFuryConfigEntry = ConfigEntry[HDFuryCoordinator]
+
+
+@dataclass(kw_only=True, frozen=True)
+class HDFuryData:
+    """HDFury Data Class."""
+
+    board: dict[str, str]
+    info: dict[str, str]
+    config: dict[str, str]
+
+
+class HDFuryCoordinator(DataUpdateCoordinator[HDFuryData]):
+    """HDFury Device Coordinator Class."""
+
+    def __init__(self, hass: HomeAssistant, entry: HDFuryConfigEntry) -> None:
+        """Initialize the coordinator."""
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=entry,
+            name="HDFury",
+            update_interval=SCAN_INTERVAL,
+        )
+        self.host: str = entry.data[CONF_HOST]
+        self.client = HDFuryAPI(self.host, async_get_clientsession(hass))
+
+    async def _async_update_data(self) -> HDFuryData:
+        """Fetch the latest device data."""
+
+        try:
+            board = await self.client.get_board()
+            info = await self.client.get_info()
+            config = await self.client.get_config()
+        except HDFuryError as error:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="communication_error",
+            ) from error
+
+        return HDFuryData(
+            board=board,
+            info=info,
+            config=config,
+        )

homeassistant/components/hdfury/entity.py

@@ -0,0 +1,39 @@
+"""Base class for HDFury entities."""
+
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .coordinator import HDFuryCoordinator
+
+
+class HDFuryEntity(CoordinatorEntity[HDFuryCoordinator]):
+    """Common elements for all entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self, coordinator: HDFuryCoordinator, entity_description: EntityDescription
+    ) -> None:
+        """Initialize the entity."""
+
+        super().__init__(coordinator)
+
+        self.entity_description = entity_description
+
+        self._attr_unique_id = (
+            f"{coordinator.data.board['serial']}_{entity_description.key}"
+        )
+        self._attr_device_info = DeviceInfo(
+            name=f"HDFury {coordinator.data.board['hostname']}",
+            manufacturer="HDFury",
+            model=coordinator.data.board["hostname"].split("-")[0],
+            serial_number=coordinator.data.board["serial"],
+            sw_version=coordinator.data.board["version"].removeprefix("FW: "),
+            hw_version=coordinator.data.board.get("pcbv"),
+            configuration_url=f"http://{coordinator.host}",
+            connections={
+                (dr.CONNECTION_NETWORK_MAC, coordinator.data.config["macaddr"])
+            },
+        )

homeassistant/components/hdfury/icons.json

@@ -0,0 +1,15 @@
+{
+  "entity": {
+    "select": {
+      "opmode": {
+        "default": "mdi:cogs"
+      },
+      "portseltx0": {
+        "default": "mdi:hdmi-port"
+      },
+      "portseltx1": {
+        "default": "mdi:hdmi-port"
+      }
+    }
+  }
+}

homeassistant/components/hdfury/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "hdfury",
+  "name": "HDFury",
+  "codeowners": ["@glenndehaan"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/hdfury",
+  "integration_type": "device",
+  "iot_class": "local_polling",
+  "quality_scale": "bronze",
+  "requirements": ["hdfury==1.3.1"]
+}

homeassistant/components/hdfury/quality_scale.yaml

@@ -17,7 +17,7 @@ rules:
   docs-removal-instructions: done
   entity-event-setup:
     status: exempt
-    comment: Local_polling without events
+    comment: Entities do not explicitly subscribe to events.
   entity-unique-id: done
   has-entity-name: done
   runtime-data: done
@@ -26,21 +26,19 @@ rules:
   unique-config-entry: done
 
   # Silver
-  action-exceptions:
-    status: exempt
-    comment: Integration does not register custom actions.
+  action-exceptions: done
   config-entry-unloading: done
   docs-configuration-parameters:
     status: exempt
-    comment: Integration does not have an options flow.
-  docs-installation-parameters: todo
+    comment: Integration has no options flow.
+  docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
-  parallel-updates:
+  parallel-updates: todo
+  reauthentication-flow:
     status: exempt
-    comment: Coordinator handles updates, no explicit parallel updates needed.
-  reauthentication-flow: todo
+    comment: Integration has no authentication flow.
   test-coverage: todo
 
   # Gold
@@ -51,20 +49,24 @@ rules:
   docs-data-update: todo
   docs-examples: todo
   docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
+  docs-supported-devices: done
+  docs-supported-functions: done
   docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
+  docs-use-cases: done
+  dynamic-devices:
+    status: exempt
+    comment: Device type integration.
+  entity-category: done
   entity-device-class: done
   entity-disabled-by-default: todo
-  entity-translations: todo
-  exception-translations: todo
-  icon-translations: todo
+  entity-translations: done
+  exception-translations: done
+  icon-translations: done
   reconfiguration-flow: todo
   repair-issues: todo
-  stale-devices: todo
+  stale-devices:
+    status: exempt
+    comment: Device type integration.
 
   # Platinum
   async-dependency: done

homeassistant/components/hdfury/select.py

@@ -0,0 +1,122 @@
+"""Select platform for HDFury Integration."""
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+
+from hdfury import (
+    OPERATION_MODES,
+    TX0_INPUT_PORTS,
+    TX1_INPUT_PORTS,
+    HDFuryAPI,
+    HDFuryError,
+)
+
+from homeassistant.components.select import SelectEntity, SelectEntityDescription
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import HDFuryConfigEntry, HDFuryCoordinator
+from .entity import HDFuryEntity
+
+
+@dataclass(kw_only=True, frozen=True)
+class HDFurySelectEntityDescription(SelectEntityDescription):
+    """Description for HDFury select entities."""
+
+    set_value_fn: Callable[[HDFuryAPI, str], Awaitable[None]]
+
+
+SELECT_PORTS: tuple[HDFurySelectEntityDescription, ...] = (
+    HDFurySelectEntityDescription(
+        key="portseltx0",
+        translation_key="portseltx0",
+        options=list(TX0_INPUT_PORTS.keys()),
+        set_value_fn=lambda coordinator, value: _set_ports(coordinator),
+    ),
+    HDFurySelectEntityDescription(
+        key="portseltx1",
+        translation_key="portseltx1",
+        options=list(TX1_INPUT_PORTS.keys()),
+        set_value_fn=lambda coordinator, value: _set_ports(coordinator),
+    ),
+)
+
+
+SELECT_OPERATION_MODE: HDFurySelectEntityDescription = HDFurySelectEntityDescription(
+    key="opmode",
+    translation_key="opmode",
+    options=list(OPERATION_MODES.keys()),
+    set_value_fn=lambda coordinator, value: coordinator.client.set_operation_mode(
+        value
+    ),
+)
+
+
+async def _set_ports(coordinator: HDFuryCoordinator) -> None:
+    tx0 = coordinator.data.info.get("portseltx0")
+    tx1 = coordinator.data.info.get("portseltx1")
+
+    if tx0 is None or tx1 is None:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="tx_state_error",
+            translation_placeholders={"details": f"tx0={tx0}, tx1={tx1}"},
+        )
+
+    await coordinator.client.set_port_selection(tx0, tx1)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: HDFuryConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up selects using the platform schema."""
+
+    coordinator = entry.runtime_data
+
+    entities: list[HDFuryEntity] = []
+
+    for description in SELECT_PORTS:
+        if description.key not in coordinator.data.info:
+            continue
+
+        entities.append(HDFurySelect(coordinator, description))
+
+    # Add OPMODE select if present
+    if "opmode" in coordinator.data.info:
+        entities.append(HDFurySelect(coordinator, SELECT_OPERATION_MODE))
+
+    async_add_entities(entities)
+
+
+class HDFurySelect(HDFuryEntity, SelectEntity):
+    """HDFury Select Class."""
+
+    entity_description: HDFurySelectEntityDescription
+
+    @property
+    def current_option(self) -> str:
+        """Return the current option."""
+
+        return self.coordinator.data.info[self.entity_description.key]
+
+    async def async_select_option(self, option: str) -> None:
+        """Update the current option."""
+
+        # Update local data first
+        self.coordinator.data.info[self.entity_description.key] = option
+
+        # Send command to device
+        try:
+            await self.entity_description.set_value_fn(self.coordinator, option)
+        except HDFuryError as error:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="communication_error",
+            ) from error
+
+        # Trigger HA coordinator refresh
+        await self.coordinator.async_request_refresh()

homeassistant/components/hdfury/strings.json

@@ -0,0 +1,64 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]"
+        },
+        "data_description": {
+          "host": "Hostname or IP address of your HDFury device."
+        },
+        "description": "Set up your HDFury to integrate with Home Assistant."
+      }
+    }
+  },
+  "entity": {
+    "select": {
+      "opmode": {
+        "name": "Operation mode",
+        "state": {
+          "0": "Mode 0 - Splitter TX0/TX1 FRL5 VRR",
+          "1": "Mode 1 - Splitter TX0/TX1 UPSCALE FRL5",
+          "2": "Mode 2 - Matrix TMDS",
+          "3": "Mode 3 - Matrix FRL->TMDS",
+          "4": "Mode 4 - Matrix DOWNSCALE",
+          "5": "Mode 5 - Matrix RX0:FRL5 + RX1-3:TMDS"
+        }
+      },
+      "portseltx0": {
+        "name": "Port select TX0",
+        "state": {
+          "0": "Input 0",
+          "1": "Input 1",
+          "2": "Input 2",
+          "3": "Input 3",
+          "4": "Copy TX1"
+        }
+      },
+      "portseltx1": {
+        "name": "Port select TX1",
+        "state": {
+          "0": "Input 0",
+          "1": "Input 1",
+          "2": "Input 2",
+          "3": "Input 3",
+          "4": "Copy TX0"
+        }
+      }
+    }
+  },
+  "exceptions": {
+    "communication_error": {
+      "message": "An error occurred while communicating with HDFury device"
+    },
+    "tx_state_error": {
+      "message": "An error occurred while validating TX states: {details}"
+    }
+  }
+}

homeassistant/components/home_connect/manifest.json

@@ -23,6 +23,6 @@
   "iot_class": "cloud_push",
   "loggers": ["aiohomeconnect"],
   "quality_scale": "platinum",
-  "requirements": ["aiohomeconnect==0.26.0"],
+  "requirements": ["aiohomeconnect==0.28.0"],
   "zeroconf": ["_homeconnect._tcp.local."]
 }

homeassistant/components/home_connect/services.yaml

@@ -15,7 +15,7 @@ set_program_and_options:
             - active_program
             - selected_program
     program:
-      example: dishcare_dishwasher_program_auto2
+      example: dishcare_dishwasher_program_auto_2
       selector:
         select:
           mode: dropdown
@@ -73,6 +73,7 @@ set_program_and_options:
             - dishcare_dishwasher_program_intensiv_45
             - dishcare_dishwasher_program_auto_half_load
             - dishcare_dishwasher_program_intensiv_power
+            - dishcare_dishwasher_program_intensive_fixed_zone
             - dishcare_dishwasher_program_magic_daily
             - dishcare_dishwasher_program_super_60
             - dishcare_dishwasher_program_kurz_60
@@ -121,6 +122,7 @@ set_program_and_options:
             - cooking_oven_program_heating_mode_pre_heating
             - cooking_oven_program_heating_mode_hot_air
             - cooking_oven_program_heating_mode_hot_air_eco
+            - cooking_oven_program_heating_mode_hot_air_gentle
             - cooking_oven_program_heating_mode_hot_air_grilling
             - cooking_oven_program_heating_mode_top_bottom_heating
             - cooking_oven_program_heating_mode_top_bottom_heating_eco
@@ -147,6 +149,7 @@ set_program_and_options:
             - cooking_oven_program_microwave_900_watt
             - cooking_oven_program_microwave_1000_watt
             - cooking_oven_program_microwave_max
+            - cooking_oven_program_steam_modes_steam
             - cooking_oven_program_heating_mode_warming_drawer
             - laundry_care_washer_program_auto_30
             - laundry_care_washer_program_auto_40
@@ -174,7 +177,7 @@ set_program_and_options:
             - laundry_care_washer_program_rinse_rinse_spin_drain
             - laundry_care_washer_program_sensitive
             - laundry_care_washer_program_shirts_blouses
-            - laundry_care_washer_program_spin_drain
+            - laundry_care_washer_program_spin_spin_drain
             - laundry_care_washer_program_sport_fitness
             - laundry_care_washer_program_super_153045_super_15
             - laundry_care_washer_program_super_153045_super_1530

homeassistant/components/home_connect/strings.json

@@ -240,6 +240,7 @@
           "cooking_oven_program_heating_mode_hot_air_60_steam": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_60_steam%]",
           "cooking_oven_program_heating_mode_hot_air_80_steam": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_80_steam%]",
           "cooking_oven_program_heating_mode_hot_air_eco": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_eco%]",
+          "cooking_oven_program_heating_mode_hot_air_gentle": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_gentle%]",
           "cooking_oven_program_heating_mode_hot_air_grilling": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_grilling%]",
           "cooking_oven_program_heating_mode_intensive_heat": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_intensive_heat%]",
           "cooking_oven_program_heating_mode_keep_warm": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_keep_warm%]",
@@ -271,6 +272,7 @@
           "dishcare_dishwasher_program_intensiv_45": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_intensiv_45%]",
           "dishcare_dishwasher_program_intensiv_70": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_intensiv_70%]",
           "dishcare_dishwasher_program_intensiv_power": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_intensiv_power%]",
+          "dishcare_dishwasher_program_intensive_fixed_zone": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_intensive_fixed_zone%]",
           "dishcare_dishwasher_program_kurz_60": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_kurz_60%]",
           "dishcare_dishwasher_program_learning_dishwasher": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_learning_dishwasher%]",
           "dishcare_dishwasher_program_machine_care": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_machine_care%]",
@@ -350,7 +352,7 @@
           "laundry_care_washer_program_rinse_rinse_spin_drain": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_rinse_rinse_spin_drain%]",
           "laundry_care_washer_program_sensitive": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_sensitive%]",
           "laundry_care_washer_program_shirts_blouses": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_shirts_blouses%]",
-          "laundry_care_washer_program_spin_drain": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_spin_drain%]",
+          "laundry_care_washer_program_spin_spin_drain": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_spin_spin_drain%]",
           "laundry_care_washer_program_sport_fitness": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_sport_fitness%]",
           "laundry_care_washer_program_super_153045_super_15": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_super_153045_super_15%]",
           "laundry_care_washer_program_super_153045_super_1530": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_super_153045_super_1530%]",
@@ -592,6 +594,7 @@
           "cooking_oven_program_heating_mode_hot_air_60_steam": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_60_steam%]",
           "cooking_oven_program_heating_mode_hot_air_80_steam": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_80_steam%]",
           "cooking_oven_program_heating_mode_hot_air_eco": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_eco%]",
+          "cooking_oven_program_heating_mode_hot_air_gentle": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_gentle%]",
           "cooking_oven_program_heating_mode_hot_air_grilling": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_grilling%]",
           "cooking_oven_program_heating_mode_intensive_heat": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_intensive_heat%]",
           "cooking_oven_program_heating_mode_keep_warm": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_keep_warm%]",
@@ -612,6 +615,7 @@
           "cooking_oven_program_microwave_900_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_900_watt%]",
           "cooking_oven_program_microwave_90_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_90_watt%]",
           "cooking_oven_program_microwave_max": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_max%]",
+          "cooking_oven_program_steam_modes_steam": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_steam_modes_steam%]",
           "dishcare_dishwasher_program_auto_1": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_auto_1%]",
           "dishcare_dishwasher_program_auto_2": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_auto_2%]",
           "dishcare_dishwasher_program_auto_3": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_auto_3%]",
@@ -623,6 +627,7 @@
           "dishcare_dishwasher_program_intensiv_45": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_intensiv_45%]",
           "dishcare_dishwasher_program_intensiv_70": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_intensiv_70%]",
           "dishcare_dishwasher_program_intensiv_power": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_intensiv_power%]",
+          "dishcare_dishwasher_program_intensive_fixed_zone": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_intensive_fixed_zone%]",
           "dishcare_dishwasher_program_kurz_60": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_kurz_60%]",
           "dishcare_dishwasher_program_learning_dishwasher": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_learning_dishwasher%]",
           "dishcare_dishwasher_program_machine_care": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_machine_care%]",
@@ -702,7 +707,7 @@
           "laundry_care_washer_program_rinse_rinse_spin_drain": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_rinse_rinse_spin_drain%]",
           "laundry_care_washer_program_sensitive": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_sensitive%]",
           "laundry_care_washer_program_shirts_blouses": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_shirts_blouses%]",
-          "laundry_care_washer_program_spin_drain": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_spin_drain%]",
+          "laundry_care_washer_program_spin_spin_drain": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_spin_spin_drain%]",
           "laundry_care_washer_program_sport_fitness": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_sport_fitness%]",
           "laundry_care_washer_program_super_153045_super_15": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_super_153045_super_15%]",
           "laundry_care_washer_program_super_153045_super_1530": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_program_super_153045_super_1530%]",
@@ -1583,6 +1588,7 @@
         "cooking_oven_program_heating_mode_hot_air_60_steam": "Hot air + 60 RH",
         "cooking_oven_program_heating_mode_hot_air_80_steam": "Hot air + 80 RH",
         "cooking_oven_program_heating_mode_hot_air_eco": "Hot air eco",
+        "cooking_oven_program_heating_mode_hot_air_gentle": "Hot air gentle",
         "cooking_oven_program_heating_mode_hot_air_grilling": "Hot air grilling",
         "cooking_oven_program_heating_mode_intensive_heat": "Intensive heat",
         "cooking_oven_program_heating_mode_keep_warm": "Keep warm",
@@ -1603,6 +1609,7 @@
         "cooking_oven_program_microwave_900_watt": "900 Watt",
         "cooking_oven_program_microwave_90_watt": "90 Watt",
         "cooking_oven_program_microwave_max": "Max",
+        "cooking_oven_program_steam_modes_steam": "Steam mode",
         "dishcare_dishwasher_program_auto_1": "Auto 1",
         "dishcare_dishwasher_program_auto_2": "Auto 2",
         "dishcare_dishwasher_program_auto_3": "Auto 3",
@@ -1614,6 +1621,7 @@
         "dishcare_dishwasher_program_intensiv_45": "Intensive 45ºC",
         "dishcare_dishwasher_program_intensiv_70": "Intensive 70ºC",
         "dishcare_dishwasher_program_intensiv_power": "Intensive power",
+        "dishcare_dishwasher_program_intensive_fixed_zone": "Intensive fixed zone",
         "dishcare_dishwasher_program_kurz_60": "Speed 60ºC",
         "dishcare_dishwasher_program_learning_dishwasher": "Intelligent",
         "dishcare_dishwasher_program_machine_care": "Machine care",
@@ -1693,7 +1701,7 @@
         "laundry_care_washer_program_rinse_rinse_spin_drain": "Rinse spin drain",
         "laundry_care_washer_program_sensitive": "Sensitive",
         "laundry_care_washer_program_shirts_blouses": "Shirts/blouses",
-        "laundry_care_washer_program_spin_drain": "Spin/drain",
+        "laundry_care_washer_program_spin_spin_drain": "Spin/drain",
         "laundry_care_washer_program_sport_fitness": "Sport/fitness",
         "laundry_care_washer_program_super_153045_super_15": "Super 15 min",
         "laundry_care_washer_program_super_153045_super_1530": "Super 15/30 min",

homeassistant/components/homevolt/__init__.py

@@ -1,51 +0,0 @@
-"""The Homevolt integration."""
-
-from __future__ import annotations
-
-from homevolt import Homevolt, HomevoltConnectionError
-
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN, HomevoltConfigEntry
-from .coordinator import HomevoltDataUpdateCoordinator
-
-PLATFORMS: list[Platform] = [Platform.SENSOR]
-
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: HomevoltConfigEntry) -> bool:
-    """Set up Homevolt from a config entry."""
-    host: str = entry.data[CONF_HOST]
-    password: str | None = entry.data.get(CONF_PASSWORD)
-
-    websession = async_get_clientsession(hass)
-    client = Homevolt(host, password, websession=websession)
-
-    try:
-        await client.update_info()
-    except HomevoltConnectionError as err:
-        raise ConfigEntryNotReady(
-            f"Unable to connect to Homevolt battery: {err}"
-        ) from err
-
-    coordinator = HomevoltDataUpdateCoordinator(hass, entry, client)
-    await coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: HomevoltConfigEntry) -> bool:
-    """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        if entry.runtime_data:
-            await entry.runtime_data.client.close_connection()
-    return unload_ok

homeassistant/components/homevolt/config_flow.py

@@ -1,63 +0,0 @@
-"""Config flow for the Homevolt integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from homevolt import Homevolt, HomevoltAuthenticationError, HomevoltConnectionError
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST, CONF_PASSWORD
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_HOST): str,
-        vol.Optional(CONF_PASSWORD): str,
-    }
-)
-
-
-class HomevoltConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Homevolt."""
-
-    VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            host = user_input[CONF_HOST]
-            password = user_input.get(CONF_PASSWORD)
-            websession = async_get_clientsession(self.hass)
-            try:
-                await Homevolt(host, password, websession=websession).update_info()
-            except HomevoltAuthenticationError:
-                errors["base"] = "invalid_auth"
-            except HomevoltConnectionError:
-                errors["base"] = "cannot_connect"
-            except Exception:  # noqa: BLE001
-                errors["base"] = "unknown"
-            else:
-                await self.async_set_unique_id(host)
-                self._abort_if_unique_id_configured()
-
-                return self.async_create_entry(
-                    title="Homevolt Local",
-                    data={
-                        CONF_HOST: host,
-                        CONF_PASSWORD: password,
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )

homeassistant/components/homevolt/const.py

@@ -1,16 +0,0 @@
-"""Constants for the Homevolt integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-from typing import TYPE_CHECKING
-
-from homeassistant.config_entries import ConfigEntry
-
-if TYPE_CHECKING:
-    from .coordinator import HomevoltDataUpdateCoordinator
-
-DOMAIN = "homevolt"
-MANUFACTURER = "Homevolt"
-SCAN_INTERVAL = timedelta(seconds=15)
-type HomevoltConfigEntry = ConfigEntry["HomevoltDataUpdateCoordinator"]

homeassistant/components/homevolt/coordinator.py

@@ -1,51 +0,0 @@
-"""Data update coordinator for Homevolt integration."""
-
-from __future__ import annotations
-
-import logging
-
-from homevolt import (
-    Device,
-    Homevolt,
-    HomevoltAuthenticationError,
-    HomevoltConnectionError,
-    HomevoltError,
-)
-
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN, SCAN_INTERVAL, HomevoltConfigEntry
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class HomevoltDataUpdateCoordinator(DataUpdateCoordinator[Device]):
-    """Class to manage fetching Homevolt data."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: HomevoltConfigEntry,
-        client: Homevolt,
-    ) -> None:
-        """Initialize the Homevolt coordinator."""
-        self.client = client
-        super().__init__(
-            hass,
-            _LOGGER,
-            name=DOMAIN,
-            update_interval=SCAN_INTERVAL,
-            config_entry=entry,
-        )
-
-    async def _async_update_data(self) -> Device:
-        """Fetch data from the Homevolt API."""
-        try:
-            await self.client.update_info()
-            return self.client.get_device()
-        except HomevoltAuthenticationError as err:
-            raise ConfigEntryAuthFailed from err
-        except (HomevoltConnectionError, HomevoltError) as err:
-            raise UpdateFailed(f"Error communicating with device: {err}") from err

homeassistant/components/homevolt/manifest.json

@@ -1,15 +0,0 @@
-{
-  "domain": "homevolt",
-  "name": "Homevolt",
-  "codeowners": ["@danielhiversen"],
-  "config_flow": true,
-  "dependencies": [],
-  "documentation": "https://www.home-assistant.io/integrations/homevolt",
-  "homekit": {},
-  "integration_type": "device",
-  "iot_class": "local_polling",
-  "quality_scale": "bronze",
-  "requirements": ["homevolt==0.2.3"],
-  "ssdp": [],
-  "zeroconf": []
-}

homeassistant/components/homevolt/sensor.py

@@ -1,167 +0,0 @@
-"""Support for Homevolt sensors."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import logging
-
-from homevolt.models import SensorType
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-)
-from homeassistant.const import (
-    PERCENTAGE,
-    SIGNAL_STRENGTH_DECIBELS,
-    UnitOfElectricCurrent,
-    UnitOfElectricPotential,
-    UnitOfEnergy,
-    UnitOfFrequency,
-    UnitOfPower,
-    UnitOfTemperature,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.typing import StateType
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN, MANUFACTURER, HomevoltConfigEntry
-from .coordinator import HomevoltDataUpdateCoordinator
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@dataclass
-class Description:
-    """Sensor metadata description."""
-
-    device_class: SensorDeviceClass | None
-    state_class: SensorStateClass | None
-    native_unit_of_measurement: str | None
-
-
-SENSOR_META: dict[SensorType, Description] = {
-    SensorType.COUNT: Description(
-        None,
-        SensorStateClass.MEASUREMENT,
-        "N",
-    ),
-    SensorType.CURRENT: Description(
-        SensorDeviceClass.CURRENT,
-        SensorStateClass.MEASUREMENT,
-        UnitOfElectricCurrent.AMPERE,
-    ),
-    SensorType.ENERGY_INCREASING: Description(
-        SensorDeviceClass.ENERGY,
-        SensorStateClass.TOTAL_INCREASING,
-        UnitOfEnergy.KILO_WATT_HOUR,
-    ),
-    SensorType.ENERGY_TOTAL: Description(
-        SensorDeviceClass.ENERGY,
-        SensorStateClass.TOTAL,
-        UnitOfEnergy.WATT_HOUR,
-    ),
-    SensorType.FREQUENCY: Description(
-        SensorDeviceClass.FREQUENCY,
-        SensorStateClass.MEASUREMENT,
-        UnitOfFrequency.HERTZ,
-    ),
-    SensorType.PERCENTAGE: Description(
-        SensorDeviceClass.BATTERY,
-        SensorStateClass.MEASUREMENT,
-        PERCENTAGE,
-    ),
-    SensorType.POWER: Description(
-        SensorDeviceClass.POWER,
-        SensorStateClass.MEASUREMENT,
-        UnitOfPower.WATT,
-    ),
-    SensorType.SCHEDULE_TYPE: Description(
-        None,
-        None,
-        None,
-    ),
-    SensorType.SIGNAL_STRENGTH: Description(
-        SensorDeviceClass.SIGNAL_STRENGTH,
-        SensorStateClass.MEASUREMENT,
-        SIGNAL_STRENGTH_DECIBELS,
-    ),
-    SensorType.TEMPERATURE: Description(
-        SensorDeviceClass.TEMPERATURE,
-        SensorStateClass.MEASUREMENT,
-        UnitOfTemperature.CELSIUS,
-    ),
-    SensorType.TEXT: Description(
-        None,
-        None,
-        None,
-    ),
-    SensorType.VOLTAGE: Description(
-        SensorDeviceClass.VOLTAGE,
-        SensorStateClass.MEASUREMENT,
-        UnitOfElectricPotential.VOLT,
-    ),
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: HomevoltConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the Homevolt sensor."""
-    coordinator = entry.runtime_data
-    entities = []
-    for sensor_name, sensor in coordinator.data.sensors.items():
-        if sensor.type not in SENSOR_META:
-            continue
-        sensor_meta = SENSOR_META[sensor.type]
-        entities.append(
-            HomevoltSensor(
-                SensorEntityDescription(
-                    key=sensor_name,
-                    name=sensor_name,
-                    device_class=sensor_meta.device_class,
-                    state_class=sensor_meta.state_class,
-                    native_unit_of_measurement=sensor_meta.native_unit_of_measurement,
-                ),
-                coordinator,
-            )
-        )
-    async_add_entities(entities)
-
-
-class HomevoltSensor(CoordinatorEntity[HomevoltDataUpdateCoordinator], SensorEntity):
-    """Representation of a Homevolt sensor."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        description: SensorEntityDescription,
-        coordinator: HomevoltDataUpdateCoordinator,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        device_id = coordinator.data.device_id
-        self._attr_unique_id = f"{device_id}_{description.key}"
-        sensor = coordinator.data.sensors[description.key]
-        sensor_device_id = sensor.device_identifier
-        device_metadata = coordinator.data.device_metadata.get(sensor_device_id)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, f"{device_id}_{sensor_device_id}")},
-            configuration_url=coordinator.client.hostname,
-            manufacturer=MANUFACTURER,
-            model=device_metadata.model,
-            name=device_metadata.name,
-        )
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the native value of the sensor."""
-        return self.coordinator.data.sensors[self.entity_description.key].value

homeassistant/components/homevolt/strings.json

@@ -1,26 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]",
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "host": "The IP address or hostname of your Homevolt battery on your local network.",
-          "password": "The local password configured for your Homevolt battery, if required."
-        },
-        "description": "Connect Home Assistant to your Homevolt battery over the local network.",
-        "title": "Homevolt Local"
-      }
-    }
-  }
-}

homeassistant/components/israel_rail/sensor.py

@@ -116,6 +116,8 @@ class IsraelRailEntitySensor(
     @property
     def native_value(self) -> StateType | datetime:
         """Return the state of the sensor."""
+        if self.entity_description.index >= len(self.coordinator.data):
+            return None
         return self.entity_description.value_fn(
             self.coordinator.data[self.entity_description.index]
         )

homeassistant/components/jvc_projector/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["jvcprojector"],
-  "requirements": ["pyjvcprojector==1.1.2"]
+  "requirements": ["pyjvcprojector==1.1.3"]
 }

homeassistant/components/jvc_projector/remote.py

@@ -41,6 +41,13 @@ COMMANDS = {
     "mode_1": const.REMOTE_MODE_1,
     "mode_2": const.REMOTE_MODE_2,
     "mode_3": const.REMOTE_MODE_3,
+    "mode_4": const.REMOTE_MODE_4,
+    "mode_5": const.REMOTE_MODE_5,
+    "mode_6": const.REMOTE_MODE_6,
+    "mode_7": const.REMOTE_MODE_7,
+    "mode_8": const.REMOTE_MODE_8,
+    "mode_9": const.REMOTE_MODE_9,
+    "mode_10": const.REMOTE_MODE_10,
     "lens_ap": const.REMOTE_LENS_AP,
     "gamma": const.REMOTE_GAMMA,
     "color_temp": const.REMOTE_COLOR_TEMP,

homeassistant/components/netatmo/binary_sensor.py

@@ -1,5 +1,9 @@
 """Support for Netatmo binary sensors."""
 
+from dataclasses import dataclass
+import logging
+from typing import Final, cast
+
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
@@ -9,17 +13,33 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
 
-from .const import NETATMO_CREATE_WEATHER_SENSOR
+from .const import NETATMO_CREATE_WEATHER_BINARY_SENSOR
 from .data_handler import NetatmoDevice
 from .entity import NetatmoWeatherModuleEntity
 
-BINARY_SENSOR_TYPES: tuple[BinarySensorEntityDescription, ...] = (
-    BinarySensorEntityDescription(
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True, kw_only=True)
+class NetatmoBinarySensorEntityDescription(BinarySensorEntityDescription):
+    """Describes Netatmo binary sensor entity."""
+
+    name: str | None = None  # The default name of the sensor
+    netatmo_name: str  # The name used by Netatmo API for this sensor
+
+
+NETATMO_WEATHER_BINARY_SENSOR_DESCRIPTIONS: Final[
+    list[NetatmoBinarySensorEntityDescription]
+] = [
+    NetatmoBinarySensorEntityDescription(
         key="reachable",
+        name="Connectivity",
+        netatmo_name="reachable",
         device_class=BinarySensorDeviceClass.CONNECTIVITY,
     ),
-)
+]
 
 
 async def async_setup_entry(
@@ -27,36 +47,75 @@ async def async_setup_entry(
     entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up Netatmo binary sensors based on a config entry."""
+    """Set up Netatmo weather binary sensors based on a config entry."""
 
     @callback
     def _create_weather_binary_sensor_entity(netatmo_device: NetatmoDevice) -> None:
-        async_add_entities(
-            NetatmoWeatherBinarySensor(netatmo_device, description)
-            for description in BINARY_SENSOR_TYPES
-            if description.key in netatmo_device.device.features
-        )
+        """Create weather binary sensor entities for a Netatmo weather device."""
+
+        descriptions_to_add = NETATMO_WEATHER_BINARY_SENSOR_DESCRIPTIONS
+
+        entities: list[NetatmoWeatherBinarySensor] = []
+
+        # Create binary sensors for module
+        for description in descriptions_to_add:
+            # Actual check is simple for reachable
+            feature_check = description.key
+            if feature_check in netatmo_device.device.features:
+                _LOGGER.debug(
+                    'Adding "%s" weather binary sensor for device %s',
+                    feature_check,
+                    netatmo_device.device.name,
+                )
+                entities.append(
+                    NetatmoWeatherBinarySensor(
+                        netatmo_device,
+                        description,
+                    )
+                )
+
+        if entities:
+            async_add_entities(entities)
 
     entry.async_on_unload(
         async_dispatcher_connect(
-            hass, NETATMO_CREATE_WEATHER_SENSOR, _create_weather_binary_sensor_entity
+            hass,
+            NETATMO_CREATE_WEATHER_BINARY_SENSOR,
+            _create_weather_binary_sensor_entity,
         )
     )
 
 
 class NetatmoWeatherBinarySensor(NetatmoWeatherModuleEntity, BinarySensorEntity):
-    """Implementation of a Netatmo binary sensor."""
+    """Implementation of a Netatmo weather binary sensor."""
+
+    entity_description: NetatmoBinarySensorEntityDescription
 
     def __init__(
-        self, device: NetatmoDevice, description: BinarySensorEntityDescription
+        self,
+        netatmo_device: NetatmoDevice,
+        description: NetatmoBinarySensorEntityDescription,
     ) -> None:
-        """Initialize a Netatmo binary sensor."""
-        super().__init__(device)
+        """Initialize a Netatmo weather binary sensor."""
+
+        super().__init__(netatmo_device)
+
         self.entity_description = description
         self._attr_unique_id = f"{self.device.entity_id}-{description.key}"
 
     @callback
     def async_update_callback(self) -> None:
         """Update the entity's state."""
-        self._attr_is_on = self.device.reachable
+
+        value: StateType | None = None
+
+        value = getattr(self.device, self.entity_description.netatmo_name, None)
+
+        if value is None:
+            self._attr_available = False
+            self._attr_is_on = False
+        else:
+            self._attr_available = True
+            self._attr_is_on = cast(bool, value)
+
         self.async_write_ha_state()

homeassistant/components/netatmo/const.py

@@ -53,6 +53,7 @@ NETATMO_CREATE_ROOM_SENSOR = "netatmo_create_room_sensor"
 NETATMO_CREATE_SELECT = "netatmo_create_select"
 NETATMO_CREATE_SENSOR = "netatmo_create_sensor"
 NETATMO_CREATE_SWITCH = "netatmo_create_switch"
+NETATMO_CREATE_WEATHER_BINARY_SENSOR = "netatmo_create_weather_binary_sensor"
 NETATMO_CREATE_WEATHER_SENSOR = "netatmo_create_weather_sensor"
 
 CONF_AREA_NAME = "area_name"

homeassistant/components/netatmo/data_handler.py

@@ -45,6 +45,7 @@ from .const import (
     NETATMO_CREATE_SELECT,
     NETATMO_CREATE_SENSOR,
     NETATMO_CREATE_SWITCH,
+    NETATMO_CREATE_WEATHER_BINARY_SENSOR,
     NETATMO_CREATE_WEATHER_SENSOR,
     PLATFORMS,
     WEBHOOK_ACTIVATION,
@@ -332,16 +333,20 @@ class NetatmoDataHandler:
         """Set up home coach/air care modules."""
         for module in self.account.modules.values():
             if module.device_category is NetatmoDeviceCategory.air_care:
-                async_dispatcher_send(
-                    self.hass,
+                for signal in (
+                    NETATMO_CREATE_WEATHER_BINARY_SENSOR,
                     NETATMO_CREATE_WEATHER_SENSOR,
-                    NetatmoDevice(
-                        self,
-                        module,
-                        AIR_CARE,
-                        AIR_CARE,
-                    ),
-                )
+                ):
+                    async_dispatcher_send(
+                        self.hass,
+                        signal,
+                        NetatmoDevice(
+                            self,
+                            module,
+                            AIR_CARE,
+                            AIR_CARE,
+                        ),
+                    )
 
     def setup_modules(self, home: pyatmo.Home, signal_home: str) -> None:
         """Set up modules."""
@@ -379,16 +384,20 @@ class NetatmoDataHandler:
                     ),
                 )
             if module.device_category is NetatmoDeviceCategory.weather:
-                async_dispatcher_send(
-                    self.hass,
+                for signal in (
+                    NETATMO_CREATE_WEATHER_BINARY_SENSOR,
                     NETATMO_CREATE_WEATHER_SENSOR,
-                    NetatmoDevice(
-                        self,
-                        module,
-                        home.entity_id,
-                        WEATHER,
-                    ),
-                )
+                ):
+                    async_dispatcher_send(
+                        self.hass,
+                        signal,
+                        NetatmoDevice(
+                            self,
+                            module,
+                            home.entity_id,
+                            WEATHER,
+                        ),
+                    )
 
     def setup_rooms(self, home: pyatmo.Home, signal_home: str) -> None:
         """Set up rooms."""

homeassistant/components/nordpool/icons.json

@@ -28,9 +28,15 @@
       "exchange_rate": {
         "default": "mdi:currency-usd"
       },
+      "highest_price": {
+        "default": "mdi:cash-plus"
+      },
       "last_price": {
         "default": "mdi:cash"
       },
+      "lowest_price": {
+        "default": "mdi:cash-minus"
+      },
       "next_price": {
         "default": "mdi:cash"
       },

homeassistant/components/openevse/__init__.py

@@ -2,23 +2,23 @@
 
 from __future__ import annotations
 
-import openevsewifi
+from openevsehttp.__main__ import OpenEVSE
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryError
 
-type OpenEVSEConfigEntry = ConfigEntry[openevsewifi.Charger]
+type OpenEVSEConfigEntry = ConfigEntry[OpenEVSE]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: OpenEVSEConfigEntry) -> bool:
     """Set up openevse from a config entry."""
 
-    entry.runtime_data = openevsewifi.Charger(entry.data[CONF_HOST])
+    entry.runtime_data = OpenEVSE(entry.data[CONF_HOST])
     try:
-        await hass.async_add_executor_job(entry.runtime_data.getStatus)
-    except AttributeError as ex:
+        await entry.runtime_data.test_and_get()
+    except TimeoutError as ex:
         raise ConfigEntryError("Unable to connect to charger") from ex
 
     await hass.config_entries.async_forward_entry_setups(entry, [Platform.SENSOR])

homeassistant/components/openevse/config_flow.py

@@ -2,13 +2,14 @@
 
 from typing import Any
 
-import openevsewifi
+from openevsehttp.__main__ import OpenEVSE
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST
+from homeassistant.const import CONF_HOST, CONF_NAME
+from homeassistant.helpers.service_info import zeroconf
 
-from .const import DOMAIN
+from .const import CONF_ID, CONF_SERIAL, DOMAIN
 
 
 class OpenEVSEConfigFlow(ConfigFlow, domain=DOMAIN):
@@ -17,27 +18,33 @@ class OpenEVSEConfigFlow(ConfigFlow, domain=DOMAIN):
     VERSION = 1
     MINOR_VERSION = 1
 
-    async def check_status(self, host: str) -> bool:
+    def __init__(self) -> None:
+        """Set up the instance."""
+        self.discovery_info: dict[str, Any] = {}
+
+    async def check_status(self, host: str) -> tuple[bool, str | None]:
         """Check if we can connect to the OpenEVSE charger."""
 
-        charger = openevsewifi.Charger(host)
+        charger = OpenEVSE(host)
         try:
-            result = await self.hass.async_add_executor_job(charger.getStatus)
-        except AttributeError:
-            return False
-        else:
-            return result is not None
+            result = await charger.test_and_get()
+        except TimeoutError:
+            return False, None
+        return True, result.get(CONF_SERIAL)
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
 
-        errors = None
+        errors = {}
         if user_input is not None:
             self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
 
-            if await self.check_status(user_input[CONF_HOST]):
+            if (result := await self.check_status(user_input[CONF_HOST]))[0]:
+                if (serial := result[1]) is not None:
+                    await self.async_set_unique_id(serial, raise_on_progress=False)
+                    self._abort_if_unique_id_configured()
                 return self.async_create_entry(
                     title=f"OpenEVSE {user_input[CONF_HOST]}",
                     data=user_input,
@@ -55,10 +62,53 @@ class OpenEVSEConfigFlow(ConfigFlow, domain=DOMAIN):
 
         self._async_abort_entries_match({CONF_HOST: data[CONF_HOST]})
 
-        if not await self.check_status(data[CONF_HOST]):
+        if (result := await self.check_status(data[CONF_HOST]))[0]:
+            if (serial := result[1]) is not None:
+                await self.async_set_unique_id(serial)
+                self._abort_if_unique_id_configured()
+        else:
             return self.async_abort(reason="unavailable_host")
 
         return self.async_create_entry(
             title=f"OpenEVSE {data[CONF_HOST]}",
             data=data,
         )
+
+    async def async_step_zeroconf(
+        self, discovery_info: zeroconf.ZeroconfServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle zeroconf discovery."""
+        self._async_abort_entries_match({CONF_HOST: discovery_info.host})
+
+        await self.async_set_unique_id(discovery_info.properties[CONF_ID])
+        self._abort_if_unique_id_configured(updates={CONF_HOST: discovery_info.host})
+
+        host = discovery_info.host
+        name = f"OpenEVSE {discovery_info.name.split('.')[0]}"
+        self.discovery_info.update(
+            {
+                CONF_HOST: host,
+                CONF_NAME: name,
+            }
+        )
+        self.context.update({"title_placeholders": {"name": name}})
+
+        if not (await self.check_status(host))[0]:
+            return self.async_abort(reason="cannot_connect")
+
+        return await self.async_step_discovery_confirm()
+
+    async def async_step_discovery_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Confirm discovery."""
+        if user_input is None:
+            return self.async_show_form(
+                step_id="discovery_confirm",
+                description_placeholders={"name": self.discovery_info[CONF_NAME]},
+            )
+
+        return self.async_create_entry(
+            title=self.discovery_info[CONF_NAME],
+            data={CONF_HOST: self.discovery_info[CONF_HOST]},
+        )

homeassistant/components/openevse/const.py

@@ -1,4 +1,6 @@
 """Constants for the OpenEVSE integration."""
 
+CONF_ID = "id"
+CONF_SERIAL = "serial"
 DOMAIN = "openevse"
 INTEGRATION_TITLE = "OpenEVSE"

homeassistant/components/openevse/manifest.json

@@ -1,12 +1,14 @@
 {
   "domain": "openevse",
   "name": "OpenEVSE",
-  "codeowners": ["@c00w"],
+  "after_dependencies": ["zeroconf"],
+  "codeowners": ["@c00w", "@firstof9"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/openevse",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "loggers": ["openevsewifi"],
+  "loggers": ["openevsehttp"],
   "quality_scale": "legacy",
-  "requirements": ["openevsewifi==1.1.2"]
+  "requirements": ["python-openevse-http==0.2.1"],
+  "zeroconf": ["_openevse._tcp.local."]
 }

homeassistant/components/openevse/sensor.py

@@ -4,8 +4,7 @@ from __future__ import annotations
 
 import logging
 
-import openevsewifi
-from requests import RequestException
+from openevsehttp.__main__ import OpenEVSE
 import voluptuous as vol
 
 from homeassistant.components.sensor import (
@@ -175,7 +174,7 @@ class OpenEVSESensor(SensorEntity):
     def __init__(
         self,
         host: str,
-        charger: openevsewifi.Charger,
+        charger: OpenEVSE,
         description: SensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""
@@ -183,25 +182,28 @@ class OpenEVSESensor(SensorEntity):
         self.host = host
         self.charger = charger
 
-    def update(self) -> None:
+    async def async_update(self) -> None:
         """Get the monitored data from the charger."""
         try:
-            sensor_type = self.entity_description.key
-            if sensor_type == "status":
-                self._attr_native_value = self.charger.getStatus()
-            elif sensor_type == "charge_time":
-                self._attr_native_value = self.charger.getChargeTimeElapsed() / 60
-            elif sensor_type == "ambient_temp":
-                self._attr_native_value = self.charger.getAmbientTemperature()
-            elif sensor_type == "ir_temp":
-                self._attr_native_value = self.charger.getIRTemperature()
-            elif sensor_type == "rtc_temp":
-                self._attr_native_value = self.charger.getRTCTemperature()
-            elif sensor_type == "usage_session":
-                self._attr_native_value = float(self.charger.getUsageSession()) / 1000
-            elif sensor_type == "usage_total":
-                self._attr_native_value = float(self.charger.getUsageTotal()) / 1000
-            else:
-                self._attr_native_value = "Unknown"
-        except (RequestException, ValueError, KeyError):
+            await self.charger.update()
+        except TimeoutError:
             _LOGGER.warning("Could not update status for %s", self.name)
+            return
+
+        sensor_type = self.entity_description.key
+        if sensor_type == "status":
+            self._attr_native_value = self.charger.status
+        elif sensor_type == "charge_time":
+            self._attr_native_value = self.charger.charge_time_elapsed / 60
+        elif sensor_type == "ambient_temp":
+            self._attr_native_value = self.charger.ambient_temperature
+        elif sensor_type == "ir_temp":
+            self._attr_native_value = self.charger.ir_temperature
+        elif sensor_type == "rtc_temp":
+            self._attr_native_value = self.charger.rtc_temperature
+        elif sensor_type == "usage_session":
+            self._attr_native_value = float(self.charger.usage_session) / 1000
+        elif sensor_type == "usage_total":
+            self._attr_native_value = float(self.charger.usage_total) / 1000
+        else:
+            self._attr_native_value = "Unknown"

homeassistant/components/openevse/strings.json

@@ -13,7 +13,7 @@
           "host": "[%key:common::config_flow::data::host%]"
         },
         "data_description": {
-          "host": "Enter the IP Address of your openevse. Should match the address you used to set it up."
+          "host": "Enter the IP address of your OpenEVSE. Should match the address you used to set it up."
         }
       }
     }

homeassistant/components/osoenergy/sensor.py

@@ -55,7 +55,7 @@ SENSOR_TYPES: dict[str, OSOEnergySensorEntityDescription] = {
         key="optimization_mode",
         translation_key="optimization_mode",
         device_class=SensorDeviceClass.ENUM,
-        options=["off", "oso", "gridcompany", "smartcompany", "advanced"],
+        options=["off", "oso", "gridcompany", "smartcompany", "advanced", "nettleie"],
         value_fn=lambda entity_data: entity_data.state.lower(),
     ),
     "power_load": OSOEnergySensorEntityDescription(

homeassistant/components/osoenergy/strings.json

@@ -58,6 +58,7 @@
         "state": {
           "advanced": "Advanced",
           "gridcompany": "Grid company",
+          "nettleie": "Nettleie",
           "off": "[%key:common::state::off%]",
           "oso": "OSO",
           "smartcompany": "Smart company"

homeassistant/components/otbr/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/otbr",
   "integration_type": "service",
   "iot_class": "local_polling",
-  "requirements": ["python-otbr-api==2.7.0"]
+  "requirements": ["python-otbr-api==2.7.1"]
 }

homeassistant/components/overkiz/manifest.json

@@ -13,7 +13,7 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["boto3", "botocore", "pyhumps", "pyoverkiz", "s3transfer"],
-  "requirements": ["pyoverkiz==1.19.3"],
+  "requirements": ["pyoverkiz==1.19.4"],
   "zeroconf": [
     {
       "name": "gateway*",

homeassistant/components/powerfox/__init__.py

@@ -11,7 +11,11 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .coordinator import PowerfoxConfigEntry, PowerfoxDataUpdateCoordinator
+from .coordinator import (
+    PowerfoxConfigEntry,
+    PowerfoxDataUpdateCoordinator,
+    PowerfoxReportDataUpdateCoordinator,
+)
 
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
@@ -30,12 +34,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: PowerfoxConfigEntry) ->
         await client.close()
         raise ConfigEntryNotReady from err
 
-    coordinators: list[PowerfoxDataUpdateCoordinator] = [
-        PowerfoxDataUpdateCoordinator(hass, entry, client, device)
-        for device in devices
-        # Filter out gas meter devices (Powerfox FLOW adapters) as they are not yet supported and cause integration failures
-        if device.type != DeviceType.GAS_METER
-    ]
+    coordinators: list[
+        PowerfoxDataUpdateCoordinator | PowerfoxReportDataUpdateCoordinator
+    ] = []
+    for device in devices:
+        if device.type == DeviceType.GAS_METER:
+            coordinators.append(
+                PowerfoxReportDataUpdateCoordinator(hass, entry, client, device)
+            )
+            continue
+        coordinators.append(PowerfoxDataUpdateCoordinator(hass, entry, client, device))
 
     await asyncio.gather(
         *[

homeassistant/components/powerfox/coordinator.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+from datetime import datetime
+
 from powerfox import (
     Device,
+    DeviceReport,
     Powerfox,
     PowerfoxAuthenticationError,
     PowerfoxConnectionError,
@@ -15,14 +18,18 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.util import dt as dt_util
 
 from .const import DOMAIN, LOGGER, SCAN_INTERVAL
 
-type PowerfoxConfigEntry = ConfigEntry[list[PowerfoxDataUpdateCoordinator]]
+type PowerfoxCoordinator = (
+    "PowerfoxDataUpdateCoordinator" | "PowerfoxReportDataUpdateCoordinator"
+)
+type PowerfoxConfigEntry = ConfigEntry[list[PowerfoxCoordinator]]
 
 
-class PowerfoxDataUpdateCoordinator(DataUpdateCoordinator[Poweropti]):
-    """Class to manage fetching Powerfox data from the API."""
+class PowerfoxBaseCoordinator[T](DataUpdateCoordinator[T]):
+    """Base coordinator handling shared Powerfox logic."""
 
     config_entry: PowerfoxConfigEntry
 
@@ -33,7 +40,7 @@ class PowerfoxDataUpdateCoordinator(DataUpdateCoordinator[Poweropti]):
         client: Powerfox,
         device: Device,
     ) -> None:
-        """Initialize global Powerfox data updater."""
+        """Initialize shared Powerfox coordinator."""
         super().__init__(
             hass,
             LOGGER,
@@ -44,11 +51,37 @@ class PowerfoxDataUpdateCoordinator(DataUpdateCoordinator[Poweropti]):
         self.client = client
         self.device = device
 
-    async def _async_update_data(self) -> Poweropti:
-        """Fetch data from Powerfox API."""
+    async def _async_update_data(self) -> T:
+        """Fetch data and normalize Powerfox errors."""
         try:
-            return await self.client.device(device_id=self.device.id)
+            return await self._async_fetch_data()
         except PowerfoxAuthenticationError as err:
             raise ConfigEntryAuthFailed(err) from err
         except (PowerfoxConnectionError, PowerfoxNoDataError) as err:
             raise UpdateFailed(err) from err
+
+    async def _async_fetch_data(self) -> T:
+        """Fetch data from the Powerfox API."""
+        raise NotImplementedError
+
+
+class PowerfoxDataUpdateCoordinator(PowerfoxBaseCoordinator[Poweropti]):
+    """Class to manage fetching Powerfox data from the API."""
+
+    async def _async_fetch_data(self) -> Poweropti:
+        """Fetch live device data from the Powerfox API."""
+        return await self.client.device(device_id=self.device.id)
+
+
+class PowerfoxReportDataUpdateCoordinator(PowerfoxBaseCoordinator[DeviceReport]):
+    """Coordinator handling report data from the API."""
+
+    async def _async_fetch_data(self) -> DeviceReport:
+        """Fetch report data from the Powerfox API."""
+        local_now = datetime.now(tz=dt_util.get_time_zone(self.hass.config.time_zone))
+        return await self.client.report(
+            device_id=self.device.id,
+            year=local_now.year,
+            month=local_now.month,
+            day=local_now.day,
+        )

homeassistant/components/powerfox/diagnostics.py

@@ -5,18 +5,18 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Any
 
-from powerfox import HeatMeter, PowerMeter, WaterMeter
+from powerfox import DeviceReport, HeatMeter, PowerMeter, WaterMeter
 
 from homeassistant.core import HomeAssistant
 
-from .coordinator import PowerfoxConfigEntry, PowerfoxDataUpdateCoordinator
+from .coordinator import PowerfoxConfigEntry
 
 
 async def async_get_config_entry_diagnostics(
     hass: HomeAssistant, entry: PowerfoxConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for Powerfox config entry."""
-    powerfox_data: list[PowerfoxDataUpdateCoordinator] = entry.runtime_data
+    powerfox_data = entry.runtime_data
 
     return {
         "devices": [
@@ -68,6 +68,21 @@ async def async_get_config_entry_diagnostics(
                     if isinstance(coordinator.data, HeatMeter)
                     else {}
                 ),
+                **(
+                    {
+                        "gas_meter": {
+                            "sum": coordinator.data.gas.sum,
+                            "consumption": coordinator.data.gas.consumption,
+                            "consumption_kwh": coordinator.data.gas.consumption_kwh,
+                            "current_consumption": coordinator.data.gas.current_consumption,
+                            "current_consumption_kwh": coordinator.data.gas.current_consumption_kwh,
+                            "sum_currency": coordinator.data.gas.sum_currency,
+                        }
+                    }
+                    if isinstance(coordinator.data, DeviceReport)
+                    and coordinator.data.gas
+                    else {}
+                ),
             }
             for coordinator in powerfox_data
         ],

homeassistant/components/powerfox/entity.py

@@ -2,23 +2,27 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 from powerfox import Device
 
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
-from .coordinator import PowerfoxDataUpdateCoordinator
+from .coordinator import PowerfoxBaseCoordinator
 
 
-class PowerfoxEntity(CoordinatorEntity[PowerfoxDataUpdateCoordinator]):
+class PowerfoxEntity[CoordinatorT: PowerfoxBaseCoordinator[Any]](
+    CoordinatorEntity[CoordinatorT]
+):
     """Base entity for Powerfox."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        coordinator: PowerfoxDataUpdateCoordinator,
+        coordinator: CoordinatorT,
         device: Device,
     ) -> None:
         """Initialize Powerfox entity."""

homeassistant/components/powerfox/quality_scale.yaml

@@ -70,10 +70,7 @@ rules:
   dynamic-devices: todo
   entity-category: done
   entity-device-class: done
-  entity-disabled-by-default:
-    status: exempt
-    comment: |
-      This integration does not have any entities that should disabled by default.
+  entity-disabled-by-default: done
   entity-translations: done
   exception-translations: done
   icon-translations:

homeassistant/components/powerfox/sensor.py

@@ -4,8 +4,9 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
 
-from powerfox import Device, HeatMeter, PowerMeter, WaterMeter
+from powerfox import Device, GasReport, HeatMeter, PowerMeter, WaterMeter
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -13,11 +14,16 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import UnitOfEnergy, UnitOfPower, UnitOfVolume
+from homeassistant.const import CURRENCY_EURO, UnitOfEnergy, UnitOfPower, UnitOfVolume
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import PowerfoxConfigEntry, PowerfoxDataUpdateCoordinator
+from .coordinator import (
+    PowerfoxBaseCoordinator,
+    PowerfoxConfigEntry,
+    PowerfoxDataUpdateCoordinator,
+    PowerfoxReportDataUpdateCoordinator,
+)
 from .entity import PowerfoxEntity
 
 
@@ -30,6 +36,13 @@ class PowerfoxSensorEntityDescription[T: (PowerMeter, WaterMeter, HeatMeter)](
     value_fn: Callable[[T], float | int | None]
 
 
+@dataclass(frozen=True, kw_only=True)
+class PowerfoxReportSensorEntityDescription(SensorEntityDescription):
+    """Describes Powerfox report sensor entity."""
+
+    value_fn: Callable[[GasReport], float | int | None]
+
+
 SENSORS_POWER: tuple[PowerfoxSensorEntityDescription[PowerMeter], ...] = (
     PowerfoxSensorEntityDescription[PowerMeter](
         key="power",
@@ -126,6 +139,104 @@ SENSORS_HEAT: tuple[PowerfoxSensorEntityDescription[HeatMeter], ...] = (
     ),
 )
 
+SENSORS_GAS: tuple[PowerfoxReportSensorEntityDescription, ...] = (
+    PowerfoxReportSensorEntityDescription(
+        key="gas_consumption_today",
+        translation_key="gas_consumption_today",
+        native_unit_of_measurement=UnitOfVolume.CUBIC_METERS,
+        device_class=SensorDeviceClass.GAS,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        value_fn=lambda gas: gas.sum,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_consumption_energy_today",
+        translation_key="gas_consumption_energy_today",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_registry_enabled_default=False,
+        value_fn=lambda gas: gas.consumption_kwh,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_current_consumption",
+        translation_key="gas_current_consumption",
+        native_unit_of_measurement=UnitOfVolume.CUBIC_METERS,
+        device_class=SensorDeviceClass.GAS,
+        value_fn=lambda gas: gas.current_consumption,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_current_consumption_energy",
+        translation_key="gas_current_consumption_energy",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        entity_registry_enabled_default=False,
+        value_fn=lambda gas: gas.current_consumption_kwh,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_cost_today",
+        translation_key="gas_cost_today",
+        native_unit_of_measurement=CURRENCY_EURO,
+        device_class=SensorDeviceClass.MONETARY,
+        suggested_display_precision=2,
+        state_class=SensorStateClass.TOTAL,
+        value_fn=lambda gas: gas.sum_currency,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_max_consumption_today",
+        translation_key="gas_max_consumption_today",
+        native_unit_of_measurement=UnitOfVolume.CUBIC_METERS,
+        device_class=SensorDeviceClass.GAS,
+        value_fn=lambda gas: gas.max_consumption,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_min_consumption_today",
+        translation_key="gas_min_consumption_today",
+        native_unit_of_measurement=UnitOfVolume.CUBIC_METERS,
+        device_class=SensorDeviceClass.GAS,
+        value_fn=lambda gas: gas.min_consumption,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_avg_consumption_today",
+        translation_key="gas_avg_consumption_today",
+        native_unit_of_measurement=UnitOfVolume.CUBIC_METERS,
+        device_class=SensorDeviceClass.GAS,
+        entity_registry_enabled_default=False,
+        value_fn=lambda gas: gas.avg_consumption,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_max_consumption_energy_today",
+        translation_key="gas_max_consumption_energy_today",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        entity_registry_enabled_default=False,
+        value_fn=lambda gas: gas.max_consumption_kwh,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_min_consumption_energy_today",
+        translation_key="gas_min_consumption_energy_today",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        entity_registry_enabled_default=False,
+        value_fn=lambda gas: gas.min_consumption_kwh,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_avg_consumption_energy_today",
+        translation_key="gas_avg_consumption_energy_today",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        entity_registry_enabled_default=False,
+        value_fn=lambda gas: gas.avg_consumption_kwh,
+    ),
+    PowerfoxReportSensorEntityDescription(
+        key="gas_max_cost_today",
+        translation_key="gas_max_cost_today",
+        native_unit_of_measurement=CURRENCY_EURO,
+        device_class=SensorDeviceClass.MONETARY,
+        suggested_display_precision=2,
+        value_fn=lambda gas: gas.max_currency,
+    ),
+)
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -135,6 +246,20 @@ async def async_setup_entry(
     """Set up Powerfox sensors based on a config entry."""
     entities: list[SensorEntity] = []
     for coordinator in entry.runtime_data:
+        if isinstance(coordinator, PowerfoxReportDataUpdateCoordinator):
+            gas_report = coordinator.data.gas
+            if gas_report is None:
+                continue
+            entities.extend(
+                PowerfoxGasSensorEntity(
+                    coordinator=coordinator,
+                    description=description,
+                    device=coordinator.device,
+                )
+                for description in SENSORS_GAS
+                if description.value_fn(gas_report) is not None
+            )
+            continue
         if isinstance(coordinator.data, PowerMeter):
             entities.extend(
                 PowerfoxSensorEntity(
@@ -166,23 +291,49 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class PowerfoxSensorEntity(PowerfoxEntity, SensorEntity):
-    """Defines a powerfox power meter sensor."""
+class BasePowerfoxSensorEntity[CoordinatorT: PowerfoxBaseCoordinator[Any]](
+    PowerfoxEntity[CoordinatorT], SensorEntity
+):
+    """Common base for Powerfox sensor entities."""
 
-    entity_description: PowerfoxSensorEntityDescription
+    entity_description: SensorEntityDescription
 
     def __init__(
         self,
-        coordinator: PowerfoxDataUpdateCoordinator,
+        coordinator: CoordinatorT,
         device: Device,
-        description: PowerfoxSensorEntityDescription,
+        description: SensorEntityDescription,
     ) -> None:
-        """Initialize Powerfox power meter sensor."""
+        """Initialize the shared Powerfox sensor."""
         super().__init__(coordinator, device)
         self.entity_description = description
         self._attr_unique_id = f"{device.id}_{description.key}"
 
+
+class PowerfoxSensorEntity(BasePowerfoxSensorEntity[PowerfoxDataUpdateCoordinator]):
+    """Defines a powerfox poweropti sensor."""
+
+    coordinator: PowerfoxDataUpdateCoordinator
+    entity_description: PowerfoxSensorEntityDescription
+
     @property
     def native_value(self) -> float | int | None:
         """Return the state of the entity."""
         return self.entity_description.value_fn(self.coordinator.data)
+
+
+class PowerfoxGasSensorEntity(
+    BasePowerfoxSensorEntity[PowerfoxReportDataUpdateCoordinator]
+):
+    """Defines a powerfox gas meter sensor."""
+
+    coordinator: PowerfoxReportDataUpdateCoordinator
+    entity_description: PowerfoxReportSensorEntityDescription
+
+    @property
+    def native_value(self) -> float | int | None:
+        """Return the state of the entity."""
+        gas_report = self.coordinator.data.gas
+        if TYPE_CHECKING:
+            assert gas_report is not None
+        return self.entity_description.value_fn(gas_report)

homeassistant/components/powerfox/strings.json

@@ -62,6 +62,42 @@
       "energy_usage_low_tariff": {
         "name": "Energy usage low tariff"
       },
+      "gas_avg_consumption_energy_today": {
+        "name": "Avg gas hourly energy - today"
+      },
+      "gas_avg_consumption_today": {
+        "name": "Avg gas hourly consumption - today"
+      },
+      "gas_consumption_energy_today": {
+        "name": "Gas consumption energy - today"
+      },
+      "gas_consumption_today": {
+        "name": "Gas consumption - today"
+      },
+      "gas_cost_today": {
+        "name": "Gas cost - today"
+      },
+      "gas_current_consumption": {
+        "name": "Gas consumption - this hour"
+      },
+      "gas_current_consumption_energy": {
+        "name": "Gas consumption energy - this hour"
+      },
+      "gas_max_consumption_energy_today": {
+        "name": "Max gas hourly energy - today"
+      },
+      "gas_max_consumption_today": {
+        "name": "Max gas hourly consumption - today"
+      },
+      "gas_max_cost_today": {
+        "name": "Max gas hourly cost - today"
+      },
+      "gas_min_consumption_energy_today": {
+        "name": "Min gas hourly energy - today"
+      },
+      "gas_min_consumption_today": {
+        "name": "Min gas hourly consumption - today"
+      },
       "heat_delta_energy": {
         "name": "Delta energy"
       },

homeassistant/components/profiler/__init__.py

@@ -453,10 +453,6 @@ async def _async_generate_memory_profile(hass: HomeAssistant, call: ServiceCall)
     # Imports deferred to avoid loading modules
     # in memory since usually only one part of this
     # integration is used at a time
-    if sys.version_info >= (3, 14):
-        raise HomeAssistantError(
-            "Memory profiling is not supported on Python 3.14. Please use Python 3.13."
-        )
     from guppy import hpy  # noqa: PLC0415
 
     start_time = int(time.time() * 1000000)

homeassistant/components/profiler/manifest.json

@@ -7,7 +7,7 @@
   "quality_scale": "internal",
   "requirements": [
     "pyprof2calltree==1.4.5",
-    "guppy3==3.1.5;python_version<'3.14'",
+    "guppy3==3.1.6",
     "objgraph==3.5.0"
   ],
   "single_config_entry": true

homeassistant/components/ring/camera.py

@@ -128,8 +128,9 @@ class RingCam(RingEntity[RingDoorBell], Camera):
         self._device = self._get_coordinator_data().get_video_device(
             self._device.device_api_id
         )
+
         history_data = self._device.last_history
-        if history_data:
+        if history_data and self._device.has_subscription:
             self._last_event = history_data[0]
             # will call async_update to update the attributes and get the
             # video url from the api
@@ -154,8 +155,16 @@ class RingCam(RingEntity[RingDoorBell], Camera):
         self, width: int | None = None, height: int | None = None
     ) -> bytes | None:
         """Return a still image response from the camera."""
+        if self._video_url is None:
+            if not self._device.has_subscription:
+                raise HomeAssistantError(
+                    translation_domain=DOMAIN,
+                    translation_key="no_subscription",
+                )
+            return None
+
         key = (width, height)
-        if not (image := self._images.get(key)) and self._video_url is not None:
+        if not (image := self._images.get(key)):
             image = await ffmpeg.async_get_image(
                 self.hass,
                 self._video_url,

homeassistant/components/ring/strings.json

@@ -151,6 +151,9 @@
     "api_timeout": {
       "message": "Timeout communicating with Ring API"
     },
+    "no_subscription": {
+      "message": "Ring Protect subscription required for snapshots"
+    },
     "sdp_m_line_index_required": {
       "message": "Error negotiating stream for {device}"
     }

homeassistant/components/roborock/manifest.json

@@ -20,7 +20,7 @@
   "loggers": ["roborock"],
   "quality_scale": "silver",
   "requirements": [
-    "python-roborock==4.2.0",
+    "python-roborock==4.2.1",
     "vacuum-map-parser-roborock==0.1.4"
   ]
 }

homeassistant/components/roborock/sensor.py

@@ -391,15 +391,6 @@ Q7_B01_SENSOR_DESCRIPTIONS = [
         translation_key="mop_life_time_left",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    RoborockSensorDescriptionB01(
-        key="total_cleaning_time",
-        value_fn=lambda data: data.real_clean_time,
-        device_class=SensorDeviceClass.DURATION,
-        native_unit_of_measurement=UnitOfTime.MINUTES,
-        suggested_unit_of_measurement=UnitOfTime.HOURS,
-        translation_key="total_cleaning_time",
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
 ]
 
 

homeassistant/components/ruuvitag_ble/manifest.json

@@ -16,5 +16,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/ruuvitag_ble",
   "iot_class": "local_push",
-  "requirements": ["ruuvitag-ble==0.3.0"]
+  "requirements": ["ruuvitag-ble==0.4.0"]
 }

homeassistant/components/sentry/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/sentry",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["sentry-sdk==1.45.1"]
+  "requirements": ["sentry-sdk==2.48.0"]
 }

homeassistant/components/shelly/manifest.json

@@ -17,7 +17,7 @@
   "iot_class": "local_push",
   "loggers": ["aioshelly"],
   "quality_scale": "platinum",
-  "requirements": ["aioshelly==13.23.0"],
+  "requirements": ["aioshelly==13.23.1"],
   "zeroconf": [
     {
       "name": "shelly*",

homeassistant/components/solarlog/manifest.json

@@ -7,5 +7,5 @@
   "iot_class": "local_polling",
   "loggers": ["solarlog_cli"],
   "quality_scale": "platinum",
-  "requirements": ["solarlog_cli==0.6.1"]
+  "requirements": ["solarlog_cli==0.7.0"]
 }

homeassistant/components/switchbot/manifest.json

@@ -42,5 +42,5 @@
   "iot_class": "local_push",
   "loggers": ["switchbot"],
   "quality_scale": "gold",
-  "requirements": ["PySwitchbot==0.75.0"]
+  "requirements": ["PySwitchbot==0.76.0"]
 }

homeassistant/components/telegram/notify.py

@@ -80,10 +80,6 @@ class TelegramNotificationService(BaseNotificationService):
     def send_message(self, message="", **kwargs):
         """Send a message to a user."""
         service_data = {ATTR_TARGET: kwargs.get(ATTR_TARGET, self._chat_id)}
-        if ATTR_TITLE in kwargs:
-            service_data.update({ATTR_TITLE: kwargs.get(ATTR_TITLE)})
-        if message:
-            service_data.update({ATTR_MESSAGE: message})
         data = kwargs.get(ATTR_DATA)
 
         # Set message tag
@@ -161,6 +157,12 @@ class TelegramNotificationService(BaseNotificationService):
             )
 
         # Send message
+
+        if ATTR_TITLE in kwargs:
+            service_data.update({ATTR_TITLE: kwargs.get(ATTR_TITLE)})
+        if message:
+            service_data.update({ATTR_MESSAGE: message})
+
         _LOGGER.debug(
             "TELEGRAM NOTIFIER calling %s.send_message with %s",
             TELEGRAM_BOT_DOMAIN,

homeassistant/components/tesla_fleet/device_tracker.py

@@ -12,6 +12,8 @@ from homeassistant.helpers.restore_state import RestoreEntity
 from .entity import TeslaFleetVehicleEntity
 from .models import TeslaFleetVehicleData
 
+PARALLEL_UPDATES = 0
+
 
 async def async_setup_entry(
     hass: HomeAssistant,

homeassistant/components/tessie/strings.json

@@ -14,6 +14,9 @@
         "data": {
           "access_token": "[%key:common::config_flow::data::access_token%]"
         },
+        "data_description": {
+          "access_token": "[%key:component::tessie::config::step::user::data_description::access_token%]"
+        },
         "description": "[%key:component::tessie::config::step::user::description%]",
         "title": "[%key:common::config_flow::title::reauth%]"
       },
@@ -21,6 +24,9 @@
         "data": {
           "access_token": "[%key:common::config_flow::data::access_token%]"
         },
+        "data_description": {
+          "access_token": "Visit developer settings and select Generate Access Token."
+        },
         "description": "Enter your access token from {url}."
       }
     }

homeassistant/components/thread/manifest.json

@@ -7,7 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/thread",
   "integration_type": "service",
   "iot_class": "local_polling",
-  "requirements": ["python-otbr-api==2.7.0", "pyroute2==0.7.5"],
+  "requirements": ["python-otbr-api==2.7.1", "pyroute2==0.7.5"],
   "single_config_entry": true,
   "zeroconf": ["_meshcop._udp.local."]
 }

homeassistant/components/tibber/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/tibber",
   "iot_class": "cloud_polling",
   "loggers": ["tibber"],
-  "requirements": ["pyTibber==0.34.0"]
+  "requirements": ["pyTibber==0.34.1"]
 }

homeassistant/components/tuya/binary_sensor.py

@@ -463,6 +463,16 @@ class TuyaBinarySensorEntity(TuyaEntity, BinarySensorEntity):
         self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
 
+    async def _handle_state_update(
+        self,
+        updated_status_properties: list[str] | None,
+        dp_timestamps: dict | None = None,
+    ) -> None:
+        """Handle state update, only if this entity's dpcode was actually updated."""
+        if self._dpcode_wrapper.skip_update(self.device, updated_status_properties):
+            return
+        self.async_write_ha_state()
+
     @property
     def is_on(self) -> bool | None:
         """Return true if sensor is on."""

homeassistant/components/unifiprotect/manifest.json

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

homeassistant/components/velbus/icons.json

@@ -1,4 +1,24 @@
 {
+  "entity": {
+    "light": {
+      "button_light": {
+        "state": {
+          "off": "mdi:led-off",
+          "on": "mdi:led-on"
+        }
+      }
+    },
+    "select": {
+      "select_program": {
+        "state": {
+          "0": "mdi:numeric-0-box",
+          "1": "mdi:numeric-1-box",
+          "2": "mdi:numeric-2-box",
+          "3": "mdi:numeric-3-box"
+        }
+      }
+    }
+  },
   "services": {
     "clear_cache": {
       "service": "mdi:delete"

homeassistant/components/velbus/light.py

@@ -113,6 +113,7 @@ class VelbusButtonLight(VelbusEntity, LightEntity):
     _attr_color_mode = ColorMode.ONOFF
     _attr_supported_color_modes = {ColorMode.ONOFF}
     _attr_supported_features = LightEntityFeature.FLASH
+    _attr_translation_key = "button_light"
 
     def __init__(self, channel: VelbusChannel) -> None:
         """Initialize the button light (led)."""

homeassistant/components/velbus/quality_scale.yaml

@@ -40,13 +40,13 @@ rules:
   diagnostics: done
   discovery-update-info: done
   discovery: done
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
   dynamic-devices:
     status: todo
     comment: |
@@ -56,7 +56,7 @@ rules:
   entity-disabled-by-default: done
   entity-translations: todo
   exception-translations: done
-  icon-translations: todo
+  icon-translations: done
   reconfiguration-flow: todo
   repair-issues:
     status: exempt

homeassistant/components/velbus/select.py

@@ -31,6 +31,7 @@ class VelbusSelect(VelbusEntity, SelectEntity):
 
     _channel: SelectedProgram
     _attr_entity_category = EntityCategory.CONFIG
+    _attr_translation_key = "select_program"
 
     def __init__(
         self,

homeassistant/components/velux/binary_sensor.py

@@ -74,6 +74,8 @@ class VeluxRainSensor(VeluxEntity, BinarySensorEntity):
 
         self._attr_available = True
 
-        # Velux windows with rain sensors report an opening limitation of 93 or 100 (Velux GPU) when rain is detected.
-        # So far, only 93 and 100 have been observed in practice, documentation on this is non-existent AFAIK.
-        self._attr_is_on = limitation.min_value in {93, 100}
+        # Velux windows with rain sensors report an opening limitation when rain is detected.
+        # So far we've seen 89, 91, 93 (most cases) or 100 (Velux GPU). It probably makes sense to
+        # assume that any large enough limitation (we use >=89) means rain is detected.
+        # Documentation on this is non-existent AFAIK.
+        self._attr_is_on = limitation.min_value >= 89

homeassistant/components/velux/cover.py

@@ -25,7 +25,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import VeluxConfigEntry
-from .entity import VeluxEntity
+from .entity import VeluxEntity, wrap_pyvlx_call_exceptions
 
 PARALLEL_UPDATES = 1
 
@@ -98,10 +98,7 @@ class VeluxCover(VeluxEntity, CoverEntity):
     @property
     def is_closed(self) -> bool:
         """Return if the cover is closed."""
-        # do not use the node's closed state but rely on cover position
-        # until https://github.com/Julius2342/pyvlx/pull/543 is merged.
-        # once merged this can again return self.node.position.closed
-        return self.current_cover_position == 0
+        return self.node.position.closed
 
     @property
     def is_opening(self) -> bool:
@@ -113,14 +110,17 @@ class VeluxCover(VeluxEntity, CoverEntity):
         """Return if the cover is closing or not."""
         return self.node.is_closing
 
+    @wrap_pyvlx_call_exceptions
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close the cover."""
         await self.node.close(wait_for_completion=False)
 
+    @wrap_pyvlx_call_exceptions
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Open the cover."""
         await self.node.open(wait_for_completion=False)
 
+    @wrap_pyvlx_call_exceptions
     async def async_set_cover_position(self, **kwargs: Any) -> None:
         """Move the cover to a specific position."""
         position_percent = 100 - kwargs[ATTR_POSITION]
@@ -129,22 +129,27 @@ class VeluxCover(VeluxEntity, CoverEntity):
             Position(position_percent=position_percent), wait_for_completion=False
         )
 
+    @wrap_pyvlx_call_exceptions
     async def async_stop_cover(self, **kwargs: Any) -> None:
         """Stop the cover."""
         await self.node.stop(wait_for_completion=False)
 
+    @wrap_pyvlx_call_exceptions
     async def async_close_cover_tilt(self, **kwargs: Any) -> None:
         """Close cover tilt."""
         await cast(Blind, self.node).close_orientation(wait_for_completion=False)
 
+    @wrap_pyvlx_call_exceptions
     async def async_open_cover_tilt(self, **kwargs: Any) -> None:
         """Open cover tilt."""
         await cast(Blind, self.node).open_orientation(wait_for_completion=False)
 
+    @wrap_pyvlx_call_exceptions
     async def async_stop_cover_tilt(self, **kwargs: Any) -> None:
         """Stop cover tilt."""
         await cast(Blind, self.node).stop_orientation(wait_for_completion=False)
 
+    @wrap_pyvlx_call_exceptions
     async def async_set_cover_tilt_position(self, **kwargs: Any) -> None:
         """Move cover tilt to a specific position."""
         position_percent = 100 - kwargs[ATTR_TILT_POSITION]

homeassistant/components/velux/entity.py

@@ -1,10 +1,13 @@
 """Support for VELUX KLF 200 devices."""
 
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Coroutine
+from functools import wraps
 import logging
+from typing import Any, ParamSpec
 
-from pyvlx import Node
+from pyvlx import Node, PyVLXException
 
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
 
@@ -12,6 +15,32 @@ from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
+P = ParamSpec("P")
+
+
+def wrap_pyvlx_call_exceptions(
+    func: Callable[P, Coroutine[Any, Any, None]],
+) -> Callable[P, Coroutine[Any, Any, None]]:
+    """Decorate pyvlx calls to handle exceptions.
+
+    Catches OSError and PyVLXException and wraps them into HomeAssistantError
+    with translation support.
+    """
+
+    @wraps(func)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> None:
+        """Wrap async function to catch exceptions thrown in pyvlx calls."""
+        try:
+            await func(*args, **kwargs)
+        except (OSError, PyVLXException) as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="device_communication_error",
+                translation_placeholders={"error": str(err)},
+            ) from err
+
+    return wrapper
+
 
 class VeluxEntity(Entity):
     """Abstraction for all Velux entities."""

homeassistant/components/velux/light.py

@@ -11,7 +11,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import VeluxConfigEntry
-from .entity import VeluxEntity
+from .entity import VeluxEntity, wrap_pyvlx_call_exceptions
 
 PARALLEL_UPDATES = 1
 
@@ -49,6 +49,7 @@ class VeluxLight(VeluxEntity, LightEntity):
         """Return true if light is on."""
         return not self.node.intensity.off and self.node.intensity.known
 
+    @wrap_pyvlx_call_exceptions
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Instruct the light to turn on."""
         if ATTR_BRIGHTNESS in kwargs:
@@ -60,6 +61,7 @@ class VeluxLight(VeluxEntity, LightEntity):
         else:
             await self.node.turn_on(wait_for_completion=True)
 
+    @wrap_pyvlx_call_exceptions
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Instruct the light to turn off."""
         await self.node.turn_off(wait_for_completion=True)

homeassistant/components/velux/quality_scale.yaml

@@ -22,7 +22,7 @@ rules:
   unique-config-entry: done
 
   # Silver
-  action-exceptions: todo
+  action-exceptions: done
   config-entry-unloading: done
   docs-configuration-parameters: todo
   docs-installation-parameters: todo

homeassistant/components/velux/scene.py

@@ -13,6 +13,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import VeluxConfigEntry
 from .const import DOMAIN
+from .entity import wrap_pyvlx_call_exceptions
 
 PARALLEL_UPDATES = 1
 
@@ -51,6 +52,7 @@ class VeluxScene(Scene):
             identifiers={(DOMAIN, f"gateway_{config_entry_id}")},
         )
 
+    @wrap_pyvlx_call_exceptions
     async def async_activate(self, **kwargs: Any) -> None:
         """Activate the scene."""
         await self.scene.run(wait_for_completion=False)

homeassistant/components/velux/strings.json

@@ -48,6 +48,9 @@
     }
   },
   "exceptions": {
+    "device_communication_error": {
+      "message": "Failed to communicate with Velux device: {error}"
+    },
     "no_gateway_loaded": {
       "message": "No loaded Velux gateway found"
     },

homeassistant/components/vesync/common.py

@@ -4,6 +4,7 @@ import logging
 
 from pyvesync.base_devices import VeSyncHumidifier
 from pyvesync.base_devices.fan_base import VeSyncFanBase
+from pyvesync.base_devices.fryer_base import VeSyncFryer
 from pyvesync.base_devices.outlet_base import VeSyncOutlet
 from pyvesync.base_devices.purifier_base import VeSyncPurifier
 from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseDevice
@@ -62,3 +63,9 @@ def is_purifier(device: VeSyncBaseDevice) -> bool:
     """Check if the device represents an air purifier."""
 
     return isinstance(device, VeSyncPurifier)
+
+
+def is_air_fryer(device: VeSyncBaseDevice) -> bool:
+    """Check if the device represents an air fryer."""
+
+    return isinstance(device, VeSyncFryer)

homeassistant/components/vesync/const.py

@@ -62,3 +62,14 @@ OUTLET_NIGHT_LIGHT_LEVEL_ON = "on"
 PURIFIER_NIGHT_LIGHT_LEVEL_DIM = "dim"
 PURIFIER_NIGHT_LIGHT_LEVEL_OFF = "off"
 PURIFIER_NIGHT_LIGHT_LEVEL_ON = "on"
+
+AIR_FRYER_MODE_MAP = {
+    "cookend": "cooking_end",
+    "cooking": "cooking",
+    "cookstop": "cooking_stop",
+    "heating": "heating",
+    "preheatend": "preheat_end",
+    "preheatstop": "preheat_stop",
+    "pullout": "pull_out",
+    "standby": "standby",
+}

homeassistant/components/vesync/sensor.py

@@ -23,14 +23,15 @@ from homeassistant.const import (
     UnitOfEnergy,
     UnitOfPower,
     UnitOfTemperature,
+    UnitOfTime,
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 
-from .common import is_humidifier, is_outlet, rgetattr
-from .const import VS_DEVICES, VS_DISCOVERY
+from .common import is_air_fryer, is_humidifier, is_outlet, rgetattr
+from .const import AIR_FRYER_MODE_MAP, VS_DEVICES, VS_DISCOVERY
 from .coordinator import VesyncConfigEntry, VeSyncDataCoordinator
 from .entity import VeSyncBaseEntity
 
@@ -47,6 +48,8 @@ class VeSyncSensorEntityDescription(SensorEntityDescription):
 
     exists_fn: Callable[[VeSyncBaseDevice], bool]
 
+    use_device_temperature_unit: bool = False
+
 
 SENSORS: tuple[VeSyncSensorEntityDescription, ...] = (
     VeSyncSensorEntityDescription(
@@ -167,6 +170,59 @@ SENSORS: tuple[VeSyncSensorEntityDescription, ...] = (
         exists_fn=lambda device: is_humidifier(device)
         and device.state.temperature is not None,
     ),
+    VeSyncSensorEntityDescription(
+        key="cook_status",
+        translation_key="cook_status",
+        device_class=SensorDeviceClass.ENUM,
+        value_fn=lambda device: AIR_FRYER_MODE_MAP.get(
+            device.state.cook_status.lower(), device.state.cook_status.lower()
+        ),
+        exists_fn=is_air_fryer,
+        options=[
+            "cooking_end",
+            "cooking",
+            "cooking_stop",
+            "heating",
+            "preheat_end",
+            "preheat_stop",
+            "pull_out",
+            "standby",
+        ],
+    ),
+    VeSyncSensorEntityDescription(
+        key="current_temp",
+        translation_key="current_temp",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        use_device_temperature_unit=True,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda device: device.state.current_temp,
+        exists_fn=is_air_fryer,
+    ),
+    VeSyncSensorEntityDescription(
+        key="cook_set_temp",
+        translation_key="cook_set_temp",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        use_device_temperature_unit=True,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda device: device.state.cook_set_temp,
+        exists_fn=is_air_fryer,
+    ),
+    VeSyncSensorEntityDescription(
+        key="cook_set_time",
+        translation_key="cook_set_time",
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.MINUTES,
+        value_fn=lambda device: device.state.cook_set_time,
+        exists_fn=is_air_fryer,
+    ),
+    VeSyncSensorEntityDescription(
+        key="preheat_set_time",
+        translation_key="preheat_set_time",
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.MINUTES,
+        value_fn=lambda device: device.state.preheat_set_time,
+        exists_fn=is_air_fryer,
+    ),
 )
 
 
@@ -232,3 +288,13 @@ class VeSyncSensorEntity(VeSyncBaseEntity, SensorEntity):
     def native_value(self) -> StateType:
         """Return the state of the sensor."""
         return self.entity_description.value_fn(self.device)
+
+    @property
+    def native_unit_of_measurement(self) -> str | None:
+        """Return the unit the value was reported in by the sensor."""
+        if self.entity_description.use_device_temperature_unit:
+            if self.device.temp_unit == "celsius":
+                return UnitOfTemperature.CELSIUS
+            if self.device.temp_unit == "fahrenheit":
+                return UnitOfTemperature.FAHRENHEIT
+        return super().native_unit_of_measurement

homeassistant/components/vesync/strings.json

@@ -92,9 +92,31 @@
       "air_quality": {
         "name": "Air quality"
       },
+      "cook_set_temp": {
+        "name": "Cooking set temperature"
+      },
+      "cook_set_time": {
+        "name": "Cooking set time"
+      },
+      "cook_status": {
+        "name": "Cooking status",
+        "state": {
+          "cooking": "Cooking",
+          "cooking_end": "Cooking finished",
+          "cooking_stop": "Cooking stopped",
+          "heating": "Preheating",
+          "preheat_end": "Preheating finished",
+          "preheat_stop": "Preheating stopped",
+          "pull_out": "Drawer pulled out",
+          "standby": "[%key:common::state::standby%]"
+        }
+      },
       "current_power": {
         "name": "Current power"
       },
+      "current_temp": {
+        "name": "Current temperature"
+      },
       "current_voltage": {
         "name": "Current voltage"
       },
@@ -112,6 +134,9 @@
       },
       "filter_life": {
         "name": "Filter lifetime"
+      },
+      "preheat_set_time": {
+        "name": "Preheating set time"
       }
     },
     "switch": {

homeassistant/components/vodafone_station/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "loggers": ["aiovodafone"],
   "quality_scale": "platinum",
-  "requirements": ["aiovodafone==3.0.0"]
+  "requirements": ["aiovodafone==3.1.1"]
 }

homeassistant/components/waterfurnace/manifest.json

@@ -1,8 +1,9 @@
 {
   "domain": "waterfurnace",
   "name": "WaterFurnace",
-  "codeowners": [],
+  "codeowners": ["@sdague", "@masterkoppa"],
   "documentation": "https://www.home-assistant.io/integrations/waterfurnace",
+  "integration_type": "device",
   "iot_class": "cloud_polling",
   "loggers": ["waterfurnace"],
   "quality_scale": "legacy",

homeassistant/components/watts/manifest.json

@@ -3,7 +3,7 @@
   "name": "Watts Vision +",
   "codeowners": ["@theobld-ww", "@devender-verma-ww", "@ssi-spyro"],
   "config_flow": true,
-  "dependencies": ["application_credentials"],
+  "dependencies": ["application_credentials", "cloud"],
   "documentation": "https://www.home-assistant.io/integrations/watts",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",