Refactor blueprint update entity and manager

This commit refactors the blueprint update entity and manager by removing unnecessary listeners and callbacks. It also renames `source_url` to `release_url` for clarity.

Co-authored-by: paulus.schoutsen <paulus.schoutsen@nabucasa.com>

.github/workflows/builder.yml

@@ -88,10 +88,6 @@ jobs:
       fail-fast: false
       matrix:
         arch: ${{ fromJson(needs.init.outputs.architectures) }}
-        exclude:
-          - arch: armv7
-          - arch: armhf
-          - arch: i386
     steps:
       - name: Checkout the repository
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.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@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/init@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/analyze@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
         with:
           category: "/language:python"

.strict-typing

@@ -362,7 +362,6 @@ homeassistant.components.myuplink.*
 homeassistant.components.nam.*
 homeassistant.components.nanoleaf.*
 homeassistant.components.nasweb.*
-homeassistant.components.neato.*
 homeassistant.components.nest.*
 homeassistant.components.netatmo.*
 homeassistant.components.network.*

CODEOWNERS

@@ -1539,8 +1539,8 @@ build.json @home-assistant/supervisor
 /tests/components/suez_water/ @ooii @jb101010-2
 /homeassistant/components/sun/ @home-assistant/core
 /tests/components/sun/ @home-assistant/core
-/homeassistant/components/sunricher_dali/ @niracler
-/tests/components/sunricher_dali/ @niracler
+/homeassistant/components/sunricher_dali_center/ @niracler
+/tests/components/sunricher_dali_center/ @niracler
 /homeassistant/components/supla/ @mwegrzynek
 /homeassistant/components/surepetcare/ @benleb @danielhiversen
 /tests/components/surepetcare/ @benleb @danielhiversen
@@ -1817,8 +1817,8 @@ build.json @home-assistant/supervisor
 /tests/components/ws66i/ @ssaenger
 /homeassistant/components/wyoming/ @synesthesiam
 /tests/components/wyoming/ @synesthesiam
-/homeassistant/components/xbox/ @hunterjm @tr4nt0r
-/tests/components/xbox/ @hunterjm @tr4nt0r
+/homeassistant/components/xbox/ @hunterjm
+/tests/components/xbox/ @hunterjm
 /homeassistant/components/xiaomi_aqara/ @danielhiversen @syssi
 /tests/components/xiaomi_aqara/ @danielhiversen @syssi
 /homeassistant/components/xiaomi_ble/ @Jc2k @Ernst79

build.yaml

@@ -1,10 +1,7 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
   aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.10.1
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.1
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.1
   amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.1
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.1
 cosign:
   base_identity: https://github.com/home-assistant/docker/.*
   identity: https://github.com/home-assistant/core/.*

homeassistant/brands/yale.json

@@ -1,5 +1,11 @@
 {
   "domain": "yale",
-  "name": "Yale (non-US/Canada)",
-  "integrations": ["yale", "yalexs_ble", "yale_smart_alarm"]
+  "name": "Yale",
+  "integrations": [
+    "august",
+    "yale_smart_alarm",
+    "yalexs_ble",
+    "yale_home",
+    "yale"
+  ]
 }

homeassistant/brands/yale_august.json

@@ -1,5 +0,0 @@
-{
-  "domain": "yale_august",
-  "name": "Yale August (US/Canada)",
-  "integrations": ["august", "august_ble"]
-}

homeassistant/components/ai_task/services.yaml

@@ -30,7 +30,6 @@ generate_data:
         media:
           accept:
             - "*"
-          multiple: true
 generate_image:
   fields:
     task_name:
@@ -58,4 +57,3 @@ generate_image:
         media:
           accept:
             - "*"
-          multiple: true

homeassistant/components/alexa/handlers.py

