Bump zeroconf to 1.0.0

no breaking changes for HA. Packaging change only

changelog: https://github.com/python-zeroconf/python-zeroconf/compare/0.147.2...1.0.0

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.30.5
+        uses: github/codeql-action/init@64d10c13136e1c5bce3e5fbde8d4906eeaafc885 # v3.30.6
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.30.5
+        uses: github/codeql-action/analyze@64d10c13136e1c5bce3e5fbde8d4906eeaafc885 # v3.30.6
         with:
           category: "/language:python"

.strict-typing

@@ -326,6 +326,7 @@ homeassistant.components.london_underground.*
 homeassistant.components.lookin.*
 homeassistant.components.lovelace.*
 homeassistant.components.luftdaten.*
+homeassistant.components.lunatone.*
 homeassistant.components.madvr.*
 homeassistant.components.manual.*
 homeassistant.components.mastodon.*
@@ -554,6 +555,7 @@ homeassistant.components.vacuum.*
 homeassistant.components.vallox.*
 homeassistant.components.valve.*
 homeassistant.components.velbus.*
+homeassistant.components.vivotek.*
 homeassistant.components.vlc_telnet.*
 homeassistant.components.vodafone_station.*
 homeassistant.components.volvo.*

CODEOWNERS

@@ -910,6 +910,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/luci/ @mzdrale
 /homeassistant/components/luftdaten/ @fabaff @frenck
 /tests/components/luftdaten/ @fabaff @frenck
+/homeassistant/components/lunatone/ @MoonDevLT
+/tests/components/lunatone/ @MoonDevLT
 /homeassistant/components/lupusec/ @majuss @suaveolent
 /tests/components/lupusec/ @majuss @suaveolent
 /homeassistant/components/lutron/ @cdheiser @wilburCForce
@@ -1194,8 +1196,6 @@ build.json @home-assistant/supervisor
 /tests/components/plex/ @jjlawren
 /homeassistant/components/plugwise/ @CoMPaTech @bouwew
 /tests/components/plugwise/ @CoMPaTech @bouwew
-/homeassistant/components/plum_lightpad/ @ColinHarrington @prystupa
-/tests/components/plum_lightpad/ @ColinHarrington @prystupa
 /homeassistant/components/point/ @fredrike
 /tests/components/point/ @fredrike
 /homeassistant/components/pooldose/ @lmaertin

build.yaml

@@ -1,10 +1,10 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
-  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.09.3
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.09.3
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.09.3
-  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.09.3
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.09.3
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.10.0
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.0
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.0
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.0
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.0
 codenotary:
   signer: notary@home-assistant.io
   base_image: notary@home-assistant.io

homeassistant/bootstrap.py

@@ -616,34 +616,44 @@ async def async_enable_logging(
         ),
     )
 
-    # Log errors to a file if we have write access to file or config dir
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO if verbose else logging.WARNING)
+
     if log_file is None:
-        err_log_path = hass.config.path(ERROR_LOG_FILENAME)
+        default_log_path = hass.config.path(ERROR_LOG_FILENAME)
+        if "SUPERVISOR" in os.environ:
+            _LOGGER.info("Running in Supervisor, not logging to file")
+            # Rename the default log file if it exists, since previous versions created
+            # it even on Supervisor
+            if os.path.isfile(default_log_path):
+                with contextlib.suppress(OSError):
+                    os.rename(default_log_path, f"{default_log_path}.old")
+            err_log_path = None
+        else:
+            err_log_path = default_log_path
     else:
         err_log_path = os.path.abspath(log_file)
 
-    err_path_exists = os.path.isfile(err_log_path)
-    err_dir = os.path.dirname(err_log_path)
+    if err_log_path:
+        err_path_exists = os.path.isfile(err_log_path)
+        err_dir = os.path.dirname(err_log_path)
 
-    # Check if we can write to the error log if it exists or that
-    # we can create files in the containing directory if not.
-    if (err_path_exists and os.access(err_log_path, os.W_OK)) or (
-        not err_path_exists and os.access(err_dir, os.W_OK)
-    ):
-        err_handler = await hass.async_add_executor_job(
-            _create_log_file, err_log_path, log_rotate_days
-        )
+        # Check if we can write to the error log if it exists or that
+        # we can create files in the containing directory if not.
+        if (err_path_exists and os.access(err_log_path, os.W_OK)) or (
+            not err_path_exists and os.access(err_dir, os.W_OK)
+        ):
+            err_handler = await hass.async_add_executor_job(
+                _create_log_file, err_log_path, log_rotate_days
+            )
 
-        err_handler.setFormatter(logging.Formatter(fmt, datefmt=FORMAT_DATETIME))
+            err_handler.setFormatter(logging.Formatter(fmt, datefmt=FORMAT_DATETIME))
+            logger.addHandler(err_handler)
 
-        logger = logging.getLogger()
-        logger.addHandler(err_handler)
-        logger.setLevel(logging.INFO if verbose else logging.WARNING)
-
-        # Save the log file location for access by other components.
-        hass.data[DATA_LOGGING] = err_log_path
-    else:
-        _LOGGER.error("Unable to set up error log %s (access denied)", err_log_path)
+            # Save the log file location for access by other components.
+            hass.data[DATA_LOGGING] = err_log_path
+        else:
+            _LOGGER.error("Unable to set up error log %s (access denied)", err_log_path)
 
     async_activate_log_queue_handler(hass)
 

homeassistant/brands/ibm.json

@@ -1,5 +0,0 @@
-{
-  "domain": "ibm",
-  "name": "IBM",
-  "integrations": ["watson_iot", "watson_tts"]
-}

homeassistant/components/airos/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/airos",
   "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["airos==0.5.3"]
+  "requirements": ["airos==0.5.4"]
 }

homeassistant/components/airthings/config_flow.py

@@ -23,6 +23,10 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
     }
 )
 
+URL_API_INTEGRATION = {
+    "url": "https://dashboard.airthings.com/integrations/api-integration"
+}
+
 
 class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Airthings."""
@@ -37,11 +41,7 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
             return self.async_show_form(
                 step_id="user",
                 data_schema=STEP_USER_DATA_SCHEMA,
-                description_placeholders={
-                    "url": (
-                        "https://dashboard.airthings.com/integrations/api-integration"
-                    ),
-                },
+                description_placeholders=URL_API_INTEGRATION,
             )
 
         errors = {}
@@ -65,5 +65,8 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
             return self.async_create_entry(title="Airthings", data=user_input)
 
         return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
+            step_id="user",
+            data_schema=STEP_USER_DATA_SCHEMA,
+            errors=errors,
+            description_placeholders=URL_API_INTEGRATION,
         )

homeassistant/components/airthings/strings.json

@@ -4,9 +4,9 @@
       "user": {
         "data": {
           "id": "ID",
-          "secret": "Secret",
-          "description": "Login at {url} to find your credentials"
-        }
+          "secret": "Secret"
+        },
+        "description": "Log in at {url} to find your credentials"
       }
     },
     "error": {

homeassistant/components/airthings_ble/config_flow.py

@@ -171,7 +171,7 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
             return self.async_abort(reason="no_devices_found")
 
         titles = {
-            address: discovery.device.name
+            address: get_name(discovery.device)
             for (address, discovery) in self._discovered_devices.items()
         }
         return self.async_show_form(

homeassistant/components/airthings_ble/manifest.json

@@ -24,5 +24,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/airthings_ble",
   "iot_class": "local_polling",
-  "requirements": ["airthings-ble==0.9.2"]
+  "requirements": ["airthings-ble==1.1.1"]
 }

homeassistant/components/airthings_ble/sensor.py

@@ -114,6 +114,8 @@ SENSORS_MAPPING_TEMPLATE: dict[str, SensorEntityDescription] = {
     ),
 }
 
+PARALLEL_UPDATES = 0
+
 
 @callback
 def async_migrate(hass: HomeAssistant, address: str, sensor_name: str) -> None:

homeassistant/components/airthings_ble/strings.json

@@ -6,6 +6,9 @@
         "description": "[%key:component::bluetooth::config::step::user::description%]",
         "data": {
           "address": "[%key:common::config_flow::data::device%]"
+        },
+        "data_description": {
+          "address": "The Airthings devices discovered via Bluetooth."
         }
       },
       "bluetooth_confirm": {

homeassistant/components/airtouch4/__init__.py

@@ -2,17 +2,14 @@
 
 from airtouch4pyapi import AirTouch
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 
-from .coordinator import AirtouchDataUpdateCoordinator
+from .coordinator import AirTouch4ConfigEntry, AirtouchDataUpdateCoordinator
 
 PLATFORMS = [Platform.CLIMATE]
 
-type AirTouch4ConfigEntry = ConfigEntry[AirtouchDataUpdateCoordinator]
-
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirTouch4ConfigEntry) -> bool:
     """Set up AirTouch4 from a config entry."""
@@ -22,7 +19,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirTouch4ConfigEntry) ->
     info = airtouch.GetAcs()
     if not info:
         raise ConfigEntryNotReady
-    coordinator = AirtouchDataUpdateCoordinator(hass, airtouch)
+    coordinator = AirtouchDataUpdateCoordinator(hass, entry, airtouch)
     await coordinator.async_config_entry_first_refresh()
     entry.runtime_data = coordinator
 

homeassistant/components/airtouch4/coordinator.py

@@ -2,26 +2,34 @@
 
 import logging
 
+from airtouch4pyapi import AirTouch
 from airtouch4pyapi.airtouch import AirTouchStatus
 
 from homeassistant.components.climate import SCAN_INTERVAL
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
+type AirTouch4ConfigEntry = ConfigEntry[AirtouchDataUpdateCoordinator]
+
 
 class AirtouchDataUpdateCoordinator(DataUpdateCoordinator):
     """Class to manage fetching Airtouch data."""
 
-    def __init__(self, hass, airtouch):
+    def __init__(
+        self, hass: HomeAssistant, entry: AirTouch4ConfigEntry, airtouch: AirTouch
+    ) -> None:
         """Initialize global Airtouch data updater."""
         self.airtouch = airtouch
 
         super().__init__(
             hass,
             _LOGGER,
+            config_entry=entry,
             name=DOMAIN,
             update_interval=SCAN_INTERVAL,
         )

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/analytics/analytics.py

@@ -505,7 +505,7 @@ DEFAULT_DEVICE_ANALYTICS_CONFIG = DeviceAnalyticsModifications()
 DEFAULT_ENTITY_ANALYTICS_CONFIG = EntityAnalyticsModifications()
 
 
-async def async_devices_payload(hass: HomeAssistant) -> dict:
+async def async_devices_payload(hass: HomeAssistant) -> dict:  # noqa: C901
     """Return detailed information about entities and devices."""
     dev_reg = dr.async_get(hass)
     ent_reg = er.async_get(hass)
@@ -513,6 +513,8 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:
     integration_inputs: dict[str, tuple[list[str], list[str]]] = {}
     integration_configs: dict[str, AnalyticsModifications] = {}
 
+    removed_devices: set[str] = set()
+
     # Get device list
     for device_entry in dev_reg.devices.values():
         if not device_entry.primary_config_entry:
@@ -525,6 +527,10 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:
         if config_entry is None:
             continue
 
+        if device_entry.entry_type is dr.DeviceEntryType.SERVICE:
+            removed_devices.add(device_entry.id)
+            continue
+
         integration_domain = config_entry.domain
 
         integration_input = integration_inputs.setdefault(integration_domain, ([], []))
@@ -614,15 +620,15 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:
                 device_config = integration_config.devices.get(device_id, device_config)
 
             if device_config.remove:
+                removed_devices.add(device_id)
                 continue
 
             device_entry = dev_reg.devices[device_id]
 
-            device_id_mapping[device_entry.id] = (integration_domain, len(devices_info))
+            device_id_mapping[device_id] = (integration_domain, len(devices_info))
 
             devices_info.append(
                 {
-                    "entities": [],
                     "entry_type": device_entry.entry_type,
                     "has_configuration_url": device_entry.configuration_url is not None,
                     "hw_version": device_entry.hw_version,
@@ -631,6 +637,7 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:
                     "model_id": device_entry.model_id,
                     "sw_version": device_entry.sw_version,
                     "via_device": device_entry.via_device_id,
+                    "entities": [],
                 }
             )
 
@@ -669,7 +676,7 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:
 
             entity_entry = ent_reg.entities[entity_id]
 
-            entity_state = hass.states.get(entity_entry.entity_id)
+            entity_state = hass.states.get(entity_id)
 
             entity_info = {
                 # LIMITATION: `assumed_state` can be overridden by users;
@@ -690,15 +697,19 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:
                 "unit_of_measurement": entity_entry.unit_of_measurement,
             }
 
-            if (
-                ((device_id_ := entity_entry.device_id) is not None)
-                and ((new_device_id := device_id_mapping.get(device_id_)) is not None)
-                and (new_device_id[0] == integration_domain)
-            ):
-                device_info = devices_info[new_device_id[1]]
-                device_info["entities"].append(entity_info)
-            else:
-                entities_info.append(entity_info)
+            if (device_id_ := entity_entry.device_id) is not None:
+                if device_id_ in removed_devices:
+                    # The device was removed, so we remove the entity too
+                    continue
+
+                if (
+                    new_device_id := device_id_mapping.get(device_id_)
+                ) is not None and (new_device_id[0] == integration_domain):
+                    device_info = devices_info[new_device_id[1]]
+                    device_info["entities"].append(entity_info)
+                    continue
+
+            entities_info.append(entity_info)
 
     return {
         "version": "home-assistant:1",

homeassistant/components/asuswrt/helpers.py

@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, TypeVar
-
-T = TypeVar("T", dict[str, Any], list[Any], None)
+from typing import Any
 
 TRANSLATION_MAP = {
     "wan_rx": "sensor_rx_bytes",
@@ -36,7 +34,7 @@ def clean_dict(raw: dict[str, Any]) -> dict[str, Any]:
     return {k: v for k, v in raw.items() if v is not None or k.endswith("state")}
 
 
-def translate_to_legacy(raw: T) -> T:
+def translate_to_legacy[T: (dict[str, Any], list[Any], None)](raw: T) -> T:
     """Translate raw data to legacy format for dicts and lists."""
 
     if raw is None:

homeassistant/components/awair/__init__.py

@@ -26,9 +26,6 @@ async def async_setup_entry(
 
     if CONF_HOST in config_entry.data:
         coordinator = AwairLocalDataUpdateCoordinator(hass, config_entry, session)
-        config_entry.async_on_unload(
-            config_entry.add_update_listener(_async_update_listener)
-        )
     else:
         coordinator = AwairCloudDataUpdateCoordinator(hass, config_entry, session)
 
@@ -36,6 +33,11 @@ async def async_setup_entry(
 
     config_entry.runtime_data = coordinator
 
+    if CONF_HOST in config_entry.data:
+        config_entry.async_on_unload(
+            config_entry.add_update_listener(_async_update_listener)
+        )
+
     await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
 
     return True

homeassistant/components/bayesian/binary_sensor.py

@@ -272,6 +272,13 @@ async def async_setup_entry(
     observations: list[ConfigType] = [
         dict(subentry.data) for subentry in config_entry.subentries.values()
     ]
+
+    for observation in observations:
+        if observation[CONF_PLATFORM] == CONF_TEMPLATE:
+            observation[CONF_VALUE_TEMPLATE] = Template(
+                observation[CONF_VALUE_TEMPLATE], hass
+            )
+
     prior: float = config[CONF_PRIOR]
     probability_threshold: float = config[CONF_PROBABILITY_THRESHOLD]
     device_class: BinarySensorDeviceClass | None = config.get(CONF_DEVICE_CLASS)

homeassistant/components/bluetooth/manifest.json

@@ -19,8 +19,8 @@
     "bleak-retry-connector==4.4.3",
     "bluetooth-adapters==2.1.0",
     "bluetooth-auto-recovery==1.5.3",
-    "bluetooth-data-tools==1.28.2",
-    "dbus-fast==2.44.3",
-    "habluetooth==5.6.4"
+    "bluetooth-data-tools==1.28.3",
+    "dbus-fast==2.44.5",
+    "habluetooth==5.7.0"
   ]
 }

homeassistant/components/camera/__init__.py

@@ -51,12 +51,6 @@ from homeassistant.const import (
 from homeassistant.core import Event, HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, issue_registry as ir
-from homeassistant.helpers.deprecation import (
-    DeprecatedConstantEnum,
-    all_with_deprecated_constants,
-    check_if_deprecated_constant,
-    dir_with_deprecated_constants,
-)
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.event import async_track_time_interval
@@ -118,12 +112,6 @@ ATTR_FILENAME: Final = "filename"
 ATTR_MEDIA_PLAYER: Final = "media_player"
 ATTR_FORMAT: Final = "format"
 
-# These constants are deprecated as of Home Assistant 2024.10
-# Please use the StreamType enum instead.
-_DEPRECATED_STATE_RECORDING = DeprecatedConstantEnum(CameraState.RECORDING, "2025.10")
-_DEPRECATED_STATE_STREAMING = DeprecatedConstantEnum(CameraState.STREAMING, "2025.10")
-_DEPRECATED_STATE_IDLE = DeprecatedConstantEnum(CameraState.IDLE, "2025.10")
-
 
 class CameraEntityFeature(IntFlag):
     """Supported features of the camera entity."""
@@ -1117,11 +1105,3 @@ async def async_handle_record_service(
         duration=service_call.data[CONF_DURATION],
         lookback=service_call.data[CONF_LOOKBACK],
     )
-
-
-# These can be removed if no deprecated constant are in this module anymore
-__getattr__ = partial(check_if_deprecated_constant, module_globals=globals())
-__dir__ = partial(
-    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
-)
-__all__ = all_with_deprecated_constants(globals())

homeassistant/components/conversation/manifest.json

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

homeassistant/components/cync/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "quality_scale": "bronze",
-  "requirements": ["pycync==0.4.0"]
+  "requirements": ["pycync==0.4.1"]
 }

homeassistant/components/devolo_home_control/binary_sensor.py

@@ -126,7 +126,7 @@ class DevoloRemoteControl(DevoloDeviceEntity, BinarySensorEntity):
         self._attr_translation_key = "button"
         self._attr_translation_placeholders = {"key": str(key)}
 
-    def _sync(self, message: tuple) -> None:
+    def sync_callback(self, message: tuple) -> None:
         """Update the binary sensor state."""
         if (
             message[0] == self._remote_control_property.element_uid

homeassistant/components/devolo_home_control/entity.py

@@ -48,7 +48,6 @@ class DevoloDeviceEntity(Entity):
         )
 
         self.subscriber: Subscriber | None = None
-        self.sync_callback = self._sync
 
         self._value: float
 
@@ -69,7 +68,7 @@ class DevoloDeviceEntity(Entity):
             self._device_instance.uid, self.subscriber
         )
 
-    def _sync(self, message: tuple) -> None:
+    def sync_callback(self, message: tuple) -> None:
         """Update the state."""
         if message[0] == self._attr_unique_id:
             self._value = message[1]

homeassistant/components/devolo_home_control/sensor.py

@@ -185,7 +185,7 @@ class DevoloConsumptionEntity(DevoloMultiLevelDeviceEntity):
         """
         return f"{self._attr_unique_id}_{self._sensor_type}"
 
-    def _sync(self, message: tuple) -> None:
+    def sync_callback(self, message: tuple) -> None:
         """Update the consumption sensor state."""
         if message[0] == self._attr_unique_id:
             self._value = getattr(

homeassistant/components/devolo_home_control/subscriber.py

@@ -13,8 +13,3 @@ class Subscriber:
         """Initiate the subscriber."""
         self.name = name
         self.callback = callback
-
-    def update(self, message: str) -> None:
-        """Trigger hass to update the device."""
-        _LOGGER.debug('%s got message "%s"', self.name, message)
-        self.callback(message)

homeassistant/components/devolo_home_control/switch.py

@@ -64,7 +64,7 @@ class DevoloSwitch(DevoloDeviceEntity, SwitchEntity):
         """Switch off the device."""
         self._binary_switch_property.set(state=False)
 
-    def _sync(self, message: tuple) -> None:
+    def sync_callback(self, message: tuple) -> None:
         """Update the binary switch state and consumption."""
         if message[0].startswith("devolo.BinarySwitch"):
             self._attr_is_on = self._device_instance.binary_switch_property[

homeassistant/components/dhcp/manifest.json

@@ -17,6 +17,6 @@
   "requirements": [
     "aiodhcpwatcher==1.2.1",
     "aiodiscover==2.7.1",
-    "cached-ipaddress==0.10.0"
+    "cached-ipaddress==1.0.1"
   ]
 }

homeassistant/components/enphase_envoy/manifest.json

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

homeassistant/components/esphome/analytics.py

@@ -0,0 +1,11 @@
+"""Analytics platform."""
+
+from homeassistant.components.analytics import AnalyticsInput, AnalyticsModifications
+from homeassistant.core import HomeAssistant
+
+
+async def async_modify_analytics(
+    hass: HomeAssistant, analytics_input: AnalyticsInput
+) -> AnalyticsModifications:
+    """Modify the analytics."""
+    return AnalyticsModifications(remove=True)

homeassistant/components/esphome/manifest.json

@@ -19,7 +19,7 @@
   "requirements": [
     "aioesphomeapi==41.11.0",
     "esphome-dashboard-api==1.3.0",
-    "bleak-esphome==3.3.0"
+    "bleak-esphome==3.4.0"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/firefly_iii/config_flow.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 import logging
 from typing import Any
 
@@ -84,6 +85,48 @@ class FireflyConfigFlow(ConfigFlow, domain=DOMAIN):
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
 
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauth when Firefly III API authentication fails."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reauth: ask for a new API key and validate."""
+        errors: dict[str, str] = {}
+        reauth_entry = self._get_reauth_entry()
+        if user_input is not None:
+            try:
+                await _validate_input(
+                    self.hass,
+                    data={
+                        **reauth_entry.data,
+                        CONF_API_KEY: user_input[CONF_API_KEY],
+                    },
+                )
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except InvalidAuth:
+                errors["base"] = "invalid_auth"
+            except FireflyClientTimeout:
+                errors["base"] = "timeout_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                return self.async_update_reload_and_abort(
+                    reauth_entry,
+                    data_updates={CONF_API_KEY: user_input[CONF_API_KEY]},
+                )
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=vol.Schema({vol.Required(CONF_API_KEY): str}),
+            errors=errors,
+        )
+
 
 class CannotConnect(HomeAssistantError):
     """Error to indicate we cannot connect."""

homeassistant/components/firefly_iii/coordinator.py

@@ -18,7 +18,7 @@ from pyfirefly.models import Account, Bill, Budget, Category, Currency
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY, CONF_URL, CONF_VERIFY_SSL
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_create_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -72,7 +72,7 @@ class FireflyDataUpdateCoordinator(DataUpdateCoordinator[FireflyCoordinatorData]
         try:
             await self.firefly.get_about()
         except FireflyAuthenticationError as err:
-            raise ConfigEntryError(
+            raise ConfigEntryAuthFailed(
                 translation_domain=DOMAIN,
                 translation_key="invalid_auth",
                 translation_placeholders={"error": repr(err)},
@@ -109,7 +109,7 @@ class FireflyDataUpdateCoordinator(DataUpdateCoordinator[FireflyCoordinatorData]
             budgets = await self.firefly.get_budgets()
             bills = await self.firefly.get_bills()
         except FireflyAuthenticationError as err:
-            raise UpdateFailed(
+            raise ConfigEntryAuthFailed(
                 translation_domain=DOMAIN,
                 translation_key="invalid_auth",
                 translation_placeholders={"error": repr(err)},

homeassistant/components/firefly_iii/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/firefly_iii",
   "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["pyfirefly==0.1.5"]
+  "requirements": ["pyfirefly==0.1.6"]
 }

homeassistant/components/firefly_iii/sensor.py

@@ -100,15 +100,6 @@ class FireflyAccountEntity(FireflyBaseEntity, SensorEntity):
         """Return the state of the sensor."""
         return self._account.attributes.current_balance
 
-    @property
-    def extra_state_attributes(self) -> dict[str, str] | None:
-        """Return extra state attributes for the account entity."""
-        return {
-            "account_role": self._account.attributes.account_role or "",
-            "account_type": self._account.attributes.type or "",
-            "current_balance": str(self._account.attributes.current_balance or ""),
-        }
-
 
 class FireflyCategoryEntity(FireflyBaseEntity, SensorEntity):
     """Entity for Firefly III category."""

homeassistant/components/firefly_iii/strings.json

@@ -13,6 +13,15 @@
           "verify_ssl": "Verify the SSL certificate of the Firefly instance"
         },
         "description": "You can create an API key in the Firefly UI. Go to **Options > Profile** and select the **OAuth** tab. Create a new personal access token and copy it (it will only display once)."
+      },
+      "reauth_confirm": {
+        "data": {
+          "api_key": "[%key:common::config_flow::data::api_key%]"
+        },
+        "data_description": {
+          "api_key": "The new API access token for authenticating with Firefly III"
+        },
+        "description": "The access token for your Firefly III instance is invalid and needs to be updated. Go to **Options > Profile** and select the **OAuth** tab. Create a new personal access token and copy it (it will only display once)."
       }
     },
     "error": {
@@ -22,7 +31,8 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     }
   },
   "exceptions": {

homeassistant/components/frontend/__init__.py

@@ -452,6 +452,10 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     hass.http.app.router.register_resource(IndexView(repo_path, hass))
 
+    async_register_built_in_panel(hass, "light")
+    async_register_built_in_panel(hass, "security")
+    async_register_built_in_panel(hass, "climate")
+
     async_register_built_in_panel(hass, "profile")
 
     async_register_built_in_panel(

homeassistant/components/google_generative_ai_conversation/entity.py

@@ -620,6 +620,13 @@ class GoogleGenerativeAILLMBaseEntity(Entity):
     def create_generate_content_config(self) -> GenerateContentConfig:
         """Create the GenerateContentConfig for the LLM."""
         options = self.subentry.data
+        model = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
+        thinking_config: ThinkingConfig | None = None
+        if model.startswith("models/gemini-2.5") and not model.endswith(
+            ("tts", "image", "image-preview")
+        ):
+            thinking_config = ThinkingConfig(include_thoughts=True)
+
         return GenerateContentConfig(
             temperature=options.get(CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE),
             top_k=options.get(CONF_TOP_K, RECOMMENDED_TOP_K),
@@ -652,7 +659,7 @@ class GoogleGenerativeAILLMBaseEntity(Entity):
                     ),
                 ),
             ],
-            thinking_config=ThinkingConfig(include_thoughts=True),
+            thinking_config=thinking_config,
         )
 
 

homeassistant/components/google_travel_time/sensor.py

@@ -22,6 +22,7 @@ from google.protobuf import timestamp_pb2
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
+    SensorEntityDescription,
     SensorStateClass,
 )
 from homeassistant.config_entries import ConfigEntry
@@ -91,6 +92,16 @@ def convert_time(time_str: str) -> timestamp_pb2.Timestamp | None:
     return timestamp
 
 