@@ -58,10 +58,7 @@ from homeassistant.const import (
 from homeassistant.helpers import network
 from homeassistant.util import color as color_util, dt as dt_util
 from homeassistant.util.decorator import Registry
-from homeassistant.util.unit_conversion import (
-    TemperatureConverter,
-    TemperatureDeltaConverter,
-)
+from homeassistant.util.unit_conversion import TemperatureConverter
 
 from .config import AbstractConfig
 from .const import (
@@ -847,7 +844,7 @@ def temperature_from_object(
         temp -= 273.15
 
     if interval:
-        return TemperatureDeltaConverter.convert(temp, from_unit, to_unit)
+        return TemperatureConverter.convert_interval(temp, from_unit, to_unit)
     return TemperatureConverter.convert(temp, from_unit, to_unit)
 
 

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/ambient_network/sensor.py

@@ -106,7 +106,7 @@ SENSOR_DESCRIPTIONS = (
         translation_key="daily_rain",
         native_unit_of_measurement=UnitOfPrecipitationDepth.INCHES,
         device_class=SensorDeviceClass.PRECIPITATION,
-        state_class=SensorStateClass.TOTAL_INCREASING,
+        state_class=SensorStateClass.TOTAL,
         suggested_display_precision=2,
     ),
     SensorEntityDescription(
@@ -150,7 +150,7 @@ SENSOR_DESCRIPTIONS = (
         key=TYPE_LIGHTNING_PER_DAY,
         translation_key="lightning_strikes_per_day",
         native_unit_of_measurement="strikes",
-        state_class=SensorStateClass.TOTAL_INCREASING,
+        state_class=SensorStateClass.TOTAL,
         entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
@@ -182,7 +182,7 @@ SENSOR_DESCRIPTIONS = (
         translation_key="monthly_rain",
         native_unit_of_measurement=UnitOfPrecipitationDepth.INCHES,
         device_class=SensorDeviceClass.PRECIPITATION,
-        state_class=SensorStateClass.TOTAL_INCREASING,
+        state_class=SensorStateClass.TOTAL,
         suggested_display_precision=2,
         entity_registry_enabled_default=False,
     ),
@@ -229,7 +229,7 @@ SENSOR_DESCRIPTIONS = (
         translation_key="weekly_rain",
         native_unit_of_measurement=UnitOfPrecipitationDepth.INCHES,
         device_class=SensorDeviceClass.PRECIPITATION,
-        state_class=SensorStateClass.TOTAL_INCREASING,
+        state_class=SensorStateClass.TOTAL,
         suggested_display_precision=2,
         entity_registry_enabled_default=False,
     ),
@@ -262,7 +262,7 @@ SENSOR_DESCRIPTIONS = (
         translation_key="yearly_rain",
         native_unit_of_measurement=UnitOfPrecipitationDepth.INCHES,
         device_class=SensorDeviceClass.PRECIPITATION,
-        state_class=SensorStateClass.TOTAL_INCREASING,
+        state_class=SensorStateClass.TOTAL,
         suggested_display_precision=2,
         entity_registry_enabled_default=False,
     ),

homeassistant/components/androidtv/config_flow.py

@@ -39,11 +39,11 @@ from .const import (
     CONF_TURN_OFF_COMMAND,
     CONF_TURN_ON_COMMAND,
     DEFAULT_ADB_SERVER_PORT,
+    DEFAULT_DEVICE_CLASS,
     DEFAULT_EXCLUDE_UNNAMED_APPS,
     DEFAULT_GET_SOURCES,
     DEFAULT_PORT,
     DEFAULT_SCREENCAP_INTERVAL,
-    DEVICE_AUTO,
     DEVICE_CLASSES,
     DOMAIN,
     PROP_ETHMAC,
@@ -89,14 +89,8 @@ class AndroidTVFlowHandler(ConfigFlow, domain=DOMAIN):
         data_schema = vol.Schema(
             {
                 vol.Required(CONF_HOST, default=host): str,
-                vol.Required(CONF_DEVICE_CLASS, default=DEVICE_AUTO): SelectSelector(
-                    SelectSelectorConfig(
-                        options=[
-                            SelectOptionDict(value=k, label=v)
-                            for k, v in DEVICE_CLASSES.items()
-                        ],
-                        translation_key="device_class",
-                    )
+                vol.Required(CONF_DEVICE_CLASS, default=DEFAULT_DEVICE_CLASS): vol.In(
+                    DEVICE_CLASSES
                 ),
                 vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port,
             },

homeassistant/components/androidtv/const.py

@@ -15,19 +15,15 @@ CONF_TURN_OFF_COMMAND = "turn_off_command"
 CONF_TURN_ON_COMMAND = "turn_on_command"
 
 DEFAULT_ADB_SERVER_PORT = 5037
+DEFAULT_DEVICE_CLASS = "auto"
 DEFAULT_EXCLUDE_UNNAMED_APPS = False
 DEFAULT_GET_SOURCES = True
 DEFAULT_PORT = 5555
 DEFAULT_SCREENCAP_INTERVAL = 5
 
-DEVICE_AUTO = "auto"
 DEVICE_ANDROIDTV = "androidtv"
 DEVICE_FIRETV = "firetv"
-DEVICE_CLASSES = {
-    DEVICE_AUTO: "auto",
-    DEVICE_ANDROIDTV: "Android TV",
-    DEVICE_FIRETV: "Fire TV",
-}
+DEVICE_CLASSES = [DEFAULT_DEVICE_CLASS, DEVICE_ANDROIDTV, DEVICE_FIRETV]
 
 PROP_ETHMAC = "ethmac"
 PROP_SERIALNO = "serialno"

homeassistant/components/androidtv/strings.json

@@ -65,13 +65,6 @@
       }
     }
   },
-  "selector": {
-    "device_class": {
-      "options": {
-        "auto": "Auto-detect device type"
-      }
-    }
-  },
   "services": {
     "adb_command": {
       "description": "Sends an ADB command to an Android / Fire TV device.",

homeassistant/components/backup/manifest.json

@@ -8,6 +8,6 @@
   "integration_type": "service",
   "iot_class": "calculated",
   "quality_scale": "internal",
-  "requirements": ["cronsim==2.7", "securetar==2025.2.1"],
+  "requirements": ["cronsim==2.6", "securetar==2025.2.1"],
   "single_config_entry": true
 }

homeassistant/components/bluemaestro/config_flow.py

@@ -72,7 +72,7 @@ class BlueMaestroConfigFlow(ConfigFlow, domain=DOMAIN):
                 title=self._discovered_devices[address], data={}
             )
 
-        current_addresses = self._async_current_ids(include_ignore=False)
+        current_addresses = self._async_current_ids()
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/blueprint/__init__.py

@@ -1,7 +1,9 @@
 """The blueprint integration."""
 
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.discovery import async_load_platform
 from homeassistant.helpers.typing import ConfigType
 
 from . import websocket_api
@@ -28,4 +30,7 @@ CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the blueprint integration."""
     websocket_api.async_setup(hass)
+    hass.async_create_task(
+        async_load_platform(hass, Platform.UPDATE, DOMAIN, None, config)
+    )
     return True

homeassistant/components/blueprint/models.py

@@ -204,8 +204,8 @@ class DomainBlueprints:
         self.hass = hass
         self.domain = domain
         self.logger = logger
-        self._blueprint_in_use = blueprint_in_use
-        self._reload_blueprint_consumers = reload_blueprint_consumers
+        self.blueprint_in_use = blueprint_in_use
+        self.reload_blueprint_consumers = reload_blueprint_consumers
         self._blueprints: dict[str, Blueprint | None] = {}
         self._load_lock = asyncio.Lock()
         self._blueprint_schema = blueprint_schema
@@ -325,7 +325,7 @@ class DomainBlueprints:
 
     async def async_remove_blueprint(self, blueprint_path: str) -> None:
         """Remove a blueprint file."""
-        if self._blueprint_in_use(self.hass, blueprint_path):
+        if self.blueprint_in_use(self.hass, blueprint_path):
             raise BlueprintInUse(self.domain, blueprint_path)
         path = self.blueprint_folder / blueprint_path
         await self.hass.async_add_executor_job(path.unlink)
@@ -362,7 +362,7 @@ class DomainBlueprints:
         self._blueprints[blueprint_path] = blueprint
 
         if overrides_existing:
-            await self._reload_blueprint_consumers(self.hass, blueprint_path)
+            await self.reload_blueprint_consumers(self.hass, blueprint_path)
 
         return overrides_existing
 

homeassistant/components/blueprint/update.py

@@ -0,0 +1,293 @@
+"""Update entities for blueprints."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+import logging
+from datetime import timedelta
+from typing import Any, Final
+
+from homeassistant.components import automation, script
+from . import importer, models
+from homeassistant.components.update import UpdateEntity, UpdateEntityFeature
+from homeassistant.const import CONF_SOURCE_URL
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import event as event_helper
+from homeassistant.helpers.entity import EntityCategory
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+
+from .const import DOMAIN as BLUEPRINT_DOMAIN
+from .errors import BlueprintException
+
+_LOGGER = logging.getLogger(__name__)
+
+_LATEST_VERSION_PLACEHOLDER: Final = "remote"
+DATA_UPDATE_MANAGER: Final = "update_manager"
+REFRESH_INTERVAL: Final = timedelta(days=1)
+
+
+@dataclass(slots=True)
+class BlueprintUsage:
+    """Details about a blueprint currently in use."""
+
+    domain: str
+    path: str
+    domain_blueprints: models.DomainBlueprints
+    blueprint: models.Blueprint
+    entities: list[str]
+
+
+async def async_setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    async_add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> None:
+    """Set up the blueprint update platform."""
+    data = hass.data.setdefault(BLUEPRINT_DOMAIN, {})
+
+    if (manager := data.get(DATA_UPDATE_MANAGER)) is None:
+        manager = BlueprintUpdateManager(hass, async_add_entities)
+        data[DATA_UPDATE_MANAGER] = manager
+        await manager.async_start()
+        return
+
+    manager.replace_add_entities(async_add_entities)
+    await manager.async_recreate_entities()
+
+
+class BlueprintUpdateManager:
+    """Manage blueprint update entities based on blueprint usage."""
+
+    def __init__(
+        self, hass: HomeAssistant, async_add_entities: AddEntitiesCallback
+    ) -> None:
+        """Initialize the manager."""
+        self.hass = hass
+        self._async_add_entities = async_add_entities
+        self._entities: dict[tuple[str, str], BlueprintUpdateEntity] = {}
+        self._lock = asyncio.Lock()
+        self._refresh_cancel: CALLBACK_TYPE | None = None
+        self._started = False
+        self._interval_unsub: CALLBACK_TYPE | None = None
+
+    async def async_start(self) -> None:
+        """Start tracking blueprint usage."""
+        if self._started:
+            return
+        self._started = True
+
+        self._interval_unsub = event_helper.async_track_time_interval(
+            self.hass, self._handle_time_interval, REFRESH_INTERVAL
+        )
+        await self.async_refresh_entities()
+
+    def replace_add_entities(self, async_add_entities: AddEntitiesCallback) -> None:
+        """Update the callback used to register entities."""
+        self._async_add_entities = async_add_entities
+
+    async def async_recreate_entities(self) -> None:
+        """Recreate entities after the platform has been reloaded."""
+        async with self._lock:
+            entities = list(self._entities.values())
+            self._entities.clear()
+
+        for entity in entities:
+            await entity.async_remove()
+
+        await self.async_refresh_entities()
+
+    async def async_refresh_entities(self) -> None:
+        """Refresh update entities based on current blueprint usage."""
+        async with self._lock:
+            usage_map = await self._async_collect_in_use_blueprints()
+
+            current_keys = set(self._entities)
+            new_keys = set(usage_map)
+
+            for key in current_keys - new_keys:
+                entity = self._entities.pop(key)
+                await entity.async_remove()
+
+            new_entities: list[BlueprintUpdateEntity] = []
+
+            for key in new_keys - current_keys:
+                usage = usage_map[key]
+                entity = BlueprintUpdateEntity(self, usage)
+                self._entities[key] = entity
+                new_entities.append(entity)
+
+            for key in new_keys & current_keys:
+                self._entities[key].update_usage(usage_map[key])
+                self._entities[key].async_write_ha_state()
+
+            if new_entities:
+                self._async_add_entities(new_entities)
+
+    def async_schedule_refresh(self) -> None:
+        """Schedule an asynchronous refresh."""
+        if self._refresh_cancel is not None:
+            return
+
+        self._refresh_cancel = event_helper.async_call_later(
+            self.hass, 0, self._handle_scheduled_refresh
+        )
+
+    @callback
+    def _handle_scheduled_refresh(self, _now: Any) -> None:
+        """Run a scheduled refresh task."""
+        self._refresh_cancel = None
+        self.hass.async_create_task(self.async_refresh_entities())
+
+    @callback
+    def _handle_time_interval(self, _now: Any) -> None:
+        """Handle scheduled interval refresh."""
+        self.async_schedule_refresh()
+
+    async def _async_collect_in_use_blueprints(self) -> dict[tuple[str, str], BlueprintUsage]:
+        """Collect blueprint usage information for automations and scripts."""
+
+        usage_keys: set[tuple[str, str]] = set()
+
+        if automation.DATA_COMPONENT in self.hass.data:
+            component = self.hass.data[automation.DATA_COMPONENT]
+            for automation_entity in list(component.entities):
+                if (path := getattr(automation_entity, "referenced_blueprint", None)):
+                    usage_keys.add((automation.DOMAIN, path))
+
+        if script.DOMAIN in self.hass.data:
+            component = self.hass.data[script.DOMAIN]
+            for script_entity in list(component.entities):
+                if (path := getattr(script_entity, "referenced_blueprint", None)):
+                    usage_keys.add((script.DOMAIN, path))
+
+        domain_blueprints_map = self.hass.data.get(BLUEPRINT_DOMAIN, {})
+        usage_map: dict[tuple[str, str], BlueprintUsage] = {}
+
+        for domain, path in usage_keys:
+            domain_blueprints: models.DomainBlueprints | None = domain_blueprints_map.get(
+                domain
+            )
+
+            if domain_blueprints is None:
+                continue
+
+            if not domain_blueprints.blueprint_in_use(self.hass, path):
+                continue
+
+            try:
+                blueprint = await domain_blueprints.async_get_blueprint(path)
+            except BlueprintException:
+                continue
+
+            source_url = blueprint.metadata.get(CONF_SOURCE_URL)
+            if not source_url:
+                continue
+
+            if domain == automation.DOMAIN:
+                entities = automation.automations_with_blueprint(self.hass, path)
+            elif domain == script.DOMAIN:
+                entities = script.scripts_with_blueprint(self.hass, path)
+            else:
+                entities = []
+
+            usage_map[(domain, path)] = BlueprintUsage(
+                domain=domain,
+                path=path,
+                domain_blueprints=domain_blueprints,
+                blueprint=blueprint,
+                entities=entities,
+            )
+
+        return usage_map
+
+
+class BlueprintUpdateEntity(UpdateEntity):
+    """Define a blueprint update entity."""
+
+    _attr_entity_category = EntityCategory.CONFIG
+    _attr_has_entity_name = True
+    _attr_should_poll = False
+    _attr_supported_features = UpdateEntityFeature.INSTALL
+
+    def __init__(self, manager: BlueprintUpdateManager, usage: BlueprintUsage) -> None:
+        """Initialize the update entity."""
+        self._manager = manager
+        self._domain = usage.domain
+        self._path = usage.path
+        self._domain_blueprints = usage.domain_blueprints
+        self._blueprint = usage.blueprint
+        self._entities_in_use = usage.entities
+        self._source_url = usage.blueprint.metadata.get(CONF_SOURCE_URL)
+        self._attr_unique_id = f"{self._domain}:{self._path}"
+        self._attr_in_progress = False
+
+        self.update_usage(usage)
+
+    @callback
+    def update_usage(self, usage: BlueprintUsage) -> None:
+        """Update the entity with latest usage information."""
+        self._domain_blueprints = usage.domain_blueprints
+        self._blueprint = usage.blueprint
+        self._entities_in_use = usage.entities
+        self._source_url = usage.blueprint.metadata.get(CONF_SOURCE_URL)
+
+        self._attr_name = usage.blueprint.name
+        self._attr_release_summary = usage.blueprint.metadata.get("description")
+        self._attr_installed_version = usage.blueprint.metadata.get("version")
+        self._attr_release_url = self._source_url
+        self._attr_available = self._source_url is not None
+        self._attr_latest_version = (
+            _LATEST_VERSION_PLACEHOLDER
+            if self._source_url is not None
+            else self._attr_installed_version
+        )
+
+    async def async_install(self, version: str | None, backup: bool) -> None:
+        """Install (refresh) the blueprint from its source."""
+        if self._source_url is None:
+            raise HomeAssistantError("Blueprint does not define a source URL")
+
+        self._attr_in_progress = True
+        self.async_write_ha_state()
+        usage: BlueprintUsage | None = None
+
+        try:
+            imported = await importer.fetch_blueprint_from_url(
+                self.hass, self._source_url
+            )
+            blueprint = imported.blueprint
+
+            if blueprint.domain != self._domain:
+                raise HomeAssistantError(
+                    "Downloaded blueprint domain does not match the existing blueprint"
+                )
+
+            await self._domain_blueprints.async_add_blueprint(
+                blueprint, self._path, allow_override=True
+            )
+
+            usage = BlueprintUsage(
+                domain=self._domain,
+                path=self._path,
+                domain_blueprints=self._domain_blueprints,
+                blueprint=blueprint,
+                entities=self._entities_in_use,
+            )
+
+        except HomeAssistantError:
+            raise
+        except Exception as err:  # noqa: BLE001 - Provide context for unexpected errors
+            raise HomeAssistantError("Failed to update blueprint from source") from err
+        finally:
+            self._attr_in_progress = False
+
+            if usage is not None:
+                self.update_usage(usage)
+
+            self.async_write_ha_state()
+
+        self._manager.async_schedule_refresh()

homeassistant/components/brother/__init__.py

@@ -9,7 +9,7 @@ from brother import Brother, SnmpError
 from homeassistant.components.snmp import async_get_snmp_engine
 from homeassistant.const import CONF_HOST, CONF_PORT, CONF_TYPE, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryNotReady
 
 from .const import (
     CONF_COMMUNITY,
@@ -50,15 +50,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: BrotherConfigEntry) -> b
     coordinator = BrotherDataUpdateCoordinator(hass, entry, brother)
     await coordinator.async_config_entry_first_refresh()
 
-    if brother.serial.lower() != entry.unique_id:
-        raise ConfigEntryError(
-            translation_domain=DOMAIN,
-            translation_key="serial_mismatch",
-            translation_placeholders={
-                "device": entry.title,
-            },
-        )
-
     entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)

homeassistant/components/brother/config_flow.py

@@ -13,7 +13,6 @@ from homeassistant.const import CONF_HOST, CONF_PORT, CONF_TYPE
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import section
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.selector import SelectSelector, SelectSelectorConfig
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 from homeassistant.util.network import is_host_valid
 
@@ -22,7 +21,6 @@ from .const import (
     DEFAULT_COMMUNITY,
     DEFAULT_PORT,
     DOMAIN,
-    PRINTER_TYPE_LASER,
     PRINTER_TYPES,
     SECTION_ADVANCED_SETTINGS,
 )
@@ -30,12 +28,7 @@ from .const import (
 DATA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_HOST): str,
-        vol.Required(CONF_TYPE, default=PRINTER_TYPE_LASER): SelectSelector(
-            SelectSelectorConfig(
-                options=PRINTER_TYPES,
-                translation_key="printer_type",
-            )
-        ),
+        vol.Optional(CONF_TYPE, default="laser"): vol.In(PRINTER_TYPES),
         vol.Required(SECTION_ADVANCED_SETTINGS): section(
             vol.Schema(
                 {
@@ -49,12 +42,7 @@ DATA_SCHEMA = vol.Schema(
 )
 ZEROCONF_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_TYPE, default=PRINTER_TYPE_LASER): SelectSelector(
-            SelectSelectorConfig(
-                options=PRINTER_TYPES,
-                translation_key="printer_type",
-            )
-        ),
+        vol.Optional(CONF_TYPE, default="laser"): vol.In(PRINTER_TYPES),
         vol.Required(SECTION_ADVANCED_SETTINGS): section(
             vol.Schema(
                 {

homeassistant/components/brother/const.py

@@ -7,10 +7,7 @@ from typing import Final
 
 DOMAIN: Final = "brother"
 
-PRINTER_TYPE_LASER = "laser"
-PRINTER_TYPE_INK = "ink"
-
-PRINTER_TYPES: Final = [PRINTER_TYPE_LASER, PRINTER_TYPE_INK]
+PRINTER_TYPES: Final = ["laser", "ink"]
 
 UPDATE_INTERVAL = timedelta(seconds=30)
 

homeassistant/components/brother/entity.py

@@ -1,30 +0,0 @@
-"""Define the Brother entity."""
-
-from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import BrotherDataUpdateCoordinator
-
-
-class BrotherPrinterEntity(CoordinatorEntity[BrotherDataUpdateCoordinator]):
-    """Define a Brother Printer entity."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: BrotherDataUpdateCoordinator,
-    ) -> None:
-        """Initialize."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            configuration_url=f"http://{coordinator.brother.host}/",
-            identifiers={(DOMAIN, coordinator.brother.serial)},
-            connections={(CONNECTION_NETWORK_MAC, coordinator.brother.mac)},
-            serial_number=coordinator.brother.serial,
-            manufacturer="Brother",
-            model=coordinator.brother.model,
-            name=coordinator.brother.model,
-            sw_version=coordinator.brother.firmware,
-        )

homeassistant/components/brother/sensor.py

@@ -19,15 +19,13 @@ from homeassistant.components.sensor import (
 from homeassistant.const import PERCENTAGE, EntityCategory
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import BrotherConfigEntry, BrotherDataUpdateCoordinator
-from .entity import BrotherPrinterEntity
-
-# Coordinator is used to centralize the data updates
-PARALLEL_UPDATES = 0
 
 ATTR_COUNTER = "counter"
 ATTR_REMAINING_PAGES = "remaining_pages"
@@ -332,9 +330,12 @@ async def async_setup_entry(
     )
 
 
-class BrotherPrinterSensor(BrotherPrinterEntity, SensorEntity):
-    """Define a Brother Printer sensor."""
+class BrotherPrinterSensor(
+    CoordinatorEntity[BrotherDataUpdateCoordinator], SensorEntity
+):
+    """Define an Brother Printer sensor."""
 
+    _attr_has_entity_name = True
     entity_description: BrotherSensorEntityDescription
 
     def __init__(
@@ -344,7 +345,16 @@ class BrotherPrinterSensor(BrotherPrinterEntity, SensorEntity):
     ) -> None:
         """Initialize."""
         super().__init__(coordinator)
-
+        self._attr_device_info = DeviceInfo(
+            configuration_url=f"http://{coordinator.brother.host}/",
+            identifiers={(DOMAIN, coordinator.brother.serial)},
+            connections={(CONNECTION_NETWORK_MAC, coordinator.brother.mac)},
+            serial_number=coordinator.brother.serial,
+            manufacturer="Brother",
+            model=coordinator.brother.model,
+            name=coordinator.brother.model,
+            sw_version=coordinator.brother.firmware,
+        )
         self._attr_native_value = description.value(coordinator.data)
         self._attr_unique_id = f"{coordinator.brother.serial.lower()}_{description.key}"
         self.entity_description = description

homeassistant/components/brother/strings.json

@@ -38,11 +38,11 @@
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
-          "type": "Printer type"
+          "type": "Type of the printer"
         },
         "data_description": {
           "host": "The hostname or IP address of the Brother printer to control.",
-          "type": "The type of the Brother printer."
+          "type": "Brother printer type: ink or laser."
         },
         "sections": {
           "advanced_settings": {
@@ -207,19 +207,8 @@
     "cannot_connect": {
       "message": "An error occurred while connecting to the {device} printer: {error}"
     },
-    "serial_mismatch": {
-      "message": "The serial number for {device} doesn't match the one in the configuration. It's possible that the two Brother printers have swapped IP addresses. Restore the previous IP address configuration or reconfigure the devices with Home Assistant."
-    },
     "update_error": {
       "message": "An error occurred while retrieving data from the {device} printer: {error}"
     }
-  },
-  "selector": {
-    "printer_type": {
-      "options": {
-        "ink": "ink",
-        "laser": "laser"
-      }
-    }
   }
 }

homeassistant/components/bryant_evolution/climate.py

@@ -189,7 +189,7 @@ class BryantEvolutionClimate(ClimateEntity):
                     return HVACAction.HEATING
         raise HomeAssistantError(
             translation_domain=DOMAIN,
-            translation_key="failed_to_parse_hvac_action",
+            translation_key="failed_to_parse_hvac_mode",
             translation_placeholders={
                 "mode_and_active": mode_and_active,
                 "current_temperature": str(self.current_temperature),

homeassistant/components/bryant_evolution/strings.json

@@ -24,7 +24,7 @@
   },
   "exceptions": {
     "failed_to_parse_hvac_action": {
-      "message": "Could not determine HVAC action: {mode_and_active}, {current_temperature}, {target_temperature_low}"
+      "message": "Could not determine HVAC action: {mode_and_active}, {self.current_temperature}, {self.target_temperature_low}"
     },
     "failed_to_parse_hvac_mode": {
       "message": "Cannot parse response to HVACMode: {mode}"

homeassistant/components/cloud/account_link.py

@@ -71,11 +71,8 @@ async def _get_services(hass: HomeAssistant) -> list[dict[str, Any]]:
         services = await account_link.async_fetch_available_services(
             hass.data[DATA_CLOUD]
         )
-    except (aiohttp.ClientError, TimeoutError) as err:
-        raise config_entry_oauth2_flow.ImplementationUnavailableError(
-            "Cannot provide OAuth2 implementation for cloud services. "
-            "Failed to fetch from account link server."
-        ) from err
+    except (aiohttp.ClientError, TimeoutError):
+        return []
 
     hass.data[DATA_SERVICES] = services
 

homeassistant/components/coolmaster/const.py

@@ -6,5 +6,3 @@ DEFAULT_PORT = 10102
 
 CONF_SUPPORTED_MODES = "supported_modes"
 CONF_SWING_SUPPORT = "swing_support"
-MAX_RETRIES = 3
-BACKOFF_BASE_DELAY = 2

homeassistant/components/coolmaster/coordinator.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import logging
 
 from pycoolmasternet_async import CoolMasterNet
@@ -13,7 +12,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import BACKOFF_BASE_DELAY, DOMAIN, MAX_RETRIES
+from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -47,34 +46,7 @@ class CoolmasterDataUpdateCoordinator(
 
     async def _async_update_data(self) -> dict[str, CoolMasterNetUnit]:
         """Fetch data from Coolmaster."""
-        retries_left = MAX_RETRIES
-        status: dict[str, CoolMasterNetUnit] = {}
-        while retries_left > 0 and not status:
-            retries_left -= 1
-            try:
-                status = await self._coolmaster.status()
-            except OSError as error:
-                if retries_left == 0:
-                    raise UpdateFailed(
-                        f"Error communicating with Coolmaster (aborting after {MAX_RETRIES} retries): {error}"
-                    ) from error
-                _LOGGER.debug(
-                    "Error communicating with coolmaster (%d retries left): %s",
-                    retries_left,
-                    str(error),
-                )
-            else:
-                if status:
-                    return status
-
-                _LOGGER.debug(
-                    "Error communicating with coolmaster: empty status received (%d retries left)",
-                    retries_left,
-                )
-
-            backoff = BACKOFF_BASE_DELAY ** (MAX_RETRIES - retries_left)
-            await asyncio.sleep(backoff)
-
-        raise UpdateFailed(
-            f"Error communicating with Coolmaster (aborting after {MAX_RETRIES} retries): empty status received"
-        )
+        try:
+            return await self._coolmaster.status()
+        except OSError as error:
+            raise UpdateFailed from error

homeassistant/components/ecovacs/icons.json

@@ -81,9 +81,6 @@
       "active_map": {
         "default": "mdi:floor-plan"
       },
-      "auto_empty": {
-        "default": "mdi:delete-empty"
-      },
       "water_amount": {
         "default": "mdi:water"
       },
@@ -92,6 +89,9 @@
       }
     },
     "sensor": {
+      "auto_empty": {
+        "default": "mdi:delete-empty"
+      },
       "error": {
         "default": "mdi:alert-circle"
       },

homeassistant/components/ecovacs/manifest.json

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

homeassistant/components/ecovacs/select.py

@@ -5,9 +5,8 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from deebot_client.capabilities import CapabilityMap, CapabilitySet, CapabilitySetTypes
-from deebot_client.command import CommandWithMessageHandling
 from deebot_client.device import Device
-from deebot_client.events import WorkModeEvent, auto_empty
+from deebot_client.events import WorkModeEvent
 from deebot_client.events.base import Event
 from deebot_client.events.map import CachedMapInfoEvent, MajorMapEvent
 from deebot_client.events.water_info import WaterAmountEvent
@@ -35,9 +34,6 @@ class EcovacsSelectEntityDescription[EventT: Event](
 
     current_option_fn: Callable[[EventT], str | None]
     options_fn: Callable[[CapabilitySetTypes], list[str]]
-    set_option_fn: Callable[[CapabilitySetTypes, str], CommandWithMessageHandling] = (
-        lambda cap, option: cap.set(option)
-    )
 
 
 ENTITY_DESCRIPTIONS: tuple[EcovacsSelectEntityDescription, ...] = (
@@ -62,14 +58,6 @@ ENTITY_DESCRIPTIONS: tuple[EcovacsSelectEntityDescription, ...] = (
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.CONFIG,
     ),
-    EcovacsSelectEntityDescription[auto_empty.AutoEmptyEvent](
-        capability_fn=lambda caps: caps.station.auto_empty if caps.station else None,
-        current_option_fn=lambda e: get_name_key(e.frequency) if e.frequency else None,
-        options_fn=lambda cap: [get_name_key(freq) for freq in cap.types],
-        set_option_fn=lambda cap, option: cap.set(None, option),
-        key="auto_empty",
-        translation_key="auto_empty",
-    ),
 )
 
 
@@ -118,17 +106,14 @@ class EcovacsSelectEntity[EventT: Event](
         await super().async_added_to_hass()
 
         async def on_event(event: EventT) -> None:
-            if (option := self.entity_description.current_option_fn(event)) is not None:
-                self._attr_current_option = option
-                self.async_write_ha_state()
+            self._attr_current_option = self.entity_description.current_option_fn(event)
+            self.async_write_ha_state()
 
         self._subscribe(self._capability.event, on_event)
 
     async def async_select_option(self, option: str) -> None:
         """Change the selected option."""
-        await self._device.execute_command(
-            self.entity_description.set_option_fn(self._capability, option)
-        )
+        await self._device.execute_command(self._capability.set(option))
 
 
 class EcovacsActiveMapSelectEntity(

homeassistant/components/ecovacs/sensor.py

@@ -17,6 +17,7 @@ from deebot_client.events import (
     NetworkInfoEvent,
     StatsEvent,
     TotalStatsEvent,
+    auto_empty,
     station,
 )
 from sucks import VacBot
@@ -158,6 +159,14 @@ ENTITY_DESCRIPTIONS: tuple[EcovacsSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENUM,
         options=get_options(station.State),
     ),
+    EcovacsSensorEntityDescription[auto_empty.AutoEmptyEvent](
+        capability_fn=lambda caps: caps.station.auto_empty if caps.station else None,
+        value_fn=lambda e: get_name_key(e.frequency) if e.frequency else None,
+        key="auto_empty",
+        translation_key="auto_empty",
+        device_class=SensorDeviceClass.ENUM,
+        options=get_options(auto_empty.Frequency),
+    ),
 )
 
 

homeassistant/components/ecovacs/strings.json

@@ -129,16 +129,6 @@
       "active_map": {
         "name": "Active map"
       },
-      "auto_empty": {
-        "name": "Auto-empty frequency",
-        "state": {
-          "auto": "Auto",
-          "min_10": "10 minutes",
-          "min_15": "15 minutes",
-          "min_25": "25 minutes",
-          "smart": "Smart"
-        }
-      },
       "water_amount": {
         "name": "[%key:component::ecovacs::entity::number::water_amount::name%]",
         "state": {
@@ -159,6 +149,13 @@
       }
     },
     "sensor": {
+      "auto_empty": {
+        "name": "Auto-empty frequency",
+        "state": {
+          "auto": "Auto",
+          "smart": "Smart"
+        }
+      },
       "error": {
         "name": "Error",
         "state_attributes": {

homeassistant/components/ecowitt/sensor.py

@@ -151,12 +151,14 @@ ECOWITT_SENSORS_MAPPING: Final = {
         key="RAIN_COUNT_MM",
         native_unit_of_measurement=UnitOfPrecipitationDepth.MILLIMETERS,
         device_class=SensorDeviceClass.PRECIPITATION,
+        state_class=SensorStateClass.TOTAL,
         suggested_display_precision=1,
     ),
     EcoWittSensorTypes.RAIN_COUNT_INCHES: SensorEntityDescription(
         key="RAIN_COUNT_INCHES",
         native_unit_of_measurement=UnitOfPrecipitationDepth.INCHES,
         device_class=SensorDeviceClass.PRECIPITATION,
+        state_class=SensorStateClass.TOTAL,
         suggested_display_precision=2,
     ),
     EcoWittSensorTypes.RAIN_RATE_MM: SensorEntityDescription(

homeassistant/components/elkm1/config_flow.py

@@ -296,7 +296,7 @@ class Elkm1ConfigFlow(ConfigFlow, domain=DOMAIN):
                 return await self.async_step_discovered_connection()
             return await self.async_step_manual_connection()
 
-        current_unique_ids = self._async_current_ids(include_ignore=False)
+        current_unique_ids = self._async_current_ids()
         current_hosts = {
             hostname_from_url(entry.data[CONF_HOST])
             for entry in self._async_current_entries(include_ignore=False)

homeassistant/components/enmax/__init__.py

@@ -0,0 +1 @@
+"""Virtual integration: Enmax Energy."""

homeassistant/components/enmax/manifest.json

@@ -0,0 +1,6 @@
+{
+  "domain": "enmax",
+  "name": "Enmax Energy",
+  "integration_type": "virtual",
+  "supported_by": "opower"
+}

homeassistant/components/esphome/__init__.py

@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-import logging
-
-from aioesphomeapi import APIClient, APIConnectionError
+from aioesphomeapi import APIClient
 
 from homeassistant.components import zeroconf
 from homeassistant.components.bluetooth import async_remove_scanner
@@ -22,12 +20,9 @@ from homeassistant.helpers.typing import ConfigType
 from . import assist_satellite, dashboard, ffmpeg_proxy
 from .const import CONF_BLUETOOTH_MAC_ADDRESS, CONF_NOISE_PSK, DOMAIN
 from .domain_data import DomainData
-from .encryption_key_storage import async_get_encryption_key_storage
 from .entry_data import ESPHomeConfigEntry, RuntimeEntryData
 from .manager import DEVICE_CONFLICT_ISSUE_FORMAT, ESPHomeManager, cleanup_instance
 
-_LOGGER = logging.getLogger(__name__)
-
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 CLIENT_INFO = f"Home Assistant {ha_version}"
@@ -80,12 +75,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ESPHomeConfigEntry) -> b
 
 async def async_unload_entry(hass: HomeAssistant, entry: ESPHomeConfigEntry) -> bool:
     """Unload an esphome config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(
-        entry, entry.runtime_data.loaded_platforms
+    entry_data = await cleanup_instance(entry)
+    return await hass.config_entries.async_unload_platforms(
+        entry, entry_data.loaded_platforms
     )
-    if unload_ok:
-        await cleanup_instance(entry)
-    return unload_ok
 
 
 async def async_remove_entry(hass: HomeAssistant, entry: ESPHomeConfigEntry) -> None:
@@ -96,57 +89,3 @@ async def async_remove_entry(hass: HomeAssistant, entry: ESPHomeConfigEntry) ->
         hass, DOMAIN, DEVICE_CONFLICT_ISSUE_FORMAT.format(entry.entry_id)
     )
     await DomainData.get(hass).get_or_create_store(hass, entry).async_remove()
-
-    await _async_clear_dynamic_encryption_key(hass, entry)
-
-
-async def _async_clear_dynamic_encryption_key(
-    hass: HomeAssistant, entry: ESPHomeConfigEntry
-) -> None:
-    """Clear the dynamic encryption key on the device and from storage."""
-    if entry.unique_id is None or entry.data.get(CONF_NOISE_PSK) is None:
-        return
-
-    # Only clear the key if it's stored in our storage, meaning it was
-    # dynamically generated by us and not user-provided
-    storage = await async_get_encryption_key_storage(hass)
-    if await storage.async_get_key(entry.unique_id) is None:
-        return
-
-    host: str = entry.data[CONF_HOST]
-    port: int = entry.data[CONF_PORT]
-    password: str | None = entry.data[CONF_PASSWORD]
-    noise_psk: str | None = entry.data.get(CONF_NOISE_PSK)
-
-    zeroconf_instance = await zeroconf.async_get_instance(hass)
-
-    cli = APIClient(
-        host,
-        port,
-        password,
-        client_info=CLIENT_INFO,
-        zeroconf_instance=zeroconf_instance,
-        noise_psk=noise_psk,
-        timezone=hass.config.time_zone,
-    )
-
-    try:
-        await cli.connect()
-        # Clear the encryption key on the device by passing an empty key
-        if not await cli.noise_encryption_set_key(b""):
-            _LOGGER.debug(
-                "Could not clear dynamic encryption key for ESPHome device %s: Device rejected key removal",
-                entry.unique_id,
-            )
-            return
-    except APIConnectionError as exc:
-        _LOGGER.debug(
-            "Could not connect to ESPHome device %s to clear dynamic encryption key: %s",
-            entry.unique_id,
-            exc,
-        )
-        return
-    finally:
-        await cli.disconnect()
-
-    await storage.async_remove_key(entry.unique_id)

homeassistant/components/esphome/manifest.json

@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==42.6.0",
+    "aioesphomeapi==42.5.0",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==3.4.0"
   ],

homeassistant/components/eufylife_ble/config_flow.py

@@ -77,7 +77,7 @@ class EufyLifeConfigFlow(ConfigFlow, domain=DOMAIN):
                 data={CONF_MODEL: model},
             )
 
-        current_addresses = self._async_current_ids(include_ignore=False)
+        current_addresses = self._async_current_ids()
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if (

homeassistant/components/firefly_iii/config_flow.py

@@ -129,51 +129,6 @@ class FireflyConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration of the integration."""
-        errors: dict[str, str] = {}
-        reconf_entry = self._get_reconfigure_entry()
-
-        if user_input:
-            try:
-                await _validate_input(
-                    self.hass,
-                    data={
-                        **reconf_entry.data,
-                        **user_input,
-                    },
-                )
-            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:
-                self._async_abort_entries_match({CONF_URL: user_input[CONF_URL]})
-                return self.async_update_reload_and_abort(
-                    reconf_entry,
-                    data_updates={
-                        CONF_URL: user_input[CONF_URL],
-                        CONF_API_KEY: user_input[CONF_API_KEY],
-                        CONF_VERIFY_SSL: user_input[CONF_VERIFY_SSL],
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=self.add_suggested_values_to_schema(
-                data_schema=STEP_USER_DATA_SCHEMA,
-                suggested_values=user_input or reconf_entry.data.copy(),
-            ),
-            errors=errors,
-        )
-
 
 class CannotConnect(HomeAssistantError):
     """Error to indicate we cannot connect."""

homeassistant/components/firefly_iii/strings.json

@@ -2,8 +2,7 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -21,20 +20,6 @@
         },
         "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)."
       },
-      "reconfigure": {
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]",
-          "url": "[%key:common::config_flow::data::url%]",
-          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
-        },
-        "data_description": {
-          "api_key": "[%key:component::firefly_iii::config::step::user::data_description::api_key%]",
-          "url": "[%key:common::config_flow::data::url%]",
-          "verify_ssl": "[%key:component::firefly_iii::config::step::user::data_description::verify_ssl%]"
-        },
-        "description": "Use the following form to reconfigure your Firefly III instance.",
-        "title": "Reconfigure Firefly III Integration"
-      },
       "user": {
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]",

homeassistant/components/foscam/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/foscam",
   "iot_class": "local_polling",
   "loggers": ["libpyfoscamcgi"],
-  "requirements": ["libpyfoscamcgi==0.0.9"]
+  "requirements": ["libpyfoscamcgi==0.0.8"]
 }

homeassistant/components/frontend/__init__.py

@@ -263,9 +263,6 @@ class Panel:
     # Title to show in the sidebar
     sidebar_title: str | None = None
 
-    # If the panel should be visible by default in the sidebar
-    sidebar_default_visible: bool = True
-
     # Url to show the panel in the frontend
     frontend_url_path: str
 
@@ -283,7 +280,6 @@ class Panel:
         component_name: str,
         sidebar_title: str | None,
         sidebar_icon: str | None,
-        sidebar_default_visible: bool,
         frontend_url_path: str | None,
         config: dict[str, Any] | None,
         require_admin: bool,
@@ -297,7 +293,6 @@ class Panel:
         self.config = config
         self.require_admin = require_admin
         self.config_panel_domain = config_panel_domain
-        self.sidebar_default_visible = sidebar_default_visible
 
     @callback
     def to_response(self) -> PanelResponse:
@@ -306,7 +301,6 @@ class Panel:
             "component_name": self.component_name,
             "icon": self.sidebar_icon,
             "title": self.sidebar_title,
-            "default_visible": self.sidebar_default_visible,
             "config": self.config,
             "url_path": self.frontend_url_path,
             "require_admin": self.require_admin,
@@ -321,7 +315,6 @@ def async_register_built_in_panel(
     component_name: str,
     sidebar_title: str | None = None,
     sidebar_icon: str | None = None,
-    sidebar_default_visible: bool = True,
     frontend_url_path: str | None = None,
     config: dict[str, Any] | None = None,
     require_admin: bool = False,
@@ -334,7 +327,6 @@ def async_register_built_in_panel(
         component_name,
         sidebar_title,
         sidebar_icon,
-        sidebar_default_visible,
         frontend_url_path,
         config,
         require_admin,
@@ -460,27 +452,9 @@ 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",
-        sidebar_icon="mdi:lamps",
-        sidebar_title="light",
-        sidebar_default_visible=False,
-    )
-    async_register_built_in_panel(
-        hass,
-        "security",
-        sidebar_icon="mdi:security",
-        sidebar_title="security",
-        sidebar_default_visible=False,
-    )
-    async_register_built_in_panel(
-        hass,
-        "climate",
-        sidebar_icon="mdi:home-thermometer",
-        sidebar_title="climate",
-        sidebar_default_visible=False,
-    )
+    async_register_built_in_panel(hass, "light")
+    async_register_built_in_panel(hass, "safety")
+    async_register_built_in_panel(hass, "climate")
 
     async_register_built_in_panel(hass, "profile")
 
@@ -905,7 +879,6 @@ class PanelResponse(TypedDict):
     component_name: str
     icon: str | None
     title: str | None
-    default_visible: bool
     config: dict[str, Any] | None
     url_path: str
     require_admin: bool

homeassistant/components/frontend/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20251105.0"]
+  "requirements": ["home-assistant-frontend==20251029.1"]
 }

homeassistant/components/gios/sensor.py

@@ -43,9 +43,6 @@ from .coordinator import GiosConfigEntry, GiosDataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
-# Coordinator is used to centralize the data updates
-PARALLEL_UPDATES = 0
-
 
 @dataclass(frozen=True, kw_only=True)
 class GiosSensorEntityDescription(SensorEntityDescription):

homeassistant/components/gios/strings.json

@@ -14,10 +14,6 @@
           "name": "[%key:common::config_flow::data::name%]",
           "station_id": "Measuring station"
         },
-        "data_description": {
-          "name": "Config entry name, by default, this is the name of your Home Assistant instance.",
-          "station_id": "The name of the measuring station where the environmental data is collected."
-        },
         "title": "GIO\u015a (Polish Chief Inspectorate Of Environmental Protection)"
       }
     }

homeassistant/components/hassio/binary_sensor.py

@@ -3,9 +3,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-import itertools
-
-from aiohasupervisor.models.mounts import MountState
 
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
@@ -16,14 +13,8 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import (
-    ADDONS_COORDINATOR,
-    ATTR_STARTED,
-    ATTR_STATE,
-    DATA_KEY_ADDONS,
-    DATA_KEY_MOUNTS,
-)
-from .entity import HassioAddonEntity, HassioMountEntity
+from .const import ADDONS_COORDINATOR, ATTR_STARTED, ATTR_STATE, DATA_KEY_ADDONS
+from .entity import HassioAddonEntity
 
 
 @dataclass(frozen=True)
@@ -43,16 +34,6 @@ ADDON_ENTITY_DESCRIPTIONS = (
     ),
 )
 
-MOUNT_ENTITY_DESCRIPTIONS = (
-    HassioBinarySensorEntityDescription(
-        device_class=BinarySensorDeviceClass.CONNECTIVITY,
-        entity_registry_enabled_default=False,
-        key=ATTR_STATE,
-        translation_key="mount",
-        target=MountState.ACTIVE.value,
-    ),
-)
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -63,26 +44,13 @@ async def async_setup_entry(
     coordinator = hass.data[ADDONS_COORDINATOR]
 
     async_add_entities(
-        itertools.chain(
-            [
-                HassioAddonBinarySensor(
-                    addon=addon,
-                    coordinator=coordinator,
-                    entity_description=entity_description,
-                )
-                for addon in coordinator.data[DATA_KEY_ADDONS].values()
-                for entity_description in ADDON_ENTITY_DESCRIPTIONS
-            ],
-            [
-                HassioMountBinarySensor(
-                    mount=mount,
-                    coordinator=coordinator,
-                    entity_description=entity_description,
-                )
-                for mount in coordinator.data[DATA_KEY_MOUNTS].values()
-                for entity_description in MOUNT_ENTITY_DESCRIPTIONS
-            ],
+        HassioAddonBinarySensor(
+            addon=addon,
+            coordinator=coordinator,
+            entity_description=entity_description,
         )
+        for addon in coordinator.data[DATA_KEY_ADDONS].values()
+        for entity_description in ADDON_ENTITY_DESCRIPTIONS
     )
 
 
@@ -100,20 +68,3 @@ class HassioAddonBinarySensor(HassioAddonEntity, BinarySensorEntity):
         if self.entity_description.target is None:
             return value
         return value == self.entity_description.target
-
-
-class HassioMountBinarySensor(HassioMountEntity, BinarySensorEntity):
-    """Binary sensor for Hass.io mount."""
-
-    entity_description: HassioBinarySensorEntityDescription
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if the binary sensor is on."""
-        value = getattr(
-            self.coordinator.data[DATA_KEY_MOUNTS][self._mount.name],
-            self.entity_description.key,
-        )
-        if self.entity_description.target is None:
-            return value
-        return value == self.entity_description.target

homeassistant/components/hassio/const.py

@@ -90,7 +90,6 @@ DATA_SUPERVISOR_INFO = "hassio_supervisor_info"
 DATA_SUPERVISOR_STATS = "hassio_supervisor_stats"
 DATA_ADDONS_INFO = "hassio_addons_info"
 DATA_ADDONS_STATS = "hassio_addons_stats"
-DATA_MOUNTS_INFO = "hassio_mounts_info"
 HASSIO_UPDATE_INTERVAL = timedelta(minutes=5)
 
 ATTR_AUTO_UPDATE = "auto_update"
@@ -111,7 +110,6 @@ DATA_KEY_SUPERVISOR = "supervisor"
 DATA_KEY_CORE = "core"
 DATA_KEY_HOST = "host"
 DATA_KEY_SUPERVISOR_ISSUES = "supervisor_issues"
-DATA_KEY_MOUNTS = "mounts"
 
 PLACEHOLDER_KEY_ADDON = "addon"
 PLACEHOLDER_KEY_ADDON_INFO = "addon_info"
@@ -176,4 +174,3 @@ class SupervisorEntityModel(StrEnum):
     CORE = "Home Assistant Core"
     SUPERVISOR = "Home Assistant Supervisor"
     HOST = "Home Assistant Host"
-    MOUNT = "Home Assistant Mount"

homeassistant/components/hassio/coordinator.py

@@ -10,11 +10,6 @@ from typing import TYPE_CHECKING, Any
 
 from aiohasupervisor import SupervisorError, SupervisorNotFoundError
 from aiohasupervisor.models import StoreInfo
-from aiohasupervisor.models.mounts import (
-    CIFSMountResponse,
-    MountsInfo,
-    NFSMountResponse,
-)
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_MANUFACTURER, ATTR_NAME
@@ -46,11 +41,9 @@ from .const import (
     DATA_KEY_ADDONS,
     DATA_KEY_CORE,
     DATA_KEY_HOST,
-    DATA_KEY_MOUNTS,
     DATA_KEY_OS,
     DATA_KEY_SUPERVISOR,
     DATA_KEY_SUPERVISOR_ISSUES,
-    DATA_MOUNTS_INFO,
     DATA_NETWORK_INFO,
     DATA_OS_INFO,
     DATA_STORE,
@@ -181,16 +174,6 @@ def get_core_info(hass: HomeAssistant) -> dict[str, Any] | None:
     return hass.data.get(DATA_CORE_INFO)
 
 
-@callback
-@bind_hass
-def get_mounts_info(hass: HomeAssistant) -> MountsInfo | None:
-    """Return Home Assistant mounts information from Supervisor.
-
-    Async friendly.
-    """
-    return hass.data.get(DATA_MOUNTS_INFO)
-
-
 @callback
 @bind_hass
 def get_issues_info(hass: HomeAssistant) -> SupervisorIssues | None:
@@ -220,25 +203,6 @@ def async_register_addons_in_dev_reg(
         dev_reg.async_get_or_create(config_entry_id=entry_id, **params)
 
 
-@callback
-def async_register_mounts_in_dev_reg(
-    entry_id: str,
-    dev_reg: dr.DeviceRegistry,
-    mounts: list[CIFSMountResponse | NFSMountResponse],
-) -> None:
-    """Register mounts in the device registry."""
-    for mount in mounts:
-        params = DeviceInfo(
-            identifiers={(DOMAIN, f"mount_{mount.name}")},
-            manufacturer="Home Assistant",
-            model=SupervisorEntityModel.MOUNT,
-            model_id=f"{mount.usage}/{mount.type}",
-            name=mount.name,
-            entry_type=dr.DeviceEntryType.SERVICE,
-        )
-        dev_reg.async_get_or_create(config_entry_id=entry_id, **params)
-
-
 @callback
 def async_register_os_in_dev_reg(
     entry_id: str, dev_reg: dr.DeviceRegistry, os_dict: dict[str, Any]
@@ -308,12 +272,12 @@ def async_register_supervisor_in_dev_reg(
 
 
 @callback
-def async_remove_devices_from_dev_reg(
-    dev_reg: dr.DeviceRegistry, devices: set[str]
+def async_remove_addons_from_dev_reg(
+    dev_reg: dr.DeviceRegistry, addons: set[str]
 ) -> None:
-    """Remove devices from the device registry."""
-    for device in devices:
-        if dev := dev_reg.async_get_device(identifiers={(DOMAIN, device)}):
+    """Remove addons from the device registry."""
+    for addon_slug in addons:
+        if dev := dev_reg.async_get_device(identifiers={(DOMAIN, addon_slug)}):
             dev_reg.async_remove_device(dev.id)
 
 
@@ -398,19 +362,12 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
             **get_supervisor_stats(self.hass),
         }
         new_data[DATA_KEY_HOST] = get_host_info(self.hass) or {}
-        new_data[DATA_KEY_MOUNTS] = {
-            mount.name: mount
-            for mount in getattr(get_mounts_info(self.hass), "mounts", [])
-        }
 
         # If this is the initial refresh, register all addons and return the dict
         if is_first_update:
             async_register_addons_in_dev_reg(
                 self.entry_id, self.dev_reg, new_data[DATA_KEY_ADDONS].values()
             )
-            async_register_mounts_in_dev_reg(
-                self.entry_id, self.dev_reg, new_data[DATA_KEY_MOUNTS].values()
-            )
             async_register_core_in_dev_reg(
                 self.entry_id, self.dev_reg, new_data[DATA_KEY_CORE]
             )
@@ -432,20 +389,7 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
             if device.model == SupervisorEntityModel.ADDON
         }
         if stale_addons := supervisor_addon_devices - set(new_data[DATA_KEY_ADDONS]):
-            async_remove_devices_from_dev_reg(self.dev_reg, stale_addons)
-
-        # Remove mounts that no longer exists from device registry
-        supervisor_mount_devices = {
-            device.name
-            for device in self.dev_reg.devices.get_devices_for_config_entry_id(
-                self.entry_id
-            )
-            if device.model == SupervisorEntityModel.MOUNT
-        }
-        if stale_mounts := supervisor_mount_devices - set(new_data[DATA_KEY_MOUNTS]):
-            async_remove_devices_from_dev_reg(
-                self.dev_reg, {f"mount_{stale_mount}" for stale_mount in stale_mounts}
-            )
+            async_remove_addons_from_dev_reg(self.dev_reg, stale_addons)
 
         if not self.is_hass_os and (
             dev := self.dev_reg.async_get_device(identifiers={(DOMAIN, "OS")})
@@ -453,12 +397,11 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
             # Remove the OS device if it exists and the installation is not hassos
             self.dev_reg.async_remove_device(dev.id)
 
-        # If there are new add-ons or mounts, we should reload the config entry so we can
+        # If there are new add-ons, we should reload the config entry so we can
         # create new devices and entities. We can return an empty dict because
         # coordinator will be recreated.
-        if self.data and (
-            set(new_data[DATA_KEY_ADDONS]) - set(self.data[DATA_KEY_ADDONS])
-            or set(new_data[DATA_KEY_MOUNTS]) - set(self.data[DATA_KEY_MOUNTS])
+        if self.data and set(new_data[DATA_KEY_ADDONS]) - set(
+            self.data[DATA_KEY_ADDONS]
         ):
             self.hass.async_create_task(
                 self.hass.config_entries.async_reload(self.entry_id)
@@ -485,7 +428,6 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
             DATA_CORE_INFO: hassio.get_core_info(),
             DATA_SUPERVISOR_INFO: hassio.get_supervisor_info(),
             DATA_OS_INFO: hassio.get_os_info(),
-            DATA_MOUNTS_INFO: self.supervisor_client.mounts.info(),
         }
         if CONTAINER_STATS in container_updates[CORE_CONTAINER]:
             updates[DATA_CORE_STATS] = hassio.get_core_stats()

homeassistant/components/hassio/entity.py

@@ -4,8 +4,6 @@ from __future__ import annotations
 
 from typing import Any
 
-from aiohasupervisor.models.mounts import CIFSMountResponse, NFSMountResponse
-
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -17,7 +15,6 @@ from .const import (
     DATA_KEY_ADDONS,
     DATA_KEY_CORE,
     DATA_KEY_HOST,
-    DATA_KEY_MOUNTS,
     DATA_KEY_OS,
     DATA_KEY_SUPERVISOR,
     DOMAIN,
@@ -195,34 +192,3 @@ class HassioCoreEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
         )
         if CONTAINER_STATS in update_types:
             await self.coordinator.async_request_refresh()
-
-
-class HassioMountEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
-    """Base Entity for Mount."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: HassioDataUpdateCoordinator,
-        entity_description: EntityDescription,
-        mount: CIFSMountResponse | NFSMountResponse,
-    ) -> None:
-        """Initialize base entity."""
-        super().__init__(coordinator)
-        self.entity_description = entity_description
-        self._attr_unique_id = (
-            f"home_assistant_mount_{mount.name}_{entity_description.key}"
-        )
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, f"mount_{mount.name}")}
-        )
-        self._mount = mount
-
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        return (
-            super().available
-            and self._mount.name in self.coordinator.data[DATA_KEY_MOUNTS]
-        )

homeassistant/components/hassio/issues.py

@@ -44,6 +44,7 @@ from .const import (
     EVENT_SUPPORTED_CHANGED,
     EXTRA_PLACEHOLDERS,
     ISSUE_KEY_ADDON_BOOT_FAIL,
+    ISSUE_KEY_ADDON_DEPRECATED,
     ISSUE_KEY_ADDON_DETACHED_ADDON_MISSING,
     ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED,
     ISSUE_KEY_ADDON_PWNED,
@@ -86,6 +87,7 @@ ISSUE_KEYS_FOR_REPAIRS = {
     "issue_system_disk_lifetime",
     ISSUE_KEY_SYSTEM_FREE_SPACE,
     ISSUE_KEY_ADDON_PWNED,
+    ISSUE_KEY_ADDON_DEPRECATED,
 }
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/hassio/strings.json

@@ -1,9 +1,6 @@
 {
   "entity": {
     "binary_sensor": {
-      "mount": {
-        "name": "Connected"
-      },
       "state": {
         "name": "Running"
       }

homeassistant/components/holiday/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/holiday",
   "iot_class": "local_polling",
-  "requirements": ["holidays==0.84", "babel==2.15.0"]
+  "requirements": ["holidays==0.83", "babel==2.15.0"]
 }

homeassistant/components/homeassistant_connect_zbt2/config_flow.py

@@ -39,8 +39,6 @@ from .const import (
     NABU_CASA_FIRMWARE_RELEASES_URL,
     PID,
     PRODUCT,
-    RADIO_TX_POWER_DBM_BY_COUNTRY,
-    RADIO_TX_POWER_DBM_DEFAULT,
     SERIAL_NUMBER,
     VID,
 )
@@ -77,7 +75,6 @@ class ZBT2FirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
 
     context: ConfigFlowContext
     BOOTLOADER_RESET_METHODS = [ResetTarget.RTS_DTR]
-    ZIGBEE_BAUDRATE = 460800
 
     async def async_step_install_zigbee_firmware(
         self, user_input: dict[str, Any] | None = None
@@ -105,21 +102,6 @@ class ZBT2FirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
             next_step_id="finish_thread_installation",
         )
 
-    def _extra_zha_hardware_options(self) -> dict[str, Any]:
-        """Return extra ZHA hardware options."""
-        country = self.hass.config.country
-
-        if country is None:
-            tx_power = RADIO_TX_POWER_DBM_DEFAULT
-        else:
-            tx_power = RADIO_TX_POWER_DBM_BY_COUNTRY.get(
-                country, RADIO_TX_POWER_DBM_DEFAULT
-            )
-
-        return {
-            "tx_power": tx_power,
-        }
-
 
 class HomeAssistantConnectZBT2ConfigFlow(
     ZBT2FirmwareMixin,
@@ -130,6 +112,7 @@ class HomeAssistantConnectZBT2ConfigFlow(
 
     VERSION = 1
     MINOR_VERSION = 1
+    ZIGBEE_BAUDRATE = 460800
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         """Initialize the config flow."""

homeassistant/components/homeassistant_connect_zbt2/const.py

@@ -1,7 +1,5 @@
 """Constants for the Home Assistant Connect ZBT-2 integration."""
 
-from homeassistant.generated.countries import COUNTRIES
-
 DOMAIN = "homeassistant_connect_zbt2"
 
 NABU_CASA_FIRMWARE_RELEASES_URL = (
@@ -19,59 +17,3 @@ VID = "vid"
 DEVICE = "device"
 
 HARDWARE_NAME = "Home Assistant Connect ZBT-2"
-
-RADIO_TX_POWER_DBM_DEFAULT = 8
-RADIO_TX_POWER_DBM_BY_COUNTRY = {
-    # EU Member States
-    "AT": 10,
-    "BE": 10,
-    "BG": 10,
-    "HR": 10,
-    "CY": 10,
-    "CZ": 10,
-    "DK": 10,
-    "EE": 10,
-    "FI": 10,
-    "FR": 10,
-    "DE": 10,
-    "GR": 10,
-    "HU": 10,
-    "IE": 10,
-    "IT": 10,
-    "LV": 10,
-    "LT": 10,
-    "LU": 10,
-    "MT": 10,
-    "NL": 10,
-    "PL": 10,
-    "PT": 10,
-    "RO": 10,
-    "SK": 10,
-    "SI": 10,
-    "ES": 10,
-    "SE": 10,
-    # EEA Members
-    "IS": 10,
-    "LI": 10,
-    "NO": 10,
-    # Standards harmonized with RED or ETSI
-    "CH": 10,
-    "GB": 10,
-    "TR": 10,
-    "AL": 10,
-    "BA": 10,
-    "GE": 10,
-    "MD": 10,
-    "ME": 10,
-    "MK": 10,
-    "RS": 10,
-    "UA": 10,
-    # Other CEPT nations
-    "AD": 10,
-    "AZ": 10,
-    "MC": 10,
-    "SM": 10,
-    "VA": 10,
-}
-
-assert set(RADIO_TX_POWER_DBM_BY_COUNTRY) <= COUNTRIES

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -456,10 +456,6 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         # This step is necessary to prevent `user_input` from being passed through
         return await self.async_step_continue_zigbee()
 
-    def _extra_zha_hardware_options(self) -> dict[str, Any]:
-        """Return extra ZHA hardware options."""
-        return {}
-
     async def async_step_continue_zigbee(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -482,7 +478,6 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
                 },
                 "radio_type": "ezsp",
                 "flow_strategy": self._zigbee_flow_strategy,
-                **self._extra_zha_hardware_options(),
             },
         )
         return self._continue_zha_flow(result)

homeassistant/components/http/__init__.py

@@ -38,7 +38,6 @@ from homeassistant.const import (
 from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, issue_registry as ir, storage
-from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.http import (
     KEY_ALLOW_CONFIGURED_CORS,
     KEY_AUTHENTICATED,  # noqa: F401
@@ -110,7 +109,7 @@ HTTP_SCHEMA: Final = vol.All(
     cv.deprecated(CONF_BASE_URL),
     vol.Schema(
         {
-            vol.Optional(CONF_SERVER_HOST): vol.All(
+            vol.Optional(CONF_SERVER_HOST, default=_DEFAULT_BIND): vol.All(
                 cv.ensure_list, vol.Length(min=1), [cv.string]
             ),
             vol.Optional(CONF_SERVER_PORT, default=SERVER_PORT): cv.port,
@@ -208,17 +207,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     if conf is None:
         conf = cast(ConfData, HTTP_SCHEMA({}))
 
-    if CONF_SERVER_HOST in conf and is_hassio(hass):
-        ir.async_create_issue(
-            hass,
-            DOMAIN,
-            "server_host_may_break_hassio",
-            is_fixable=False,
-            severity=ir.IssueSeverity.ERROR,
-            translation_key="server_host_may_break_hassio",
-        )
-
-    server_host = conf.get(CONF_SERVER_HOST, _DEFAULT_BIND)
+    server_host = conf[CONF_SERVER_HOST]
     server_port = conf[CONF_SERVER_PORT]
     ssl_certificate = conf.get(CONF_SSL_CERTIFICATE)
     ssl_peer_certificate = conf.get(CONF_SSL_PEER_CERTIFICATE)

homeassistant/components/http/strings.json

@@ -1,9 +1,5 @@
 {
   "issues": {
-    "server_host_may_break_hassio": {
-      "description": "The `server_host` configuration option in the HTTP integration is prone to break the communication between Home Assistant Core and Supervisor, and will be removed in a future release.\n\nIf you are using this option to bind Home Assistant to specific network interfaces, please remove it from your configuration. Home Assistant will automatically bind to all available interfaces by default.\n\nIf you have specific networking requirements, consider using firewall rules or other network configuration to control access to Home Assistant.",
-      "title": "The `server_host` HTTP configuration may break Home Assistant Core - Supervisor communication"
-    },
     "ssl_configured_without_configured_urls": {
       "description": "Home Assistant detected that SSL has been set up on your instance, however, no custom external internet URL has been set.\n\nThis may result in unexpected behavior. Text-to-speech may fail, and integrations may not be able to connect back to your instance correctly.\n\nTo address this issue, go to Settings > System > Network; under the \"Home Assistant URL\" section, configure your new \"Internet\" and \"Local network\" addresses that match your new SSL configuration.",
       "title": "SSL is configured without an external URL or internal URL"

homeassistant/components/incomfort/icons.json

@@ -20,11 +20,6 @@
         }
       }
     },
-    "sensor": {
-      "rf_message_rssi": {
-        "default": "mdi:signal"
-      }
-    },
     "water_heater": {
       "boiler": {
         "state": {

homeassistant/components/incomfort/sensor.py

@@ -61,16 +61,6 @@ SENSOR_TYPES: tuple[IncomfortSensorEntityDescription, ...] = (
         value_key="tap_temp",
         entity_registry_enabled_default=False,
     ),
-    # A lower RSSI value is better
-    # A typical RSSI value is 28 for connection just in range
-    IncomfortSensorEntityDescription(
-        key="rf_message_rssi",
-        translation_key="rf_message_rssi",
-        state_class=SensorStateClass.MEASUREMENT,
-        value_key="rf_message_rssi",
-        extra_key="rfstatus_cntr",
-        entity_registry_enabled_default=False,
-    ),
 )
 
 

homeassistant/components/incomfort/strings.json

@@ -76,9 +76,6 @@
       }
     },
     "sensor": {
-      "rf_message_rssi": {
-        "name": "RSSI"
-      },
       "tap_temperature": {
         "name": "Tap temperature"
       }

homeassistant/components/kegtron/config_flow.py

@@ -72,7 +72,7 @@ class KegtronConfigFlow(ConfigFlow, domain=DOMAIN):
                 title=self._discovered_devices[address], data={}
             )
 
-        current_addresses = self._async_current_ids(include_ignore=False)
+        current_addresses = self._async_current_ids()
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/keymitt_ble/config_flow.py

@@ -85,7 +85,7 @@ class MicroBotConfigFlow(ConfigFlow, domain=DOMAIN):
         if discovery := self._discovered_adv:
             self._discovered_advs[discovery.address] = discovery
         else:
-            current_addresses = self._async_current_ids(include_ignore=False)
+            current_addresses = self._async_current_ids()
             for discovery_info in async_discovered_service_info(self.hass):
                 self._ble_device = discovery_info.device
                 address = discovery_info.address

homeassistant/components/knx/climate.py

@@ -299,8 +299,8 @@ def _create_climate_ui(xknx: XKNX, conf: ConfigExtractor, name: str) -> XknxClim
         group_address_active_state=conf.get_state_and_passive(CONF_GA_ACTIVE),
         group_address_command_value_state=conf.get_state_and_passive(CONF_GA_VALVE),
         sync_state=sync_state,
-        min_temp=conf.get(CONF_TARGET_TEMPERATURE, ClimateConf.MIN_TEMP),
-        max_temp=conf.get(CONF_TARGET_TEMPERATURE, ClimateConf.MAX_TEMP),
+        min_temp=conf.get(ClimateConf.MIN_TEMP),
+        max_temp=conf.get(ClimateConf.MAX_TEMP),
         mode=climate_mode,
         group_address_fan_speed=conf.get_write(CONF_GA_FAN_SPEED),
         group_address_fan_speed_state=conf.get_state_and_passive(CONF_GA_FAN_SPEED),
@@ -486,7 +486,7 @@ class _KnxClimate(ClimateEntity, _KnxEntityBase):
                 ha_controller_modes.append(self._last_hvac_mode)
             ha_controller_modes.append(HVACMode.OFF)
 
-        hvac_modes = sorted(set(filter(None, ha_controller_modes)))
+        hvac_modes = list(set(filter(None, ha_controller_modes)))
         return (
             hvac_modes
             if hvac_modes

homeassistant/components/knx/manifest.json

@@ -13,7 +13,7 @@
   "requirements": [
     "xknx==3.10.0",
     "xknxproject==3.8.2",
-    "knx-frontend==2025.10.31.195356"
+    "knx-frontend==2025.10.26.81530"
   ],
   "single_config_entry": true
 }

homeassistant/components/kulersky/config_flow.py

@@ -106,7 +106,7 @@ class KulerskyConfigFlow(ConfigFlow, domain=DOMAIN):
         if discovery := self._discovery_info:
             self._discovered_devices[discovery.address] = discovery
         else:
-            current_addresses = self._async_current_ids(include_ignore=False)
+            current_addresses = self._async_current_ids()
             for discovery in async_discovered_service_info(self.hass):
                 if (
                     discovery.address in current_addresses

homeassistant/components/ld2410_ble/config_flow.py

@@ -79,7 +79,7 @@ class Ld2410BleConfigFlow(ConfigFlow, domain=DOMAIN):
         if discovery := self._discovery_info:
             self._discovered_devices[discovery.address] = discovery
         else:
-            current_addresses = self._async_current_ids(include_ignore=False)
+            current_addresses = self._async_current_ids()
             for discovery in async_discovered_service_info(self.hass):
                 if (
                     discovery.address in current_addresses

homeassistant/components/leaone/config_flow.py

@@ -35,7 +35,7 @@ class LeaoneConfigFlow(ConfigFlow, domain=DOMAIN):
                 title=self._discovered_devices[address], data={}
             )
 
-        current_addresses = self._async_current_ids(include_ignore=False)
+        current_addresses = self._async_current_ids()
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/led_ble/config_flow.py

@@ -85,7 +85,7 @@ class LedBleConfigFlow(ConfigFlow, domain=DOMAIN):
         if discovery := self._discovery_info:
             self._discovered_devices[discovery.address] = discovery
         else:
-            current_addresses = self._async_current_ids(include_ignore=False)
+            current_addresses = self._async_current_ids()
             for discovery in async_discovered_service_info(self.hass):
                 if (
                     discovery.address in current_addresses

homeassistant/components/lg_thinq/sensor.py

@@ -622,7 +622,6 @@ ENERGY_USAGE_SENSORS: tuple[ThinQEnergySensorEntityDescription, ...] = (
         usage_period=USAGE_MONTHLY,
         start_date_fn=lambda today: today,
         end_date_fn=lambda today: today,
-        state_class=SensorStateClass.TOTAL_INCREASING,
     ),
     ThinQEnergySensorEntityDescription(
         key="last_month",

homeassistant/components/litterrobot/manifest.json

@@ -13,5 +13,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pylitterbot"],
   "quality_scale": "bronze",
-  "requirements": ["pylitterbot==2025.0.0"]
+  "requirements": ["pylitterbot==2024.2.7"]
 }

homeassistant/components/manual/alarm_control_panel.py

@@ -408,20 +408,6 @@ class ManualAlarm(AlarmControlPanelEntity, RestoreEntity):
         if not alarm_code or code == alarm_code:
             return
 
-        current_context = (
-            self._context if hasattr(self, "_context") and self._context else None
-        )
-        user_id_from_context = current_context.user_id if current_context else None
-
-        self.hass.bus.async_fire(
-            "manual_alarm_bad_code_attempt",
-            {
-                "entity_id": self.entity_id,
-                "user_id": user_id_from_context,
-                "target_state": state,
-            },
-        )
-
         raise ServiceValidationError(
             "Invalid alarm code provided",
             translation_domain=DOMAIN,

homeassistant/components/matter/select.py

@@ -527,57 +527,4 @@ DISCOVERY_SCHEMAS = [
         vendor_id=(4447,),
         product_id=(8194,),
     ),
-    MatterDiscoverySchema(
-        platform=Platform.SELECT,
-        entity_description=MatterSelectEntityDescription(
-            key="AqaraOccupancySensorBooleanStateConfigurationCurrentSensitivityLevel",
-            entity_category=EntityCategory.CONFIG,
-            translation_key="sensitivity_level",
-            options=["low", "standard", "high"],
-            device_to_ha={
-                0: "low",
-                1: "standard",
-                2: "high",
-            }.get,
-            ha_to_device={
-                "low": 0,
-                "standard": 1,
-                "high": 2,
-            }.get,
-        ),
-        entity_class=MatterAttributeSelectEntity,
-        required_attributes=(
-            clusters.BooleanStateConfiguration.Attributes.CurrentSensitivityLevel,
-        ),
-        vendor_id=(4447,),
-        product_id=(
-            8197,
-            8195,
-        ),
-    ),
-    MatterDiscoverySchema(
-        platform=Platform.SELECT,
-        entity_description=MatterSelectEntityDescription(
-            key="HeimanOccupancySensorBooleanStateConfigurationCurrentSensitivityLevel",
-            entity_category=EntityCategory.CONFIG,
-            translation_key="sensitivity_level",
-            options=["low", "standard", "high"],
-            device_to_ha={
-                0: "low",
-                1: "standard",
-                2: "high",
-            }.get,
-            ha_to_device={
-                "low": 0,
-                "standard": 1,
-                "high": 2,
-            }.get,
-        ),
-        entity_class=MatterAttributeSelectEntity,
-        required_attributes=(
-            clusters.BooleanStateConfiguration.Attributes.CurrentSensitivityLevel,
-        ),
-        vendor_id=(4619,),
-        product_id=(4097,),
-    ),
 ]

homeassistant/components/medcom_ble/config_flow.py

@@ -93,7 +93,7 @@ class InspectorBLEConfigFlow(ConfigFlow, domain=DOMAIN):
             self._discovery_info = self._discovered_devices[address]
             return await self.async_step_check_connection()
 
-        current_addresses = self._async_current_ids(include_ignore=False)
+        current_addresses = self._async_current_ids()
         for discovery_info in async_discovered_service_info(self.hass):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/melcloud/sensor.py

@@ -49,15 +49,6 @@ ATA_SENSORS: tuple[MelcloudSensorEntityDescription, ...] = (
         value_fn=lambda x: x.device.total_energy_consumed,
         enabled=lambda x: x.device.has_energy_consumed_meter,
     ),
-    MelcloudSensorEntityDescription(
-        key="outside_temperature",
-        translation_key="outside_temperature",
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        device_class=SensorDeviceClass.TEMPERATURE,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda x: x.device.outdoor_temperature,
-        enabled=lambda x: x.device.has_outdoor_temperature,
-    ),
 )
 ATW_SENSORS: tuple[MelcloudSensorEntityDescription, ...] = (
     MelcloudSensorEntityDescription(

homeassistant/components/melnor/config_flow.py

@@ -75,7 +75,7 @@ class MelnorConfigFlow(ConfigFlow, domain=DOMAIN):
 
             return self._create_entry(address)
 
-        current_addresses = self._async_current_ids(include_ignore=False)
+        current_addresses = self._async_current_ids()
         for discovery_info in async_discovered_service_info(
             self.hass, connectable=True
         ):

homeassistant/components/miele/manifest.json

@@ -9,7 +9,7 @@
   "iot_class": "cloud_push",
   "loggers": ["pymiele"],
   "quality_scale": "platinum",
-  "requirements": ["pymiele==0.6.0"],
+  "requirements": ["pymiele==0.5.6"],
   "single_config_entry": true,
   "zeroconf": ["_mieleathome._tcp.local."]
 }

homeassistant/components/moat/config_flow.py

@@ -72,7 +72,7 @@ class MoatConfigFlow(ConfigFlow, domain=DOMAIN):
                 title=self._discovered_devices[address], data={}
             )
 
-        current_addresses = self._async_current_ids(include_ignore=False)
+        current_addresses = self._async_current_ids()
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/modbus/__init__.py

@@ -66,8 +66,6 @@ from .const import (
     CONF_BYTESIZE,
     CONF_CLIMATES,
     CONF_COLOR_TEMP_REGISTER,
-    CONF_CURRENT_TEMP_OFFSET,
-    CONF_CURRENT_TEMP_SCALE,
     CONF_DATA_TYPE,
     CONF_DEVICE_ADDRESS,
     CONF_FAN_MODE_AUTO,
@@ -139,8 +137,6 @@ from .const import (
     CONF_SWING_MODE_SWING_VERT,
     CONF_SWING_MODE_VALUES,
     CONF_TARGET_TEMP,
-    CONF_TARGET_TEMP_OFFSET,
-    CONF_TARGET_TEMP_SCALE,
     CONF_TARGET_TEMP_WRITE_REGISTERS,
     CONF_VERIFY,
     CONF_VIRTUAL_COUNT,
@@ -163,10 +159,8 @@ from .modbus import DATA_MODBUS_HUBS, ModbusHub, async_modbus_setup
 from .validators import (
     duplicate_fan_mode_validator,
     duplicate_swing_mode_validator,
-    ensure_and_check_conflicting_scales_and_offsets,
     hvac_fixedsize_reglist_validator,
     nan_validator,
-    not_zero_value,
     register_int_list_validator,
     struct_validator,
 )
@@ -216,10 +210,8 @@ BASE_STRUCT_SCHEMA = BASE_COMPONENT_SCHEMA.extend(
             ]
         ),
         vol.Optional(CONF_STRUCTURE): cv.string,
-        vol.Optional(CONF_SCALE): vol.All(
-            vol.Coerce(float), lambda v: not_zero_value(v, "Scale cannot be zero.")
-        ),
-        vol.Optional(CONF_OFFSET): vol.Coerce(float),
+        vol.Optional(CONF_SCALE, default=1): vol.Coerce(float),
+        vol.Optional(CONF_OFFSET, default=0): vol.Coerce(float),
         vol.Optional(CONF_PRECISION): cv.positive_int,
         vol.Optional(
             CONF_SWAP,
@@ -281,18 +273,6 @@ CLIMATE_SCHEMA = vol.All(
             vol.Optional(CONF_TEMPERATURE_UNIT, default=DEFAULT_TEMP_UNIT): cv.string,
             vol.Exclusive(CONF_HVAC_ONOFF_COIL, "hvac_onoff_type"): cv.positive_int,
             vol.Exclusive(CONF_HVAC_ONOFF_REGISTER, "hvac_onoff_type"): cv.positive_int,
-            vol.Optional(CONF_CURRENT_TEMP_SCALE): vol.All(
-                vol.Coerce(float),
-                lambda v: not_zero_value(
-                    v, "Current temperature scale cannot be zero."
-                ),
-            ),
-            vol.Optional(CONF_TARGET_TEMP_SCALE): vol.All(
-                vol.Coerce(float),
-                lambda v: not_zero_value(v, "Target temperature scale cannot be zero."),
-            ),
-            vol.Optional(CONF_CURRENT_TEMP_OFFSET): vol.Coerce(float),
-            vol.Optional(CONF_TARGET_TEMP_OFFSET): vol.Coerce(float),
             vol.Optional(
                 CONF_HVAC_ON_VALUE, default=DEFAULT_HVAC_ON_VALUE
             ): cv.positive_int,
@@ -405,7 +385,6 @@ CLIMATE_SCHEMA = vol.All(
             ),
         },
     ),
-    ensure_and_check_conflicting_scales_and_offsets,
 )
 
 COVERS_SCHEMA = BASE_COMPONENT_SCHEMA.extend(

homeassistant/components/modbus/climate.py

@@ -50,8 +50,6 @@ from .const import (
     CALL_TYPE_WRITE_REGISTER,
     CALL_TYPE_WRITE_REGISTERS,
     CONF_CLIMATES,
-    CONF_CURRENT_TEMP_OFFSET,
-    CONF_CURRENT_TEMP_SCALE,
     CONF_FAN_MODE_AUTO,
     CONF_FAN_MODE_DIFFUSE,
     CONF_FAN_MODE_FOCUS,
@@ -99,12 +97,8 @@ from .const import (
     CONF_SWING_MODE_SWING_VERT,
     CONF_SWING_MODE_VALUES,
     CONF_TARGET_TEMP,
-    CONF_TARGET_TEMP_OFFSET,
-    CONF_TARGET_TEMP_SCALE,
     CONF_TARGET_TEMP_WRITE_REGISTERS,
     CONF_WRITE_REGISTERS,
-    DEFAULT_OFFSET,
-    DEFAULT_SCALE,
     DataType,
 )
 from .entity import ModbusStructEntity
@@ -172,10 +166,6 @@ class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
         self._attr_min_temp = config[CONF_MIN_TEMP]
         self._attr_max_temp = config[CONF_MAX_TEMP]
         self._attr_target_temperature_step = config[CONF_STEP]
-        self._current_temp_scale = config[CONF_CURRENT_TEMP_SCALE]
-        self._current_temp_offset = config[CONF_CURRENT_TEMP_OFFSET]
-        self._target_temp_scale = config[CONF_TARGET_TEMP_SCALE]
-        self._target_temp_offset = config[CONF_TARGET_TEMP_OFFSET]
 
         if CONF_HVAC_MODE_REGISTER in config:
             mode_config = config[CONF_HVAC_MODE_REGISTER]
@@ -423,8 +413,8 @@ class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
         target_temperature = (
-            float(kwargs[ATTR_TEMPERATURE]) - self._target_temp_offset
-        ) / self._target_temp_scale
+            float(kwargs[ATTR_TEMPERATURE]) - self._offset
+        ) / self._scale
         if self._data_type in (
             DataType.INT16,
             DataType.INT32,
@@ -482,25 +472,15 @@ class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
             self._target_temperature_register[
                 HVACMODE_TO_TARG_TEMP_REG_INDEX_ARRAY[self._attr_hvac_mode]
             ],
-            self._target_temp_scale,
-            self._target_temp_offset,
         )
 
         self._attr_current_temperature = await self._async_read_register(
-            self._input_type,
-            self._address,
-            self._current_temp_scale,
-            self._current_temp_offset,
+            self._input_type, self._address
         )
-
         # Read the HVAC mode register if defined
         if self._hvac_mode_register is not None:
             hvac_mode = await self._async_read_register(
-                CALL_TYPE_REGISTER_HOLDING,
-                self._hvac_mode_register,
-                DEFAULT_SCALE,
-                DEFAULT_OFFSET,
-                raw=True,
+                CALL_TYPE_REGISTER_HOLDING, self._hvac_mode_register, raw=True
             )
 
             # Translate the value received
@@ -519,11 +499,7 @@ class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
         # Read the HVAC action register if defined
         if self._hvac_action_register is not None:
             hvac_action = await self._async_read_register(
-                self._hvac_action_type,
-                self._hvac_action_register,
-                DEFAULT_SCALE,
-                DEFAULT_OFFSET,
-                raw=True,
+                self._hvac_action_type, self._hvac_action_register, raw=True
             )
 
             # Translate the value received
@@ -541,8 +517,6 @@ class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
                 self._fan_mode_register
                 if isinstance(self._fan_mode_register, int)
                 else self._fan_mode_register[0],
-                DEFAULT_SCALE,
-                DEFAULT_OFFSET,
                 raw=True,
             )
 
@@ -559,8 +533,6 @@ class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
                 self._swing_mode_register
                 if isinstance(self._swing_mode_register, int)
                 else self._swing_mode_register[0],
-                DEFAULT_SCALE,
-                DEFAULT_OFFSET,
                 raw=True,
             )
 
@@ -579,11 +551,7 @@ class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
         # in the mode register.
         if self._hvac_onoff_register is not None:
             onoff = await self._async_read_register(
-                CALL_TYPE_REGISTER_HOLDING,
-                self._hvac_onoff_register,
-                DEFAULT_SCALE,
-                DEFAULT_OFFSET,
-                raw=True,
+                CALL_TYPE_REGISTER_HOLDING, self._hvac_onoff_register, raw=True
             )
             if onoff == self._hvac_off_value:
                 self._attr_hvac_mode = HVACMode.OFF
@@ -594,12 +562,7 @@ class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
                 self._attr_hvac_mode = HVACMode.OFF
 
     async def _async_read_register(
-        self,
-        register_type: str,
-        register: int,
-        scale: float,
-        offset: float,
-        raw: bool | None = False,
+        self, register_type: str, register: int, raw: bool | None = False
     ) -> float | None:
         """Read register using the Modbus hub slave."""
         result = await self._hub.async_pb_call(
@@ -616,7 +579,7 @@ class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
             return int(result.registers[0])
 
         # The regular handling of the value
-        self._value = self.unpack_structure_result(result.registers, scale, offset)
+        self._value = self.unpack_structure_result(result.registers)
         if not self._value:
             self._attr_available = False
             return None

homeassistant/components/modbus/const.py

@@ -19,8 +19,6 @@ CONF_BYTESIZE = "bytesize"
 CONF_CLIMATES = "climates"
 CONF_BRIGHTNESS_REGISTER = "brightness_address"
 CONF_COLOR_TEMP_REGISTER = "color_temp_address"
-CONF_CURRENT_TEMP_OFFSET = "current_temp_offset"
-CONF_CURRENT_TEMP_SCALE = "current_temp_scale"
 CONF_DATA_TYPE = "data_type"
 CONF_DEVICE_ADDRESS = "device_address"
 CONF_FANS = "fans"
@@ -50,8 +48,6 @@ CONF_SWAP_BYTE = "byte"
 CONF_SWAP_WORD = "word"
 CONF_SWAP_WORD_BYTE = "word_byte"
 CONF_TARGET_TEMP = "target_temp_register"
-CONF_TARGET_TEMP_OFFSET = "target_temp_offset"
-CONF_TARGET_TEMP_SCALE = "target_temp_scale"
 CONF_TARGET_TEMP_WRITE_REGISTERS = "target_temp_write_registers"
 CONF_FAN_MODE_REGISTER = "fan_mode_register"
 CONF_FAN_MODE_ON = "state_fan_on"
@@ -185,7 +181,4 @@ LIGHT_MODBUS_SCALE_MIN = 0
 LIGHT_MODBUS_SCALE_MAX = 100
 LIGHT_MODBUS_INVALID_VALUE = 0xFFFF
 
-DEFAULT_SCALE = 1.0
-DEFAULT_OFFSET = 0
-
 _LOGGER = logging.getLogger(__package__)

homeassistant/components/modbus/entity.py

@@ -17,6 +17,7 @@ from homeassistant.const import (
     CONF_DELAY,
     CONF_DEVICE_CLASS,
     CONF_NAME,
+    CONF_OFFSET,
     CONF_SCAN_INTERVAL,
     CONF_SLAVE,
     CONF_STRUCTURE,
@@ -49,6 +50,7 @@ from .const import (
     CONF_MIN_VALUE,
     CONF_NAN_VALUE,
     CONF_PRECISION,
+    CONF_SCALE,
     CONF_SLAVE_COUNT,
     CONF_STATE_OFF,
     CONF_STATE_ON,
@@ -60,8 +62,6 @@ from .const import (
     CONF_VIRTUAL_COUNT,
     CONF_WRITE_TYPE,
     CONF_ZERO_SUPPRESS,
-    DEFAULT_OFFSET,
-    DEFAULT_SCALE,
     SIGNAL_STOP_ENTITY,
     DataType,
 )
@@ -163,6 +163,8 @@ class ModbusStructEntity(ModbusBaseEntity, RestoreEntity):
         self._swap = config[CONF_SWAP]
         self._data_type = config[CONF_DATA_TYPE]
         self._structure: str = config[CONF_STRUCTURE]
+        self._scale = config[CONF_SCALE]
+        self._offset = config[CONF_OFFSET]
         self._slave_count = config.get(CONF_SLAVE_COUNT) or config.get(
             CONF_VIRTUAL_COUNT, 0
         )
@@ -179,6 +181,8 @@ class ModbusStructEntity(ModbusBaseEntity, RestoreEntity):
             self._precision = config.get(CONF_PRECISION, 2)
         else:
             self._precision = config.get(CONF_PRECISION, 0)
+            if self._precision > 0 or self._scale != int(self._scale):
+                self._value_is_int = False
 
     def _swap_registers(self, registers: list[int], slave_count: int) -> list[int]:
         """Do swap as needed."""
@@ -202,12 +206,7 @@ class ModbusStructEntity(ModbusBaseEntity, RestoreEntity):
             registers.reverse()
         return registers
 
-    def __process_raw_value(
-        self,
-        entry: float | bytes,
-        scale: float = DEFAULT_SCALE,
-        offset: float = DEFAULT_OFFSET,
-    ) -> str | None:
+    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 is not None and entry in (self._nan_value, -self._nan_value):
             return None
@@ -216,7 +215,7 @@ class ModbusStructEntity(ModbusBaseEntity, RestoreEntity):
         if entry != entry:  # noqa: PLR0124
             # NaN float detection replace with None
             return None
-        val: float | int = scale * entry + offset
+        val: float | int = self._scale * entry + self._offset
         if self._min_value is not None and val < self._min_value:
             val = self._min_value
         if self._max_value is not None and val > self._max_value:
@@ -227,12 +226,7 @@ class ModbusStructEntity(ModbusBaseEntity, RestoreEntity):
             return str(round(val))
         return f"{float(val):.{self._precision}f}"
 
-    def unpack_structure_result(
-        self,
-        registers: list[int],
-        scale: float = DEFAULT_SCALE,
-        offset: float = DEFAULT_OFFSET,
-    ) -> str | None:
+    def unpack_structure_result(self, registers: list[int]) -> str | None:
         """Convert registers to proper result."""
 
         if self._swap:
@@ -256,7 +250,7 @@ class ModbusStructEntity(ModbusBaseEntity, RestoreEntity):
             # Apply scale, precision, limits to floats and ints
             v_result = []
             for entry in val:
-                v_temp = self.__process_raw_value(entry, scale, offset)
+                v_temp = self.__process_raw_value(entry)
                 if self._data_type != DataType.CUSTOM:
                     v_result.append(str(v_temp))
                 else:
@@ -264,7 +258,7 @@ class ModbusStructEntity(ModbusBaseEntity, RestoreEntity):
             return ",".join(map(str, v_result))
 
         # Apply scale, precision, limits to floats and ints
-        return self.__process_raw_value(val[0], scale, offset)
+        return self.__process_raw_value(val[0])
 
 
 class ModbusToggleEntity(ModbusBaseEntity, ToggleEntity, RestoreEntity):

homeassistant/components/modbus/sensor.py

@@ -12,7 +12,6 @@ from homeassistant.components.sensor import (
 from homeassistant.const import (
     CONF_DEVICE_CLASS,
     CONF_NAME,
-    CONF_OFFSET,
     CONF_SENSORS,
     CONF_UNIQUE_ID,
     CONF_UNIT_OF_MEASUREMENT,
@@ -26,14 +25,7 @@ from homeassistant.helpers.update_coordinator import (
 )
 
 from . import get_hub
-from .const import (
-    _LOGGER,
-    CONF_SCALE,
-    CONF_SLAVE_COUNT,
-    CONF_VIRTUAL_COUNT,
-    DEFAULT_OFFSET,
-    DEFAULT_SCALE,
-)
+from .const import _LOGGER, CONF_SLAVE_COUNT, CONF_VIRTUAL_COUNT
 from .entity import ModbusStructEntity
 from .modbus import ModbusHub
 
@@ -81,13 +73,9 @@ class ModbusRegisterSensor(ModbusStructEntity, RestoreSensor, SensorEntity):
         self._coordinator: DataUpdateCoordinator[list[float | None] | None] | None = (
             None
         )
-        self._scale = entry.get(CONF_SCALE, DEFAULT_SCALE)
-        self._offset = entry.get(CONF_OFFSET, DEFAULT_OFFSET)
         self._attr_native_unit_of_measurement = entry.get(CONF_UNIT_OF_MEASUREMENT)
         self._attr_state_class = entry.get(CONF_STATE_CLASS)
         self._attr_device_class = entry.get(CONF_DEVICE_CLASS)
-        if self._precision > 0 or self._scale != int(self._scale):
-            self._value_is_int = False
 
     async def async_setup_slaves(
         self, hass: HomeAssistant, slave_count: int, entry: dict[str, Any]
@@ -129,9 +117,7 @@ class ModbusRegisterSensor(ModbusStructEntity, RestoreSensor, SensorEntity):
             self.async_write_ha_state()
             return
         self._attr_available = True
-        result = self.unpack_structure_result(
-            raw_result.registers, self._scale, self._offset
-        )
+        result = self.unpack_structure_result(raw_result.registers)
         if self._coordinator:
             result_array: list[float | None] = []
             if result:

homeassistant/components/modbus/validators.py

@@ -15,7 +15,6 @@ from homeassistant.const import (
     CONF_COUNT,
     CONF_HOST,
     CONF_NAME,
-    CONF_OFFSET,
     CONF_PORT,
     CONF_SCAN_INTERVAL,
     CONF_STRUCTURE,
@@ -26,23 +25,16 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 
 from .const import (
-    CONF_CURRENT_TEMP_OFFSET,
-    CONF_CURRENT_TEMP_SCALE,
     CONF_DATA_TYPE,
     CONF_FAN_MODE_VALUES,
-    CONF_SCALE,
     CONF_SLAVE_COUNT,
     CONF_SWAP,
     CONF_SWAP_BYTE,
     CONF_SWAP_WORD,
     CONF_SWAP_WORD_BYTE,
     CONF_SWING_MODE_VALUES,
-    CONF_TARGET_TEMP_OFFSET,
-    CONF_TARGET_TEMP_SCALE,
     CONF_VIRTUAL_COUNT,
     DEFAULT_HUB,
-    DEFAULT_OFFSET,
-    DEFAULT_SCALE,
     DEFAULT_SCAN_INTERVAL,
     DOMAIN,
     PLATFORMS,
@@ -251,46 +243,6 @@ def duplicate_fan_mode_validator(config: dict[str, Any]) -> dict:
     return config
 
 
-def not_zero_value(val: float, errMsg: str) -> float:
-    """Check value is not zero."""
-    if val == 0:
-        raise vol.Invalid(errMsg)
-    return val
-
-
-def ensure_and_check_conflicting_scales_and_offsets(config: dict[str, Any]) -> dict:
-    """Check for conflicts in scale/offset and ensure target/current temp scale/offset is set."""
-    config_keys = [
-        (CONF_SCALE, CONF_TARGET_TEMP_SCALE, CONF_CURRENT_TEMP_SCALE, DEFAULT_SCALE),
-        (
-            CONF_OFFSET,
-            CONF_TARGET_TEMP_OFFSET,
-            CONF_CURRENT_TEMP_OFFSET,
-            DEFAULT_OFFSET,
-        ),
-    ]
-
-    for generic_key, target_key, current_key, default_value in config_keys:
-        if generic_key in config and (target_key in config or current_key in config):
-            raise vol.Invalid(
-                f"Cannot use both '{generic_key}' and temperature-specific parameters "
-                f"('{target_key}' or '{current_key}') in the same configuration. "
-                f"Either the '{generic_key}' parameter (which applies to both temperatures) "
-                "or the new temperature-specific parameters, but not both."
-            )
-        if generic_key in config:
-            value = config.pop(generic_key)
-            config[target_key] = value
-            config[current_key] = value
-
-        if target_key not in config:
-            config[target_key] = default_value
-        if current_key not in config:
-            config[current_key] = default_value
-
-    return config
-
-
 def duplicate_swing_mode_validator(config: dict[str, Any]) -> dict:
     """Control modbus climate swing mode values for duplicates."""
     swing_modes: set[int] = set()

homeassistant/components/music_assistant/__init__.py

@@ -26,8 +26,8 @@ from homeassistant.helpers.issue_registry import (
     async_delete_issue,
 )
 
+from .actions import get_music_assistant_client, register_actions
 from .const import ATTR_CONF_EXPOSE_PLAYER_TO_HA, DOMAIN, LOGGER
-from .services import get_music_assistant_client, register_actions
 
 if TYPE_CHECKING:
     from music_assistant_models.event import MassEvent
@@ -238,14 +238,12 @@ async def _client_listen(
         hass.async_create_task(hass.config_entries.async_reload(entry.entry_id))
 
 
-async def async_unload_entry(
-    hass: HomeAssistant, entry: MusicAssistantConfigEntry
-) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
     if unload_ok:
-        mass_entry_data = entry.runtime_data
+        mass_entry_data: MusicAssistantEntryData = entry.runtime_data
         mass_entry_data.listen_task.cancel()
         await mass_entry_data.mass.disconnect()
 
@@ -253,9 +251,7 @@ async def async_unload_entry(
 
 
 async def async_remove_config_entry_device(
-    hass: HomeAssistant,
-    config_entry: MusicAssistantConfigEntry,
-    device_entry: dr.DeviceEntry,
+    hass: HomeAssistant, config_entry: ConfigEntry, device_entry: dr.DeviceEntry
 ) -> bool:
     """Remove a config entry from a device."""
     player_id = next(

homeassistant/components/music_assistant/media_player.py

@@ -115,13 +115,6 @@ QUEUE_OPTION_MAP = {
     MediaPlayerEnqueue.REPLACE: QueueOption.REPLACE,
 }
 
-REPEAT_MODE_MAPPING_TO_HA = {
-    MassRepeatMode.OFF: RepeatMode.OFF,
-    MassRepeatMode.ONE: RepeatMode.ONE,
-    MassRepeatMode.ALL: RepeatMode.ALL,
-    # UNKNOWN is intentionally not mapped - will return None
-}
-
 SERVICE_PLAY_MEDIA_ADVANCED = "play_media"
 SERVICE_PLAY_ANNOUNCEMENT = "play_announcement"
 SERVICE_TRANSFER_QUEUE = "transfer_queue"
@@ -664,7 +657,7 @@ class MusicAssistantPlayer(MusicAssistantEntity, MediaPlayerEntity):
         # player has an MA queue active (either its own queue or some group queue)
         self._attr_app_id = DOMAIN
         self._attr_shuffle = queue.shuffle_enabled
-        self._attr_repeat = REPEAT_MODE_MAPPING_TO_HA.get(queue.repeat_mode)
+        self._attr_repeat = queue.repeat_mode.value
         if not (cur_item := queue.current_item):
             # queue is empty
             return

homeassistant/components/nasweb/__init__.py

@@ -19,11 +19,7 @@ from .const import DOMAIN, MANUFACTURER, SUPPORT_EMAIL
 from .coordinator import NASwebCoordinator
 from .nasweb_data import NASwebData
 
-PLATFORMS: list[Platform] = [
-    Platform.ALARM_CONTROL_PANEL,
-    Platform.SENSOR,
-    Platform.SWITCH,
-]
+PLATFORMS: list[Platform] = [Platform.SENSOR, Platform.SWITCH]
 
 NASWEB_CONFIG_URL = "https://{host}/page"
 

homeassistant/components/nasweb/alarm_control_panel.py

@@ -1,154 +0,0 @@
-"""Platform for NASweb alarms."""
-
-from __future__ import annotations
-
-import logging
-import time
-
-from webio_api import Zone as NASwebZone
-from webio_api.const import STATE_ZONE_ALARM, STATE_ZONE_ARMED, STATE_ZONE_DISARMED
-
-from homeassistant.components.alarm_control_panel import (
-    DOMAIN as DOMAIN_ALARM_CONTROL_PANEL,
-    AlarmControlPanelEntity,
-    AlarmControlPanelEntityFeature,
-    AlarmControlPanelState,
-    CodeFormat,
-)
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-import homeassistant.helpers.entity_registry as er
-from homeassistant.helpers.typing import DiscoveryInfoType
-from homeassistant.helpers.update_coordinator import (
-    BaseCoordinatorEntity,
-    BaseDataUpdateCoordinatorProtocol,
-)
-
-from . import NASwebConfigEntry
-from .const import DOMAIN, STATUS_UPDATE_MAX_TIME_INTERVAL
-
-_LOGGER = logging.getLogger(__name__)
-ALARM_CONTROL_PANEL_TRANSLATION_KEY = "zone"
-
-NASWEB_STATE_TO_HA_STATE = {
-    STATE_ZONE_ALARM: AlarmControlPanelState.TRIGGERED,
-    STATE_ZONE_ARMED: AlarmControlPanelState.ARMED_AWAY,
-    STATE_ZONE_DISARMED: AlarmControlPanelState.DISARMED,
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config: NASwebConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> None:
-    """Set up alarm control panel platform."""
-    coordinator = config.runtime_data
-    current_zones: set[int] = set()
-
-    @callback
-    def _check_entities() -> None:
-        received_zones: dict[int, NASwebZone] = {
-            entry.index: entry for entry in coordinator.webio_api.zones
-        }
-        added = {i for i in received_zones if i not in current_zones}
-        removed = {i for i in current_zones if i not in received_zones}
-        entities_to_add: list[ZoneEntity] = []
-        for index in added:
-            webio_zone = received_zones[index]
-            if not isinstance(webio_zone, NASwebZone):
-                _LOGGER.error("Cannot create ZoneEntity without NASwebZone")
-                continue
-            new_zone = ZoneEntity(coordinator, webio_zone)
-            entities_to_add.append(new_zone)
-            current_zones.add(index)
-        async_add_entities(entities_to_add)
-        entity_registry = er.async_get(hass)
-        for index in removed:
-            unique_id = f"{DOMAIN}.{config.unique_id}.zone.{index}"
-            if entity_id := entity_registry.async_get_entity_id(
-                DOMAIN_ALARM_CONTROL_PANEL, DOMAIN, unique_id
-            ):
-                entity_registry.async_remove(entity_id)
-                current_zones.remove(index)
-            else:
-                _LOGGER.warning("Failed to remove old zone: no entity_id")
-
-    coordinator.async_add_listener(_check_entities)
-    _check_entities()
-
-
-class ZoneEntity(AlarmControlPanelEntity, BaseCoordinatorEntity):
-    """Entity representing NASweb zone."""
-
-    _attr_has_entity_name = True
-    _attr_should_poll = False
-    _attr_translation_key = ALARM_CONTROL_PANEL_TRANSLATION_KEY
-
-    def __init__(
-        self, coordinator: BaseDataUpdateCoordinatorProtocol, nasweb_zone: NASwebZone
-    ) -> None:
-        """Initialize zone entity."""
-        super().__init__(coordinator)
-        self._zone = nasweb_zone
-        self._attr_name = nasweb_zone.name
-        self._attr_translation_placeholders = {"index": f"{nasweb_zone.index:2d}"}
-        self._attr_unique_id = (
-            f"{DOMAIN}.{self._zone.webio_serial}.zone.{self._zone.index}"
-        )
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, self._zone.webio_serial)},
-        )
-
-    async def async_added_to_hass(self) -> None:
-        """When entity is added to hass."""
-        await super().async_added_to_hass()
-        self._handle_coordinator_update()
-
-    def _set_attr_available(
-        self, entity_last_update: float, available: bool | None
-    ) -> None:
-        if (
-            self.coordinator.last_update is None
-            or time.time() - entity_last_update >= STATUS_UPDATE_MAX_TIME_INTERVAL
-        ):
-            self._attr_available = False
-        else:
-            self._attr_available = available if available is not None else False
-
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
-        self._attr_alarm_state = NASWEB_STATE_TO_HA_STATE[self._zone.state]
-        if self._zone.pass_type == 0:
-            self._attr_code_format = CodeFormat.TEXT
-        elif self._zone.pass_type == 1:
-            self._attr_code_format = CodeFormat.NUMBER
-        else:
-            self._attr_code_format = None
-        self._attr_code_arm_required = self._attr_code_format is not None
-
-        self._set_attr_available(self._zone.last_update, self._zone.available)
-        self.async_write_ha_state()
-
-    async def async_update(self) -> None:
-        """Update the entity.
-
-        Only used by the generic entity update service.
-        Scheduling updates is not necessary, the coordinator takes care of updates via push notifications.
-        """
-
-    @property
-    def supported_features(self) -> AlarmControlPanelEntityFeature:
-        """Return the list of supported features."""
-        return AlarmControlPanelEntityFeature.ARM_AWAY
-
-    async def async_alarm_arm_away(self, code: str | None = None) -> None:
-        """Arm away ZoneEntity."""
-        await self._zone.arm(code)
-
-    async def async_alarm_disarm(self, code: str | None = None) -> None:
-        """Disarm ZoneEntity."""
-        await self._zone.disarm(code)

homeassistant/components/nasweb/coordinator.py

@@ -23,7 +23,6 @@ _LOGGER = logging.getLogger(__name__)
 
 KEY_INPUTS = "inputs"
 KEY_OUTPUTS = "outputs"
-KEY_ZONES = "zones"
 
 
 class NotificationCoordinator:
@@ -104,7 +103,6 @@ class NASwebCoordinator(BaseDataUpdateCoordinatorProtocol):
             KEY_OUTPUTS: self.webio_api.outputs,
             KEY_INPUTS: self.webio_api.inputs,
             KEY_TEMP_SENSOR: self.webio_api.temp_sensor,
-            KEY_ZONES: self.webio_api.zones,
         }
         self.async_set_updated_data(data)
 
@@ -199,6 +197,5 @@ class NASwebCoordinator(BaseDataUpdateCoordinatorProtocol):
             KEY_OUTPUTS: self.webio_api.outputs,
             KEY_INPUTS: self.webio_api.inputs,
             KEY_TEMP_SENSOR: self.webio_api.temp_sensor,
-            KEY_ZONES: self.webio_api.zones,
         }
         self.async_set_updated_data(new_data)

homeassistant/components/nasweb/strings.json

@@ -24,11 +24,6 @@
     }
   },
   "entity": {
-    "alarm_control_panel": {
-      "zone": {
-        "name": "Zone {index}"
-      }
-    },
     "sensor": {
       "sensor_input": {
         "name": "Input {index}",

homeassistant/components/neato/__init__.py

@@ -1,76 +0,0 @@
-"""Support for Neato botvac connected vacuum cleaners."""
-
-import logging
-
-import aiohttp
-from pybotvac import Account
-from pybotvac.exceptions import NeatoException
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_TOKEN, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import config_entry_oauth2_flow
-
-from . import api
-from .const import NEATO_DOMAIN, NEATO_LOGIN
-from .hub import NeatoHub
-
-_LOGGER = logging.getLogger(__name__)
-
-PLATFORMS = [
-    Platform.BUTTON,
-    Platform.CAMERA,
-    Platform.SENSOR,
-    Platform.SWITCH,
-    Platform.VACUUM,
-]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up config entry."""
-    hass.data.setdefault(NEATO_DOMAIN, {})
-    if CONF_TOKEN not in entry.data:
-        raise ConfigEntryAuthFailed
-
-    implementation = (
-        await config_entry_oauth2_flow.async_get_config_entry_implementation(
-            hass, entry
-        )
-    )
-
-    session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
-    try:
-        await session.async_ensure_token_valid()
-    except aiohttp.ClientResponseError as ex:
-        _LOGGER.debug("API error: %s (%s)", ex.code, ex.message)
-        if ex.code in (401, 403):
-            raise ConfigEntryAuthFailed("Token not valid, trigger renewal") from ex
-        raise ConfigEntryNotReady from ex
-
-    neato_session = api.ConfigEntryAuth(hass, entry, implementation)
-    hass.data[NEATO_DOMAIN][entry.entry_id] = neato_session
-    hub = NeatoHub(hass, Account(neato_session))
-
-    await hub.async_update_entry_unique_id(entry)
-
-    try:
-        await hass.async_add_executor_job(hub.update_robots)
-    except NeatoException as ex:
-        _LOGGER.debug("Failed to connect to Neato API")
-        raise ConfigEntryNotReady from ex
-
-    hass.data[NEATO_LOGIN] = hub
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-    if unload_ok:
-        hass.data[NEATO_DOMAIN].pop(entry.entry_id)
-
-    return unload_ok

homeassistant/components/neato/api.py

@@ -1,58 +0,0 @@
-"""API for Neato Botvac bound to Home Assistant OAuth."""
-
-from __future__ import annotations
-
-from asyncio import run_coroutine_threadsafe
-from typing import Any
-
-import pybotvac
-
-from homeassistant import config_entries, core
-from homeassistant.components.application_credentials import AuthImplementation
-from homeassistant.helpers import config_entry_oauth2_flow
-
-
-class ConfigEntryAuth(pybotvac.OAuthSession):  # type: ignore[misc]
-    """Provide Neato Botvac authentication tied to an OAuth2 based config entry."""
-
-    def __init__(
-        self,
-        hass: core.HomeAssistant,
-        config_entry: config_entries.ConfigEntry,
-        implementation: config_entry_oauth2_flow.AbstractOAuth2Implementation,
-    ) -> None:
-        """Initialize Neato Botvac Auth."""
-        self.hass = hass
-        self.session = config_entry_oauth2_flow.OAuth2Session(
-            hass, config_entry, implementation
-        )
-        super().__init__(self.session.token, vendor=pybotvac.Neato())
-
-    def refresh_tokens(self) -> str:
-        """Refresh and return new Neato Botvac tokens."""
-        run_coroutine_threadsafe(
-            self.session.async_ensure_token_valid(), self.hass.loop
-        ).result()
-
-        return self.session.token["access_token"]  # type: ignore[no-any-return]
-
-
-class NeatoImplementation(AuthImplementation):
-    """Neato implementation of LocalOAuth2Implementation.
-
-    We need this class because we have to add client_secret
-    and scope to the authorization request.
-    """
-
-    @property
-    def extra_authorize_data(self) -> dict[str, Any]:
-        """Extra data that needs to be appended to the authorize url."""
-        return {"client_secret": self.client_secret}
-
-    async def async_generate_authorize_url(self, flow_id: str) -> str:
-        """Generate a url for the user to authorize.
-
-        We must make sure that the plus signs are not encoded.
-        """
-        url = await super().async_generate_authorize_url(flow_id)
-        return f"{url}&scope=public_profile+control_robots+maps"

homeassistant/components/neato/application_credentials.py

@@ -1,28 +0,0 @@
-"""Application credentials platform for neato."""
-
-from pybotvac import Neato
-
-from homeassistant.components.application_credentials import (
-    AuthorizationServer,
-    ClientCredential,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_entry_oauth2_flow
-
-from . import api
-
-
-async def async_get_auth_implementation(
-    hass: HomeAssistant, auth_domain: str, credential: ClientCredential
-) -> config_entry_oauth2_flow.AbstractOAuth2Implementation:
-    """Return auth implementation for a custom auth implementation."""
-    vendor = Neato()
-    return api.NeatoImplementation(
-        hass,
-        auth_domain,
-        credential,
-        AuthorizationServer(
-            authorize_url=vendor.auth_endpoint,
-            token_url=vendor.token_endpoint,
-        ),
-    )

homeassistant/components/neato/button.py

@@ -1,44 +0,0 @@
-"""Support for Neato buttons."""
-
-from __future__ import annotations
-
-from pybotvac import Robot
-
-from homeassistant.components.button import ButtonEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import NEATO_ROBOTS
-from .entity import NeatoEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Neato button from config entry."""
-    entities = [NeatoDismissAlertButton(robot) for robot in hass.data[NEATO_ROBOTS]]
-
-    async_add_entities(entities, True)
-
-
-class NeatoDismissAlertButton(NeatoEntity, ButtonEntity):
-    """Representation of a dismiss_alert button entity."""
-
-    _attr_translation_key = "dismiss_alert"
-    _attr_entity_category = EntityCategory.CONFIG
-
-    def __init__(
-        self,
-        robot: Robot,
-    ) -> None:
-        """Initialize a dismiss_alert Neato button entity."""
-        super().__init__(robot)
-        self._attr_unique_id = f"{robot.serial}_dismiss_alert"
-
-    async def async_press(self) -> None:
-        """Press the button."""
-        await self.hass.async_add_executor_job(self.robot.dismiss_current_alert)

homeassistant/components/neato/camera.py

@@ -1,130 +0,0 @@
-"""Support for loading picture from Neato."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-import logging
-from typing import Any
-
-from pybotvac.exceptions import NeatoRobotException
-from pybotvac.robot import Robot
-from urllib3.response import HTTPResponse
-
-from homeassistant.components.camera import Camera
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import NEATO_LOGIN, NEATO_MAP_DATA, NEATO_ROBOTS, SCAN_INTERVAL_MINUTES
-from .entity import NeatoEntity
-from .hub import NeatoHub
-
-_LOGGER = logging.getLogger(__name__)
-
-SCAN_INTERVAL = timedelta(minutes=SCAN_INTERVAL_MINUTES)
-ATTR_GENERATED_AT = "generated_at"
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Neato camera with config entry."""
-    neato: NeatoHub = hass.data[NEATO_LOGIN]
-    mapdata: dict[str, Any] | None = hass.data.get(NEATO_MAP_DATA)
-    dev = [
-        NeatoCleaningMap(neato, robot, mapdata)
-        for robot in hass.data[NEATO_ROBOTS]
-        if "maps" in robot.traits
-    ]
-
-    if not dev:
-        return
-
-    _LOGGER.debug("Adding robots for cleaning maps %s", dev)
-    async_add_entities(dev, True)
-
-
-class NeatoCleaningMap(NeatoEntity, Camera):
-    """Neato cleaning map for last clean."""
-
-    _attr_translation_key = "cleaning_map"
-
-    def __init__(
-        self, neato: NeatoHub, robot: Robot, mapdata: dict[str, Any] | None
-    ) -> None:
-        """Initialize Neato cleaning map."""
-        super().__init__(robot)
-        Camera.__init__(self)
-        self.neato = neato
-        self._mapdata = mapdata
-        self._available = neato is not None
-        self._robot_serial: str = self.robot.serial
-        self._attr_unique_id = self.robot.serial
-        self._generated_at: str | None = None
-        self._image_url: str | None = None
-        self._image: bytes | None = None
-
-    def camera_image(
-        self, width: int | None = None, height: int | None = None
-    ) -> bytes | None:
-        """Return image response."""
-        self.update()
-        return self._image
-
-    def update(self) -> None:
-        """Check the contents of the map list."""
-
-        _LOGGER.debug("Running camera update for '%s'", self.entity_id)
-        try:
-            self.neato.update_robots()
-        except NeatoRobotException as ex:
-            if self._available:  # Print only once when available
-                _LOGGER.error(
-                    "Neato camera connection error for '%s': %s", self.entity_id, ex
-                )
-            self._image = None
-            self._image_url = None
-            self._available = False
-            return
-
-        if self._mapdata:
-            map_data: dict[str, Any] = self._mapdata[self._robot_serial]["maps"][0]
-        if (image_url := map_data["url"]) == self._image_url:
-            _LOGGER.debug(
-                "The map image_url for '%s' is the same as old", self.entity_id
-            )
-            return
-
-        try:
-            image: HTTPResponse = self.neato.download_map(image_url)
-        except NeatoRobotException as ex:
-            if self._available:  # Print only once when available
-                _LOGGER.error(
-                    "Neato camera connection error for '%s': %s", self.entity_id, ex
-                )
-            self._image = None
-            self._image_url = None
-            self._available = False
-            return
-
-        self._image = image.read()
-        self._image_url = image_url
-        self._generated_at = map_data.get("generated_at")
-        self._available = True
-
-    @property
-    def available(self) -> bool:
-        """Return if the robot is available."""
-        return self._available
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return the state attributes of the vacuum cleaner."""
-        data: dict[str, Any] = {}
-
-        if self._generated_at is not None:
-            data[ATTR_GENERATED_AT] = self._generated_at
-
-        return data

homeassistant/components/neato/config_flow.py

@@ -1,64 +0,0 @@
-"""Config flow for Neato Botvac."""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-import logging
-from typing import Any
-
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
-from homeassistant.helpers import config_entry_oauth2_flow
-
-from .const import NEATO_DOMAIN
-
-
-class OAuth2FlowHandler(
-    config_entry_oauth2_flow.AbstractOAuth2FlowHandler, domain=NEATO_DOMAIN
-):
-    """Config flow to handle Neato Botvac OAuth2 authentication."""
-
-    DOMAIN = NEATO_DOMAIN
-
-    @property
-    def logger(self) -> logging.Logger:
-        """Return logger."""
-        return logging.getLogger(__name__)
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Create an entry for the flow."""
-        current_entries = self._async_current_entries()
-        if self.source != SOURCE_REAUTH and current_entries:
-            # Already configured
-            return self.async_abort(reason="already_configured")
-
-        return await super().async_step_user(user_input=user_input)
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Perform reauth upon migration of old entries."""
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Confirm reauth upon migration of old entries."""
-        if user_input is None:
-            return self.async_show_form(step_id="reauth_confirm")
-        return await self.async_step_user()
-
-    async def async_oauth_create_entry(self, data: dict[str, Any]) -> ConfigFlowResult:
-        """Create an entry for the flow. Update an entry if one already exist."""
-        current_entries = self._async_current_entries()
-        if self.source == SOURCE_REAUTH and current_entries:
-            # Update entry
-            self.hass.config_entries.async_update_entry(
-                current_entries[0], title=self.flow_impl.name, data=data
-            )
-            self.hass.async_create_task(
-                self.hass.config_entries.async_reload(current_entries[0].entry_id)
-            )
-            return self.async_abort(reason="reauth_successful")
-        return self.async_create_entry(title=self.flow_impl.name, data=data)