+SENSOR_DESCRIPTIONS = [
+    SensorEntityDescription(
+        key="duration",
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.MINUTES,
+    )
+]
+
+
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: ConfigEntry,
@@ -105,20 +116,20 @@ async def async_setup_entry(
     client_options = ClientOptions(api_key=api_key)
     client = RoutesAsyncClient(client_options=client_options)
 
-    sensor = GoogleTravelTimeSensor(
-        config_entry, name, api_key, origin, destination, client
-    )
+    sensors = [
+        GoogleTravelTimeSensor(
+            config_entry, name, api_key, origin, destination, client, sensor_description
+        )
+        for sensor_description in SENSOR_DESCRIPTIONS
+    ]
 
-    async_add_entities([sensor], False)
+    async_add_entities(sensors, False)
 
 
 class GoogleTravelTimeSensor(SensorEntity):
     """Representation of a Google travel time sensor."""
 
     _attr_attribution = ATTRIBUTION
-    _attr_native_unit_of_measurement = UnitOfTime.MINUTES
-    _attr_device_class = SensorDeviceClass.DURATION
-    _attr_state_class = SensorStateClass.MEASUREMENT
 
     def __init__(
         self,
@@ -128,8 +139,10 @@ class GoogleTravelTimeSensor(SensorEntity):
         origin: str,
         destination: str,
         client: RoutesAsyncClient,
+        sensor_description: SensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""
+        self.entity_description = sensor_description
         self._attr_name = name
         self._attr_unique_id = config_entry.entry_id
         self._attr_device_info = DeviceInfo(

homeassistant/components/growatt_server/__init__.py

@@ -1,14 +1,18 @@
 """The Growatt server PV inverter sensor integration."""
 
 from collections.abc import Mapping
+import logging
 
 import growattServer
 
-from homeassistant.const import CONF_PASSWORD, CONF_URL, CONF_USERNAME
+from homeassistant.const import CONF_PASSWORD, CONF_TOKEN, CONF_URL, CONF_USERNAME
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryError
 
 from .const import (
+    AUTH_API_TOKEN,
+    AUTH_PASSWORD,
+    CONF_AUTH_TYPE,
     CONF_PLANT_ID,
     DEFAULT_PLANT_ID,
     DEFAULT_URL,
@@ -19,36 +23,110 @@ from .const import (
 from .coordinator import GrowattConfigEntry, GrowattCoordinator
 from .models import GrowattRuntimeData
 
+_LOGGER = logging.getLogger(__name__)
 
-def get_device_list(
+
+def get_device_list_classic(
     api: growattServer.GrowattApi, config: Mapping[str, str]
 ) -> tuple[list[dict[str, str]], str]:
     """Retrieve the device list for the selected plant."""
     plant_id = config[CONF_PLANT_ID]
 
     # Log in to api and fetch first plant if no plant id is defined.
-    login_response = api.login(config[CONF_USERNAME], config[CONF_PASSWORD])
-    if (
-        not login_response["success"]
-        and login_response["msg"] == LOGIN_INVALID_AUTH_CODE
-    ):
-        raise ConfigEntryError("Username, Password or URL may be incorrect!")
+    try:
+        login_response = api.login(config[CONF_USERNAME], config[CONF_PASSWORD])
+        # DEBUG: Log the actual response structure
+    except Exception as ex:
+        _LOGGER.error("DEBUG - Login response: %s", login_response)
+        raise ConfigEntryError(
+            f"Error communicating with Growatt API during login: {ex}"
+        ) from ex
+
+    if not login_response.get("success"):
+        msg = login_response.get("msg", "Unknown error")
+        _LOGGER.debug("Growatt login failed: %s", msg)
+        if msg == LOGIN_INVALID_AUTH_CODE:
+            raise ConfigEntryAuthFailed("Username, Password or URL may be incorrect!")
+        raise ConfigEntryError(f"Growatt login failed: {msg}")
+
     user_id = login_response["user"]["id"]
+
     if plant_id == DEFAULT_PLANT_ID:
-        plant_info = api.plant_list(user_id)
+        try:
+            plant_info = api.plant_list(user_id)
+        except Exception as ex:
+            raise ConfigEntryError(
+                f"Error communicating with Growatt API during plant list: {ex}"
+            ) from ex
+        if not plant_info or "data" not in plant_info or not plant_info["data"]:
+            raise ConfigEntryError("No plants found for this account.")
         plant_id = plant_info["data"][0]["plantId"]
 
     # Get a list of devices for specified plant to add sensors for.
-    devices = api.device_list(plant_id)
+    try:
+        devices = api.device_list(plant_id)
+    except Exception as ex:
+        raise ConfigEntryError(
+            f"Error communicating with Growatt API during device list: {ex}"
+        ) from ex
+
     return devices, plant_id
 
 
+def get_device_list_v1(
+    api, config: Mapping[str, str]
+) -> tuple[list[dict[str, str]], str]:
+    """Device list logic for Open API V1.
+
+    Note: Plant selection (including auto-selection if only one plant exists)
+    is handled in the config flow before this function is called. This function
+    only fetches devices for the already-selected plant_id.
+    """
+    plant_id = config[CONF_PLANT_ID]
+    try:
+        devices_dict = api.device_list(plant_id)
+    except growattServer.GrowattV1ApiError as e:
+        raise ConfigEntryError(
+            f"API error during device list: {e} (Code: {getattr(e, 'error_code', None)}, Message: {getattr(e, 'error_msg', None)})"
+        ) from e
+    devices = devices_dict.get("devices", [])
+    # Only MIN device (type = 7) support implemented in current V1 API
+    supported_devices = [
+        {
+            "deviceSn": device.get("device_sn", ""),
+            "deviceType": "min",
+        }
+        for device in devices
+        if device.get("type") == 7
+    ]
+
+    for device in devices:
+        if device.get("type") != 7:
+            _LOGGER.warning(
+                "Device %s with type %s not supported in Open API V1, skipping",
+                device.get("device_sn", ""),
+                device.get("type"),
+            )
+    return supported_devices, plant_id
+
+
+def get_device_list(
+    api, config: Mapping[str, str], api_version: str
+) -> tuple[list[dict[str, str]], str]:
+    """Dispatch to correct device list logic based on API version."""
+    if api_version == "v1":
+        return get_device_list_v1(api, config)
+    if api_version == "classic":
+        return get_device_list_classic(api, config)
+    raise ConfigEntryError(f"Unknown API version: {api_version}")
+
+
 async def async_setup_entry(
     hass: HomeAssistant, config_entry: GrowattConfigEntry
 ) -> bool:
     """Set up Growatt from a config entry."""
+
     config = config_entry.data
-    username = config[CONF_USERNAME]
     url = config.get(CONF_URL, DEFAULT_URL)
 
     # If the URL has been deprecated then change to the default instead
@@ -58,11 +136,24 @@ async def async_setup_entry(
         new_data[CONF_URL] = url
         hass.config_entries.async_update_entry(config_entry, data=new_data)
 
-    # Initialise the library with the username & a random id each time it is started
-    api = growattServer.GrowattApi(add_random_user_id=True, agent_identifier=username)
-    api.server_url = url
+    # Determine API version
+    if config.get(CONF_AUTH_TYPE) == AUTH_API_TOKEN:
+        api_version = "v1"
+        token = config[CONF_TOKEN]
+        api = growattServer.OpenApiV1(token=token)
+    elif config.get(CONF_AUTH_TYPE) == AUTH_PASSWORD:
+        api_version = "classic"
+        username = config[CONF_USERNAME]
+        api = growattServer.GrowattApi(
+            add_random_user_id=True, agent_identifier=username
+        )
+        api.server_url = url
+    else:
+        raise ConfigEntryError("Unknown authentication type in config entry.")
 
-    devices, plant_id = await hass.async_add_executor_job(get_device_list, api, config)
+    devices, plant_id = await hass.async_add_executor_job(
+        get_device_list, api, config, api_version
+    )
 
     # Create a coordinator for the total sensors
     total_coordinator = GrowattCoordinator(
@@ -75,7 +166,7 @@ async def async_setup_entry(
             hass, config_entry, device["deviceSn"], device["deviceType"], plant_id
         )
         for device in devices
-        if device["deviceType"] in ["inverter", "tlx", "storage", "mix"]
+        if device["deviceType"] in ["inverter", "tlx", "storage", "mix", "min"]
     }
 
     # Perform the first refresh for the total coordinator

homeassistant/components/growatt_server/config_flow.py

@@ -1,22 +1,38 @@
 """Config flow for growatt server integration."""
 
+import logging
 from typing import Any
 
 import growattServer
+import requests
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_NAME, CONF_PASSWORD, CONF_URL, CONF_USERNAME
+from homeassistant.const import (
+    CONF_NAME,
+    CONF_PASSWORD,
+    CONF_TOKEN,
+    CONF_URL,
+    CONF_USERNAME,
+)
 from homeassistant.core import callback
 
 from .const import (
+    ABORT_NO_PLANTS,
+    AUTH_API_TOKEN,
+    AUTH_PASSWORD,
+    CONF_AUTH_TYPE,
     CONF_PLANT_ID,
     DEFAULT_URL,
     DOMAIN,
+    ERROR_CANNOT_CONNECT,
+    ERROR_INVALID_AUTH,
     LOGIN_INVALID_AUTH_CODE,
     SERVER_URLS,
 )
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
     """Config flow class."""
@@ -27,12 +43,98 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialise growatt server flow."""
-        self.user_id = None
+        self.user_id: str | None = None
         self.data: dict[str, Any] = {}
+        self.auth_type: str | None = None
+        self.plants: list[dict[str, Any]] = []
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the start of the config flow."""
+        return self.async_show_menu(
+            step_id="user",
+            menu_options=["password_auth", "token_auth"],
+        )
+
+    async def async_step_password_auth(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle username/password authentication."""
+        if user_input is None:
+            return self._async_show_password_form()
+
+        self.auth_type = AUTH_PASSWORD
+
+        # Traditional username/password authentication
+        self.api = growattServer.GrowattApi(
+            add_random_user_id=True, agent_identifier=user_input[CONF_USERNAME]
+        )
+        self.api.server_url = user_input[CONF_URL]
+
+        try:
+            login_response = await self.hass.async_add_executor_job(
+                self.api.login, user_input[CONF_USERNAME], user_input[CONF_PASSWORD]
+            )
+        except requests.exceptions.RequestException as ex:
+            _LOGGER.error("Network error during Growatt API login: %s", ex)
+            return self._async_show_password_form({"base": ERROR_CANNOT_CONNECT})
+        except (ValueError, KeyError, TypeError, AttributeError) as ex:
+            _LOGGER.error("Invalid response format during login: %s", ex)
+            return self._async_show_password_form({"base": ERROR_CANNOT_CONNECT})
+
+        if (
+            not login_response["success"]
+            and login_response["msg"] == LOGIN_INVALID_AUTH_CODE
+        ):
+            return self._async_show_password_form({"base": ERROR_INVALID_AUTH})
+
+        self.user_id = login_response["user"]["id"]
+        self.data = user_input
+        self.data[CONF_AUTH_TYPE] = self.auth_type
+        return await self.async_step_plant()
+
+    async def async_step_token_auth(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle API token authentication."""
+        if user_input is None:
+            return self._async_show_token_form()
+
+        self.auth_type = AUTH_API_TOKEN
+
+        # Using token authentication
+        token = user_input[CONF_TOKEN]
+        self.api = growattServer.OpenApiV1(token=token)
+
+        # Verify token by fetching plant list
+        try:
+            plant_response = await self.hass.async_add_executor_job(self.api.plant_list)
+            self.plants = plant_response.get("plants", [])
+        except requests.exceptions.RequestException as ex:
+            _LOGGER.error("Network error during Growatt V1 API plant list: %s", ex)
+            return self._async_show_token_form({"base": ERROR_CANNOT_CONNECT})
+        except growattServer.GrowattV1ApiError as e:
+            _LOGGER.error(
+                "Growatt V1 API error: %s (Code: %s)",
+                e.error_msg or str(e),
+                getattr(e, "error_code", None),
+            )
+            return self._async_show_token_form({"base": ERROR_INVALID_AUTH})
+        except (ValueError, KeyError, TypeError, AttributeError) as ex:
+            _LOGGER.error(
+                "Invalid response format during Growatt V1 API plant list: %s", ex
+            )
+            return self._async_show_token_form({"base": ERROR_CANNOT_CONNECT})
+        self.data = user_input
+        self.data[CONF_AUTH_TYPE] = self.auth_type
+        return await self.async_step_plant()
 
     @callback
-    def _async_show_user_form(self, errors=None):
-        """Show the form to the user."""
+    def _async_show_password_form(
+        self, errors: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Show the username/password form to the user."""
         data_schema = vol.Schema(
             {
                 vol.Required(CONF_USERNAME): str,
@@ -42,58 +144,87 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
         )
 
         return self.async_show_form(
-            step_id="user", data_schema=data_schema, errors=errors
+            step_id="password_auth", data_schema=data_schema, errors=errors
         )
 
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
+    @callback
+    def _async_show_token_form(
+        self, errors: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Handle the start of the config flow."""
-        if not user_input:
-            return self._async_show_user_form()
-
-        # Initialise the library with the username & a random id each time it is started
-        self.api = growattServer.GrowattApi(
-            add_random_user_id=True, agent_identifier=user_input[CONF_USERNAME]
-        )
-        self.api.server_url = user_input[CONF_URL]
-        login_response = await self.hass.async_add_executor_job(
-            self.api.login, user_input[CONF_USERNAME], user_input[CONF_PASSWORD]
+        """Show the API token form to the user."""
+        data_schema = vol.Schema(
+            {
+                vol.Required(CONF_TOKEN): str,
+            }
         )
 
-        if (
-            not login_response["success"]
-            and login_response["msg"] == LOGIN_INVALID_AUTH_CODE
-        ):
-            return self._async_show_user_form({"base": "invalid_auth"})
-        self.user_id = login_response["user"]["id"]
-
-        self.data = user_input
-        return await self.async_step_plant()
+        return self.async_show_form(
+            step_id="token_auth",
+            data_schema=data_schema,
+            errors=errors,
+        )
 
     async def async_step_plant(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle adding a "plant" to Home Assistant."""
-        plant_info = await self.hass.async_add_executor_job(
-            self.api.plant_list, self.user_id
-        )
+        if self.auth_type == AUTH_API_TOKEN:
+            # Using V1 API with token
+            if not self.plants:
+                return self.async_abort(reason=ABORT_NO_PLANTS)
 
-        if not plant_info["data"]:
-            return self.async_abort(reason="no_plants")
+            # Create dictionary of plant_id -> name
+            plant_dict = {
+                str(plant["plant_id"]): plant.get("name", "Unknown Plant")
+                for plant in self.plants
+            }
 
-        plants = {plant["plantId"]: plant["plantName"] for plant in plant_info["data"]}
+            if user_input is None and len(plant_dict) > 1:
+                data_schema = vol.Schema(
+                    {vol.Required(CONF_PLANT_ID): vol.In(plant_dict)}
+                )
+                return self.async_show_form(step_id="plant", data_schema=data_schema)
 
-        if user_input is None and len(plant_info["data"]) > 1:
-            data_schema = vol.Schema({vol.Required(CONF_PLANT_ID): vol.In(plants)})
+            if user_input is None:
+                # Single plant => mark it as selected
+                user_input = {CONF_PLANT_ID: list(plant_dict.keys())[0]}
 
-            return self.async_show_form(step_id="plant", data_schema=data_schema)
+            user_input[CONF_NAME] = plant_dict[user_input[CONF_PLANT_ID]]
 
-        if user_input is None:
-            # single plant => mark it as selected
-            user_input = {CONF_PLANT_ID: plant_info["data"][0]["plantId"]}
+        else:
+            # Traditional API
+            try:
+                plant_info = await self.hass.async_add_executor_job(
+                    self.api.plant_list, self.user_id
+                )
+            except requests.exceptions.RequestException as ex:
+                _LOGGER.error("Network error during Growatt API plant list: %s", ex)
+                return self.async_abort(reason=ERROR_CANNOT_CONNECT)
+
+            # Access plant_info["data"] - validate response structure
+            if not isinstance(plant_info, dict) or "data" not in plant_info:
+                _LOGGER.error(
+                    "Invalid response format during plant list: missing 'data' key"
+                )
+                return self.async_abort(reason=ERROR_CANNOT_CONNECT)
+
+            plant_data = plant_info["data"]
+
+            if not plant_data:
+                return self.async_abort(reason=ABORT_NO_PLANTS)
+
+            plants = {plant["plantId"]: plant["plantName"] for plant in plant_data}
+
+            if user_input is None and len(plant_data) > 1:
+                data_schema = vol.Schema({vol.Required(CONF_PLANT_ID): vol.In(plants)})
+                return self.async_show_form(step_id="plant", data_schema=data_schema)
+
+            if user_input is None:
+                # single plant => mark it as selected
+                user_input = {CONF_PLANT_ID: plant_data[0]["plantId"]}
+
+            user_input[CONF_NAME] = plants[user_input[CONF_PLANT_ID]]
 
-        user_input[CONF_NAME] = plants[user_input[CONF_PLANT_ID]]
         await self.async_set_unique_id(user_input[CONF_PLANT_ID])
         self._abort_if_unique_id_configured()
         self.data.update(user_input)

homeassistant/components/growatt_server/const.py

@@ -4,6 +4,16 @@ from homeassistant.const import Platform
 
 CONF_PLANT_ID = "plant_id"
 
+
+# API key support
+CONF_API_KEY = "api_key"
+
+# Auth types for config flow
+AUTH_PASSWORD = "password"
+AUTH_API_TOKEN = "api_token"
+CONF_AUTH_TYPE = "auth_type"
+DEFAULT_AUTH_TYPE = AUTH_PASSWORD
+
 DEFAULT_PLANT_ID = "0"
 
 DEFAULT_NAME = "Growatt"
@@ -29,3 +39,10 @@ DOMAIN = "growatt_server"
 PLATFORMS = [Platform.SENSOR]
 
 LOGIN_INVALID_AUTH_CODE = "502"
+
+# Config flow error types (also used as abort reasons)
+ERROR_CANNOT_CONNECT = "cannot_connect"  # Used for both form errors and aborts
+ERROR_INVALID_AUTH = "invalid_auth"
+
+# Config flow abort reasons
+ABORT_NO_PLANTS = "no_plants"

homeassistant/components/growatt_server/coordinator.py

@@ -1,5 +1,7 @@
 """Coordinator module for managing Growatt data fetching."""
 
+from __future__ import annotations
+
 import datetime
 import json
 import logging
@@ -38,23 +40,31 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         plant_id: str,
     ) -> None:
         """Initialize the coordinator."""
-        self.username = config_entry.data[CONF_USERNAME]
-        self.password = config_entry.data[CONF_PASSWORD]
-        self.url = config_entry.data.get(CONF_URL, DEFAULT_URL)
-        self.api = growattServer.GrowattApi(
-            add_random_user_id=True, agent_identifier=self.username
+        self.api_version = (
+            "v1" if config_entry.data.get("auth_type") == "api_token" else "classic"
         )
-
-        # Set server URL
-        self.api.server_url = self.url
-
         self.device_id = device_id
         self.device_type = device_type
         self.plant_id = plant_id
-
-        # Initialize previous_values to store historical data
         self.previous_values: dict[str, Any] = {}
 
+        if self.api_version == "v1":
+            self.username = None
+            self.password = None
+            self.url = config_entry.data.get(CONF_URL, DEFAULT_URL)
+            self.token = config_entry.data["token"]
+            self.api = growattServer.OpenApiV1(token=self.token)
+        elif self.api_version == "classic":
+            self.username = config_entry.data.get(CONF_USERNAME)
+            self.password = config_entry.data[CONF_PASSWORD]
+            self.url = config_entry.data.get(CONF_URL, DEFAULT_URL)
+            self.api = growattServer.GrowattApi(
+                add_random_user_id=True, agent_identifier=self.username
+            )
+            self.api.server_url = self.url
+        else:
+            raise ValueError(f"Unknown API version: {self.api_version}")
+
         super().__init__(
             hass,
             _LOGGER,
@@ -67,21 +77,54 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         """Update data via library synchronously."""
         _LOGGER.debug("Updating data for %s (%s)", self.device_id, self.device_type)
 
-        # Login in to the Growatt server
-        self.api.login(self.username, self.password)
+        # login only required for classic API
+        if self.api_version == "classic":
+            self.api.login(self.username, self.password)
 
         if self.device_type == "total":
-            total_info = self.api.plant_info(self.device_id)
-            del total_info["deviceList"]
-            plant_money_text, currency = total_info["plantMoneyText"].split("/")
-            total_info["plantMoneyText"] = plant_money_text
-            total_info["currency"] = currency
+            if self.api_version == "v1":
+                # The V1 Plant APIs do not provide the same information as the classic plant_info() API
+                # More specifically:
+                # 1. There is no monetary information to be found, so today and lifetime money is not available
+                # 2. There is no nominal power, this is provided by inverter min_energy()
+                # This means, for the total coordinator we can only fetch and map the following:
+                # todayEnergy -> today_energy
+                # totalEnergy -> total_energy
+                # invTodayPpv -> current_power
+                total_info = self.api.plant_energy_overview(self.plant_id)
+                total_info["todayEnergy"] = total_info["today_energy"]
+                total_info["totalEnergy"] = total_info["total_energy"]
+                total_info["invTodayPpv"] = total_info["current_power"]
+            else:
+                # Classic API: use plant_info as before
+                total_info = self.api.plant_info(self.device_id)
+                del total_info["deviceList"]
+                plant_money_text, currency = total_info["plantMoneyText"].split("/")
+                total_info["plantMoneyText"] = plant_money_text
+                total_info["currency"] = currency
+            _LOGGER.debug("Total info for plant %s: %r", self.plant_id, total_info)
             self.data = total_info
         elif self.device_type == "inverter":
             self.data = self.api.inverter_detail(self.device_id)
+        elif self.device_type == "min":
+            # Open API V1: min device
+            try:
+                min_details = self.api.min_detail(self.device_id)
+                min_settings = self.api.min_settings(self.device_id)
+                min_energy = self.api.min_energy(self.device_id)
+            except growattServer.GrowattV1ApiError as err:
+                _LOGGER.error(
+                    "Error fetching min device data for %s: %s", self.device_id, err
+                )
+                raise UpdateFailed(f"Error fetching min device data: {err}") from err
+
+            min_info = {**min_details, **min_settings, **min_energy}
+            self.data = min_info
+            _LOGGER.debug("min_info for device %s: %r", self.device_id, min_info)
         elif self.device_type == "tlx":
             tlx_info = self.api.tlx_detail(self.device_id)
             self.data = tlx_info["data"]
+            _LOGGER.debug("tlx_info for device %s: %r", self.device_id, tlx_info)
         elif self.device_type == "storage":
             storage_info_detail = self.api.storage_params(self.device_id)
             storage_energy_overview = self.api.storage_energy_overview(
@@ -145,7 +188,7 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         return self.data.get("currency")
 
     def get_data(
-        self, entity_description: "GrowattSensorEntityDescription"
+        self, entity_description: GrowattSensorEntityDescription
     ) -> str | int | float | None:
         """Get the data."""
         variable = entity_description.api_key

homeassistant/components/growatt_server/sensor/__init__.py

@@ -51,7 +51,7 @@ async def async_setup_entry(
         sensor_descriptions: list = []
         if device_coordinator.device_type == "inverter":
             sensor_descriptions = list(INVERTER_SENSOR_TYPES)
-        elif device_coordinator.device_type == "tlx":
+        elif device_coordinator.device_type in ("tlx", "min"):
             sensor_descriptions = list(TLX_SENSOR_TYPES)
         elif device_coordinator.device_type == "storage":
             sensor_descriptions = list(STORAGE_SENSOR_TYPES)

homeassistant/components/growatt_server/strings.json

@@ -2,26 +2,42 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "no_plants": "No plants have been found on this account"
     },
     "error": {
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]"
+      "invalid_auth": "Authentication failed. Please check your credentials and try again.",
+      "cannot_connect": "Cannot connect to Growatt servers. Please check your internet connection and try again."
     },
     "step": {
+      "user": {
+        "title": "Choose authentication method",
+        "description": "Note: API Token authentication is currently only supported for MIN/TLX devices. For other device types, please use Username & Password authentication.",
+        "menu_options": {
+          "password_auth": "Username & Password",
+          "token_auth": "API Token (MIN/TLX only)"
+        }
+      },
+      "password_auth": {
+        "title": "Enter your Growatt login credentials",
+        "data": {
+          "username": "[%key:common::config_flow::data::username%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "url": "[%key:common::config_flow::data::url%]"
+        }
+      },
+      "token_auth": {
+        "title": "Enter your API token",
+        "description": "Token authentication is only supported for MIN/TLX devices. For other device types, please use username/password authentication.",
+        "data": {
+          "token": "API Token"
+        }
+      },
       "plant": {
         "data": {
           "plant_id": "Plant"
         },
         "title": "Select your plant"
-      },
-      "user": {
-        "data": {
-          "name": "[%key:common::config_flow::data::name%]",
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]",
-          "url": "[%key:common::config_flow::data::url%]"
-        },
-        "title": "Enter your Growatt information"
       }
     }
   },

homeassistant/components/habitica/icons.json

@@ -174,6 +174,9 @@
       },
       "collected_items": {
         "default": "mdi:sack"
+      },
+      "last_checkin": {
+        "default": "mdi:login-variant"
       }
     },
     "switch": {

homeassistant/components/habitica/sensor.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from datetime import datetime
 from enum import StrEnum
 import logging
 from typing import Any
@@ -53,7 +54,7 @@ PARALLEL_UPDATES = 1
 class HabiticaSensorEntityDescription(SensorEntityDescription):
     """Habitica Sensor Description."""
 
-    value_fn: Callable[[UserData, ContentData], StateType]
+    value_fn: Callable[[UserData, ContentData], StateType | datetime]
     attributes_fn: Callable[[UserData, ContentData], dict[str, Any] | None] | None = (
         None
     )
@@ -114,6 +115,7 @@ class HabiticaSensorEntity(StrEnum):
     COLLECTED_ITEMS = "collected_items"
     BOSS_RAGE = "boss_rage"
     BOSS_RAGE_LIMIT = "boss_rage_limit"
+    LAST_CHECKIN = "last_checkin"
 
 
 SENSOR_DESCRIPTIONS: tuple[HabiticaSensorEntityDescription, ...] = (
@@ -284,6 +286,16 @@ SENSOR_DESCRIPTIONS: tuple[HabiticaSensorEntityDescription, ...] = (
         translation_key=HabiticaSensorEntity.PENDING_QUEST_ITEMS,
         value_fn=pending_quest_items,
     ),
+    HabiticaSensorEntityDescription(
+        key=HabiticaSensorEntity.LAST_CHECKIN,
+        translation_key=HabiticaSensorEntity.LAST_CHECKIN,
+        value_fn=(
+            lambda user, _: dt_util.as_local(last)
+            if (last := user.auth.timestamps.loggedin)
+            else None
+        ),
+        device_class=SensorDeviceClass.TIMESTAMP,
+    ),
 )
 
 
@@ -399,7 +411,7 @@ class HabiticaSensor(HabiticaBase, SensorEntity):
     entity_description: HabiticaSensorEntityDescription
 
     @property
-    def native_value(self) -> StateType:
+    def native_value(self) -> StateType | datetime:
         """Return the state of the device."""
 
         return self.entity_description.value_fn(
@@ -442,7 +454,7 @@ class HabiticaPartySensor(HabiticaPartyBase, SensorEntity):
     entity_description: HabiticaPartySensorEntityDescription
 
     @property
-    def native_value(self) -> StateType:
+    def native_value(self) -> StateType | datetime:
         """Return the state of the device."""
 
         return self.entity_description.value_fn(

homeassistant/components/habitica/strings.json

@@ -290,6 +290,9 @@
           }
         }
       },
+      "last_checkin": {
+        "name": "Last check-in"
+      },
       "health": {
         "name": "Health",
         "unit_of_measurement": "[%key:component::habitica::common::unit_health_points%]"

homeassistant/components/hassio/manifest.json

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

homeassistant/components/hassio/switch.py

@@ -73,7 +73,6 @@ class HassioAddonSwitch(HassioAddonEntity, SwitchEntity):
         try:
             await supervisor_client.addons.start_addon(self._addon_slug)
         except SupervisorError as err:
-            _LOGGER.error("Failed to start addon %s: %s", self._addon_slug, err)
             raise HomeAssistantError(err) from err
 
         await self.coordinator.force_addon_info_data_refresh(self._addon_slug)

homeassistant/components/homeassistant_connect_zbt2/config_flow.py

@@ -10,6 +10,7 @@ from homeassistant.components.homeassistant_hardware import firmware_config_flow
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.config_entries import (
     ConfigEntry,
@@ -66,6 +67,7 @@ class ZBT2FirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     """Mixin for Home Assistant Connect ZBT-2 firmware methods."""
 
     context: ConfigFlowContext
+    BOOTLOADER_RESET_METHODS = [ResetTarget.RTS_DTR]
 
     async def async_step_install_zigbee_firmware(
         self, user_input: dict[str, Any] | None = None

homeassistant/components/homeassistant_connect_zbt2/update.py

@@ -16,6 +16,7 @@ from homeassistant.components.homeassistant_hardware.update import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.update import UpdateDeviceClass
 from homeassistant.config_entries import ConfigEntry
@@ -156,7 +157,7 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Connect ZBT-2 firmware update entity."""
 
-    bootloader_reset_type = None
+    bootloader_reset_methods = [ResetTarget.RTS_DTR]
 
     def __init__(
         self,

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -39,6 +39,7 @@ from .util import (
     FirmwareInfo,
     OwningAddon,
     OwningIntegration,
+    ResetTarget,
     async_flash_silabs_firmware,
     get_otbr_addon_manager,
     guess_firmware_info,
@@ -79,6 +80,8 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
     """Base flow to install firmware."""
 
     ZIGBEE_BAUDRATE = 115200  # Default, subclasses may override
+    BOOTLOADER_RESET_METHODS: list[ResetTarget] = []  # Default, subclasses may override
+
     _picked_firmware_type: PickedFirmwareType
     _zigbee_flow_strategy: ZigbeeFlowStrategy = ZigbeeFlowStrategy.RECOMMENDED
 
@@ -274,7 +277,7 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
             device=self._device,
             fw_data=fw_data,
             expected_installed_firmware_type=expected_installed_firmware_type,
-            bootloader_reset_type=None,
+            bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
             progress_callback=lambda offset, total: self.async_update_progress(
                 offset / total
             ),

homeassistant/components/homeassistant_hardware/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_hardware",
   "integration_type": "system",
   "requirements": [
-    "universal-silabs-flasher==0.0.32",
+    "universal-silabs-flasher==0.0.35",
     "ha-silabs-firmware-client==0.2.0"
   ]
 }

homeassistant/components/homeassistant_hardware/update.py

@@ -22,7 +22,12 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import FirmwareUpdateCoordinator
 from .helpers import async_register_firmware_info_callback
-from .util import ApplicationType, FirmwareInfo, async_flash_silabs_firmware
+from .util import (
+    ApplicationType,
+    FirmwareInfo,
+    ResetTarget,
+    async_flash_silabs_firmware,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -81,7 +86,7 @@ class BaseFirmwareUpdateEntity(
 
     # Subclasses provide the mapping between firmware types and entity descriptions
     entity_description: FirmwareUpdateEntityDescription
-    bootloader_reset_type: str | None = None
+    bootloader_reset_methods: list[ResetTarget] = []
 
     _attr_supported_features = (
         UpdateEntityFeature.INSTALL | UpdateEntityFeature.PROGRESS
@@ -268,7 +273,7 @@ class BaseFirmwareUpdateEntity(
                 device=self._current_device,
                 fw_data=fw_data,
                 expected_installed_firmware_type=self.entity_description.expected_firmware_type,
-                bootloader_reset_type=self.bootloader_reset_type,
+                bootloader_reset_methods=self.bootloader_reset_methods,
                 progress_callback=self._update_progress,
             )
         finally:

homeassistant/components/homeassistant_hardware/util.py

@@ -4,13 +4,16 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
-from collections.abc import AsyncIterator, Callable, Iterable
+from collections.abc import AsyncIterator, Callable, Iterable, Sequence
 from contextlib import AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from enum import StrEnum
 import logging
 
-from universal_silabs_flasher.const import ApplicationType as FlasherApplicationType
+from universal_silabs_flasher.const import (
+    ApplicationType as FlasherApplicationType,
+    ResetTarget as FlasherResetTarget,
+)
 from universal_silabs_flasher.firmware import parse_firmware_image
 from universal_silabs_flasher.flasher import Flasher
 
@@ -59,6 +62,18 @@ class ApplicationType(StrEnum):
         return FlasherApplicationType(self.value)
 
 
+class ResetTarget(StrEnum):
+    """Methods to reset a device into bootloader mode."""
+
+    RTS_DTR = "rts_dtr"
+    BAUDRATE = "baudrate"
+    YELLOW = "yellow"
+
+    def as_flasher_reset_target(self) -> FlasherResetTarget:
+        """Convert the reset target enum into one compatible with USF."""
+        return FlasherResetTarget(self.value)
+
+
 @singleton(OTBR_ADDON_MANAGER_DATA)
 @callback
 def get_otbr_addon_manager(hass: HomeAssistant) -> WaitingAddonManager:
@@ -342,7 +357,7 @@ async def async_flash_silabs_firmware(
     device: str,
     fw_data: bytes,
     expected_installed_firmware_type: ApplicationType,
-    bootloader_reset_type: str | None = None,
+    bootloader_reset_methods: Sequence[ResetTarget] = (),
     progress_callback: Callable[[int, int], None] | None = None,
 ) -> FirmwareInfo:
     """Flash firmware to the SiLabs device."""
@@ -359,7 +374,9 @@ async def async_flash_silabs_firmware(
             ApplicationType.SPINEL.as_flasher_application_type(),
             ApplicationType.CPC.as_flasher_application_type(),
         ),
-        bootloader_reset=bootloader_reset_type,
+        bootloader_reset=tuple(
+            m.as_flasher_reset_target() for m in bootloader_reset_methods
+        ),
     )
 
     async with AsyncExitStack() as stack:

homeassistant/components/homeassistant_sky_connect/update.py

@@ -168,7 +168,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """SkyConnect firmware update entity."""
 
-    bootloader_reset_type = None
+    # The ZBT-1 does not have a hardware bootloader trigger
+    bootloader_reset_methods = []
 
     def __init__(
         self,

homeassistant/components/homeassistant_yellow/config_flow.py

@@ -27,6 +27,7 @@ from homeassistant.components.homeassistant_hardware.silabs_multiprotocol_addon
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
     probe_silabs_firmware_info,
 )
 from homeassistant.config_entries import (
@@ -83,6 +84,8 @@ else:
 class YellowFirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     """Mixin for Home Assistant Yellow firmware methods."""
 
+    BOOTLOADER_RESET_METHODS = [ResetTarget.YELLOW]
+
     async def async_step_install_zigbee_firmware(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/homeassistant_yellow/update.py

@@ -16,6 +16,7 @@ from homeassistant.components.homeassistant_hardware.update import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.update import UpdateDeviceClass
 from homeassistant.config_entries import ConfigEntry
@@ -173,7 +174,7 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Yellow firmware update entity."""
 
-    bootloader_reset_type = "yellow"  # Triggers a GPIO reset
+    bootloader_reset_methods = [ResetTarget.YELLOW]  # Triggers a GPIO reset
 
     def __init__(
         self,

homeassistant/components/homekit/manifest.json

@@ -10,7 +10,7 @@
   "loggers": ["pyhap"],
   "requirements": [
     "HAP-python==5.0.0",
-    "fnv-hash-fast==1.5.0",
+    "fnv-hash-fast==1.6.0",
     "PyQRCode==1.2.1",
     "base36==0.1.1"
   ],

homeassistant/components/homekit_controller/manifest.json

@@ -14,6 +14,6 @@
   "documentation": "https://www.home-assistant.io/integrations/homekit_controller",
   "iot_class": "local_push",
   "loggers": ["aiohomekit", "commentjson"],
-  "requirements": ["aiohomekit==3.2.18"],
+  "requirements": ["aiohomekit==3.2.19"],
   "zeroconf": ["_hap._tcp.local.", "_hap._udp.local."]
 }

homeassistant/components/idasen_desk/coordinator.py

@@ -8,13 +8,16 @@ from idasen_ha import Desk
 
 from homeassistant.components import bluetooth
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
 type IdasenDeskConfigEntry = ConfigEntry[IdasenDeskCoordinator]
 
+UPDATE_DEBOUNCE_TIME = 0.2
+
 
 class IdasenDeskCoordinator(DataUpdateCoordinator[int | None]):
     """Class to manage updates for the Idasen Desk."""
@@ -33,9 +36,22 @@ class IdasenDeskCoordinator(DataUpdateCoordinator[int | None]):
             hass, _LOGGER, config_entry=config_entry, name=config_entry.title
         )
         self.address = address
-        self._expected_connected = False
+        self.desk = Desk(self._async_handle_update)
 
-        self.desk = Desk(self.async_set_updated_data)
+        self._expected_connected = False
+        self._height: int | None = None
+
+        @callback
+        def async_update_data() -> None:
+            self.async_set_updated_data(self._height)
+
+        self._debouncer = Debouncer(
+            hass=self.hass,
+            logger=_LOGGER,
+            cooldown=UPDATE_DEBOUNCE_TIME,
+            immediate=True,
+            function=async_update_data,
+        )
 
     async def async_connect(self) -> bool:
         """Connect to desk."""
@@ -60,3 +76,9 @@ class IdasenDeskCoordinator(DataUpdateCoordinator[int | None]):
         """Ensure that the desk is connected if that is the expected state."""
         if self._expected_connected:
             await self.async_connect()
+
+    @callback
+    def _async_handle_update(self, height: int | None) -> None:
+        """Handle an update from the desk."""
+        self._height = height
+        self._debouncer.async_schedule_call()

homeassistant/components/inkbird/__init__.py

@@ -11,7 +11,7 @@ from homeassistant.core import HomeAssistant
 from .const import CONF_DEVICE_DATA, CONF_DEVICE_TYPE
 from .coordinator import INKBIRDActiveBluetoothProcessorCoordinator
 
-INKBIRDConfigEntry = ConfigEntry[INKBIRDActiveBluetoothProcessorCoordinator]
+type INKBIRDConfigEntry = ConfigEntry[INKBIRDActiveBluetoothProcessorCoordinator]
 
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 

homeassistant/components/kraken/__init__.py

@@ -147,8 +147,9 @@ class KrakenData:
 
     def _get_websocket_name_asset_pairs(self) -> str:
         return ",".join(
-            self.tradable_asset_pairs[tracked_pair]
+            pair
             for tracked_pair in self._config_entry.options[CONF_TRACKED_ASSET_PAIRS]
+            if (pair := self.tradable_asset_pairs.get(tracked_pair)) is not None
         )
 
     def set_update_interval(self, update_interval: int) -> None:

homeassistant/components/kraken/sensor.py

@@ -156,7 +156,7 @@ async def async_setup_entry(
                     for description in SENSOR_TYPES
                 ]
             )
-        async_add_entities(entities, True)
+        async_add_entities(entities)
 
     _async_add_kraken_sensors(config_entry.options[CONF_TRACKED_ASSET_PAIRS])
 

homeassistant/components/ld2410_ble/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ld2410_ble",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["bluetooth-data-tools==1.28.2", "ld2410-ble==0.1.1"]
+  "requirements": ["bluetooth-data-tools==1.28.3", "ld2410-ble==0.1.1"]
 }

homeassistant/components/led_ble/manifest.json

@@ -35,5 +35,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/led_ble",
   "iot_class": "local_polling",
-  "requirements": ["bluetooth-data-tools==1.28.2", "led-ble==1.1.7"]
+  "requirements": ["bluetooth-data-tools==1.28.3", "led-ble==1.1.7"]
 }

homeassistant/components/local_todo/todo.py

@@ -196,11 +196,11 @@ class LocalTodoListEntity(TodoListEntity):
             item_idx: dict[str, int] = {itm.uid: idx for idx, itm in enumerate(todos)}
             if uid not in item_idx:
                 raise HomeAssistantError(
-                    "Item '{uid}' not found in todo list {self.entity_id}"
+                    f"Item '{uid}' not found in todo list {self.entity_id}"
                 )
             if previous_uid and previous_uid not in item_idx:
                 raise HomeAssistantError(
-                    "Item '{previous_uid}' not found in todo list {self.entity_id}"
+                    f"Item '{previous_uid}' not found in todo list {self.entity_id}"
                 )
             dst_idx = item_idx[previous_uid] + 1 if previous_uid else 0
             src_idx = item_idx[uid]

homeassistant/components/lock/__init__.py

@@ -13,28 +13,16 @@ from propcache.api import cached_property
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (  # noqa: F401
-    _DEPRECATED_STATE_JAMMED,
-    _DEPRECATED_STATE_LOCKED,
-    _DEPRECATED_STATE_LOCKING,
-    _DEPRECATED_STATE_UNLOCKED,
-    _DEPRECATED_STATE_UNLOCKING,
+from homeassistant.const import (
     ATTR_CODE,
     ATTR_CODE_FORMAT,
     SERVICE_LOCK,
     SERVICE_OPEN,
     SERVICE_UNLOCK,
-    STATE_OPEN,
-    STATE_OPENING,
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.deprecation import (
-    all_with_deprecated_constants,
-    check_if_deprecated_constant,
-    dir_with_deprecated_constants,
-)
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType, StateType
@@ -317,11 +305,3 @@ class LockEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
             return
 
         self._lock_option_default_code = ""
-
-
-# These can be removed if no deprecated constant are in this module anymore
-__getattr__ = ft.partial(check_if_deprecated_constant, module_globals=globals())
-__dir__ = ft.partial(
-    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
-)
-__all__ = all_with_deprecated_constants(globals())

homeassistant/components/lunatone/__init__.py

@@ -0,0 +1,64 @@
+"""The Lunatone integration."""
+
+from typing import Final
+
+from lunatone_rest_api_client import Auth, Devices, Info
+
+from homeassistant.const import CONF_URL, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+from .coordinator import (
+    LunatoneConfigEntry,
+    LunatoneData,
+    LunatoneDevicesDataUpdateCoordinator,
+    LunatoneInfoDataUpdateCoordinator,
+)
+
+PLATFORMS: Final[list[Platform]] = [Platform.LIGHT]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: LunatoneConfigEntry) -> bool:
+    """Set up Lunatone from a config entry."""
+    auth_api = Auth(async_get_clientsession(hass), entry.data[CONF_URL])
+    info_api = Info(auth_api)
+    devices_api = Devices(auth_api)
+
+    coordinator_info = LunatoneInfoDataUpdateCoordinator(hass, entry, info_api)
+    await coordinator_info.async_config_entry_first_refresh()
+
+    if info_api.serial_number is None:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN, translation_key="missing_device_info"
+        )
+
+    device_registry = dr.async_get(hass)
+    device_registry.async_get_or_create(
+        config_entry_id=entry.entry_id,
+        identifiers={(DOMAIN, str(info_api.serial_number))},
+        name=info_api.name,
+        manufacturer="Lunatone",
+        sw_version=info_api.version,
+        hw_version=info_api.data.device.pcb,
+        configuration_url=entry.data[CONF_URL],
+        serial_number=str(info_api.serial_number),
+        model_id=(
+            f"{info_api.data.device.article_number}{info_api.data.device.article_info}"
+        ),
+    )
+
+    coordinator_devices = LunatoneDevicesDataUpdateCoordinator(hass, entry, devices_api)
+    await coordinator_devices.async_config_entry_first_refresh()
+
+    entry.runtime_data = LunatoneData(coordinator_info, coordinator_devices)
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: LunatoneConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/lunatone/config_flow.py

@@ -0,0 +1,83 @@
+"""Config flow for Lunatone."""
+
+from typing import Any, Final
+
+import aiohttp
+from lunatone_rest_api_client import Auth, Info
+import voluptuous as vol
+
+from homeassistant.config_entries import (
+    SOURCE_RECONFIGURE,
+    ConfigFlow,
+    ConfigFlowResult,
+)
+from homeassistant.const import CONF_URL
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+DATA_SCHEMA: Final[vol.Schema] = vol.Schema(
+    {vol.Required(CONF_URL, default="http://"): cv.string},
+)
+
+
+def compose_title(name: str | None, serial_number: int) -> str:
+    """Compose a title string from a given name and serial number."""
+    return f"{name or 'DALI Gateway'} {serial_number}"
+
+
+class LunatoneConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Lunatone config flow."""
+
+    VERSION = 1
+    MINOR_VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a flow initialized by the user."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            url = user_input[CONF_URL]
+            data = {CONF_URL: url}
+            self._async_abort_entries_match(data)
+            auth_api = Auth(
+                session=async_get_clientsession(self.hass),
+                base_url=url,
+            )
+            info_api = Info(auth_api)
+            try:
+                await info_api.async_update()
+            except aiohttp.InvalidUrlClientError:
+                errors["base"] = "invalid_url"
+            except aiohttp.ClientConnectionError:
+                errors["base"] = "cannot_connect"
+            else:
+                if info_api.data is None or info_api.serial_number is None:
+                    errors["base"] = "missing_device_info"
+                else:
+                    await self.async_set_unique_id(str(info_api.serial_number))
+                    if self.source == SOURCE_RECONFIGURE:
+                        self._abort_if_unique_id_mismatch()
+                        return self.async_update_reload_and_abort(
+                            self._get_reconfigure_entry(),
+                            data_updates=data,
+                            title=compose_title(info_api.name, info_api.serial_number),
+                        )
+                    self._abort_if_unique_id_configured()
+                    return self.async_create_entry(
+                        title=compose_title(info_api.name, info_api.serial_number),
+                        data={CONF_URL: url},
+                    )
+        return self.async_show_form(
+            step_id="user",
+            data_schema=DATA_SCHEMA,
+            errors=errors,
+        )
+
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a reconfiguration flow initialized by the user."""
+        return await self.async_step_user(user_input)

homeassistant/components/lunatone/const.py

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

homeassistant/components/lunatone/coordinator.py

@@ -0,0 +1,101 @@
+"""Coordinator for handling data fetching and updates."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+
+import aiohttp
+from lunatone_rest_api_client import Device, Devices, Info
+from lunatone_rest_api_client.models import InfoData
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_DEVICES_SCAN_INTERVAL = timedelta(seconds=10)
+
+
+@dataclass
+class LunatoneData:
+    """Data for Lunatone integration."""
+
+    coordinator_info: LunatoneInfoDataUpdateCoordinator
+    coordinator_devices: LunatoneDevicesDataUpdateCoordinator
+
+
+type LunatoneConfigEntry = ConfigEntry[LunatoneData]
+
+
+class LunatoneInfoDataUpdateCoordinator(DataUpdateCoordinator[InfoData]):
+    """Data update coordinator for Lunatone info."""
+
+    config_entry: LunatoneConfigEntry
+
+    def __init__(
+        self, hass: HomeAssistant, config_entry: LunatoneConfigEntry, info_api: Info
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=f"{DOMAIN}-info",
+            always_update=False,
+        )
+        self.info_api = info_api
+
+    async def _async_update_data(self) -> InfoData:
+        """Update info data."""
+        try:
+            await self.info_api.async_update()
+        except aiohttp.ClientConnectionError as ex:
+            raise UpdateFailed(
+                "Unable to retrieve info data from Lunatone REST API"
+            ) from ex
+
+        if self.info_api.data is None:
+            raise UpdateFailed("Did not receive info data from Lunatone REST API")
+        return self.info_api.data
+
+
+class LunatoneDevicesDataUpdateCoordinator(DataUpdateCoordinator[dict[int, Device]]):
+    """Data update coordinator for Lunatone devices."""
+
+    config_entry: LunatoneConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: LunatoneConfigEntry,
+        devices_api: Devices,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=f"{DOMAIN}-devices",
+            always_update=False,
+            update_interval=DEFAULT_DEVICES_SCAN_INTERVAL,
+        )
+        self.devices_api = devices_api
+
+    async def _async_update_data(self) -> dict[int, Device]:
+        """Update devices data."""
+        try:
+            await self.devices_api.async_update()
+        except aiohttp.ClientConnectionError as ex:
+            raise UpdateFailed(
+                "Unable to retrieve devices data from Lunatone REST API"
+            ) from ex
+
+        if self.devices_api.data is None:
+            raise UpdateFailed("Did not receive devices data from Lunatone REST API")
+
+        return {device.id: device for device in self.devices_api.devices}

homeassistant/components/lunatone/light.py

@@ -0,0 +1,103 @@
+"""Platform for Lunatone light integration."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from homeassistant.components.light import ColorMode, LightEntity
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import LunatoneConfigEntry, LunatoneDevicesDataUpdateCoordinator
+
+PARALLEL_UPDATES = 0
+STATUS_UPDATE_DELAY = 0.04
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: LunatoneConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Lunatone Light platform."""
+    coordinator_info = config_entry.runtime_data.coordinator_info
+    coordinator_devices = config_entry.runtime_data.coordinator_devices
+
+    async_add_entities(
+        [
+            LunatoneLight(
+                coordinator_devices, device_id, coordinator_info.data.device.serial
+            )
+            for device_id in coordinator_devices.data
+        ]
+    )
+
+
+class LunatoneLight(
+    CoordinatorEntity[LunatoneDevicesDataUpdateCoordinator], LightEntity
+):
+    """Representation of a Lunatone light."""
+
+    _attr_color_mode = ColorMode.ONOFF
+    _attr_supported_color_modes = {ColorMode.ONOFF}
+    _attr_has_entity_name = True
+    _attr_name = None
+    _attr_should_poll = False
+
+    def __init__(
+        self,
+        coordinator: LunatoneDevicesDataUpdateCoordinator,
+        device_id: int,
+        interface_serial_number: int,
+    ) -> None:
+        """Initialize a LunatoneLight."""
+        super().__init__(coordinator=coordinator)
+        self._device_id = device_id
+        self._interface_serial_number = interface_serial_number
+        self._device = self.coordinator.data.get(self._device_id)
+        self._attr_unique_id = f"{interface_serial_number}-device{device_id}"
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        assert self.unique_id
+        name = self._device.name if self._device is not None else None
+        return DeviceInfo(
+            identifiers={(DOMAIN, self.unique_id)},
+            name=name,
+            via_device=(DOMAIN, str(self._interface_serial_number)),
+        )
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return super().available and self._device is not None
+
+    @property
+    def is_on(self) -> bool:
+        """Return True if light is on."""
+        return self._device is not None and self._device.is_on
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        self._device = self.coordinator.data.get(self._device_id)
+        self.async_write_ha_state()
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Instruct the light to turn on."""
+        assert self._device
+        await self._device.switch_on()
+        await asyncio.sleep(STATUS_UPDATE_DELAY)
+        await self.coordinator.async_refresh()
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Instruct the light to turn off."""
+        assert self._device
+        await self._device.switch_off()
+        await asyncio.sleep(STATUS_UPDATE_DELAY)
+        await self.coordinator.async_refresh()

homeassistant/components/lunatone/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "lunatone",
+  "name": "Lunatone",
+  "codeowners": ["@MoonDevLT"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/lunatone",
+  "integration_type": "hub",
+  "iot_class": "local_polling",
+  "quality_scale": "silver",
+  "requirements": ["lunatone-rest-api-client==0.4.8"]
+}

homeassistant/components/lunatone/quality_scale.yaml

@@ -0,0 +1,82 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  appropriate-polling: done
+  brands: done
+  common-modules:
+    status: exempt
+    comment: |
+      This integration has only one platform which uses a coordinator.
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: |
+      Entities of this integration does not explicitly subscribe to events.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: no actions
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No options to configure
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow:
+    status: exempt
+    comment: |
+      This integration does not require authentication.
+  test-coverage: done
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: todo
+    comment: Discovery not yet supported
+  discovery:
+    status: todo
+    comment: Discovery not yet supported
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: done
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: todo

homeassistant/components/lunatone/strings.json

@@ -0,0 +1,36 @@
+{
+  "config": {
+    "step": {
+      "confirm": {
+        "description": "[%key:common::config_flow::description::confirm_setup%]"
+      },
+      "user": {
+        "description": "Connect to the API of your Lunatone DALI IoT Gateway.",
+        "data": {
+          "url": "[%key:common::config_flow::data::url%]"
+        },
+        "data_description": {
+          "url": "The URL of the Lunatone gateway device."
+        }
+      },
+      "reconfigure": {
+        "description": "Update the URL.",
+        "data": {
+          "url": "[%key:common::config_flow::data::url%]"
+        },
+        "data_description": {
+          "url": "[%key:component::lunatone::config::step::user::data_description::url%]"
+        }
+      }
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_url": "Failed to connect. Check the URL and if the device is connected to power",
+      "missing_device_info": "Failed to read device information. Check the network connection of the device"
+    },
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+    }
+  }
+}

homeassistant/components/matter/binary_sensor.py

@@ -88,6 +88,17 @@ DISCOVERY_SCHEMAS = [
         entity_class=MatterBinarySensor,
         required_attributes=(clusters.OccupancySensing.Attributes.Occupancy,),
     ),
+    MatterDiscoverySchema(
+        platform=Platform.BINARY_SENSOR,
+        entity_description=MatterBinarySensorEntityDescription(
+            key="ThermostatOccupancySensor",
+            device_class=BinarySensorDeviceClass.OCCUPANCY,
+            # The first bit = if occupied
+            device_to_ha=lambda x: (x & 1 == 1) if x is not None else None,
+        ),
+        entity_class=MatterBinarySensor,
+        required_attributes=(clusters.Thermostat.Attributes.Occupancy,),
+    ),
     MatterDiscoverySchema(
         platform=Platform.BINARY_SENSOR,
         entity_description=MatterBinarySensorEntityDescription(

homeassistant/components/matter/climate.py

@@ -30,6 +30,7 @@ from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
+HUMIDITY_SCALING_FACTOR = 100
 TEMPERATURE_SCALING_FACTOR = 100
 HVAC_SYSTEM_MODE_MAP = {
     HVACMode.OFF: 0,
@@ -261,6 +262,18 @@ class MatterClimate(MatterEntity, ClimateEntity):
         self._attr_current_temperature = self._get_temperature_in_degrees(
             clusters.Thermostat.Attributes.LocalTemperature
         )
+
+        self._attr_current_humidity = (
+            int(raw_measured_humidity) / HUMIDITY_SCALING_FACTOR
+            if (
+                raw_measured_humidity := self.get_matter_attribute_value(
+                    clusters.RelativeHumidityMeasurement.Attributes.MeasuredValue
+                )
+            )
+            is not None
+            else None
+        )
+
         if self.get_matter_attribute_value(clusters.OnOff.Attributes.OnOff) is False:
             # special case: the appliance has a dedicated Power switch on the OnOff cluster
             # if the mains power is off - treat it as if the HVAC mode is off
@@ -428,6 +441,7 @@ DISCOVERY_SCHEMAS = [
             clusters.Thermostat.Attributes.TemperatureSetpointHold,
             clusters.Thermostat.Attributes.UnoccupiedCoolingSetpoint,
             clusters.Thermostat.Attributes.UnoccupiedHeatingSetpoint,
+            clusters.RelativeHumidityMeasurement.Attributes.MeasuredValue,
             clusters.OnOff.Attributes.OnOff,
         ),
         device_type=(device_types.Thermostat, device_types.RoomAirConditioner),

homeassistant/components/matter/sensor.py

@@ -351,6 +351,7 @@ DISCOVERY_SCHEMAS = [
         required_attributes=(
             clusters.RelativeHumidityMeasurement.Attributes.MeasuredValue,
         ),
+        allow_multi=True,  # also used for climate entity
     ),
     MatterDiscoverySchema(
         platform=Platform.SENSOR,

homeassistant/components/mcp/coordinator.py

@@ -27,7 +27,7 @@ _LOGGER = logging.getLogger(__name__)
 UPDATE_INTERVAL = datetime.timedelta(minutes=30)
 TIMEOUT = 10
 
-TokenManager = Callable[[], Awaitable[str]]
+type TokenManager = Callable[[], Awaitable[str]]
 
 
 @asynccontextmanager

homeassistant/components/media_player/__init__.py

@@ -55,12 +55,6 @@ from homeassistant.const import (  # noqa: F401
 from homeassistant.core import HomeAssistant, SupportsResponse
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.deprecation import (
-    DeprecatedConstantEnum,
-    all_with_deprecated_constants,
-    check_if_deprecated_constant,
-    dir_with_deprecated_constants,
-)
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.network import get_url
@@ -75,26 +69,6 @@ from .browse_media import (  # noqa: F401
     async_process_play_media_url,
 )
 from .const import (  # noqa: F401
-    _DEPRECATED_MEDIA_CLASS_DIRECTORY,
-    _DEPRECATED_SUPPORT_BROWSE_MEDIA,
-    _DEPRECATED_SUPPORT_CLEAR_PLAYLIST,
-    _DEPRECATED_SUPPORT_GROUPING,
-    _DEPRECATED_SUPPORT_NEXT_TRACK,
-    _DEPRECATED_SUPPORT_PAUSE,
-    _DEPRECATED_SUPPORT_PLAY,
-    _DEPRECATED_SUPPORT_PLAY_MEDIA,
-    _DEPRECATED_SUPPORT_PREVIOUS_TRACK,
-    _DEPRECATED_SUPPORT_REPEAT_SET,
-    _DEPRECATED_SUPPORT_SEEK,
-    _DEPRECATED_SUPPORT_SELECT_SOUND_MODE,
-    _DEPRECATED_SUPPORT_SELECT_SOURCE,
-    _DEPRECATED_SUPPORT_SHUFFLE_SET,
-    _DEPRECATED_SUPPORT_STOP,
-    _DEPRECATED_SUPPORT_TURN_OFF,
-    _DEPRECATED_SUPPORT_TURN_ON,
-    _DEPRECATED_SUPPORT_VOLUME_MUTE,
-    _DEPRECATED_SUPPORT_VOLUME_SET,
-    _DEPRECATED_SUPPORT_VOLUME_STEP,
     ATTR_APP_ID,
     ATTR_APP_NAME,
     ATTR_ENTITY_PICTURE_LOCAL,
@@ -188,17 +162,6 @@ class MediaPlayerDeviceClass(StrEnum):
 DEVICE_CLASSES_SCHEMA = vol.All(vol.Lower, vol.Coerce(MediaPlayerDeviceClass))
 
 
-# DEVICE_CLASS* below are deprecated as of 2021.12
-# use the MediaPlayerDeviceClass enum instead.
-_DEPRECATED_DEVICE_CLASS_TV = DeprecatedConstantEnum(
-    MediaPlayerDeviceClass.TV, "2025.10"
-)
-_DEPRECATED_DEVICE_CLASS_SPEAKER = DeprecatedConstantEnum(
-    MediaPlayerDeviceClass.SPEAKER, "2025.10"
-)
-_DEPRECATED_DEVICE_CLASS_RECEIVER = DeprecatedConstantEnum(
-    MediaPlayerDeviceClass.RECEIVER, "2025.10"
-)
 DEVICE_CLASSES = [cls.value for cls in MediaPlayerDeviceClass]
 
 
@@ -1196,6 +1159,7 @@ class MediaPlayerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         media_content_id: str | None = None,
         media_filter_classes: list[MediaClass] | None = None,
     ) -> SearchMedia:
+        """Search for media."""
         return await self.async_search_media(
             query=SearchMediaQuery(
                 search_query=search_query,
@@ -1510,13 +1474,3 @@ async def async_fetch_image(
         logger.warning("Error retrieving proxied image from %s", url)
 
     return content, content_type
-
-
-# As we import deprecated constants from the const module, we need to add these two functions
-# otherwise this module will be logged for using deprecated constants and not the custom component
-# These can be removed if no deprecated constant are in this module anymore
-__getattr__ = ft.partial(check_if_deprecated_constant, module_globals=globals())
-__dir__ = ft.partial(
-    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
-)
-__all__ = all_with_deprecated_constants(globals())

homeassistant/components/media_player/const.py

@@ -1,15 +1,8 @@
 """Provides the constants needed for component."""
 
 from enum import IntFlag, StrEnum
-from functools import partial
 
-from homeassistant.helpers.deprecation import (
-    DeprecatedConstantEnum,
-    EnumWithDeprecatedMembers,
-    all_with_deprecated_constants,
-    check_if_deprecated_constant,
-    dir_with_deprecated_constants,
-)
+from homeassistant.helpers.deprecation import EnumWithDeprecatedMembers
 
 # How long our auth signature on the content should be valid for
 CONTENT_AUTH_EXPIRY_TIME = 3600 * 24
@@ -94,38 +87,6 @@ class MediaClass(StrEnum):
     VIDEO = "video"
 
 
-# These MEDIA_CLASS_* constants are deprecated as of Home Assistant 2022.10.
-# Please use the MediaClass enum instead.
-_DEPRECATED_MEDIA_CLASS_ALBUM = DeprecatedConstantEnum(MediaClass.ALBUM, "2025.10")
-_DEPRECATED_MEDIA_CLASS_APP = DeprecatedConstantEnum(MediaClass.APP, "2025.10")
-_DEPRECATED_MEDIA_CLASS_ARTIST = DeprecatedConstantEnum(MediaClass.ARTIST, "2025.10")
-_DEPRECATED_MEDIA_CLASS_CHANNEL = DeprecatedConstantEnum(MediaClass.CHANNEL, "2025.10")
-_DEPRECATED_MEDIA_CLASS_COMPOSER = DeprecatedConstantEnum(
-    MediaClass.COMPOSER, "2025.10"
-)
-_DEPRECATED_MEDIA_CLASS_CONTRIBUTING_ARTIST = DeprecatedConstantEnum(
-    MediaClass.CONTRIBUTING_ARTIST, "2025.10"
-)
-_DEPRECATED_MEDIA_CLASS_DIRECTORY = DeprecatedConstantEnum(
-    MediaClass.DIRECTORY, "2025.10"
-)
-_DEPRECATED_MEDIA_CLASS_EPISODE = DeprecatedConstantEnum(MediaClass.EPISODE, "2025.10")
-_DEPRECATED_MEDIA_CLASS_GAME = DeprecatedConstantEnum(MediaClass.GAME, "2025.10")
-_DEPRECATED_MEDIA_CLASS_GENRE = DeprecatedConstantEnum(MediaClass.GENRE, "2025.10")
-_DEPRECATED_MEDIA_CLASS_IMAGE = DeprecatedConstantEnum(MediaClass.IMAGE, "2025.10")
-_DEPRECATED_MEDIA_CLASS_MOVIE = DeprecatedConstantEnum(MediaClass.MOVIE, "2025.10")
-_DEPRECATED_MEDIA_CLASS_MUSIC = DeprecatedConstantEnum(MediaClass.MUSIC, "2025.10")
-_DEPRECATED_MEDIA_CLASS_PLAYLIST = DeprecatedConstantEnum(
-    MediaClass.PLAYLIST, "2025.10"
-)
-_DEPRECATED_MEDIA_CLASS_PODCAST = DeprecatedConstantEnum(MediaClass.PODCAST, "2025.10")
-_DEPRECATED_MEDIA_CLASS_SEASON = DeprecatedConstantEnum(MediaClass.SEASON, "2025.10")
-_DEPRECATED_MEDIA_CLASS_TRACK = DeprecatedConstantEnum(MediaClass.TRACK, "2025.10")
-_DEPRECATED_MEDIA_CLASS_TV_SHOW = DeprecatedConstantEnum(MediaClass.TV_SHOW, "2025.10")
-_DEPRECATED_MEDIA_CLASS_URL = DeprecatedConstantEnum(MediaClass.URL, "2025.10")
-_DEPRECATED_MEDIA_CLASS_VIDEO = DeprecatedConstantEnum(MediaClass.VIDEO, "2025.10")
-
-
 class MediaType(StrEnum):
     """Media type for media player entities."""
 
@@ -152,33 +113,6 @@ class MediaType(StrEnum):
     VIDEO = "video"
 
 
-# These MEDIA_TYPE_* constants are deprecated as of Home Assistant 2022.10.
-# Please use the MediaType enum instead.
-_DEPRECATED_MEDIA_TYPE_ALBUM = DeprecatedConstantEnum(MediaType.ALBUM, "2025.10")
-_DEPRECATED_MEDIA_TYPE_APP = DeprecatedConstantEnum(MediaType.APP, "2025.10")
-_DEPRECATED_MEDIA_TYPE_APPS = DeprecatedConstantEnum(MediaType.APPS, "2025.10")
-_DEPRECATED_MEDIA_TYPE_ARTIST = DeprecatedConstantEnum(MediaType.ARTIST, "2025.10")
-_DEPRECATED_MEDIA_TYPE_CHANNEL = DeprecatedConstantEnum(MediaType.CHANNEL, "2025.10")
-_DEPRECATED_MEDIA_TYPE_CHANNELS = DeprecatedConstantEnum(MediaType.CHANNELS, "2025.10")
-_DEPRECATED_MEDIA_TYPE_COMPOSER = DeprecatedConstantEnum(MediaType.COMPOSER, "2025.10")
-_DEPRECATED_MEDIA_TYPE_CONTRIBUTING_ARTIST = DeprecatedConstantEnum(
-    MediaType.CONTRIBUTING_ARTIST, "2025.10"
-)
-_DEPRECATED_MEDIA_TYPE_EPISODE = DeprecatedConstantEnum(MediaType.EPISODE, "2025.10")
-_DEPRECATED_MEDIA_TYPE_GAME = DeprecatedConstantEnum(MediaType.GAME, "2025.10")
-_DEPRECATED_MEDIA_TYPE_GENRE = DeprecatedConstantEnum(MediaType.GENRE, "2025.10")
-_DEPRECATED_MEDIA_TYPE_IMAGE = DeprecatedConstantEnum(MediaType.IMAGE, "2025.10")
-_DEPRECATED_MEDIA_TYPE_MOVIE = DeprecatedConstantEnum(MediaType.MOVIE, "2025.10")
-_DEPRECATED_MEDIA_TYPE_MUSIC = DeprecatedConstantEnum(MediaType.MUSIC, "2025.10")
-_DEPRECATED_MEDIA_TYPE_PLAYLIST = DeprecatedConstantEnum(MediaType.PLAYLIST, "2025.10")
-_DEPRECATED_MEDIA_TYPE_PODCAST = DeprecatedConstantEnum(MediaType.PODCAST, "2025.10")
-_DEPRECATED_MEDIA_TYPE_SEASON = DeprecatedConstantEnum(MediaType.SEASON, "2025.10")
-_DEPRECATED_MEDIA_TYPE_TRACK = DeprecatedConstantEnum(MediaType.TRACK, "2025.10")
-_DEPRECATED_MEDIA_TYPE_TVSHOW = DeprecatedConstantEnum(MediaType.TVSHOW, "2025.10")
-_DEPRECATED_MEDIA_TYPE_URL = DeprecatedConstantEnum(MediaType.URL, "2025.10")
-_DEPRECATED_MEDIA_TYPE_VIDEO = DeprecatedConstantEnum(MediaType.VIDEO, "2025.10")
-
-
 SERVICE_CLEAR_PLAYLIST = "clear_playlist"
 SERVICE_JOIN = "join"
 SERVICE_PLAY_MEDIA = "play_media"
@@ -197,11 +131,6 @@ class RepeatMode(StrEnum):
     ONE = "one"
 
 
-# These REPEAT_MODE_* constants are deprecated as of Home Assistant 2022.10.
-# Please use the RepeatMode enum instead.
-_DEPRECATED_REPEAT_MODE_ALL = DeprecatedConstantEnum(RepeatMode.ALL, "2025.10")
-_DEPRECATED_REPEAT_MODE_OFF = DeprecatedConstantEnum(RepeatMode.OFF, "2025.10")
-_DEPRECATED_REPEAT_MODE_ONE = DeprecatedConstantEnum(RepeatMode.ONE, "2025.10")
 REPEAT_MODES = [cls.value for cls in RepeatMode]
 
 
@@ -231,71 +160,3 @@ class MediaPlayerEntityFeature(IntFlag):
     MEDIA_ANNOUNCE = 1048576
     MEDIA_ENQUEUE = 2097152
     SEARCH_MEDIA = 4194304
-
-
-# These SUPPORT_* constants are deprecated as of Home Assistant 2022.5.
-# Please use the MediaPlayerEntityFeature enum instead.
-_DEPRECATED_SUPPORT_PAUSE = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.PAUSE, "2025.10"
-)
-_DEPRECATED_SUPPORT_SEEK = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.SEEK, "2025.10"
-)
-_DEPRECATED_SUPPORT_VOLUME_SET = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.VOLUME_SET, "2025.10"
-)
-_DEPRECATED_SUPPORT_VOLUME_MUTE = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.VOLUME_MUTE, "2025.10"
-)
-_DEPRECATED_SUPPORT_PREVIOUS_TRACK = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.PREVIOUS_TRACK, "2025.10"
-)
-_DEPRECATED_SUPPORT_NEXT_TRACK = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.NEXT_TRACK, "2025.10"
-)
-_DEPRECATED_SUPPORT_TURN_ON = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.TURN_ON, "2025.10"
-)
-_DEPRECATED_SUPPORT_TURN_OFF = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.TURN_OFF, "2025.10"
-)
-_DEPRECATED_SUPPORT_PLAY_MEDIA = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.PLAY_MEDIA, "2025.10"
-)
-_DEPRECATED_SUPPORT_VOLUME_STEP = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.VOLUME_STEP, "2025.10"
-)
-_DEPRECATED_SUPPORT_SELECT_SOURCE = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.SELECT_SOURCE, "2025.10"
-)
-_DEPRECATED_SUPPORT_STOP = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.STOP, "2025.10"
-)
-_DEPRECATED_SUPPORT_CLEAR_PLAYLIST = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.CLEAR_PLAYLIST, "2025.10"
-)
-_DEPRECATED_SUPPORT_PLAY = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.PLAY, "2025.10"
-)
-_DEPRECATED_SUPPORT_SHUFFLE_SET = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.SHUFFLE_SET, "2025.10"
-)
-_DEPRECATED_SUPPORT_SELECT_SOUND_MODE = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.SELECT_SOUND_MODE, "2025.10"
-)
-_DEPRECATED_SUPPORT_BROWSE_MEDIA = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.BROWSE_MEDIA, "2025.10"
-)
-_DEPRECATED_SUPPORT_REPEAT_SET = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.REPEAT_SET, "2025.10"
-)
-_DEPRECATED_SUPPORT_GROUPING = DeprecatedConstantEnum(
-    MediaPlayerEntityFeature.GROUPING, "2025.10"
-)
-
-# These can be removed if no deprecated constant are in this module anymore
-__getattr__ = partial(check_if_deprecated_constant, module_globals=globals())
-__dir__ = partial(
-    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
-)
-__all__ = all_with_deprecated_constants(globals())

homeassistant/components/media_source/models.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any
 
 from homeassistant.components.media_player import BrowseMedia, MediaClass, MediaType
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.translation import async_get_cached_translations
 
 from .const import MEDIA_SOURCE_DATA, URI_SCHEME, URI_SCHEME_REGEX
 
@@ -62,12 +63,15 @@ class MediaSourceItem:
     async def async_browse(self) -> BrowseMediaSource:
         """Browse this item."""
         if self.domain is None:
+            title = async_get_cached_translations(
+                self.hass, self.hass.config.language, "common", "media_source"
+            ).get("component.media_source.common.sources_default", "Media Sources")
             base = BrowseMediaSource(
                 domain=None,
                 identifier=None,
                 media_class=MediaClass.APP,
                 media_content_type=MediaType.APPS,
-                title="Media Sources",
+                title=title,
                 can_play=False,
                 can_expand=True,
                 children_media_class=MediaClass.APP,

homeassistant/components/media_source/strings.json

@@ -9,5 +9,8 @@
     "unknown_media_source": {
       "message": "Unknown media source: {domain}"
     }
+  },
+  "common": {
+    "sources_default": "Media sources"
   }
 }

homeassistant/components/modbus/entity.py

@@ -208,7 +208,7 @@ class ModbusStructEntity(ModbusBaseEntity, RestoreEntity):
 
     def __process_raw_value(self, entry: float | str | bytes) -> str | None:
         """Process value from sensor with NaN handling, scaling, offset, min/max etc."""
-        if self._nan_value and entry in (self._nan_value, -self._nan_value):
+        if self._nan_value is not None and entry in (self._nan_value, -self._nan_value):
             return None
         if isinstance(entry, bytes):
             return entry.decode()

homeassistant/components/mqtt/lock.py

@@ -188,7 +188,10 @@ class MqttLock(MqttEntity, LockEntity):
             return
         if payload == self._config[CONF_PAYLOAD_RESET]:
             # Reset the state to `unknown`
-            self._attr_is_locked = None
+            self._attr_is_locked = self._attr_is_locking = None
+            self._attr_is_unlocking = None
+            self._attr_is_open = self._attr_is_opening = None
+            self._attr_is_jammed = None
         elif payload in self._valid_states:
             self._attr_is_locked = payload == self._config[CONF_STATE_LOCKED]
             self._attr_is_locking = payload == self._config[CONF_STATE_LOCKING]

homeassistant/components/nordpool/__init__.py

@@ -34,6 +34,7 @@ async def async_setup_entry(
 
     coordinator = NordPoolDataUpdateCoordinator(hass, config_entry)
     await coordinator.fetch_data(dt_util.utcnow(), True)
+    await coordinator.update_listeners(dt_util.utcnow())
     if not coordinator.last_update_success:
         raise ConfigEntryNotReady(
             translation_domain=DOMAIN,

homeassistant/components/nordpool/coordinator.py

@@ -44,9 +44,10 @@ class NordPoolDataUpdateCoordinator(DataUpdateCoordinator[DeliveryPeriodsData]):
             name=DOMAIN,
         )
         self.client = NordPoolClient(session=async_get_clientsession(hass))
-        self.unsub: Callable[[], None] | None = None
+        self.data_unsub: Callable[[], None] | None = None
+        self.listener_unsub: Callable[[], None] | None = None
 
-    def get_next_interval(self, now: datetime) -> datetime:
+    def get_next_data_interval(self, now: datetime) -> datetime:
         """Compute next time an update should occur."""
         next_hour = dt_util.utcnow() + timedelta(hours=1)
         next_run = datetime(
@@ -56,23 +57,45 @@ class NordPoolDataUpdateCoordinator(DataUpdateCoordinator[DeliveryPeriodsData]):
             next_hour.hour,
             tzinfo=dt_util.UTC,
         )
-        LOGGER.debug("Next update at %s", next_run)
+        LOGGER.debug("Next data update at %s", next_run)
+        return next_run
+
+    def get_next_15_interval(self, now: datetime) -> datetime:
+        """Compute next time we need to notify listeners."""
+        next_run = dt_util.utcnow() + timedelta(minutes=15)
+        next_minute = next_run.minute // 15 * 15
+        next_run = next_run.replace(
+            minute=next_minute, second=0, microsecond=0, tzinfo=dt_util.UTC
+        )
+
+        LOGGER.debug("Next listener update at %s", next_run)
         return next_run
 
     async def async_shutdown(self) -> None:
         """Cancel any scheduled call, and ignore new runs."""
         await super().async_shutdown()
-        if self.unsub:
-            self.unsub()
-            self.unsub = None
+        if self.data_unsub:
+            self.data_unsub()
+            self.data_unsub = None
+        if self.listener_unsub:
+            self.listener_unsub()
+            self.listener_unsub = None
+
+    async def update_listeners(self, now: datetime) -> None:
+        """Update entity listeners."""
+        self.listener_unsub = async_track_point_in_utc_time(
+            self.hass,
+            self.update_listeners,
+            self.get_next_15_interval(dt_util.utcnow()),
+        )
+        self.async_update_listeners()
 
     async def fetch_data(self, now: datetime, initial: bool = False) -> None:
         """Fetch data from Nord Pool."""
-        self.unsub = async_track_point_in_utc_time(
-            self.hass, self.fetch_data, self.get_next_interval(dt_util.utcnow())
+        self.data_unsub = async_track_point_in_utc_time(
+            self.hass, self.fetch_data, self.get_next_data_interval(dt_util.utcnow())
         )
         if self.config_entry.pref_disable_polling and not initial:
-            self.async_update_listeners()
             return
         try:
             data = await self.handle_data(initial)

homeassistant/components/nordpool/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "cloud_polling",
   "loggers": ["pynordpool"],
   "quality_scale": "platinum",
-  "requirements": ["pynordpool==0.3.0"],
+  "requirements": ["pynordpool==0.3.1"],
   "single_config_entry": true
 }

homeassistant/components/ntfy/strings.json

@@ -307,7 +307,7 @@
         },
         "markdown": {
           "name": "Format as Markdown",
-          "description": "Enable Markdown formatting for the message body (Web app only). See the Markdown guide for syntax details: https://www.markdownguide.org/basic-syntax/."
+          "description": "Enable Markdown formatting for the message body. See the Markdown guide for syntax details: https://www.markdownguide.org/basic-syntax/."
         },
         "tags": {
           "name": "Tags/Emojis",

homeassistant/components/onedrive/backup.py

@@ -35,7 +35,8 @@ from .const import CONF_DELETE_PERMANENTLY, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
 from .coordinator import OneDriveConfigEntry
 
 _LOGGER = logging.getLogger(__name__)
-UPLOAD_CHUNK_SIZE = 16 * 320 * 1024  # 5.2MB
+MAX_CHUNK_SIZE = 60 * 1024 * 1024  # largest chunk possible, must be <= 60 MiB
+TARGET_CHUNKS = 20
 TIMEOUT = ClientTimeout(connect=10, total=43200)  # 12 hours
 METADATA_VERSION = 2
 CACHE_TTL = 300
@@ -161,9 +162,22 @@ class OneDriveBackupAgent(BackupAgent):
             self._folder_id,
             await open_stream(),
         )
+
+        # determine chunk based on target chunks
+        upload_chunk_size = backup.size / TARGET_CHUNKS
+        # find the nearest multiple of 320KB
+        upload_chunk_size = round(upload_chunk_size / (320 * 1024)) * (320 * 1024)
+        # limit to max chunk size
+        upload_chunk_size = min(upload_chunk_size, MAX_CHUNK_SIZE)
+        # ensure minimum chunk size of 320KB
+        upload_chunk_size = max(upload_chunk_size, 320 * 1024)
+
         try:
             backup_file = await LargeFileUploadClient.upload(
-                self._token_function, file, session=async_get_clientsession(self._hass)
+                self._token_function,
+                file,
+                upload_chunk_size=upload_chunk_size,
+                session=async_get_clientsession(self._hass),
             )
         except HashMismatchError as err:
             raise BackupAgentError(

homeassistant/components/oralb/icons.json

@@ -0,0 +1,61 @@
+{
+  "entity": {
+    "sensor": {
+      "pressure": {
+        "default": "mdi:tooth-outline",
+        "state": {
+          "high": "mdi:tooth",
+          "low": "mdi:alert",
+          "power_button_pressed": "mdi:power",
+          "button_pressed": "mdi:radiobox-marked"
+        }
+      },
+      "sector": {
+        "default": "mdi:circle-outline",
+        "state": {
+          "sector_1": "mdi:circle-slice-2",
+          "sector_2": "mdi:circle-slice-4",
+          "sector_3": "mdi:circle-slice-6",
+          "sector_4": "mdi:circle-slice-8",
+          "success": "mdi:check-circle-outline"
+        }
+      },
+      "toothbrush_state": {
+        "default": "mdi:toothbrush-electric",
+        "state": {
+          "initializing": "mdi:sync",
+          "idle": "mdi:toothbrush-electric",
+          "running": "mdi:waveform",
+          "charging": "mdi:battery-charging",
+          "setup": "mdi:wrench",
+          "flight_menu": "mdi:airplane",
+          "selection_menu": "mdi:menu",
+          "off": "mdi:power",
+          "sleeping": "mdi:sleep",
+          "transport": "mdi:dolly"
+        }
+      },
+      "number_of_sectors": {
+        "default": "mdi:chart-pie"
+      },
+      "mode": {
+        "default": "mdi:toothbrush-paste",
+        "state": {
+          "daily_clean": "mdi:repeat-once",
+          "sensitive": "mdi:feather",
+          "gum_care": "mdi:tooth-outline",
+          "intense": "mdi:shape-circle-plus",
+          "whitening": "mdi:shimmer",
+          "whiten": "mdi:shimmer",
+          "tongue_cleaning": "mdi:gate-and",
+          "super_sensitive": "mdi:feather",
+          "massage": "mdi:spa",
+          "deep_clean": "mdi:water",
+          "turbo": "mdi:car-turbocharger",
+          "off": "mdi:power",
+          "settings": "mdi:cog-outline"
+        }
+      }
+    }
+  }
+}

homeassistant/components/oralb/sensor.py

@@ -3,6 +3,13 @@
 from __future__ import annotations
 
 from oralb_ble import OralBSensor, SensorUpdate
+from oralb_ble.parser import (
+    IO_SERIES_MODES,
+    PRESSURE,
+    SECTOR_MAP,
+    SMART_SERIES_MODES,
+    STATES,
+)
 
 from homeassistant.components.bluetooth.passive_update_processor import (
     PassiveBluetoothDataProcessor,
@@ -39,6 +46,8 @@ SENSOR_DESCRIPTIONS: dict[str, SensorEntityDescription] = {
         key=OralBSensor.SECTOR,
         translation_key="sector",
         entity_category=EntityCategory.DIAGNOSTIC,
+        options=[v.replace(" ", "_") for v in set(SECTOR_MAP.values()) | {"no_sector"}],
+        device_class=SensorDeviceClass.ENUM,
     ),
     OralBSensor.NUMBER_OF_SECTORS: SensorEntityDescription(
         key=OralBSensor.NUMBER_OF_SECTORS,
@@ -53,16 +62,26 @@ SENSOR_DESCRIPTIONS: dict[str, SensorEntityDescription] = {
     ),
     OralBSensor.TOOTHBRUSH_STATE: SensorEntityDescription(
         key=OralBSensor.TOOTHBRUSH_STATE,
+        translation_key="toothbrush_state",
+        options=[v.replace(" ", "_") for v in set(STATES.values())],
+        device_class=SensorDeviceClass.ENUM,
         name=None,
     ),
     OralBSensor.PRESSURE: SensorEntityDescription(
         key=OralBSensor.PRESSURE,
         translation_key="pressure",
+        options=[v.replace(" ", "_") for v in set(PRESSURE.values()) | {"low"}],
+        device_class=SensorDeviceClass.ENUM,
     ),
     OralBSensor.MODE: SensorEntityDescription(
         key=OralBSensor.MODE,
         translation_key="mode",
         entity_category=EntityCategory.DIAGNOSTIC,
+        options=[
+            v.replace(" ", "_")
+            for v in set(IO_SERIES_MODES.values()) | set(SMART_SERIES_MODES.values())
+        ],
+        device_class=SensorDeviceClass.ENUM,
     ),
     OralBSensor.SIGNAL_STRENGTH: SensorEntityDescription(
         key=OralBSensor.SIGNAL_STRENGTH,
@@ -134,7 +153,15 @@ class OralBBluetoothSensorEntity(
     @property
     def native_value(self) -> str | int | None:
         """Return the native value."""
-        return self.processor.entity_data.get(self.entity_key)
+        value = self.processor.entity_data.get(self.entity_key)
+        if isinstance(value, str):
+            value = value.replace(" ", "_")
+            if (
+                self.entity_description.options is not None
+                and value not in self.entity_description.options
+            ):  # append unknown values to enum
+                self.entity_description.options.append(value)
+        return value
 
     @property
     def available(self) -> bool:

homeassistant/components/oralb/strings.json

@@ -22,7 +22,15 @@
   "entity": {
     "sensor": {
       "sector": {
-        "name": "Sector"
+        "name": "Sector",
+        "state": {
+          "no_sector": "No sector",
+          "sector_1": "Sector 1",
+          "sector_2": "Sector 2",
+          "sector_3": "Sector 3",
+          "sector_4": "Sector 4",
+          "success": "Success"
+        }
       },
       "number_of_sectors": {
         "name": "Number of sectors"
@@ -31,10 +39,48 @@
         "name": "Sector timer"
       },
       "pressure": {
-        "name": "Pressure"
+        "name": "Pressure",
+        "state": {
+          "normal": "[%key:common::state::normal%]",
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "power_button_pressed": "Power button pressed",
+          "button_pressed": "Button pressed"
+        }
       },
       "mode": {
-        "name": "Brushing mode"
+        "name": "Brushing mode",
+        "state": {
+          "daily_clean": "Daily clean",
+          "sensitive": "Sensitive",
+          "gum_care": "Gum care",
+          "intense": "Intense",
+          "whitening": "Whiten",
+          "whiten": "[%key:component::oralb::entity::sensor::mode::state::whitening%]",
+          "tongue_cleaning": "Tongue clean",
+          "super_sensitive": "Super sensitive",
+          "massage": "Massage",
+          "deep_clean": "Deep clean",
+          "turbo": "Turbo",
+          "off": "[%key:common::state::off%]",
+          "settings": "Settings"
+        }
+      },
+      "toothbrush_state": {
+        "state": {
+          "initializing": "Initializing",
+          "idle": "[%key:common::state::idle%]",
+          "running": "Running",
+          "charging": "[%key:common::state::charging%]",
+          "setup": "Setup",
+          "flight_menu": "Flight menu",
+          "selection_menu": "Selection menu",
+          "off": "[%key:common::state::off%]",
+          "sleeping": "Sleeping",
+          "transport": "Transport",
+          "final_test": "Final test",
+          "pcb_test": "PCB test"
+        }
       }
     }
   }

homeassistant/components/ovo_energy/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["ovoenergy"],
-  "requirements": ["ovoenergy==2.0.1"]
+  "requirements": ["ovoenergy==3.0.2"]
 }

homeassistant/components/pandora/media_player.py

@@ -115,9 +115,7 @@ class PandoraMediaPlayer(MediaPlayerEntity):
     async def _start_pianobar(self) -> bool:
         pianobar = pexpect.spawn("pianobar", encoding="utf-8")
         pianobar.delaybeforesend = None
-        # mypy thinks delayafterread must be a float but that is not what pexpect says
-        # https://github.com/pexpect/pexpect/blob/4.9/pexpect/expect.py#L170
-        pianobar.delayafterread = None  # type: ignore[assignment]
+        pianobar.delayafterread = None
         pianobar.delayafterclose = 0
         pianobar.delayafterterminate = 0
         _LOGGER.debug("Started pianobar subprocess")

homeassistant/components/plum_lightpad/__init__.py

@@ -1,52 +1,36 @@
 """Support for Plum Lightpad devices."""
 
-import logging
-
-from aiohttp import ContentTypeError
-from requests.exceptions import ConnectTimeout, HTTPError
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_PASSWORD,
-    CONF_USERNAME,
-    EVENT_HOMEASSISTANT_STOP,
-    Platform,
-)
+from homeassistant.config_entries import ConfigEntry, ConfigEntryState
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import issue_registry as ir
 
-from .const import DOMAIN
-from .utils import load_plum
-
-_LOGGER = logging.getLogger(__name__)
-
-PLATFORMS = [Platform.LIGHT]
+DOMAIN = "plum_lightpad"
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, _: ConfigEntry) -> bool:
     """Set up Plum Lightpad from a config entry."""
-    _LOGGER.debug("Setting up config entry with ID = %s", entry.unique_id)
+    ir.async_create_issue(
+        hass,
+        DOMAIN,
+        DOMAIN,
+        is_fixable=False,
+        severity=ir.IssueSeverity.ERROR,
+        translation_key="integration_removed",
+        translation_placeholders={
+            "entries": "/config/integrations/integration/plum_lightpad",
+        },
+    )
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload config entry."""
+    if all(
+        config_entry.state is ConfigEntryState.NOT_LOADED
+        for config_entry in hass.config_entries.async_entries(DOMAIN)
+        if config_entry.entry_id != entry.entry_id
+    ):
+        ir.async_delete_issue(hass, DOMAIN, DOMAIN)
 
-    username = entry.data[CONF_USERNAME]
-    password = entry.data[CONF_PASSWORD]
-
-    try:
-        plum = await load_plum(username, password, hass)
-    except ContentTypeError as ex:
-        _LOGGER.error("Unable to authenticate to Plum cloud: %s", ex)
-        return False
-    except (ConnectTimeout, HTTPError) as ex:
-        _LOGGER.error("Unable to connect to Plum cloud: %s", ex)
-        raise ConfigEntryNotReady from ex
-
-    hass.data.setdefault(DOMAIN, {})
-    hass.data[DOMAIN][entry.entry_id] = plum
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    def cleanup(event):
-        """Clean up resources."""
-        plum.cleanup()
-
-    entry.async_on_unload(hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, cleanup))
     return True