Add Aqara W100 identify button snapshots to test suite

.github/workflows/ci.yaml

@@ -37,7 +37,7 @@ on:
         type: boolean
 
 env:
-  CACHE_VERSION: 2
+  CACHE_VERSION: 1
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
   HA_SHORT_VERSION: "2025.12"
@@ -622,7 +622,7 @@ jobs:
     steps:
       - *checkout
       - name: Dependency review
-        uses: actions/dependency-review-action@3c4e3dcb1aa7874d2c16be7d79418e9b7efd6261 # v4.8.2
+        uses: actions/dependency-review-action@40c09b7dc99638e5ddb0bfd91c1673effc064d8a # v4.8.1
         with:
           license-check: false # We use our own license audit checks
 

CODEOWNERS

@@ -1017,8 +1017,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/msteams/ @peroyvind
 /homeassistant/components/mullvad/ @meichthys
 /tests/components/mullvad/ @meichthys
-/homeassistant/components/music_assistant/ @music-assistant @arturpragacz
-/tests/components/music_assistant/ @music-assistant @arturpragacz
+/homeassistant/components/music_assistant/ @music-assistant
+/tests/components/music_assistant/ @music-assistant
 /homeassistant/components/mutesync/ @currentoor
 /tests/components/mutesync/ @currentoor
 /homeassistant/components/my/ @home-assistant/core

homeassistant/components/conversation/__init__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 import logging
-from typing import Any, Literal
+from typing import Literal
 
 from hassil.recognize import RecognizeResult
 import voluptuous as vol
@@ -21,7 +21,6 @@ from homeassistant.core import (
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, intent
 from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.reload import async_integration_yaml_config
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import bind_hass
 
@@ -53,8 +52,6 @@ from .const import (
     DATA_COMPONENT,
     DOMAIN,
     HOME_ASSISTANT_AGENT,
-    METADATA_CUSTOM_FILE,
-    METADATA_CUSTOM_SENTENCE,
     SERVICE_PROCESS,
     SERVICE_RELOAD,
     ConversationEntityFeature,
@@ -269,13 +266,10 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     entity_component = EntityComponent[ConversationEntity](_LOGGER, DOMAIN, hass)
     hass.data[DATA_COMPONENT] = entity_component
 
-    manager = get_agent_manager(hass)
-
-    hass_config_path = hass.config.path()
-    config_intents = _get_config_intents(config, hass_config_path)
-    manager.update_config_intents(config_intents)
-
-    await async_setup_default_agent(hass, entity_component)
+    agent_config = config.get(DOMAIN, {})
+    await async_setup_default_agent(
+        hass, entity_component, config_intents=agent_config.get("intents", {})
+    )
 
     async def handle_process(service: ServiceCall) -> ServiceResponse:
         """Parse text into commands."""
@@ -300,16 +294,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     async def handle_reload(service: ServiceCall) -> None:
         """Reload intents."""
-        language = service.data.get(ATTR_LANGUAGE)
-        if language is None:
-            conf = await async_integration_yaml_config(hass, DOMAIN)
-            if conf is not None:
-                config_intents = _get_config_intents(conf, hass_config_path)
-                manager.update_config_intents(config_intents)
-
-        agent = manager.default_agent
+        agent = get_agent_manager(hass).default_agent
         if agent is not None:
-            await agent.async_reload(language=language)
+            await agent.async_reload(language=service.data.get(ATTR_LANGUAGE))
 
     hass.services.async_register(
         DOMAIN,
@@ -326,27 +313,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     return True
 
 
-def _get_config_intents(config: ConfigType, hass_config_path: str) -> dict[str, Any]:
-    """Return config intents."""
-    intents = config.get(DOMAIN, {}).get("intents", {})
-    return {
-        "intents": {
-            intent_name: {
-                "data": [
-                    {
-                        "sentences": sentences,
-                        "metadata": {
-                            METADATA_CUSTOM_SENTENCE: True,
-                            METADATA_CUSTOM_FILE: hass_config_path,
-                        },
-                    }
-                ]
-            }
-            for intent_name, sentences in intents.items()
-        }
-    }
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up a config entry."""
     return await hass.data[DATA_COMPONENT].async_setup_entry(entry)

homeassistant/components/conversation/agent_manager.py

@@ -147,7 +147,6 @@ class AgentManager:
         self.hass = hass
         self._agents: dict[str, AbstractConversationAgent] = {}
         self.default_agent: DefaultAgent | None = None
-        self.config_intents: dict[str, Any] = {}
         self.triggers_details: list[TriggerDetails] = []
 
     @callback
@@ -200,16 +199,9 @@ class AgentManager:
 
     async def async_setup_default_agent(self, agent: DefaultAgent) -> None:
         """Set up the default agent."""
-        agent.update_config_intents(self.config_intents)
         agent.update_triggers(self.triggers_details)
         self.default_agent = agent
 
-    def update_config_intents(self, intents: dict[str, Any]) -> None:
-        """Update config intents."""
-        self.config_intents = intents
-        if self.default_agent is not None:
-            self.default_agent.update_config_intents(intents)
-
     def register_trigger(self, trigger_details: TriggerDetails) -> CALLBACK_TYPE:
         """Register a trigger."""
         self.triggers_details.append(trigger_details)

homeassistant/components/conversation/const.py

@@ -30,7 +30,3 @@ class ConversationEntityFeature(IntFlag):
     """Supported features of the conversation entity."""
 
     CONTROL = 1
-
-
-METADATA_CUSTOM_SENTENCE = "hass_custom_sentence"
-METADATA_CUSTOM_FILE = "hass_custom_file"

homeassistant/components/conversation/default_agent.py

@@ -77,12 +77,7 @@ from homeassistant.util.json import JsonObjectType, json_loads_object
 
 from .agent_manager import get_agent_manager
 from .chat_log import AssistantContent, ChatLog
-from .const import (
-    DOMAIN,
-    METADATA_CUSTOM_FILE,
-    METADATA_CUSTOM_SENTENCE,
-    ConversationEntityFeature,
-)
+from .const import DOMAIN, ConversationEntityFeature
 from .entity import ConversationEntity
 from .models import ConversationInput, ConversationResult
 from .trace import ConversationTraceEventType, async_conversation_trace_append
@@ -96,6 +91,8 @@ _ENTITY_REGISTRY_UPDATE_FIELDS = ["aliases", "name", "original_name"]
 
 _DEFAULT_EXPOSED_ATTRIBUTES = {"device_class"}
 
+METADATA_CUSTOM_SENTENCE = "hass_custom_sentence"
+METADATA_CUSTOM_FILE = "hass_custom_file"
 METADATA_FUZZY_MATCH = "hass_fuzzy_match"
 
 ERROR_SENTINEL = object()
@@ -205,9 +202,10 @@ class IntentCache:
 async def async_setup_default_agent(
     hass: HomeAssistant,
     entity_component: EntityComponent[ConversationEntity],
+    config_intents: dict[str, Any],
 ) -> None:
     """Set up entity registry listener for the default agent."""
-    agent = DefaultAgent(hass)
+    agent = DefaultAgent(hass, config_intents)
     await entity_component.async_add_entities([agent])
     await get_agent_manager(hass).async_setup_default_agent(agent)
 
@@ -232,14 +230,14 @@ class DefaultAgent(ConversationEntity):
     _attr_name = "Home Assistant"
     _attr_supported_features = ConversationEntityFeature.CONTROL
 
-    def __init__(self, hass: HomeAssistant) -> None:
+    def __init__(self, hass: HomeAssistant, config_intents: dict[str, Any]) -> None:
         """Initialize the default agent."""
         self.hass = hass
         self._lang_intents: dict[str, LanguageIntents | object] = {}
         self._load_intents_lock = asyncio.Lock()
 
-        # Intents from common conversation config
-        self._config_intents: dict[str, Any] = {}
+        # intent -> [sentences]
+        self._config_intents: dict[str, Any] = config_intents
 
         # Sentences that will trigger a callback (skipping intent recognition)
         self._triggers_details: list[TriggerDetails] = []
@@ -1037,14 +1035,6 @@ class DefaultAgent(ConversationEntity):
         # Intents have changed, so we must clear the cache
         self._intent_cache.clear()
 
-    @callback
-    def update_config_intents(self, intents: dict[str, Any]) -> None:
-        """Update config intents."""
-        self._config_intents = intents
-
-        # Intents have changed, so we must clear the cache
-        self._intent_cache.clear()
-
     async def async_prepare(self, language: str | None = None) -> None:
         """Load intents for a language."""
         if language is None:
@@ -1169,10 +1159,33 @@ class DefaultAgent(ConversationEntity):
                     custom_sentences_path,
                 )
 
-        merge_dict(
-            intents_dict,
-            self._config_intents,
-        )
+        # Load sentences from HA config for default language only
+        if self._config_intents and (
+            self.hass.config.language in (language, language_variant)
+        ):
+            hass_config_path = self.hass.config.path()
+            merge_dict(
+                intents_dict,
+                {
+                    "intents": {
+                        intent_name: {
+                            "data": [
+                                {
+                                    "sentences": sentences,
+                                    "metadata": {
+                                        METADATA_CUSTOM_SENTENCE: True,
+                                        METADATA_CUSTOM_FILE: hass_config_path,
+                                    },
+                                }
+                            ]
+                        }
+                        for intent_name, sentences in self._config_intents.items()
+                    }
+                },
+            )
+            _LOGGER.debug(
+                "Loaded intents from configuration.yaml",
+            )
 
         if not intents_dict:
             return None

homeassistant/components/ecobee/manifest.json

@@ -9,7 +9,7 @@
   },
   "iot_class": "cloud_polling",
   "loggers": ["pyecobee"],
-  "requirements": ["python-ecobee-api==0.3.2"],
+  "requirements": ["python-ecobee-api==0.2.20"],
   "single_config_entry": true,
   "zeroconf": [
     {

homeassistant/components/energy/data.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 from collections import Counter
 from collections.abc import Awaitable, Callable
-from typing import Literal, NotRequired, TypedDict
+from typing import Literal, TypedDict
 
 import voluptuous as vol
 
@@ -29,7 +29,7 @@ async def async_get_manager(hass: HomeAssistant) -> EnergyManager:
 class FlowFromGridSourceType(TypedDict):
     """Dictionary describing the 'from' stat for the grid source."""
 
-    # statistic_id of an energy meter (kWh)
+    # statistic_id of a an energy meter (kWh)
     stat_energy_from: str
 
     # statistic_id of costs ($) incurred from the energy meter
@@ -58,14 +58,6 @@ class FlowToGridSourceType(TypedDict):
     number_energy_price: float | None  # Price for energy ($/kWh)
 
 
-class GridPowerSourceType(TypedDict):
-    """Dictionary holding the source of grid power consumption."""
-
-    # statistic_id of a power meter (kW)
-    # negative values indicate grid return
-    stat_rate: str
-
-
 class GridSourceType(TypedDict):
     """Dictionary holding the source of grid energy consumption."""
 
@@ -73,7 +65,6 @@ class GridSourceType(TypedDict):
 
     flow_from: list[FlowFromGridSourceType]
     flow_to: list[FlowToGridSourceType]
-    power: NotRequired[list[GridPowerSourceType]]
 
     cost_adjustment_day: float
 
@@ -84,7 +75,6 @@ class SolarSourceType(TypedDict):
     type: Literal["solar"]
 
     stat_energy_from: str
-    stat_rate: NotRequired[str]
     config_entry_solar_forecast: list[str] | None
 
 
@@ -95,8 +85,6 @@ class BatterySourceType(TypedDict):
 
     stat_energy_from: str
     stat_energy_to: str
-    # positive when discharging, negative when charging
-    stat_rate: NotRequired[str]
 
 
 class GasSourceType(TypedDict):
@@ -148,15 +136,12 @@ class DeviceConsumption(TypedDict):
     # This is an ever increasing value
     stat_consumption: str
 
-    # Instantaneous rate of flow: W, L/min or m³/h
-    stat_rate: NotRequired[str]
-
     # An optional custom name for display in energy graphs
     name: str | None
 
     # An optional statistic_id identifying a device
     # that includes this device's consumption in its total
-    included_in_stat: NotRequired[str]
+    included_in_stat: str | None
 
 
 class EnergyPreferences(TypedDict):
@@ -209,12 +194,6 @@ FLOW_TO_GRID_SOURCE_SCHEMA = vol.Schema(
     }
 )
 
-GRID_POWER_SOURCE_SCHEMA = vol.Schema(
-    {
-        vol.Required("stat_rate"): str,
-    }
-)
-
 
 def _generate_unique_value_validator(key: str) -> Callable[[list[dict]], list[dict]]:
     """Generate a validator that ensures a value is only used once."""
@@ -245,10 +224,6 @@ GRID_SOURCE_SCHEMA = vol.Schema(
             [FLOW_TO_GRID_SOURCE_SCHEMA],
             _generate_unique_value_validator("stat_energy_to"),
         ),
-        vol.Optional("power"): vol.All(
-            [GRID_POWER_SOURCE_SCHEMA],
-            _generate_unique_value_validator("stat_rate"),
-        ),
         vol.Required("cost_adjustment_day"): vol.Coerce(float),
     }
 )
@@ -256,7 +231,6 @@ SOLAR_SOURCE_SCHEMA = vol.Schema(
     {
         vol.Required("type"): "solar",
         vol.Required("stat_energy_from"): str,
-        vol.Optional("stat_rate"): str,
         vol.Optional("config_entry_solar_forecast"): vol.Any([str], None),
     }
 )
@@ -265,7 +239,6 @@ BATTERY_SOURCE_SCHEMA = vol.Schema(
         vol.Required("type"): "battery",
         vol.Required("stat_energy_from"): str,
         vol.Required("stat_energy_to"): str,
-        vol.Optional("stat_rate"): str,
     }
 )
 GAS_SOURCE_SCHEMA = vol.Schema(
@@ -321,7 +294,6 @@ ENERGY_SOURCE_SCHEMA = vol.All(
 DEVICE_CONSUMPTION_SCHEMA = vol.Schema(
     {
         vol.Required("stat_consumption"): str,
-        vol.Optional("stat_rate"): str,
         vol.Optional("name"): str,
         vol.Optional("included_in_stat"): str,
     }

homeassistant/components/energy/validate.py

@@ -12,7 +12,6 @@ from homeassistant.const import (
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
     UnitOfEnergy,
-    UnitOfPower,
     UnitOfVolume,
 )
 from homeassistant.core import HomeAssistant, callback, valid_entity_id
@@ -24,17 +23,12 @@ ENERGY_USAGE_DEVICE_CLASSES = (sensor.SensorDeviceClass.ENERGY,)
 ENERGY_USAGE_UNITS: dict[str, tuple[UnitOfEnergy, ...]] = {
     sensor.SensorDeviceClass.ENERGY: tuple(UnitOfEnergy)
 }
-POWER_USAGE_DEVICE_CLASSES = (sensor.SensorDeviceClass.POWER,)
-POWER_USAGE_UNITS: dict[str, tuple[UnitOfPower, ...]] = {
-    sensor.SensorDeviceClass.POWER: tuple(UnitOfPower)
-}
 
 ENERGY_PRICE_UNITS = tuple(
     f"/{unit}" for units in ENERGY_USAGE_UNITS.values() for unit in units
 )
 ENERGY_UNIT_ERROR = "entity_unexpected_unit_energy"
 ENERGY_PRICE_UNIT_ERROR = "entity_unexpected_unit_energy_price"
-POWER_UNIT_ERROR = "entity_unexpected_unit_power"
 GAS_USAGE_DEVICE_CLASSES = (
     sensor.SensorDeviceClass.ENERGY,
     sensor.SensorDeviceClass.GAS,
@@ -88,10 +82,6 @@ def _get_placeholders(hass: HomeAssistant, issue_type: str) -> dict[str, str] |
                 f"{currency}{unit}" for unit in ENERGY_PRICE_UNITS
             ),
         }
-    if issue_type == POWER_UNIT_ERROR:
-        return {
-            "power_units": ", ".join(POWER_USAGE_UNITS[sensor.SensorDeviceClass.POWER]),
-        }
     if issue_type == GAS_UNIT_ERROR:
         return {
             "energy_units": ", ".join(GAS_USAGE_UNITS[sensor.SensorDeviceClass.ENERGY]),
@@ -169,7 +159,7 @@ class EnergyPreferencesValidation:
 
 
 @callback
-def _async_validate_stat_common(
+def _async_validate_usage_stat(
     hass: HomeAssistant,
     metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
     stat_id: str,
@@ -177,41 +167,37 @@ def _async_validate_stat_common(
     allowed_units: Mapping[str, Sequence[str]],
     unit_error: str,
     issues: ValidationIssues,
-    check_negative: bool = False,
-) -> str | None:
-    """Validate common aspects of a statistic.
-
-    Returns the entity_id if validation succeeds, None otherwise.
-    """
+) -> None:
+    """Validate a statistic."""
     if stat_id not in metadata:
         issues.add_issue(hass, "statistics_not_defined", stat_id)
 
     has_entity_source = valid_entity_id(stat_id)
 
     if not has_entity_source:
-        return None
+        return
 
     entity_id = stat_id
 
     if not recorder.is_entity_recorded(hass, entity_id):
         issues.add_issue(hass, "recorder_untracked", entity_id)
-        return None
+        return
 
     if (state := hass.states.get(entity_id)) is None:
         issues.add_issue(hass, "entity_not_defined", entity_id)
-        return None
+        return
 
     if state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
         issues.add_issue(hass, "entity_unavailable", entity_id, state.state)
-        return None
+        return
 
     try:
         current_value: float | None = float(state.state)
     except ValueError:
         issues.add_issue(hass, "entity_state_non_numeric", entity_id, state.state)
-        return None
+        return
 
-    if check_negative and current_value is not None and current_value < 0:
+    if current_value is not None and current_value < 0:
         issues.add_issue(hass, "entity_negative_state", entity_id, current_value)
 
     device_class = state.attributes.get(ATTR_DEVICE_CLASS)
@@ -225,36 +211,6 @@ def _async_validate_stat_common(
         if device_class and unit not in allowed_units.get(device_class, []):
             issues.add_issue(hass, unit_error, entity_id, unit)
 
-    return entity_id
-
-
-@callback
-def _async_validate_usage_stat(
-    hass: HomeAssistant,
-    metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    stat_id: str,
-    allowed_device_classes: Sequence[str],
-    allowed_units: Mapping[str, Sequence[str]],
-    unit_error: str,
-    issues: ValidationIssues,
-) -> None:
-    """Validate a statistic."""
-    entity_id = _async_validate_stat_common(
-        hass,
-        metadata,
-        stat_id,
-        allowed_device_classes,
-        allowed_units,
-        unit_error,
-        issues,
-        check_negative=True,
-    )
-
-    if entity_id is None:
-        return
-
-    state = hass.states.get(entity_id)
-    assert state is not None
     state_class = state.attributes.get(sensor.ATTR_STATE_CLASS)
 
     allowed_state_classes = [
@@ -299,39 +255,6 @@ def _async_validate_price_entity(
         issues.add_issue(hass, unit_error, entity_id, unit)
 
 
-@callback
-def _async_validate_power_stat(
-    hass: HomeAssistant,
-    metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    stat_id: str,
-    allowed_device_classes: Sequence[str],
-    allowed_units: Mapping[str, Sequence[str]],
-    unit_error: str,
-    issues: ValidationIssues,
-) -> None:
-    """Validate a power statistic."""
-    entity_id = _async_validate_stat_common(
-        hass,
-        metadata,
-        stat_id,
-        allowed_device_classes,
-        allowed_units,
-        unit_error,
-        issues,
-        check_negative=False,
-    )
-
-    if entity_id is None:
-        return
-
-    state = hass.states.get(entity_id)
-    assert state is not None
-    state_class = state.attributes.get(sensor.ATTR_STATE_CLASS)
-
-    if state_class != sensor.SensorStateClass.MEASUREMENT:
-        issues.add_issue(hass, "entity_unexpected_state_class", entity_id, state_class)
-
-
 @callback
 def _async_validate_cost_stat(
     hass: HomeAssistant,
@@ -511,21 +434,6 @@ async def async_validate(hass: HomeAssistant) -> EnergyPreferencesValidation:
                         )
                     )
 
-            for power_stat in source.get("power", []):
-                wanted_statistics_metadata.add(power_stat["stat_rate"])
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_power_stat,
-                        hass,
-                        statistics_metadata,
-                        power_stat["stat_rate"],
-                        POWER_USAGE_DEVICE_CLASSES,
-                        POWER_USAGE_UNITS,
-                        POWER_UNIT_ERROR,
-                        source_result,
-                    )
-                )
-
         elif source["type"] == "gas":
             wanted_statistics_metadata.add(source["stat_energy_from"])
             validate_calls.append(

homeassistant/components/frontend/__init__.py

@@ -481,13 +481,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         sidebar_title="climate",
         sidebar_default_visible=False,
     )
-    async_register_built_in_panel(
-        hass,
-        "home",
-        sidebar_icon="mdi:home",
-        sidebar_title="home",
-        sidebar_default_visible=False,
-    )
 
     async_register_built_in_panel(hass, "profile")
 

homeassistant/components/google/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/google",
   "iot_class": "cloud_polling",
   "loggers": ["googleapiclient"],
-  "requirements": ["gcal-sync==8.0.0", "oauth2client==4.1.3", "ical==11.1.0"]
+  "requirements": ["gcal-sync==8.0.0", "oauth2client==4.1.3", "ical==11.0.0"]
 }

homeassistant/components/hive/manifest.json

@@ -9,5 +9,5 @@
   },
   "iot_class": "cloud_polling",
   "loggers": ["apyhiveapi"],
-  "requirements": ["pyhive-integration==1.0.7"]
+  "requirements": ["pyhive-integration==1.0.6"]
 }

homeassistant/components/home_connect/manifest.json

@@ -22,6 +22,6 @@
   "iot_class": "cloud_push",
   "loggers": ["aiohomeconnect"],
   "quality_scale": "platinum",
-  "requirements": ["aiohomeconnect==0.23.1"],
+  "requirements": ["aiohomeconnect==0.23.0"],
   "zeroconf": ["_homeconnect._tcp.local."]
 }

homeassistant/components/home_connect/select.py

@@ -412,8 +412,8 @@ class HomeConnectProgramSelectEntity(HomeConnectEntity, SelectEntity):
         """Set the program value."""
         event = self.appliance.events.get(cast(EventKey, self.bsh_key))
         self._attr_current_option = (
-            PROGRAMS_TRANSLATION_KEYS_MAP.get(ProgramKey(event_value))
-            if event and isinstance(event_value := event.value, str)
+            PROGRAMS_TRANSLATION_KEYS_MAP.get(cast(ProgramKey, event.value))
+            if event
             else None
         )
 

homeassistant/components/home_connect/sensor.py

@@ -556,11 +556,8 @@ class HomeConnectSensor(HomeConnectEntity, SensorEntity):
         status = self.appliance.status[cast(StatusKey, self.bsh_key)].value
         self._update_native_value(status)
 
-    def _update_native_value(self, status: str | float | None) -> None:
+    def _update_native_value(self, status: str | float) -> None:
         """Set the value of the sensor based on the given value."""
-        if status is None:
-            self._attr_native_value = None
-            return
         match self.device_class:
             case SensorDeviceClass.TIMESTAMP:
                 self._attr_native_value = dt_util.utcnow() + timedelta(

homeassistant/components/home_connect/strings.json

@@ -1237,7 +1237,7 @@
       "message": "Error obtaining data from the API: {error}"
     },
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation temporarily unavailable, will retry"
     },
     "pause_program": {
       "message": "Error pausing program: {error}"

homeassistant/components/homeassistant_connect_zbt2/config_flow.py

@@ -76,18 +76,9 @@ class ZBT2FirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     """Mixin for Home Assistant Connect ZBT-2 firmware methods."""
 
     context: ConfigFlowContext
-
+    BOOTLOADER_RESET_METHODS = [ResetTarget.RTS_DTR]
     ZIGBEE_BAUDRATE = 460800
 
-    # Early ZBT-2 samples used RTS/DTR to trigger the bootloader, later ones use the
-    # baudrate method. Since the two are mutually exclusive we just use both.
-    BOOTLOADER_RESET_METHODS = [ResetTarget.RTS_DTR, ResetTarget.BAUDRATE]
-    APPLICATION_PROBE_METHODS = [
-        (ApplicationType.GECKO_BOOTLOADER, 115200),
-        (ApplicationType.EZSP, ZIGBEE_BAUDRATE),
-        (ApplicationType.SPINEL, 460800),
-    ]
-
     async def async_step_install_zigbee_firmware(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/homeassistant_connect_zbt2/update.py

@@ -14,6 +14,7 @@ from homeassistant.components.homeassistant_hardware.update import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.update import UpdateDeviceClass
 from homeassistant.const import EntityCategory
@@ -23,7 +24,6 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantConnectZBT2ConfigEntry
-from .config_flow import ZBT2FirmwareMixin
 from .const import DOMAIN, FIRMWARE, FIRMWARE_VERSION, HARDWARE_NAME, SERIAL_NUMBER
 
 _LOGGER = logging.getLogger(__name__)
@@ -134,8 +134,7 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Connect ZBT-2 firmware update entity."""
 
-    BOOTLOADER_RESET_METHODS = ZBT2FirmwareMixin.BOOTLOADER_RESET_METHODS
-    APPLICATION_PROBE_METHODS = ZBT2FirmwareMixin.APPLICATION_PROBE_METHODS
+    bootloader_reset_methods = [ResetTarget.RTS_DTR]
 
     def __init__(
         self,

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -81,7 +81,6 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
 
     ZIGBEE_BAUDRATE = 115200  # Default, subclasses may override
     BOOTLOADER_RESET_METHODS: list[ResetTarget] = []  # Default, subclasses may override
-    APPLICATION_PROBE_METHODS: list[tuple[ApplicationType, int]] = []
 
     _picked_firmware_type: PickedFirmwareType
     _zigbee_flow_strategy: ZigbeeFlowStrategy = ZigbeeFlowStrategy.RECOMMENDED
@@ -231,11 +230,7 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         # Installing new firmware is only truly required if the wrong type is
         # installed: upgrading to the latest release of the current firmware type
         # isn't strictly necessary for functionality.
-        self._probed_firmware_info = await probe_silabs_firmware_info(
-            self._device,
-            bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-            application_probe_methods=self.APPLICATION_PROBE_METHODS,
-        )
+        self._probed_firmware_info = await probe_silabs_firmware_info(self._device)
 
         firmware_install_required = self._probed_firmware_info is None or (
             self._probed_firmware_info.firmware_type != expected_installed_firmware_type
@@ -300,7 +295,6 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
             fw_data=fw_data,
             expected_installed_firmware_type=expected_installed_firmware_type,
             bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-            application_probe_methods=self.APPLICATION_PROBE_METHODS,
             progress_callback=lambda offset, total: self.async_update_progress(
                 offset / total
             ),

homeassistant/components/homeassistant_hardware/manifest.json

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

homeassistant/components/homeassistant_hardware/update.py

@@ -86,8 +86,7 @@ class BaseFirmwareUpdateEntity(
 
     # Subclasses provide the mapping between firmware types and entity descriptions
     entity_description: FirmwareUpdateEntityDescription
-    BOOTLOADER_RESET_METHODS: list[ResetTarget]
-    APPLICATION_PROBE_METHODS: list[tuple[ApplicationType, int]]
+    bootloader_reset_methods: list[ResetTarget] = []
 
     _attr_supported_features = (
         UpdateEntityFeature.INSTALL | UpdateEntityFeature.PROGRESS
@@ -279,8 +278,7 @@ class BaseFirmwareUpdateEntity(
                 device=self._current_device,
                 fw_data=fw_data,
                 expected_installed_firmware_type=self.entity_description.expected_firmware_type,
-                bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-                application_probe_methods=self.APPLICATION_PROBE_METHODS,
+                bootloader_reset_methods=self.bootloader_reset_methods,
                 progress_callback=self._update_progress,
                 domain=self._config_entry.domain,
             )

homeassistant/components/homeassistant_hardware/util.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
-from collections.abc import AsyncIterator, Callable, Sequence
+from collections.abc import AsyncIterator, Callable, Iterable, Sequence
 from contextlib import AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from enum import StrEnum
@@ -309,20 +309,15 @@ async def guess_firmware_info(hass: HomeAssistant, device_path: str) -> Firmware
 
 
 async def probe_silabs_firmware_info(
-    device: str,
-    *,
-    bootloader_reset_methods: Sequence[ResetTarget],
-    application_probe_methods: Sequence[tuple[ApplicationType, int]],
+    device: str, *, probe_methods: Iterable[ApplicationType] | None = None
 ) -> FirmwareInfo | None:
     """Probe the running firmware on a SiLabs device."""
     flasher = Flasher(
         device=device,
-        probe_methods=tuple(
-            (m.as_flasher_application_type(), baudrate)
-            for m, baudrate in application_probe_methods
-        ),
-        bootloader_reset=tuple(
-            m.as_flasher_reset_target() for m in bootloader_reset_methods
+        **(
+            {"probe_methods": [m.as_flasher_application_type() for m in probe_methods]}
+            if probe_methods
+            else {}
         ),
     )
 
@@ -348,18 +343,11 @@ async def probe_silabs_firmware_info(
 
 
 async def probe_silabs_firmware_type(
-    device: str,
-    *,
-    bootloader_reset_methods: Sequence[ResetTarget],
-    application_probe_methods: Sequence[tuple[ApplicationType, int]],
+    device: str, *, probe_methods: Iterable[ApplicationType] | None = None
 ) -> ApplicationType | None:
     """Probe the running firmware type on a SiLabs device."""
 
-    fw_info = await probe_silabs_firmware_info(
-        device,
-        bootloader_reset_methods=bootloader_reset_methods,
-        application_probe_methods=application_probe_methods,
-    )
+    fw_info = await probe_silabs_firmware_info(device, probe_methods=probe_methods)
     if fw_info is None:
         return None
 
@@ -371,22 +359,12 @@ async def async_flash_silabs_firmware(
     device: str,
     fw_data: bytes,
     expected_installed_firmware_type: ApplicationType,
-    bootloader_reset_methods: Sequence[ResetTarget],
-    application_probe_methods: Sequence[tuple[ApplicationType, int]],
+    bootloader_reset_methods: Sequence[ResetTarget] = (),
     progress_callback: Callable[[int, int], None] | None = None,
     *,
     domain: str = DOMAIN,
 ) -> FirmwareInfo:
     """Flash firmware to the SiLabs device."""
-    if not any(
-        method == expected_installed_firmware_type
-        for method, _ in application_probe_methods
-    ):
-        raise ValueError(
-            f"Expected installed firmware type {expected_installed_firmware_type!r}"
-            f" not in application probe methods {application_probe_methods!r}"
-        )
-
     async with async_firmware_update_context(hass, device, domain):
         firmware_info = await guess_firmware_info(hass, device)
         _LOGGER.debug("Identified firmware info: %s", firmware_info)
@@ -395,9 +373,11 @@ async def async_flash_silabs_firmware(
 
         flasher = Flasher(
             device=device,
-            probe_methods=tuple(
-                (m.as_flasher_application_type(), baudrate)
-                for m, baudrate in application_probe_methods
+            probe_methods=(
+                ApplicationType.GECKO_BOOTLOADER.as_flasher_application_type(),
+                ApplicationType.EZSP.as_flasher_application_type(),
+                ApplicationType.SPINEL.as_flasher_application_type(),
+                ApplicationType.CPC.as_flasher_application_type(),
             ),
             bootloader_reset=tuple(
                 m.as_flasher_reset_target() for m in bootloader_reset_methods
@@ -421,13 +401,7 @@ async def async_flash_silabs_firmware(
 
             probed_firmware_info = await probe_silabs_firmware_info(
                 device,
-                bootloader_reset_methods=bootloader_reset_methods,
-                # Only probe for the expected installed firmware type
-                application_probe_methods=[
-                    (method, baudrate)
-                    for method, baudrate in application_probe_methods
-                    if method == expected_installed_firmware_type
-                ],
+                probe_methods=(expected_installed_firmware_type,),
             )
 
         if probed_firmware_info is None:

homeassistant/components/homeassistant_sky_connect/config_flow.py

@@ -16,7 +16,6 @@ from homeassistant.components.homeassistant_hardware.helpers import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
-    ResetTarget,
 )
 from homeassistant.components.usb import (
     usb_service_info_from_device,
@@ -80,20 +79,6 @@ class SkyConnectFirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
 
     context: ConfigFlowContext
 
-    ZIGBEE_BAUDRATE = 115200
-    # There is no hardware bootloader trigger
-    BOOTLOADER_RESET_METHODS: list[ResetTarget] = []
-    APPLICATION_PROBE_METHODS = [
-        (ApplicationType.GECKO_BOOTLOADER, 115200),
-        (ApplicationType.EZSP, ZIGBEE_BAUDRATE),
-        (ApplicationType.SPINEL, 460800),
-        # CPC baudrates can be removed once multiprotocol is removed
-        (ApplicationType.CPC, 115200),
-        (ApplicationType.CPC, 230400),
-        (ApplicationType.CPC, 460800),
-        (ApplicationType.ROUTER, 115200),
-    ]
-
     def _get_translation_placeholders(self) -> dict[str, str]:
         """Shared translation placeholders."""
         placeholders = {

homeassistant/components/homeassistant_sky_connect/update.py

@@ -23,7 +23,6 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantSkyConnectConfigEntry
-from .config_flow import SkyConnectFirmwareMixin
 from .const import (
     DOMAIN,
     FIRMWARE,
@@ -152,8 +151,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """SkyConnect firmware update entity."""
 
-    BOOTLOADER_RESET_METHODS = SkyConnectFirmwareMixin.BOOTLOADER_RESET_METHODS
-    APPLICATION_PROBE_METHODS = SkyConnectFirmwareMixin.APPLICATION_PROBE_METHODS
+    # The ZBT-1 does not have a hardware bootloader trigger
+    bootloader_reset_methods = []
 
     def __init__(
         self,

homeassistant/components/homeassistant_yellow/config_flow.py

@@ -82,18 +82,7 @@ else:
 class YellowFirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     """Mixin for Home Assistant Yellow firmware methods."""
 
-    ZIGBEE_BAUDRATE = 115200
     BOOTLOADER_RESET_METHODS = [ResetTarget.YELLOW]
-    APPLICATION_PROBE_METHODS = [
-        (ApplicationType.GECKO_BOOTLOADER, 115200),
-        (ApplicationType.EZSP, ZIGBEE_BAUDRATE),
-        (ApplicationType.SPINEL, 460800),
-        # CPC baudrates can be removed once multiprotocol is removed
-        (ApplicationType.CPC, 115200),
-        (ApplicationType.CPC, 230400),
-        (ApplicationType.CPC, 460800),
-        (ApplicationType.ROUTER, 115200),
-    ]
 
     async def async_step_install_zigbee_firmware(
         self, user_input: dict[str, Any] | None = None
@@ -157,11 +146,7 @@ class HomeAssistantYellowConfigFlow(
         assert self._device is not None
 
         # We do not actually use any portion of `BaseFirmwareConfigFlow` beyond this
-        self._probed_firmware_info = await probe_silabs_firmware_info(
-            self._device,
-            bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-            application_probe_methods=self.APPLICATION_PROBE_METHODS,
-        )
+        self._probed_firmware_info = await probe_silabs_firmware_info(self._device)
 
         # Kick off ZHA hardware discovery automatically if Zigbee firmware is running
         if (

homeassistant/components/homeassistant_yellow/update.py

@@ -14,6 +14,7 @@ from homeassistant.components.homeassistant_hardware.update import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.update import UpdateDeviceClass
 from homeassistant.const import EntityCategory
@@ -23,7 +24,6 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantYellowConfigEntry
-from .config_flow import YellowFirmwareMixin
 from .const import DOMAIN, FIRMWARE, FIRMWARE_VERSION, MANUFACTURER, MODEL, RADIO_DEVICE
 
 _LOGGER = logging.getLogger(__name__)
@@ -150,8 +150,7 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Yellow firmware update entity."""
 
-    BOOTLOADER_RESET_METHODS = YellowFirmwareMixin.BOOTLOADER_RESET_METHODS
-    APPLICATION_PROBE_METHODS = YellowFirmwareMixin.APPLICATION_PROBE_METHODS
+    bootloader_reset_methods = [ResetTarget.YELLOW]  # Triggers a GPIO reset
 
     def __init__(
         self,

homeassistant/components/hyperion/camera.py

@@ -13,7 +13,6 @@ from typing import Any
 from aiohttp import web
 from hyperion import client
 from hyperion.const import (
-    KEY_DATA,
     KEY_IMAGE,
     KEY_IMAGE_STREAM,
     KEY_LEDCOLORS,
@@ -156,8 +155,7 @@ class HyperionCamera(Camera):
         """Update Hyperion components."""
         if not img:
             return
-        # Prefer KEY_DATA (Hyperion server >= 2.1.1); fall back to KEY_RESULT for older server versions
-        img_data = img.get(KEY_DATA, img.get(KEY_RESULT, {})).get(KEY_IMAGE)
+        img_data = img.get(KEY_RESULT, {}).get(KEY_IMAGE)
         if not img_data or not img_data.startswith(IMAGE_STREAM_JPG_SENTINEL):
             return
         async with self._image_cond:

homeassistant/components/lamarzocco/update.py

@@ -125,7 +125,7 @@ class LaMarzoccoUpdateEntity(LaMarzoccoEntity, UpdateEntity):
             await self.coordinator.device.update_firmware()
             while (
                 update_progress := await self.coordinator.device.get_firmware()
-            ).command_status is not UpdateStatus.UPDATED:
+            ).command_status is UpdateStatus.IN_PROGRESS:
                 if counter >= MAX_UPDATE_WAIT:
                     _raise_timeout_error()
                 self._attr_update_percentage = update_progress.progress_percentage

homeassistant/components/local_calendar/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/local_calendar",
   "iot_class": "local_polling",
   "loggers": ["ical"],
-  "requirements": ["ical==11.1.0"]
+  "requirements": ["ical==11.0.0"]
 }

homeassistant/components/local_todo/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/local_todo",
   "iot_class": "local_polling",
-  "requirements": ["ical==11.1.0"]
+  "requirements": ["ical==11.0.0"]
 }

homeassistant/components/lunatone/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["lunatone-rest-api-client==0.5.7"]
+  "requirements": ["lunatone-rest-api-client==0.5.3"]
 }

homeassistant/components/matter/adapter.py

@@ -234,12 +234,22 @@ class MatterAdapter:
         self._create_device_registry(endpoint)
         # run platform discovery from device type instances
         for entity_info in async_discover_entities(endpoint):
-            discovery_key = (
-                f"{entity_info.platform}_{endpoint.node.node_id}_{endpoint.endpoint_id}_"
-                f"{entity_info.primary_attribute.cluster_id}_"
-                f"{entity_info.primary_attribute.attribute_id}_"
-                f"{entity_info.entity_description.key}"
-            )
+            # For entities that should only exist once per device (not per endpoint),
+            # exclude endpoint_id from the discovery key
+            if entity_info.discovery_schema.once_per_device:
+                discovery_key = (
+                    f"{entity_info.platform}_{endpoint.node.node_id}_"
+                    f"{entity_info.primary_attribute.cluster_id}_"
+                    f"{entity_info.primary_attribute.attribute_id}_"
+                    f"{entity_info.entity_description.key}"
+                )
+            else:
+                discovery_key = (
+                    f"{entity_info.platform}_{endpoint.node.node_id}_{endpoint.endpoint_id}_"
+                    f"{entity_info.primary_attribute.cluster_id}_"
+                    f"{entity_info.primary_attribute.attribute_id}_"
+                    f"{entity_info.entity_description.key}"
+                )
             if discovery_key in self.discovered_entities:
                 continue
             LOGGER.debug(

homeassistant/components/matter/button.py

@@ -65,7 +65,10 @@ DISCOVERY_SCHEMAS = [
         entity_class=MatterCommandButton,
         required_attributes=(clusters.Identify.Attributes.IdentifyType,),
         value_is_not=clusters.Identify.Enums.IdentifyTypeEnum.kNone,
-        allow_multi=True,
+        # Only create a single Identify button per device, not one per endpoint.
+        # The Identify cluster can appear on multiple endpoints; once_per_device=True
+        # ensures only one button is created for the entire device.
+        once_per_device=True,
     ),
     MatterDiscoverySchema(
         platform=Platform.BUTTON,

homeassistant/components/matter/models.py

@@ -152,3 +152,7 @@ class MatterDiscoverySchema:
     # [optional] the secondary (required) attribute value must NOT have this value
     # for example to filter out empty lists in list sensor values
     secondary_value_is_not: Any = UNSET
+
+    # [optional] bool to specify if this entity should only be created once per device
+    # instead of once per endpoint (useful for device-level entities like identify button)
+    once_per_device: bool = False

homeassistant/components/miele/strings.json

@@ -1089,7 +1089,7 @@
       "message": "Invalid device targeted."
     },
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     },
     "set_program_error": {
       "message": "'Set program' action failed: {status} / {message}"

homeassistant/components/mill/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/mill",
   "iot_class": "local_polling",
   "loggers": ["mill", "mill_local"],
-  "requirements": ["millheater==0.14.1", "mill-local==0.3.0"]
+  "requirements": ["millheater==0.14.0", "mill-local==0.3.0"]
 }

homeassistant/components/mobile_app/binary_sensor.py

@@ -61,12 +61,10 @@ async def async_setup_entry(
 
         async_add_entities([MobileAppBinarySensor(data, config_entry)])
 
-    config_entry.async_on_unload(
-        async_dispatcher_connect(
-            hass,
-            f"{DOMAIN}_{ENTITY_TYPE}_register",
-            handle_sensor_registration,
-        )
+    async_dispatcher_connect(
+        hass,
+        f"{DOMAIN}_{ENTITY_TYPE}_register",
+        handle_sensor_registration,
     )
 
 

homeassistant/components/mobile_app/sensor.py

@@ -72,12 +72,10 @@ async def async_setup_entry(
 
         async_add_entities([MobileAppSensor(data, config_entry)])
 
-    config_entry.async_on_unload(
-        async_dispatcher_connect(
-            hass,
-            f"{DOMAIN}_{ENTITY_TYPE}_register",
-            handle_sensor_registration,
-        )
+    async_dispatcher_connect(
+        hass,
+        f"{DOMAIN}_{ENTITY_TYPE}_register",
+        handle_sensor_registration,
     )
 
 

homeassistant/components/music_assistant/config_flow.py

@@ -13,7 +13,7 @@ from music_assistant_client.exceptions import (
 from music_assistant_models.api import ServerInfoMessage
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import SOURCE_IGNORE, ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_URL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import aiohttp_client
@@ -21,14 +21,21 @@ from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
 from .const import DOMAIN, LOGGER
 
-DEFAULT_TITLE = "Music Assistant"
 DEFAULT_URL = "http://mass.local:8095"
+DEFAULT_TITLE = "Music Assistant"
 
 
-STEP_USER_SCHEMA = vol.Schema({vol.Required(CONF_URL): str})
+def get_manual_schema(user_input: dict[str, Any]) -> vol.Schema:
+    """Return a schema for the manual step."""
+    default_url = user_input.get(CONF_URL, DEFAULT_URL)
+    return vol.Schema(
+        {
+            vol.Required(CONF_URL, default=default_url): str,
+        }
+    )
 
 
-async def _get_server_info(hass: HomeAssistant, url: str) -> ServerInfoMessage:
+async def get_server_info(hass: HomeAssistant, url: str) -> ServerInfoMessage:
     """Validate the user input allows us to connect."""
     async with MusicAssistantClient(
         url, aiohttp_client.async_get_clientsession(hass)
@@ -45,17 +52,25 @@ class MusicAssistantConfigFlow(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Set up flow instance."""
-        self.url: str | None = None
+        self.server_info: ServerInfoMessage | None = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle a manual configuration."""
         errors: dict[str, str] = {}
-
         if user_input is not None:
             try:
-                server_info = await _get_server_info(self.hass, user_input[CONF_URL])
+                self.server_info = await get_server_info(
+                    self.hass, user_input[CONF_URL]
+                )
+                await self.async_set_unique_id(
+                    self.server_info.server_id, raise_on_progress=False
+                )
+                self._abort_if_unique_id_configured(
+                    updates={CONF_URL: user_input[CONF_URL]},
+                    reload_on_update=True,
+                )
             except CannotConnect:
                 errors["base"] = "cannot_connect"
             except InvalidServerVersion:
@@ -64,49 +79,68 @@ class MusicAssistantConfigFlow(ConfigFlow, domain=DOMAIN):
                 LOGGER.exception("Unexpected exception")
                 errors["base"] = "unknown"
             else:
-                await self.async_set_unique_id(
-                    server_info.server_id, raise_on_progress=False
-                )
-                self._abort_if_unique_id_configured(
-                    updates={CONF_URL: user_input[CONF_URL]}
-                )
-
                 return self.async_create_entry(
                     title=DEFAULT_TITLE,
-                    data={CONF_URL: user_input[CONF_URL]},
+                    data={
+                        CONF_URL: user_input[CONF_URL],
+                    },
                 )
 
-        suggested_values = user_input
-        if suggested_values is None:
-            suggested_values = {CONF_URL: DEFAULT_URL}
+            return self.async_show_form(
+                step_id="user", data_schema=get_manual_schema(user_input), errors=errors
+            )
 
-        return self.async_show_form(
-            step_id="user",
-            data_schema=self.add_suggested_values_to_schema(
-                STEP_USER_SCHEMA, suggested_values
-            ),
-            errors=errors,
-        )
+        return self.async_show_form(step_id="user", data_schema=get_manual_schema({}))
 
     async def async_step_zeroconf(
         self, discovery_info: ZeroconfServiceInfo
     ) -> ConfigFlowResult:
-        """Handle a zeroconf discovery for a Music Assistant server."""
+        """Handle a discovered Mass server.
+
+        This flow is triggered by the Zeroconf component. It will check if the
+        host is already configured and delegate to the import step if not.
+        """
+        # abort if discovery info is not what we expect
+        if "server_id" not in discovery_info.properties:
+            return self.async_abort(reason="missing_server_id")
+
+        self.server_info = ServerInfoMessage.from_dict(discovery_info.properties)
+        await self.async_set_unique_id(self.server_info.server_id)
+
+        # Check if we already have a config entry for this server_id
+        existing_entry = self.hass.config_entries.async_entry_for_domain_unique_id(
+            DOMAIN, self.server_info.server_id
+        )
+
+        if existing_entry:
+            # If the entry was ignored or disabled, don't make any changes
+            if existing_entry.source == SOURCE_IGNORE or existing_entry.disabled_by:
+                return self.async_abort(reason="already_configured")
+
+            # Test connectivity to the current URL first
+            current_url = existing_entry.data[CONF_URL]
+            try:
+                await get_server_info(self.hass, current_url)
+                # Current URL is working, no need to update
+                return self.async_abort(reason="already_configured")
+            except CannotConnect:
+                # Current URL is not working, update to the discovered URL
+                # and continue to discovery confirm
+                self.hass.config_entries.async_update_entry(
+                    existing_entry,
+                    data={**existing_entry.data, CONF_URL: self.server_info.base_url},
+                )
+                # Schedule reload since URL changed
+                self.hass.config_entries.async_schedule_reload(existing_entry.entry_id)
+        else:
+            # No existing entry, proceed with normal flow
+            self._abort_if_unique_id_configured()
+
+        # Test connectivity to the discovered URL
         try:
-            server_info = ServerInfoMessage.from_dict(discovery_info.properties)
-        except LookupError:
-            return self.async_abort(reason="invalid_discovery_info")
-
-        self.url = server_info.base_url
-
-        await self.async_set_unique_id(server_info.server_id)
-        self._abort_if_unique_id_configured(updates={CONF_URL: self.url})
-
-        try:
-            await _get_server_info(self.hass, self.url)
+            await get_server_info(self.hass, self.server_info.base_url)
         except CannotConnect:
             return self.async_abort(reason="cannot_connect")
-
         return await self.async_step_discovery_confirm()
 
     async def async_step_discovery_confirm(
@@ -114,16 +148,16 @@ class MusicAssistantConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle user-confirmation of discovered server."""
         if TYPE_CHECKING:
-            assert self.url is not None
-
+            assert self.server_info is not None
         if user_input is not None:
             return self.async_create_entry(
                 title=DEFAULT_TITLE,
-                data={CONF_URL: self.url},
+                data={
+                    CONF_URL: self.server_info.base_url,
+                },
             )
-
         self._set_confirm_only()
         return self.async_show_form(
             step_id="discovery_confirm",
-            description_placeholders={"url": self.url},
+            description_placeholders={"url": self.server_info.base_url},
         )

homeassistant/components/music_assistant/manifest.json

@@ -2,7 +2,7 @@
   "domain": "music_assistant",
   "name": "Music Assistant",
   "after_dependencies": ["media_source", "media_player"],
-  "codeowners": ["@music-assistant", "@arturpragacz"],
+  "codeowners": ["@music-assistant"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/music_assistant",
   "iot_class": "local_push",

homeassistant/components/myuplink/strings.json

@@ -57,7 +57,7 @@
       "message": "Error while loading the integration."
     },
     "implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation is not available, will retry."
     },
     "incorrect_oauth2_scope": {
       "message": "Stored permissions are invalid. Please login again to update permissions."

homeassistant/components/netatmo/__init__.py

@@ -20,11 +20,10 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_WEBHOOK_ID, EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import aiohttp_client, config_validation as cv
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
-    OAuth2Session,
-    async_get_config_entry_implementation,
+from homeassistant.helpers import (
+    aiohttp_client,
+    config_entry_oauth2_flow,
+    config_validation as cv,
 )
 from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.dispatcher import async_dispatcher_send
@@ -74,19 +73,17 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Netatmo from a config entry."""
-    try:
-        implementation = await async_get_config_entry_implementation(hass, entry)
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
+    implementation = (
+        await config_entry_oauth2_flow.async_get_config_entry_implementation(
+            hass, entry
+        )
+    )
 
     # Set unique id if non was set (migration)
     if not entry.unique_id:
         hass.config_entries.async_update_entry(entry, unique_id=DOMAIN)
 
-    session = OAuth2Session(hass, entry, implementation)
+    session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
     try:
         await session.async_ensure_token_valid()
     except aiohttp.ClientResponseError as ex:

homeassistant/components/netatmo/strings.json

@@ -143,11 +143,6 @@
       }
     }
   },
-  "exceptions": {
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    }
-  },
   "options": {
     "step": {
       "public_weather": {

homeassistant/components/onedrive/strings.json

@@ -109,7 +109,7 @@
       "message": "Cannot read {filename}, no access to path; `allowlist_external_dirs` may need to be adjusted in `configuration.yaml`"
     },
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     },
     "update_failed": {
       "message": "Failed to update drive state"

homeassistant/components/point/strings.json

@@ -36,7 +36,7 @@
   },
   "exceptions": {
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     }
   }
 }

homeassistant/components/recorder/auto_repairs/schema.py

@@ -12,7 +12,7 @@ from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 
 from ..const import SupportedDialect
-from ..db_schema import DOUBLE_PRECISION_TYPE_SQL, DOUBLE_TYPE, MYSQL_COLLATE
+from ..db_schema import DOUBLE_PRECISION_TYPE_SQL, DOUBLE_TYPE
 from ..util import session_scope
 
 if TYPE_CHECKING:
@@ -105,13 +105,12 @@ def _validate_table_schema_has_correct_collation(
             or dialect_kwargs.get("mariadb_collate")
             or connection.dialect._fetch_setting(connection, "collation_server")  # type: ignore[attr-defined]  # noqa: SLF001
         )
-        if collate and collate != MYSQL_COLLATE:
+        if collate and collate != "utf8mb4_unicode_ci":
             _LOGGER.debug(
-                "Database %s collation is not %s",
+                "Database %s collation is not utf8mb4_unicode_ci",
                 table,
-                MYSQL_COLLATE,
             )
-            schema_errors.add(f"{table}.{MYSQL_COLLATE}")
+            schema_errors.add(f"{table}.utf8mb4_unicode_ci")
     return schema_errors
 
 
@@ -241,7 +240,7 @@ def correct_db_schema_utf8(
     table_name = table_object.__tablename__
     if (
         f"{table_name}.4-byte UTF-8" in schema_errors
-        or f"{table_name}.{MYSQL_COLLATE}" in schema_errors
+        or f"{table_name}.utf8mb4_unicode_ci" in schema_errors
     ):
         from ..migration import (  # noqa: PLC0415
             _correct_table_character_set_and_collation,

homeassistant/components/recorder/auto_repairs/statistics/schema.py

@@ -26,9 +26,6 @@ def validate_db_schema(instance: Recorder) -> set[str]:
     schema_errors |= validate_table_schema_supports_utf8(
         instance, StatisticsMeta, (StatisticsMeta.statistic_id,)
     )
-    schema_errors |= validate_table_schema_has_correct_collation(
-        instance, StatisticsMeta
-    )
     for table in (Statistics, StatisticsShortTerm):
         schema_errors |= validate_db_schema_precision(instance, table)
         schema_errors |= validate_table_schema_has_correct_collation(instance, table)

homeassistant/components/recorder/db_schema.py

@@ -71,7 +71,7 @@ class LegacyBase(DeclarativeBase):
     """Base class for tables, used for schema migration."""
 
 
-SCHEMA_VERSION = 53
+SCHEMA_VERSION = 52
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -128,7 +128,7 @@ LEGACY_STATES_ENTITY_ID_LAST_UPDATED_TS_INDEX = "ix_states_entity_id_last_update
 LEGACY_MAX_LENGTH_EVENT_CONTEXT_ID: Final = 36
 CONTEXT_ID_BIN_MAX_LENGTH = 16
 
-MYSQL_COLLATE = "utf8mb4_bin"
+MYSQL_COLLATE = "utf8mb4_unicode_ci"
 MYSQL_DEFAULT_CHARSET = "utf8mb4"
 MYSQL_ENGINE = "InnoDB"
 

homeassistant/components/recorder/migration.py

@@ -1361,7 +1361,7 @@ class _SchemaVersion20Migrator(_SchemaVersionMigrator, target_version=20):
 class _SchemaVersion21Migrator(_SchemaVersionMigrator, target_version=21):
     def _apply_update(self) -> None:
         """Version specific update method."""
-        # Try to change the character set of events, states and statistics_meta tables
+        # Try to change the character set of the statistic_meta table
         if self.engine.dialect.name == SupportedDialect.MYSQL:
             for table in ("events", "states", "statistics_meta"):
                 _correct_table_character_set_and_collation(table, self.session_maker)
@@ -2125,23 +2125,6 @@ class _SchemaVersion52Migrator(_SchemaVersionMigrator, target_version=52):
                 )
 
 
-class _SchemaVersion53Migrator(_SchemaVersionMigrator, target_version=53):
-    def _apply_update(self) -> None:
-        """Version specific update method."""
-        # Try to change the character set of events, states and statistics_meta tables
-        if self.engine.dialect.name == SupportedDialect.MYSQL:
-            for table in (
-                "events",
-                "event_data",
-                "states",
-                "state_attributes",
-                "statistics",
-                "statistics_meta",
-                "statistics_short_term",
-            ):
-                _correct_table_character_set_and_collation(table, self.session_maker)
-
-
 def _migrate_statistics_columns_to_timestamp_removing_duplicates(
     hass: HomeAssistant,
     instance: Recorder,
@@ -2184,10 +2167,8 @@ def _correct_table_character_set_and_collation(
     """Correct issues detected by validate_db_schema."""
     # Attempt to convert the table to utf8mb4
     _LOGGER.warning(
-        "Updating table %s to character set %s and collation %s. %s",
+        "Updating character set and collation of table %s to utf8mb4. %s",
         table,
-        MYSQL_DEFAULT_CHARSET,
-        MYSQL_COLLATE,
         MIGRATION_NOTE_MINUTES,
     )
     with (

homeassistant/components/recorder/table_managers/statistics_meta.py

@@ -26,7 +26,7 @@ CACHE_SIZE = 8192
 
 _LOGGER = logging.getLogger(__name__)
 
-QUERY_STATISTICS_META = (
+QUERY_STATISTIC_META = (
     StatisticsMeta.id,
     StatisticsMeta.statistic_id,
     StatisticsMeta.source,
@@ -55,7 +55,7 @@ def _generate_get_metadata_stmt(
 
     Depending on the schema version, either mean_type (added in version 49) or has_mean column is used.
     """
-    columns: list[InstrumentedAttribute[Any]] = list(QUERY_STATISTICS_META)
+    columns: list[InstrumentedAttribute[Any]] = list(QUERY_STATISTIC_META)
     if schema_version >= CIRCULAR_MEAN_SCHEMA_VERSION:
         columns.append(StatisticsMeta.mean_type)
     else:

homeassistant/components/remote_calendar/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["ical"],
   "quality_scale": "silver",
-  "requirements": ["ical==11.1.0"]
+  "requirements": ["ical==11.0.0"]
 }

homeassistant/components/satel_integra/alarm_control_panel.py

@@ -3,9 +3,10 @@
 from __future__ import annotations
 
 import asyncio
+from collections import OrderedDict
 import logging
 
-from satel_integra.satel_integra import AlarmState, AsyncSatel
+from satel_integra.satel_integra import AlarmState
 
 from homeassistant.components.alarm_control_panel import (
     AlarmControlPanelEntity,
@@ -15,31 +16,17 @@ from homeassistant.components.alarm_control_panel import (
 )
 from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import (
     CONF_ARM_HOME_MODE,
     CONF_PARTITION_NUMBER,
-    DOMAIN,
     SIGNAL_PANEL_MESSAGE,
     SUBENTRY_TYPE_PARTITION,
     SatelConfigEntry,
 )
 
-ALARM_STATE_MAP = {
-    AlarmState.TRIGGERED: AlarmControlPanelState.TRIGGERED,
-    AlarmState.TRIGGERED_FIRE: AlarmControlPanelState.TRIGGERED,
-    AlarmState.ENTRY_TIME: AlarmControlPanelState.PENDING,
-    AlarmState.ARMED_MODE3: AlarmControlPanelState.ARMED_HOME,
-    AlarmState.ARMED_MODE2: AlarmControlPanelState.ARMED_HOME,
-    AlarmState.ARMED_MODE1: AlarmControlPanelState.ARMED_HOME,
-    AlarmState.ARMED_MODE0: AlarmControlPanelState.ARMED_AWAY,
-    AlarmState.EXIT_COUNTDOWN_OVER_10: AlarmControlPanelState.ARMING,
-    AlarmState.EXIT_COUNTDOWN_UNDER_10: AlarmControlPanelState.ARMING,
-}
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -58,9 +45,9 @@ async def async_setup_entry(
     )
 
     for subentry in partition_subentries:
-        partition_num: int = subentry.data[CONF_PARTITION_NUMBER]
-        zone_name: str = subentry.data[CONF_NAME]
-        arm_home_mode: int = subentry.data[CONF_ARM_HOME_MODE]
+        partition_num = subentry.data[CONF_PARTITION_NUMBER]
+        zone_name = subentry.data[CONF_NAME]
+        arm_home_mode = subentry.data[CONF_ARM_HOME_MODE]
 
         async_add_entities(
             [
@@ -86,31 +73,20 @@ class SatelIntegraAlarmPanel(AlarmControlPanelEntity):
         | AlarmControlPanelEntityFeature.ARM_AWAY
     )
 
-    _attr_has_entity_name = True
-    _attr_name = None
-
     def __init__(
-        self,
-        controller: AsyncSatel,
-        device_name: str,
-        arm_home_mode: int,
-        partition_id: int,
-        config_entry_id: str,
+        self, controller, name, arm_home_mode, partition_id, config_entry_id
     ) -> None:
         """Initialize the alarm panel."""
+        self._attr_name = name
         self._attr_unique_id = f"{config_entry_id}_alarm_panel_{partition_id}"
         self._arm_home_mode = arm_home_mode
         self._partition_id = partition_id
         self._satel = controller
 
-        self._attr_device_info = DeviceInfo(
-            name=device_name, identifiers={(DOMAIN, self._attr_unique_id)}
-        )
-
     async def async_added_to_hass(self) -> None:
         """Update alarm status and register callbacks for future updates."""
-        self._attr_alarm_state = self._read_alarm_state()
-
+        _LOGGER.debug("Starts listening for panel messages")
+        self._update_alarm_status()
         self.async_on_remove(
             async_dispatcher_connect(
                 self.hass, SIGNAL_PANEL_MESSAGE, self._update_alarm_status
@@ -118,29 +94,55 @@ class SatelIntegraAlarmPanel(AlarmControlPanelEntity):
         )
 
     @callback
-    def _update_alarm_status(self) -> None:
+    def _update_alarm_status(self):
         """Handle alarm status update."""
         state = self._read_alarm_state()
-
+        _LOGGER.debug("Got status update, current status: %s", state)
         if state != self._attr_alarm_state:
             self._attr_alarm_state = state
             self.async_write_ha_state()
+        else:
+            _LOGGER.debug("Ignoring alarm status message, same state")
 
-    def _read_alarm_state(self) -> AlarmControlPanelState | None:
+    def _read_alarm_state(self):
         """Read current status of the alarm and translate it into HA status."""
 
+        # Default - disarmed:
+        hass_alarm_status = AlarmControlPanelState.DISARMED
+
         if not self._satel.connected:
-            _LOGGER.debug("Alarm panel not connected")
             return None
 
-        for satel_state, ha_state in ALARM_STATE_MAP.items():
+        state_map = OrderedDict(
+            [
+                (AlarmState.TRIGGERED, AlarmControlPanelState.TRIGGERED),
+                (AlarmState.TRIGGERED_FIRE, AlarmControlPanelState.TRIGGERED),
+                (AlarmState.ENTRY_TIME, AlarmControlPanelState.PENDING),
+                (AlarmState.ARMED_MODE3, AlarmControlPanelState.ARMED_HOME),
+                (AlarmState.ARMED_MODE2, AlarmControlPanelState.ARMED_HOME),
+                (AlarmState.ARMED_MODE1, AlarmControlPanelState.ARMED_HOME),
+                (AlarmState.ARMED_MODE0, AlarmControlPanelState.ARMED_AWAY),
+                (
+                    AlarmState.EXIT_COUNTDOWN_OVER_10,
+                    AlarmControlPanelState.PENDING,
+                ),
+                (
+                    AlarmState.EXIT_COUNTDOWN_UNDER_10,
+                    AlarmControlPanelState.PENDING,
+                ),
+            ]
+        )
+        _LOGGER.debug("State map of Satel: %s", self._satel.partition_states)
+
+        for satel_state, ha_state in state_map.items():
             if (
                 satel_state in self._satel.partition_states
                 and self._partition_id in self._satel.partition_states[satel_state]
             ):
-                return ha_state
+                hass_alarm_status = ha_state
+                break
 
-        return AlarmControlPanelState.DISARMED
+        return hass_alarm_status
 
     async def async_alarm_disarm(self, code: str | None = None) -> None:
         """Send disarm command."""
@@ -152,6 +154,8 @@ class SatelIntegraAlarmPanel(AlarmControlPanelEntity):
             self._attr_alarm_state == AlarmControlPanelState.TRIGGERED
         )
 
+        _LOGGER.debug("Disarming, self._attr_alarm_state: %s", self._attr_alarm_state)
+
         await self._satel.disarm(code, [self._partition_id])
 
         if clear_alarm_necessary:
@@ -161,12 +165,14 @@ class SatelIntegraAlarmPanel(AlarmControlPanelEntity):
 
     async def async_alarm_arm_away(self, code: str | None = None) -> None:
         """Send arm away command."""
+        _LOGGER.debug("Arming away")
 
         if code:
             await self._satel.arm(code, [self._partition_id])
 
     async def async_alarm_arm_home(self, code: str | None = None) -> None:
         """Send arm home command."""
+        _LOGGER.debug("Arming home")
 
         if code:
             await self._satel.arm(code, [self._partition_id], self._arm_home_mode)

homeassistant/components/sensor/icons.json

@@ -118,9 +118,6 @@
     "pm25": {
       "default": "mdi:molecule"
     },
-    "pm4": {
-      "default": "mdi:molecule"
-    },
     "power": {
       "default": "mdi:flash"
     },

homeassistant/components/senz/__init__.py

@@ -12,11 +12,10 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv, httpx_client
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
-    OAuth2Session,
-    async_get_config_entry_implementation,
+from homeassistant.helpers import (
+    config_entry_oauth2_flow,
+    config_validation as cv,
+    httpx_client,
 )
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -29,22 +28,19 @@ _LOGGER = logging.getLogger(__name__)
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
-PLATFORMS = [Platform.CLIMATE, Platform.SENSOR]
+PLATFORMS = [Platform.CLIMATE]
 
 type SENZDataUpdateCoordinator = DataUpdateCoordinator[dict[str, Thermostat]]
-type SENZConfigEntry = ConfigEntry[SENZDataUpdateCoordinator]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: SENZConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up SENZ from a config entry."""
-    try:
-        implementation = await async_get_config_entry_implementation(hass, entry)
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
-    session = OAuth2Session(hass, entry, implementation)
+    implementation = (
+        await config_entry_oauth2_flow.async_get_config_entry_implementation(
+            hass, entry
+        )
+    )
+    session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
     auth = SENZConfigEntryAuth(httpx_client.get_async_client(hass), session)
     senz_api = SENZAPI(auth)
 
@@ -72,13 +68,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: SENZConfigEntry) -> bool
 
     await coordinator.async_config_entry_first_refresh()
 
-    entry.runtime_data = coordinator
+    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: SENZConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unload_ok

homeassistant/components/senz/climate.py

@@ -12,29 +12,30 @@ from homeassistant.components.climate import (
     HVACAction,
     HVACMode,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_TEMPERATURE, PRECISION_TENTHS, UnitOfTemperature
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from . import SENZConfigEntry, SENZDataUpdateCoordinator
+from . import SENZDataUpdateCoordinator
 from .const import DOMAIN
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: SENZConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the SENZ climate entities from a config entry."""
-    coordinator = entry.runtime_data
+    coordinator: SENZDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
     async_add_entities(
         SENZClimate(thermostat, coordinator) for thermostat in coordinator.data.values()
     )
 
 
-class SENZClimate(CoordinatorEntity[SENZDataUpdateCoordinator], ClimateEntity):
+class SENZClimate(CoordinatorEntity, ClimateEntity):
     """Representation of a SENZ climate entity."""
 
     _attr_temperature_unit = UnitOfTemperature.CELSIUS

homeassistant/components/senz/diagnostics.py

@@ -1,26 +0,0 @@
-"""Diagnostics platform for Senz integration."""
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.core import HomeAssistant
-
-from . import SENZConfigEntry
-
-TO_REDACT = [
-    "access_token",
-    "refresh_token",
-]
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: SENZConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-
-    raw_data = ([device.raw_data for device in entry.runtime_data.data.values()],)
-
-    return {
-        "entry_data": async_redact_data(entry.data, TO_REDACT),
-        "thermostats": raw_data,
-    }

homeassistant/components/senz/sensor.py

@@ -1,92 +0,0 @@
-"""nVent RAYCHEM SENZ sensor platform."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from aiosenz import Thermostat
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-)
-from homeassistant.const import UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from . import SENZConfigEntry, SENZDataUpdateCoordinator
-from .const import DOMAIN
-
-
-@dataclass(kw_only=True, frozen=True)
-class SenzSensorDescription(SensorEntityDescription):
-    """Describes SENZ sensor entity."""
-
-    value_fn: Callable[[Thermostat], str | int | float | None]
-
-
-SENSORS: tuple[SenzSensorDescription, ...] = (
-    SenzSensorDescription(
-        key="temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        value_fn=lambda data: data.current_temperatue,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=1,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: SENZConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the SENZ sensor entities from a config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        SENZSensor(thermostat, coordinator, description)
-        for description in SENSORS
-        for thermostat in coordinator.data.values()
-    )
-
-
-class SENZSensor(CoordinatorEntity[SENZDataUpdateCoordinator], SensorEntity):
-    """Representation of a SENZ sensor entity."""
-
-    entity_description: SenzSensorDescription
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        thermostat: Thermostat,
-        coordinator: SENZDataUpdateCoordinator,
-        description: SenzSensorDescription,
-    ) -> None:
-        """Init SENZ sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._thermostat = thermostat
-        self._attr_unique_id = f"{thermostat.serial_number}_{description.key}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, thermostat.serial_number)},
-            manufacturer="nVent Raychem",
-            model="SENZ WIFI",
-            name=thermostat.name,
-            serial_number=thermostat.serial_number,
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return True if the thermostat is available."""
-        return super().available and self._thermostat.online
-
-    @property
-    def native_value(self) -> str | float | int | None:
-        """Return the state of the sensor."""
-        return self.entity_description.value_fn(self._thermostat)

homeassistant/components/senz/strings.json

@@ -25,10 +25,5 @@
         "title": "[%key:common::config_flow::title::oauth2_pick_implementation%]"
       }
     }
-  },
-  "exceptions": {
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    }
   }
 }

homeassistant/components/smartthings/strings.json

@@ -663,7 +663,7 @@
   },
   "exceptions": {
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     }
   },
   "issues": {

homeassistant/components/spotify/strings.json

@@ -34,7 +34,7 @@
   },
   "exceptions": {
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     }
   },
   "system_health": {

homeassistant/components/switchbot/__init__.py

@@ -75,7 +75,6 @@ PLATFORMS_BY_TYPE = {
     SupportedModels.HUBMINI_MATTER.value: [Platform.SENSOR],
     SupportedModels.CIRCULATOR_FAN.value: [Platform.FAN, Platform.SENSOR],
     SupportedModels.S10_VACUUM.value: [Platform.VACUUM, Platform.SENSOR],
-    SupportedModels.S20_VACUUM.value: [Platform.VACUUM, Platform.SENSOR],
     SupportedModels.K10_VACUUM.value: [Platform.VACUUM, Platform.SENSOR],
     SupportedModels.K10_PRO_VACUUM.value: [Platform.VACUUM, Platform.SENSOR],
     SupportedModels.K10_PRO_COMBO_VACUUM.value: [Platform.VACUUM, Platform.SENSOR],
@@ -103,10 +102,6 @@ PLATFORMS_BY_TYPE = {
     SupportedModels.RELAY_SWITCH_2PM.value: [Platform.SWITCH, Platform.SENSOR],
     SupportedModels.GARAGE_DOOR_OPENER.value: [Platform.COVER, Platform.SENSOR],
     SupportedModels.CLIMATE_PANEL.value: [Platform.SENSOR, Platform.BINARY_SENSOR],
-    SupportedModels.SMART_THERMOSTAT_RADIATOR.value: [
-        Platform.CLIMATE,
-        Platform.SENSOR,
-    ],
 }
 CLASS_BY_DEVICE = {
     SupportedModels.CEILING_LIGHT.value: switchbot.SwitchbotCeilingLight,
@@ -124,7 +119,6 @@ CLASS_BY_DEVICE = {
     SupportedModels.ROLLER_SHADE.value: switchbot.SwitchbotRollerShade,
     SupportedModels.CIRCULATOR_FAN.value: switchbot.SwitchbotFan,
     SupportedModels.S10_VACUUM.value: switchbot.SwitchbotVacuum,
-    SupportedModels.S20_VACUUM.value: switchbot.SwitchbotVacuum,
     SupportedModels.K10_VACUUM.value: switchbot.SwitchbotVacuum,
     SupportedModels.K10_PRO_VACUUM.value: switchbot.SwitchbotVacuum,
     SupportedModels.K10_PRO_COMBO_VACUUM.value: switchbot.SwitchbotVacuum,
@@ -142,7 +136,6 @@ CLASS_BY_DEVICE = {
     SupportedModels.PLUG_MINI_EU.value: switchbot.SwitchbotRelaySwitch,
     SupportedModels.RELAY_SWITCH_2PM.value: switchbot.SwitchbotRelaySwitch2PM,
     SupportedModels.GARAGE_DOOR_OPENER.value: switchbot.SwitchbotGarageDoorOpener,
-    SupportedModels.SMART_THERMOSTAT_RADIATOR.value: switchbot.SwitchbotSmartThermostatRadiator,
 }
 
 

homeassistant/components/switchbot/climate.py

@@ -1,140 +0,0 @@
-"""Support for Switchbot Climate devices."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-import switchbot
-from switchbot import (
-    ClimateAction as SwitchBotClimateAction,
-    ClimateMode as SwitchBotClimateMode,
-)
-
-from homeassistant.components.climate import (
-    ClimateEntity,
-    ClimateEntityFeature,
-    HVACAction,
-    HVACMode,
-)
-from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import SwitchbotConfigEntry
-from .entity import SwitchbotEntity, exception_handler
-
-SWITCHBOT_CLIMATE_TO_HASS_HVAC_MODE = {
-    SwitchBotClimateMode.HEAT: HVACMode.HEAT,
-    SwitchBotClimateMode.OFF: HVACMode.OFF,
-}
-
-HASS_HVAC_MODE_TO_SWITCHBOT_CLIMATE = {
-    HVACMode.HEAT: SwitchBotClimateMode.HEAT,
-    HVACMode.OFF: SwitchBotClimateMode.OFF,
-}
-
-SWITCHBOT_ACTION_TO_HASS_HVAC_ACTION = {
-    SwitchBotClimateAction.HEATING: HVACAction.HEATING,
-    SwitchBotClimateAction.IDLE: HVACAction.IDLE,
-    SwitchBotClimateAction.OFF: HVACAction.OFF,
-}
-
-_LOGGER = logging.getLogger(__name__)
-PARALLEL_UPDATES = 0
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: SwitchbotConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Switchbot climate based on a config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities([SwitchBotClimateEntity(coordinator)])
-
-
-class SwitchBotClimateEntity(SwitchbotEntity, ClimateEntity):
-    """Representation of a Switchbot Climate device."""
-
-    _device: switchbot.SwitchbotDevice
-    _attr_supported_features = (
-        ClimateEntityFeature.PRESET_MODE
-        | ClimateEntityFeature.TARGET_TEMPERATURE
-        | ClimateEntityFeature.TURN_OFF
-        | ClimateEntityFeature.TURN_ON
-    )
-    _attr_target_temperature_step = 0.5
-    _attr_temperature_unit = UnitOfTemperature.CELSIUS
-    _attr_translation_key = "climate"
-    _attr_name = None
-
-    @property
-    def min_temp(self) -> float:
-        """Return the minimum temperature."""
-        return self._device.min_temperature
-
-    @property
-    def max_temp(self) -> float:
-        """Return the maximum temperature."""
-        return self._device.max_temperature
-
-    @property
-    def preset_modes(self) -> list[str] | None:
-        """Return the list of available preset modes."""
-        return self._device.preset_modes
-
-    @property
-    def preset_mode(self) -> str | None:
-        """Return the current preset mode."""
-        return self._device.preset_mode
-
-    @property
-    def hvac_mode(self) -> HVACMode | None:
-        """Return the current HVAC mode."""
-        return SWITCHBOT_CLIMATE_TO_HASS_HVAC_MODE.get(
-            self._device.hvac_mode, HVACMode.OFF
-        )
-
-    @property
-    def hvac_modes(self) -> list[HVACMode]:
-        """Return the list of available HVAC modes."""
-        return [
-            SWITCHBOT_CLIMATE_TO_HASS_HVAC_MODE[mode]
-            for mode in self._device.hvac_modes
-        ]
-
-    @property
-    def hvac_action(self) -> HVACAction | None:
-        """Return the current HVAC action."""
-        return SWITCHBOT_ACTION_TO_HASS_HVAC_ACTION.get(
-            self._device.hvac_action, HVACAction.OFF
-        )
-
-    @property
-    def current_temperature(self) -> float | None:
-        """Return the current temperature."""
-        return self._device.current_temperature
-
-    @property
-    def target_temperature(self) -> float | None:
-        """Return the temperature we try to reach."""
-        return self._device.target_temperature
-
-    @exception_handler
-    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set new HVAC mode."""
-        return await self._device.set_hvac_mode(
-            HASS_HVAC_MODE_TO_SWITCHBOT_CLIMATE[hvac_mode]
-        )
-
-    @exception_handler
-    async def async_set_preset_mode(self, preset_mode: str) -> None:
-        """Set new preset mode."""
-        return await self._device.set_preset_mode(preset_mode)
-
-    @exception_handler
-    async def async_set_temperature(self, **kwargs: Any) -> None:
-        """Set new target temperature."""
-        temperature = kwargs.get(ATTR_TEMPERATURE)
-        return await self._device.set_target_temperature(temperature)

homeassistant/components/switchbot/const.py

@@ -58,8 +58,6 @@ class SupportedModels(StrEnum):
     K11_PLUS_VACUUM = "k11+_vacuum"
     GARAGE_DOOR_OPENER = "garage_door_opener"
     CLIMATE_PANEL = "climate_panel"
-    SMART_THERMOSTAT_RADIATOR = "smart_thermostat_radiator"
-    S20_VACUUM = "s20_vacuum"
 
 
 CONNECTABLE_SUPPORTED_MODEL_TYPES = {
@@ -80,7 +78,6 @@ CONNECTABLE_SUPPORTED_MODEL_TYPES = {
     SwitchbotModel.CIRCULATOR_FAN: SupportedModels.CIRCULATOR_FAN,
     SwitchbotModel.K20_VACUUM: SupportedModels.K20_VACUUM,
     SwitchbotModel.S10_VACUUM: SupportedModels.S10_VACUUM,
-    SwitchbotModel.S20_VACUUM: SupportedModels.S20_VACUUM,
     SwitchbotModel.K10_VACUUM: SupportedModels.K10_VACUUM,
     SwitchbotModel.K10_PRO_VACUUM: SupportedModels.K10_PRO_VACUUM,
     SwitchbotModel.K10_PRO_COMBO_VACUUM: SupportedModels.K10_PRO_COMBO_VACUUM,
@@ -98,7 +95,6 @@ CONNECTABLE_SUPPORTED_MODEL_TYPES = {
     SwitchbotModel.K11_VACUUM: SupportedModels.K11_PLUS_VACUUM,
     SwitchbotModel.GARAGE_DOOR_OPENER: SupportedModels.GARAGE_DOOR_OPENER,
     SwitchbotModel.CLIMATE_PANEL: SupportedModels.CLIMATE_PANEL,
-    SwitchbotModel.SMART_THERMOSTAT_RADIATOR: SupportedModels.SMART_THERMOSTAT_RADIATOR,
 }
 
 NON_CONNECTABLE_SUPPORTED_MODEL_TYPES = {
@@ -136,7 +132,6 @@ ENCRYPTED_MODELS = {
     SwitchbotModel.PLUG_MINI_EU,
     SwitchbotModel.RELAY_SWITCH_2PM,
     SwitchbotModel.GARAGE_DOOR_OPENER,
-    SwitchbotModel.SMART_THERMOSTAT_RADIATOR,
 }
 
 ENCRYPTED_SWITCHBOT_MODEL_TO_CLASS: dict[
@@ -158,7 +153,6 @@ ENCRYPTED_SWITCHBOT_MODEL_TO_CLASS: dict[
     SwitchbotModel.PLUG_MINI_EU: switchbot.SwitchbotRelaySwitch,
     SwitchbotModel.RELAY_SWITCH_2PM: switchbot.SwitchbotRelaySwitch2PM,
     SwitchbotModel.GARAGE_DOOR_OPENER: switchbot.SwitchbotRelaySwitch,
-    SwitchbotModel.SMART_THERMOSTAT_RADIATOR: switchbot.SwitchbotSmartThermostatRadiator,
 }
 
 HASS_SENSOR_TYPE_TO_SWITCHBOT_MODEL = {

homeassistant/components/switchbot/icons.json

@@ -1,18 +1,5 @@
 {
   "entity": {
-    "climate": {
-      "climate": {
-        "state_attributes": {
-          "preset_mode": {
-            "state": {
-              "manual": "mdi:hand-back-right",
-              "off": "mdi:hvac-off",
-              "schedule": "mdi:calendar-clock"
-            }
-          }
-        }
-      }
-    },
     "fan": {
       "air_purifier": {
         "default": "mdi:air-purifier",

homeassistant/components/switchbot/strings.json

@@ -100,19 +100,6 @@
         "name": "Unlocked alarm"
       }
     },
-    "climate": {
-      "climate": {
-        "state_attributes": {
-          "preset_mode": {
-            "state": {
-              "manual": "[%key:common::state::manual%]",
-              "off": "[%key:common::state::off%]",
-              "schedule": "Schedule"
-            }
-          }
-        }
-      }
-    },
     "cover": {
       "cover": {
         "state_attributes": {

homeassistant/components/telegram_bot/strings.json

@@ -84,7 +84,6 @@
       "abort": {
         "already_configured": "Chat already configured"
       },
-      "entry_type": "Allowed chat ID",
       "error": {
         "chat_not_found": "Chat not found"
       },

homeassistant/components/tesla_fleet/__init__.py

@@ -23,7 +23,6 @@ from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
     OAuth2Session,
     async_get_config_entry_implementation,
 )
@@ -62,11 +61,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: TeslaFleetConfigEntry) -
 
     try:
         implementation = await async_get_config_entry_implementation(hass, entry)
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
     except ValueError as e:
         # Remove invalid implementation from config entry then raise AuthFailed
         hass.config_entries.async_update_entry(

homeassistant/components/tesla_fleet/strings.json

@@ -609,9 +609,6 @@
     "no_cable": {
       "message": "Charge cable will lock automatically when connected"
     },
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    },
     "update_failed": {
       "message": "{endpoint} data request failed: {message}"
     }

homeassistant/components/tesla_wall_connector/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/tesla_wall_connector",
   "iot_class": "local_polling",
   "loggers": ["tesla_wall_connector"],
-  "requirements": ["tesla-wall-connector==1.1.0"]
+  "requirements": ["tesla-wall-connector==1.0.2"]
 }

homeassistant/components/teslemetry/update.py

@@ -237,7 +237,7 @@ class TeslemetryStreamingUpdateEntity(
         if self._download_percentage > 1 and self._download_percentage < 100:
             self._attr_in_progress = True
             self._attr_update_percentage = self._download_percentage
-        elif self._install_percentage > 10:
+        elif self._install_percentage > 1:
             self._attr_in_progress = True
             self._attr_update_percentage = self._install_percentage
         else:

homeassistant/components/toon/__init__.py

@@ -11,10 +11,8 @@ from homeassistant.const import (
     Platform,
 )
 from homeassistant.core import CoreState, HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
     OAuth2Session,
     async_get_config_entry_implementation,
 )
@@ -88,13 +86,7 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Toon from a config entry."""
-    try:
-        implementation = await async_get_config_entry_implementation(hass, entry)
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
+    implementation = await async_get_config_entry_implementation(hass, entry)
     session = OAuth2Session(hass, entry, implementation)
 
     coordinator = ToonDataUpdateCoordinator(hass, entry, session)

homeassistant/components/toon/strings.json

@@ -32,11 +32,6 @@
       }
     }
   },
-  "exceptions": {
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    }
-  },
   "services": {
     "update": {
       "description": "Updates all entities with fresh data from Toon.",

homeassistant/components/tplink/climate.py

@@ -181,14 +181,15 @@ class TPLinkClimateEntity(CoordinatedTPLinkModuleEntity, ClimateEntity):
             HVACMode.HEAT if self._thermostat_module.state else HVACMode.OFF
         )
 
-        if self._thermostat_module.mode not in STATE_TO_ACTION:
-            # Report a warning on the first non-default unknown mode
-            if self._attr_hvac_action is not HVACAction.OFF:
-                _LOGGER.warning(
-                    "Unknown thermostat state, defaulting to OFF: %s",
-                    self._thermostat_module.mode,
-                )
-                self._attr_hvac_action = HVACAction.OFF
+        if (
+            self._thermostat_module.mode not in STATE_TO_ACTION
+            and self._attr_hvac_action is not HVACAction.OFF
+        ):
+            _LOGGER.warning(
+                "Unknown thermostat state, defaulting to OFF: %s",
+                self._thermostat_module.mode,
+            )
+            self._attr_hvac_action = HVACAction.OFF
             return True
 
         self._attr_hvac_action = STATE_TO_ACTION[self._thermostat_module.mode]

homeassistant/components/transmission/services.py

@@ -2,14 +2,13 @@
 
 from functools import partial
 import logging
-from typing import cast
 
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_ID
 from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import ServiceValidationError
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, selector
 
 from .const import (
@@ -24,7 +23,7 @@ from .const import (
     SERVICE_START_TORRENT,
     SERVICE_STOP_TORRENT,
 )
-from .coordinator import TransmissionDataUpdateCoordinator
+from .coordinator import TransmissionConfigEntry, TransmissionDataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -68,52 +67,45 @@ SERVICE_STOP_TORRENT_SCHEMA = vol.All(
 
 
 def _get_coordinator_from_service_data(
-    call: ServiceCall,
+    hass: HomeAssistant, entry_id: str
 ) -> TransmissionDataUpdateCoordinator:
     """Return coordinator for entry id."""
-    config_entry_id: str = call.data[CONF_ENTRY_ID]
-    if not (entry := call.hass.config_entries.async_get_entry(config_entry_id)):
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="integration_not_found",
-            translation_placeholders={"target": DOMAIN},
-        )
-    if entry.state is not ConfigEntryState.LOADED:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="not_loaded",
-            translation_placeholders={"target": entry.title},
-        )
-    return cast(TransmissionDataUpdateCoordinator, entry.runtime_data)
+    entry: TransmissionConfigEntry | None = hass.config_entries.async_get_entry(
+        entry_id
+    )
+    if entry is None or entry.state is not ConfigEntryState.LOADED:
+        raise HomeAssistantError(f"Config entry {entry_id} is not found or not loaded")
+    return entry.runtime_data
 
 
 async def _async_add_torrent(service: ServiceCall) -> None:
     """Add new torrent to download."""
-    coordinator = _get_coordinator_from_service_data(service)
+    entry_id: str = service.data[CONF_ENTRY_ID]
+    coordinator = _get_coordinator_from_service_data(service.hass, entry_id)
     torrent: str = service.data[ATTR_TORRENT]
     download_path: str | None = service.data.get(ATTR_DOWNLOAD_PATH)
-
-    if not (
-        torrent.startswith(("http", "ftp:", "magnet:"))
-        or service.hass.config.is_allowed_path(torrent)
-    ):
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="could_not_add_torrent",
-        )
-
-    if download_path:
-        await service.hass.async_add_executor_job(
-            partial(coordinator.api.add_torrent, torrent, download_dir=download_path)
-        )
+    if torrent.startswith(
+        ("http", "ftp:", "magnet:")
+    ) or service.hass.config.is_allowed_path(torrent):
+        if download_path:
+            await service.hass.async_add_executor_job(
+                partial(
+                    coordinator.api.add_torrent, torrent, download_dir=download_path
+                )
+            )
+        else:
+            await service.hass.async_add_executor_job(
+                coordinator.api.add_torrent, torrent
+            )
+        await coordinator.async_request_refresh()
     else:
-        await service.hass.async_add_executor_job(coordinator.api.add_torrent, torrent)
-    await coordinator.async_request_refresh()
+        _LOGGER.warning("Could not add torrent: unsupported type or no permission")
 
 
 async def _async_start_torrent(service: ServiceCall) -> None:
     """Start torrent."""
-    coordinator = _get_coordinator_from_service_data(service)
+    entry_id: str = service.data[CONF_ENTRY_ID]
+    coordinator = _get_coordinator_from_service_data(service.hass, entry_id)
     torrent_id = service.data[CONF_ID]
     await service.hass.async_add_executor_job(coordinator.api.start_torrent, torrent_id)
     await coordinator.async_request_refresh()
@@ -121,7 +113,8 @@ async def _async_start_torrent(service: ServiceCall) -> None:
 
 async def _async_stop_torrent(service: ServiceCall) -> None:
     """Stop torrent."""
-    coordinator = _get_coordinator_from_service_data(service)
+    entry_id: str = service.data[CONF_ENTRY_ID]
+    coordinator = _get_coordinator_from_service_data(service.hass, entry_id)
     torrent_id = service.data[CONF_ID]
     await service.hass.async_add_executor_job(coordinator.api.stop_torrent, torrent_id)
     await coordinator.async_request_refresh()
@@ -129,7 +122,8 @@ async def _async_stop_torrent(service: ServiceCall) -> None:
 
 async def _async_remove_torrent(service: ServiceCall) -> None:
     """Remove torrent."""
-    coordinator = _get_coordinator_from_service_data(service)
+    entry_id: str = service.data[CONF_ENTRY_ID]
+    coordinator = _get_coordinator_from_service_data(service.hass, entry_id)
     torrent_id = service.data[CONF_ID]
     delete_data = service.data[ATTR_DELETE_DATA]
     await service.hass.async_add_executor_job(

homeassistant/components/transmission/services.yaml

@@ -1,7 +1,6 @@
 add_torrent:
   fields:
     entry_id:
-      required: true
       selector:
         config_entry:
           integration: transmission
@@ -19,7 +18,6 @@ add_torrent:
 remove_torrent:
   fields:
     entry_id:
-      required: true
       selector:
         config_entry:
           integration: transmission
@@ -29,7 +27,6 @@ remove_torrent:
       selector:
         text:
     delete_data:
-      required: true
       default: false
       selector:
         boolean:
@@ -37,12 +34,10 @@ remove_torrent:
 start_torrent:
   fields:
     entry_id:
-      required: true
       selector:
         config_entry:
           integration: transmission
     id:
-      required: true
       example: 123
       selector:
         text:
@@ -50,7 +45,6 @@ start_torrent:
 stop_torrent:
   fields:
     entry_id:
-      required: true
       selector:
         config_entry:
           integration: transmission

homeassistant/components/transmission/strings.json

@@ -87,17 +87,6 @@
       }
     }
   },
-  "exceptions": {
-    "could_not_add_torrent": {
-      "message": "Could not add torrent: unsupported type or no permission."
-    },
-    "integration_not_found": {
-      "message": "Integration \"{target}\" not found in registry."
-    },
-    "not_loaded": {
-      "message": "{target} is not loaded."
-    }
-  },
   "options": {
     "step": {
       "init": {

homeassistant/components/tuya/alarm_control_panel.py

@@ -19,9 +19,9 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import TuyaConfigEntry
-from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
+from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode, DPType
 from .entity import TuyaEntity
-from .models import DPCodeEnumWrapper
+from .models import EnumTypeData, find_dpcode
 from .util import get_dpcode
 
 
@@ -85,21 +85,9 @@ async def async_setup_entry(
             device = manager.device_map[device_id]
             if descriptions := ALARM.get(device.category):
                 entities.extend(
-                    TuyaAlarmEntity(
-                        device,
-                        manager,
-                        description,
-                        action_dpcode_wrapper=action_dpcode_wrapper,
-                        state_dpcode_wrapper=DPCodeEnumWrapper.find_dpcode(
-                            device, description.master_state
-                        ),
-                    )
+                    TuyaAlarmEntity(device, manager, description)
                     for description in descriptions
-                    if (
-                        action_dpcode_wrapper := DPCodeEnumWrapper.find_dpcode(
-                            device, description.key, prefer_function=True
-                        )
-                    )
+                    if description.key in device.status
                 )
         async_add_entities(entities)
 
@@ -115,6 +103,7 @@ class TuyaAlarmEntity(TuyaEntity, AlarmControlPanelEntity):
 
     _attr_name = None
     _attr_code_arm_required = False
+    _master_state: EnumTypeData | None = None
     _alarm_msg_dpcode: DPCode | None = None
 
     def __init__(
@@ -122,24 +111,33 @@ class TuyaAlarmEntity(TuyaEntity, AlarmControlPanelEntity):
         device: CustomerDevice,
         device_manager: Manager,
         description: TuyaAlarmControlPanelEntityDescription,
-        *,
-        action_dpcode_wrapper: DPCodeEnumWrapper,
-        state_dpcode_wrapper: DPCodeEnumWrapper | None,
     ) -> None:
         """Init Tuya Alarm."""
         super().__init__(device, device_manager)
         self.entity_description = description
         self._attr_unique_id = f"{super().unique_id}{description.key}"
-        self._action_dpcode_wrapper = action_dpcode_wrapper
-        self._state_dpcode_wrapper = state_dpcode_wrapper
 
         # Determine supported  modes
-        if Mode.HOME in action_dpcode_wrapper.type_information.range:
-            self._attr_supported_features |= AlarmControlPanelEntityFeature.ARM_HOME
-        if Mode.ARM in action_dpcode_wrapper.type_information.range:
-            self._attr_supported_features |= AlarmControlPanelEntityFeature.ARM_AWAY
-        if Mode.SOS in action_dpcode_wrapper.type_information.range:
-            self._attr_supported_features |= AlarmControlPanelEntityFeature.TRIGGER
+        if supported_modes := find_dpcode(
+            self.device, description.key, dptype=DPType.ENUM, prefer_function=True
+        ):
+            if Mode.HOME in supported_modes.range:
+                self._attr_supported_features |= AlarmControlPanelEntityFeature.ARM_HOME
+
+            if Mode.ARM in supported_modes.range:
+                self._attr_supported_features |= AlarmControlPanelEntityFeature.ARM_AWAY
+
+            if Mode.SOS in supported_modes.range:
+                self._attr_supported_features |= AlarmControlPanelEntityFeature.TRIGGER
+
+        # Determine master state
+        if enum_type := find_dpcode(
+            self.device,
+            description.master_state,
+            dptype=DPType.ENUM,
+            prefer_function=True,
+        ):
+            self._master_state = enum_type
 
         # Determine alarm message
         if dp_code := get_dpcode(self.device, description.alarm_msg):
@@ -151,8 +149,8 @@ class TuyaAlarmEntity(TuyaEntity, AlarmControlPanelEntity):
         # When the alarm is triggered, only its 'state' is changing. From 'normal' to 'alarm'.
         # The 'mode' doesn't change, and stays as 'arm' or 'home'.
         if (
-            self._state_dpcode_wrapper is not None
-            and self.device.status.get(self._state_dpcode_wrapper.dpcode) == State.ALARM
+            self._master_state is not None
+            and self.device.status.get(self._master_state.dpcode) == State.ALARM
         ):
             # Only report as triggered if NOT a battery warning
             if (
@@ -168,26 +166,28 @@ class TuyaAlarmEntity(TuyaEntity, AlarmControlPanelEntity):
     def changed_by(self) -> str | None:
         """Last change triggered by."""
         if (
-            self._state_dpcode_wrapper is not None
+            self._master_state is not None
             and self._alarm_msg_dpcode is not None
-            and self.device.status.get(self._state_dpcode_wrapper.dpcode) == State.ALARM
+            and self.device.status.get(self._master_state.dpcode) == State.ALARM
             and (encoded_msg := self.device.status.get(self._alarm_msg_dpcode))
         ):
             return b64decode(encoded_msg).decode("utf-16be")
         return None
 
-    async def async_alarm_disarm(self, code: str | None = None) -> None:
+    def alarm_disarm(self, code: str | None = None) -> None:
         """Send Disarm command."""
-        await self._async_send_dpcode_update(self._action_dpcode_wrapper, Mode.DISARMED)
+        self._send_command(
+            [{"code": self.entity_description.key, "value": Mode.DISARMED}]
+        )
 
-    async def async_alarm_arm_home(self, code: str | None = None) -> None:
+    def alarm_arm_home(self, code: str | None = None) -> None:
         """Send Home command."""
-        await self._async_send_dpcode_update(self._action_dpcode_wrapper, Mode.HOME)
+        self._send_command([{"code": self.entity_description.key, "value": Mode.HOME}])
 
-    async def async_alarm_arm_away(self, code: str | None = None) -> None:
+    def alarm_arm_away(self, code: str | None = None) -> None:
         """Send Arm command."""
-        await self._async_send_dpcode_update(self._action_dpcode_wrapper, Mode.ARM)
+        self._send_command([{"code": self.entity_description.key, "value": Mode.ARM}])
 
-    async def async_alarm_trigger(self, code: str | None = None) -> None:
+    def alarm_trigger(self, code: str | None = None) -> None:
         """Send SOS command."""
-        await self._async_send_dpcode_update(self._action_dpcode_wrapper, Mode.SOS)
+        self._send_command([{"code": self.entity_description.key, "value": Mode.SOS}])

homeassistant/components/tuya/diagnostics.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
-from typing import Any
+from contextlib import suppress
+import json
+from typing import Any, cast
 
 from tuya_sharing import CustomerDevice
 
@@ -99,20 +101,30 @@ def _async_device_as_dict(
             data["status"][dpcode] = REDACTED
             continue
 
+        with suppress(ValueError, TypeError):
+            value = json.loads(value)
         data["status"][dpcode] = value
 
     # Gather Tuya functions
     for function in device.function.values():
+        value = function.values
+        with suppress(ValueError, TypeError, AttributeError):
+            value = json.loads(cast(str, function.values))
+
         data["function"][function.code] = {
             "type": function.type,
-            "value": function.values,
+            "value": value,
         }
 
     # Gather Tuya status ranges
     for status_range in device.status_range.values():
+        value = status_range.values
+        with suppress(ValueError, TypeError, AttributeError):
+            value = json.loads(status_range.values)
+
         data["status_range"][status_range.code] = {
             "type": status_range.type,
-            "value": status_range.values,
+            "value": value,
         }
 
     # Gather information how this Tuya device is represented in Home Assistant

homeassistant/components/tuya/light.py

@@ -24,7 +24,6 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import color as color_util
-from homeassistant.util.json import json_loads_object
 
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode, DPType, WorkMode
@@ -500,11 +499,11 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
                 values = self.device.status_range[dpcode].values
 
             # Fetch color data type information
-            if function_data := json_loads_object(values):
+            if function_data := json.loads(values):
                 self._color_data_type = ColorTypeData(
-                    h_type=IntegerTypeData(dpcode, **cast(dict, function_data["h"])),
-                    s_type=IntegerTypeData(dpcode, **cast(dict, function_data["s"])),
-                    v_type=IntegerTypeData(dpcode, **cast(dict, function_data["v"])),
+                    h_type=IntegerTypeData(dpcode, **function_data["h"]),
+                    s_type=IntegerTypeData(dpcode, **function_data["s"]),
+                    v_type=IntegerTypeData(dpcode, **function_data["v"]),
                 )
             else:
                 # If no type is found, use a default one
@@ -771,12 +770,12 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
         if not (status_data := self.device.status[self._color_data_dpcode]):
             return None
 
-        if not (status := json_loads_object(status_data)):
+        if not (status := json.loads(status_data)):
             return None
 
         return ColorData(
             type_data=self._color_data_type,
-            h_value=cast(int, status["h"]),
-            s_value=cast(int, status["s"]),
-            v_value=cast(int, status["v"]),
+            h_value=status["h"],
+            s_value=status["s"],
+            v_value=status["v"],
         )

homeassistant/components/tuya/models.py

@@ -5,14 +5,14 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import base64
 from dataclasses import dataclass
-from typing import Any, Literal, Self, cast, overload
+import json
+import struct
+from typing import Any, Literal, Self, overload
 
 from tuya_sharing import CustomerDevice
 
-from homeassistant.util.json import json_loads, json_loads_object
-
 from .const import DPCode, DPType
-from .util import parse_dptype, remap_value
+from .util import remap_value
 
 
 @dataclass
@@ -87,7 +87,7 @@ class IntegerTypeData(TypeInformation):
     @classmethod
     def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
         """Load JSON string and return a IntegerTypeData object."""
-        if not (parsed := cast(dict[str, Any] | None, json_loads_object(data))):
+        if not (parsed := json.loads(data)):
             return None
 
         return cls(
@@ -110,9 +110,9 @@ class BitmapTypeInformation(TypeInformation):
     @classmethod
     def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
         """Load JSON string and return a BitmapTypeInformation object."""
-        if not (parsed := json_loads_object(data)):
+        if not (parsed := json.loads(data)):
             return None
-        return cls(dpcode, **cast(dict[str, list[str]], parsed))
+        return cls(dpcode, **parsed)
 
 
 @dataclass
@@ -124,9 +124,9 @@ class EnumTypeData(TypeInformation):
     @classmethod
     def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
         """Load JSON string and return a EnumTypeData object."""
-        if not (parsed := json_loads_object(data)):
+        if not (parsed := json.loads(data)):
             return None
-        return cls(dpcode, **cast(dict[str, list[str]], parsed))
+        return cls(dpcode, **parsed)
 
 
 _TYPE_INFORMATION_MAPPINGS: dict[DPType, type[TypeInformation]] = {
@@ -134,8 +134,6 @@ _TYPE_INFORMATION_MAPPINGS: dict[DPType, type[TypeInformation]] = {
     DPType.BOOLEAN: TypeInformation,
     DPType.ENUM: EnumTypeData,
     DPType.INTEGER: IntegerTypeData,
-    DPType.JSON: TypeInformation,
-    DPType.RAW: TypeInformation,
 }
 
 
@@ -146,9 +144,6 @@ class DPCodeWrapper(ABC):
     access read conversion routines.
     """
 
-    native_unit: str | None = None
-    suggested_unit: str | None = None
-
     def __init__(self, dpcode: str) -> None:
         """Init DPCodeWrapper."""
         self.dpcode = dpcode
@@ -201,7 +196,7 @@ class DPCodeTypeInformationWrapper[T: TypeInformation](DPCodeWrapper):
     def find_dpcode(
         cls,
         device: CustomerDevice,
-        dpcodes: str | DPCode | tuple[DPCode, ...] | None,
+        dpcodes: str | DPCode | tuple[DPCode, ...],
         *,
         prefer_function: bool = False,
     ) -> Self | None:
@@ -215,20 +210,6 @@ class DPCodeTypeInformationWrapper[T: TypeInformation](DPCodeWrapper):
         return None
 
 
-class DPCodeBase64Wrapper(DPCodeTypeInformationWrapper[TypeInformation]):
-    """Wrapper to extract information from a RAW/binary value."""
-
-    DPTYPE = DPType.RAW
-
-    def read_bytes(self, device: CustomerDevice) -> bytes | None:
-        """Read the device value for the dpcode."""
-        if (raw_value := self._read_device_status_raw(device)) is None or (
-            len(decoded := base64.b64decode(raw_value)) == 0
-        ):
-            return None
-        return decoded
-
-
 class DPCodeBooleanWrapper(DPCodeTypeInformationWrapper[TypeInformation]):
     """Simple wrapper for boolean values.
 
@@ -254,18 +235,6 @@ class DPCodeBooleanWrapper(DPCodeTypeInformationWrapper[TypeInformation]):
         raise ValueError(f"Invalid boolean value `{value}`")
 
 
-class DPCodeJsonWrapper(DPCodeTypeInformationWrapper[TypeInformation]):
-    """Wrapper to extract information from a JSON value."""
-
-    DPTYPE = DPType.JSON
-
-    def read_json(self, device: CustomerDevice) -> Any | None:
-        """Read the device value for the dpcode."""
-        if (raw_value := self._read_device_status_raw(device)) is None:
-            return None
-        return json_loads(raw_value)
-
-
 class DPCodeEnumWrapper(DPCodeTypeInformationWrapper[EnumTypeData]):
     """Simple wrapper for EnumTypeData values."""
 
@@ -299,11 +268,6 @@ class DPCodeIntegerWrapper(DPCodeTypeInformationWrapper[IntegerTypeData]):
 
     DPTYPE = DPType.INTEGER
 
-    def __init__(self, dpcode: str, type_information: IntegerTypeData) -> None:
-        """Init DPCodeIntegerWrapper."""
-        super().__init__(dpcode, type_information)
-        self.native_unit = type_information.unit
-
     def read_device_status(self, device: CustomerDevice) -> float | None:
         """Read the device value for the dpcode.
 
@@ -388,16 +352,6 @@ def find_dpcode(
 ) -> IntegerTypeData | None: ...
 
 
-@overload
-def find_dpcode(
-    device: CustomerDevice,
-    dpcodes: str | DPCode | tuple[DPCode, ...] | None,
-    *,
-    prefer_function: bool = False,
-    dptype: Literal[DPType.BOOLEAN, DPType.JSON, DPType.RAW],
-) -> TypeInformation | None: ...
-
-
 def find_dpcode(
     device: CustomerDevice,
     dpcodes: str | DPCode | tuple[DPCode, ...] | None,
@@ -427,7 +381,7 @@ def find_dpcode(
         for device_specs in lookup_tuple:
             if (
                 (current_definition := device_specs.get(dpcode))
-                and parse_dptype(current_definition.type) is dptype
+                and current_definition.type == dptype
                 and (
                     type_information := type_information_cls.from_json(
                         dpcode, current_definition.values
@@ -437,3 +391,44 @@ def find_dpcode(
                 return type_information
 
     return None
+
+
+class ComplexValue:
+    """Complex value (for JSON/RAW parsing)."""
+
+    @classmethod
+    def from_json(cls, data: str) -> Self:
+        """Load JSON string and return a ComplexValue object."""
+        raise NotImplementedError("from_json is not implemented for this type")
+
+    @classmethod
+    def from_raw(cls, data: str) -> Self | None:
+        """Decode base64 string and return a ComplexValue object."""
+        raise NotImplementedError("from_raw is not implemented for this type")
+
+
+@dataclass
+class ElectricityValue(ComplexValue):
+    """Electricity complex value."""
+
+    electriccurrent: str | None = None
+    power: str | None = None
+    voltage: str | None = None
+
+    @classmethod
+    def from_json(cls, data: str) -> Self:
+        """Load JSON string and return a ElectricityValue object."""
+        return cls(**json.loads(data.lower()))
+
+    @classmethod
+    def from_raw(cls, data: str) -> Self | None:
+        """Decode base64 string and return a ElectricityValue object."""
+        raw = base64.b64decode(data)
+        if len(raw) == 0:
+            return None
+        voltage = struct.unpack(">H", raw[0:2])[0] / 10.0
+        electriccurrent = struct.unpack(">L", b"\x00" + raw[2:5])[0] / 1000.0
+        power = struct.unpack(">L", b"\x00" + raw[5:8])[0] / 1000.0
+        return cls(
+            electriccurrent=str(electriccurrent), power=str(power), voltage=str(voltage)
+        )

homeassistant/components/tuya/number.py

@@ -502,19 +502,14 @@ class TuyaNumberEntity(TuyaEntity, NumberEntity):
         self._attr_native_min_value = dpcode_wrapper.type_information.min_scaled
         self._attr_native_step = dpcode_wrapper.type_information.step_scaled
         if description.native_unit_of_measurement is None:
-            self._attr_native_unit_of_measurement = dpcode_wrapper.native_unit
-
-        self._validate_device_class_unit()
-
-    def _validate_device_class_unit(self) -> None:
-        """Validate device class unit compatibility."""
+            self._attr_native_unit_of_measurement = dpcode_wrapper.type_information.unit
 
         # Logic to ensure the set device class and API received Unit Of Measurement
         # match Home Assistants requirements.
         if (
             self.device_class is not None
             and not self.device_class.startswith(DOMAIN)
-            and self.entity_description.native_unit_of_measurement is None
+            and description.native_unit_of_measurement is None
             # we do not need to check mappings if the API UOM is allowed
             and self.native_unit_of_measurement
             not in NUMBER_DEVICE_CLASS_UNITS[self.device_class]

homeassistant/components/tuya/sensor.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-import struct
+from typing import Any
 
 from tuya_sharing import CustomerDevice, Manager
 
@@ -41,134 +42,41 @@ from .const import (
 )
 from .entity import TuyaEntity
 from .models import (
-    DPCodeBase64Wrapper,
-    DPCodeEnumWrapper,
-    DPCodeIntegerWrapper,
-    DPCodeJsonWrapper,
-    DPCodeTypeInformationWrapper,
-    DPCodeWrapper,
+    ComplexValue,
+    ElectricityValue,
     EnumTypeData,
+    IntegerTypeData,
+    find_dpcode,
 )
+from .util import get_dptype
 
-
-class _WindDirectionWrapper(DPCodeTypeInformationWrapper[EnumTypeData]):
-    """Custom DPCode Wrapper for converting enum to wind direction."""
-
-    DPTYPE = DPType.ENUM
-
-    _WIND_DIRECTIONS = {
-        "north": 0.0,
-        "north_north_east": 22.5,
-        "north_east": 45.0,
-        "east_north_east": 67.5,
-        "east": 90.0,
-        "east_south_east": 112.5,
-        "south_east": 135.0,
-        "south_south_east": 157.5,
-        "south": 180.0,
-        "south_south_west": 202.5,
-        "south_west": 225.0,
-        "west_south_west": 247.5,
-        "west": 270.0,
-        "west_north_west": 292.5,
-        "north_west": 315.0,
-        "north_north_west": 337.5,
-    }
-
-    def read_device_status(self, device: CustomerDevice) -> float | None:
-        """Read the device value for the dpcode."""
-        if (
-            raw_value := self._read_device_status_raw(device)
-        ) in self.type_information.range:
-            return self._WIND_DIRECTIONS.get(raw_value)
-        return None
-
-
-class _JsonElectricityCurrentWrapper(DPCodeJsonWrapper):
-    """Custom DPCode Wrapper for extracting electricity current from JSON."""
-
-    native_unit = UnitOfElectricCurrent.AMPERE
-
-    def read_device_status(self, device: CustomerDevice) -> float | None:
-        """Read the device value for the dpcode."""
-        if (raw_value := super().read_json(device)) is None:
-            return None
-        return raw_value.get("electricCurrent")
-
-
-class _JsonElectricityPowerWrapper(DPCodeJsonWrapper):
-    """Custom DPCode Wrapper for extracting electricity power from JSON."""
-
-    native_unit = UnitOfPower.KILO_WATT
-
-    def read_device_status(self, device: CustomerDevice) -> float | None:
-        """Read the device value for the dpcode."""
-        if (raw_value := super().read_json(device)) is None:
-            return None
-        return raw_value.get("power")
-
-
-class _JsonElectricityVoltageWrapper(DPCodeJsonWrapper):
-    """Custom DPCode Wrapper for extracting electricity voltage from JSON."""
-
-    native_unit = UnitOfElectricPotential.VOLT
-
-    def read_device_status(self, device: CustomerDevice) -> float | None:
-        """Read the device value for the dpcode."""
-        if (raw_value := super().read_json(device)) is None:
-            return None
-        return raw_value.get("voltage")
-
-
-class _RawElectricityCurrentWrapper(DPCodeBase64Wrapper):
-    """Custom DPCode Wrapper for extracting electricity current from base64."""
-
-    native_unit = UnitOfElectricCurrent.MILLIAMPERE
-    suggested_unit = UnitOfElectricCurrent.AMPERE
-
-    def read_device_status(self, device: CustomerDevice) -> float | None:
-        """Read the device value for the dpcode."""
-        if (raw_value := super().read_bytes(device)) is None:
-            return None
-        return struct.unpack(">L", b"\x00" + raw_value[2:5])[0]
-
-
-class _RawElectricityPowerWrapper(DPCodeBase64Wrapper):
-    """Custom DPCode Wrapper for extracting electricity power from base64."""
-
-    native_unit = UnitOfPower.WATT
-    suggested_unit = UnitOfPower.KILO_WATT
-
-    def read_device_status(self, device: CustomerDevice) -> float | None:
-        """Read the device value for the dpcode."""
-        if (raw_value := super().read_bytes(device)) is None:
-            return None
-        return struct.unpack(">L", b"\x00" + raw_value[5:8])[0]
-
-
-class _RawElectricityVoltageWrapper(DPCodeBase64Wrapper):
-    """Custom DPCode Wrapper for extracting electricity voltage from base64."""
-
-    native_unit = UnitOfElectricPotential.VOLT
-
-    def read_device_status(self, device: CustomerDevice) -> float | None:
-        """Read the device value for the dpcode."""
-        if (raw_value := super().read_bytes(device)) is None:
-            return None
-        return struct.unpack(">H", raw_value[0:2])[0] / 10.0
-
-
-CURRENT_WRAPPER = (_RawElectricityCurrentWrapper, _JsonElectricityCurrentWrapper)
-POWER_WRAPPER = (_RawElectricityPowerWrapper, _JsonElectricityPowerWrapper)
-VOLTAGE_WRAPPER = (_RawElectricityVoltageWrapper, _JsonElectricityVoltageWrapper)
+_WIND_DIRECTIONS = {
+    "north": 0.0,
+    "north_north_east": 22.5,
+    "north_east": 45.0,
+    "east_north_east": 67.5,
+    "east": 90.0,
+    "east_south_east": 112.5,
+    "south_east": 135.0,
+    "south_south_east": 157.5,
+    "south": 180.0,
+    "south_south_west": 202.5,
+    "south_west": 225.0,
+    "west_south_west": 247.5,
+    "west": 270.0,
+    "west_north_west": 292.5,
+    "north_west": 315.0,
+    "north_north_west": 337.5,
+}
 
 
 @dataclass(frozen=True)
 class TuyaSensorEntityDescription(SensorEntityDescription):
     """Describes Tuya sensor entity."""
 
-    dpcode: DPCode | None = None
-    wrapper_class: tuple[type[DPCodeTypeInformationWrapper], ...] | None = None
+    complex_type: type[ComplexValue] | None = None
+    subkey: str | None = None
+    state_conversion: Callable[[Any], StateType] | None = None
 
 
 # Commonly used battery sensors, that are reused in the sensors down below.
@@ -486,76 +394,85 @@ SENSORS: dict[DeviceCategory, tuple[TuyaSensorEntityDescription, ...]] = {
             state_class=SensorStateClass.MEASUREMENT,
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_A}electriccurrent",
-            dpcode=DPCode.PHASE_A,
+            key=DPCode.PHASE_A,
             translation_key="phase_a_current",
             device_class=SensorDeviceClass.CURRENT,
+            native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=CURRENT_WRAPPER,
+            complex_type=ElectricityValue,
+            subkey="electriccurrent",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_A}power",
-            dpcode=DPCode.PHASE_A,
+            key=DPCode.PHASE_A,
             translation_key="phase_a_power",
             device_class=SensorDeviceClass.POWER,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=POWER_WRAPPER,
+            native_unit_of_measurement=UnitOfPower.KILO_WATT,
+            complex_type=ElectricityValue,
+            subkey="power",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_A}voltage",
-            dpcode=DPCode.PHASE_A,
+            key=DPCode.PHASE_A,
             translation_key="phase_a_voltage",
             device_class=SensorDeviceClass.VOLTAGE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=VOLTAGE_WRAPPER,
+            native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            complex_type=ElectricityValue,
+            subkey="voltage",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_B}electriccurrent",
-            dpcode=DPCode.PHASE_B,
+            key=DPCode.PHASE_B,
             translation_key="phase_b_current",
             device_class=SensorDeviceClass.CURRENT,
+            native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=CURRENT_WRAPPER,
+            complex_type=ElectricityValue,
+            subkey="electriccurrent",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_B}power",
-            dpcode=DPCode.PHASE_B,
+            key=DPCode.PHASE_B,
             translation_key="phase_b_power",
             device_class=SensorDeviceClass.POWER,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=POWER_WRAPPER,
+            native_unit_of_measurement=UnitOfPower.KILO_WATT,
+            complex_type=ElectricityValue,
+            subkey="power",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_B}voltage",
-            dpcode=DPCode.PHASE_B,
+            key=DPCode.PHASE_B,
             translation_key="phase_b_voltage",
             device_class=SensorDeviceClass.VOLTAGE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=VOLTAGE_WRAPPER,
+            native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            complex_type=ElectricityValue,
+            subkey="voltage",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_C}electriccurrent",
-            dpcode=DPCode.PHASE_C,
+            key=DPCode.PHASE_C,
             translation_key="phase_c_current",
             device_class=SensorDeviceClass.CURRENT,
+            native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=CURRENT_WRAPPER,
+            complex_type=ElectricityValue,
+            subkey="electriccurrent",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_C}power",
-            dpcode=DPCode.PHASE_C,
+            key=DPCode.PHASE_C,
             translation_key="phase_c_power",
             device_class=SensorDeviceClass.POWER,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=POWER_WRAPPER,
+            native_unit_of_measurement=UnitOfPower.KILO_WATT,
+            complex_type=ElectricityValue,
+            subkey="power",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_C}voltage",
-            dpcode=DPCode.PHASE_C,
+            key=DPCode.PHASE_C,
             translation_key="phase_c_voltage",
             device_class=SensorDeviceClass.VOLTAGE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=VOLTAGE_WRAPPER,
+            native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            complex_type=ElectricityValue,
+            subkey="voltage",
         ),
         TuyaSensorEntityDescription(
             key=DPCode.CUR_CURRENT,
@@ -1055,7 +972,7 @@ SENSORS: dict[DeviceCategory, tuple[TuyaSensorEntityDescription, ...]] = {
             translation_key="wind_direction",
             device_class=SensorDeviceClass.WIND_DIRECTION,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=(_WindDirectionWrapper,),
+            state_conversion=lambda state: _WIND_DIRECTIONS.get(str(state)),
         ),
         TuyaSensorEntityDescription(
             key=DPCode.DEW_POINT_TEMP,
@@ -1568,11 +1485,12 @@ SENSORS: dict[DeviceCategory, tuple[TuyaSensorEntityDescription, ...]] = {
             state_class=SensorStateClass.MEASUREMENT,
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.TOTAL_POWER}power",
-            dpcode=DPCode.TOTAL_POWER,
+            key=DPCode.TOTAL_POWER,
             translation_key="total_power",
             device_class=SensorDeviceClass.POWER,
             state_class=SensorStateClass.MEASUREMENT,
+            complex_type=ElectricityValue,
+            subkey="power",
         ),
         TuyaSensorEntityDescription(
             key=DPCode.SUPPLY_FREQUENCY,
@@ -1582,76 +1500,85 @@ SENSORS: dict[DeviceCategory, tuple[TuyaSensorEntityDescription, ...]] = {
             state_class=SensorStateClass.MEASUREMENT,
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_A}electriccurrent",
-            dpcode=DPCode.PHASE_A,
+            key=DPCode.PHASE_A,
             translation_key="phase_a_current",
             device_class=SensorDeviceClass.CURRENT,
+            native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=CURRENT_WRAPPER,
+            complex_type=ElectricityValue,
+            subkey="electriccurrent",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_A}power",
-            dpcode=DPCode.PHASE_A,
+            key=DPCode.PHASE_A,
             translation_key="phase_a_power",
             device_class=SensorDeviceClass.POWER,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=POWER_WRAPPER,
+            native_unit_of_measurement=UnitOfPower.KILO_WATT,
+            complex_type=ElectricityValue,
+            subkey="power",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_A}voltage",
-            dpcode=DPCode.PHASE_A,
+            key=DPCode.PHASE_A,
             translation_key="phase_a_voltage",
             device_class=SensorDeviceClass.VOLTAGE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=VOLTAGE_WRAPPER,
+            native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            complex_type=ElectricityValue,
+            subkey="voltage",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_B}electriccurrent",
-            dpcode=DPCode.PHASE_B,
+            key=DPCode.PHASE_B,
             translation_key="phase_b_current",
             device_class=SensorDeviceClass.CURRENT,
+            native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=CURRENT_WRAPPER,
+            complex_type=ElectricityValue,
+            subkey="electriccurrent",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_B}power",
-            dpcode=DPCode.PHASE_B,
+            key=DPCode.PHASE_B,
             translation_key="phase_b_power",
             device_class=SensorDeviceClass.POWER,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=POWER_WRAPPER,
+            native_unit_of_measurement=UnitOfPower.KILO_WATT,
+            complex_type=ElectricityValue,
+            subkey="power",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_B}voltage",
-            dpcode=DPCode.PHASE_B,
+            key=DPCode.PHASE_B,
             translation_key="phase_b_voltage",
             device_class=SensorDeviceClass.VOLTAGE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=VOLTAGE_WRAPPER,
+            native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            complex_type=ElectricityValue,
+            subkey="voltage",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_C}electriccurrent",
-            dpcode=DPCode.PHASE_C,
+            key=DPCode.PHASE_C,
             translation_key="phase_c_current",
             device_class=SensorDeviceClass.CURRENT,
+            native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=CURRENT_WRAPPER,
+            complex_type=ElectricityValue,
+            subkey="electriccurrent",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_C}power",
-            dpcode=DPCode.PHASE_C,
+            key=DPCode.PHASE_C,
             translation_key="phase_c_power",
             device_class=SensorDeviceClass.POWER,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=POWER_WRAPPER,
+            native_unit_of_measurement=UnitOfPower.KILO_WATT,
+            complex_type=ElectricityValue,
+            subkey="power",
         ),
         TuyaSensorEntityDescription(
-            key=f"{DPCode.PHASE_C}voltage",
-            dpcode=DPCode.PHASE_C,
+            key=DPCode.PHASE_C,
             translation_key="phase_c_voltage",
             device_class=SensorDeviceClass.VOLTAGE,
             state_class=SensorStateClass.MEASUREMENT,
-            wrapper_class=VOLTAGE_WRAPPER,
+            native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            complex_type=ElectricityValue,
+            subkey="voltage",
         ),
     ),
     DeviceCategory.ZNNBQ: (
@@ -1712,27 +1639,6 @@ SENSORS[DeviceCategory.DGHSXJ] = SENSORS[DeviceCategory.SP]
 SENSORS[DeviceCategory.PC] = SENSORS[DeviceCategory.KG]
 
 
-def _get_dpcode_wrapper(
-    device: CustomerDevice,
-    description: TuyaSensorEntityDescription,
-) -> DPCodeWrapper | None:
-    """Get DPCode wrapper for an entity description."""
-    dpcode = description.dpcode or description.key
-    wrapper: DPCodeWrapper | None
-
-    if description.wrapper_class:
-        for cls in description.wrapper_class:
-            if wrapper := cls.find_dpcode(device, dpcode):
-                return wrapper
-        return None
-
-    for cls in (DPCodeIntegerWrapper, DPCodeEnumWrapper):
-        if wrapper := cls.find_dpcode(device, dpcode):
-            return wrapper
-
-    return None
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: TuyaConfigEntry,
@@ -1749,9 +1655,9 @@ async def async_setup_entry(
             device = manager.device_map[device_id]
             if descriptions := SENSORS.get(device.category):
                 entities.extend(
-                    TuyaSensorEntity(device, manager, description, dpcode_wrapper)
+                    TuyaSensorEntity(device, manager, description)
                     for description in descriptions
-                    if (dpcode_wrapper := _get_dpcode_wrapper(device, description))
+                    if description.key in device.status
                 )
 
         async_add_entities(entities)
@@ -1767,25 +1673,35 @@ class TuyaSensorEntity(TuyaEntity, SensorEntity):
     """Tuya Sensor Entity."""
 
     entity_description: TuyaSensorEntityDescription
-    _dpcode_wrapper: DPCodeWrapper
+
+    _type: DPType | None = None
+    _type_data: IntegerTypeData | EnumTypeData | None = None
 
     def __init__(
         self,
         device: CustomerDevice,
         device_manager: Manager,
         description: TuyaSensorEntityDescription,
-        dpcode_wrapper: DPCodeWrapper,
     ) -> None:
         """Init Tuya sensor."""
         super().__init__(device, device_manager)
         self.entity_description = description
-        self._attr_unique_id = f"{super().unique_id}{description.key}"
-        self._dpcode_wrapper = dpcode_wrapper
+        self._attr_unique_id = (
+            f"{super().unique_id}{description.key}{description.subkey or ''}"
+        )
 
-        if description.native_unit_of_measurement is None:
-            self._attr_native_unit_of_measurement = dpcode_wrapper.native_unit
-        if description.suggested_unit_of_measurement is None:
-            self._attr_suggested_unit_of_measurement = dpcode_wrapper.suggested_unit
+        if int_type := find_dpcode(self.device, description.key, dptype=DPType.INTEGER):
+            self._type_data = int_type
+            self._type = DPType.INTEGER
+            if description.native_unit_of_measurement is None:
+                self._attr_native_unit_of_measurement = int_type.unit
+        elif enum_type := find_dpcode(
+            self.device, description.key, dptype=DPType.ENUM, prefer_function=True
+        ):
+            self._type_data = enum_type
+            self._type = DPType.ENUM
+        else:
+            self._type = get_dptype(self.device, DPCode(description.key))
 
         self._validate_device_class_unit()
 
@@ -1836,4 +1752,55 @@ class TuyaSensorEntity(TuyaEntity, SensorEntity):
     @property
     def native_value(self) -> StateType:
         """Return the value reported by the sensor."""
-        return self._dpcode_wrapper.read_device_status(self.device)
+        # Only continue if data type is known
+        if self._type not in (
+            DPType.INTEGER,
+            DPType.STRING,
+            DPType.ENUM,
+            DPType.JSON,
+            DPType.RAW,
+        ):
+            return None
+
+        # Raw value
+        value = self.device.status.get(self.entity_description.key)
+        if value is None:
+            return None
+
+        # Convert value, if required
+        if (convert := self.entity_description.state_conversion) is not None:
+            return convert(value)
+
+        # Scale integer/float value
+        if isinstance(self._type_data, IntegerTypeData):
+            return self._type_data.scale_value(value)
+
+        # Unexpected enum value
+        if (
+            isinstance(self._type_data, EnumTypeData)
+            and value not in self._type_data.range
+        ):
+            return None
+
+        # Get subkey value from Json string.
+        if self._type is DPType.JSON:
+            if (
+                self.entity_description.complex_type is None
+                or self.entity_description.subkey is None
+            ):
+                return None
+            values = self.entity_description.complex_type.from_json(value)
+            return getattr(values, self.entity_description.subkey)
+
+        if self._type is DPType.RAW:
+            if (
+                self.entity_description.complex_type is None
+                or self.entity_description.subkey is None
+                or (raw_values := self.entity_description.complex_type.from_raw(value))
+                is None
+            ):
+                return None
+            return getattr(raw_values, self.entity_description.subkey)
+
+        # Valid string or enum value
+        return value

homeassistant/components/tuya/siren.py

@@ -19,7 +19,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import DPCodeBooleanWrapper
 
 SIRENS: dict[DeviceCategory, tuple[SirenEntityDescription, ...]] = {
     DeviceCategory.CO2BJ: (
@@ -65,13 +64,9 @@ async def async_setup_entry(
             device = manager.device_map[device_id]
             if descriptions := SIRENS.get(device.category):
                 entities.extend(
-                    TuyaSirenEntity(device, manager, description, dpcode_wrapper)
+                    TuyaSirenEntity(device, manager, description)
                     for description in descriptions
-                    if (
-                        dpcode_wrapper := DPCodeBooleanWrapper.find_dpcode(
-                            device, description.key, prefer_function=True
-                        )
-                    )
+                    if description.key in device.status
                 )
 
         async_add_entities(entities)
@@ -94,23 +89,21 @@ class TuyaSirenEntity(TuyaEntity, SirenEntity):
         device: CustomerDevice,
         device_manager: Manager,
         description: SirenEntityDescription,
-        dpcode_wrapper: DPCodeBooleanWrapper,
     ) -> None:
         """Init Tuya Siren."""
         super().__init__(device, device_manager)
         self.entity_description = description
         self._attr_unique_id = f"{super().unique_id}{description.key}"
-        self._dpcode_wrapper = dpcode_wrapper
 
     @property
-    def is_on(self) -> bool | None:
+    def is_on(self) -> bool:
         """Return true if siren is on."""
-        return self._dpcode_wrapper.read_device_status(self.device)
+        return self.device.status.get(self.entity_description.key, False)
 
-    async def async_turn_on(self, **kwargs: Any) -> None:
+    def turn_on(self, **kwargs: Any) -> None:
         """Turn the siren on."""
-        await self._async_send_dpcode_update(self._dpcode_wrapper, True)
+        self._send_command([{"code": self.entity_description.key, "value": True}])
 
-    async def async_turn_off(self, **kwargs: Any) -> None:
+    def turn_off(self, **kwargs: Any) -> None:
         """Turn the siren off."""
-        await self._async_send_dpcode_update(self._dpcode_wrapper, False)
+        self._send_command([{"code": self.entity_description.key, "value": False}])

homeassistant/components/tuya/util.py

@@ -42,16 +42,6 @@ def get_dpcode(
     return None
 
 
-def parse_dptype(dptype: str) -> DPType | None:
-    """Parse DPType from device DPCode information."""
-    try:
-        return DPType(dptype)
-    except ValueError:
-        # Sometimes, we get ill-formed DPTypes from the cloud,
-        # this fixes them and maps them to the correct DPType.
-        return _DPTYPE_MAPPING.get(dptype)
-
-
 def get_dptype(
     device: CustomerDevice, dpcode: DPCode | None, *, prefer_function: bool = False
 ) -> DPType | None:
@@ -67,7 +57,13 @@ def get_dptype(
 
     for device_specs in lookup_tuple:
         if current_definition := device_specs.get(dpcode):
-            return parse_dptype(current_definition.type)
+            current_type = current_definition.type
+            try:
+                return DPType(current_type)
+            except ValueError:
+                # Sometimes, we get ill-formed DPTypes from the cloud,
+                # this fixes them and maps them to the correct DPType.
+                return _DPTYPE_MAPPING.get(current_type)
 
     return None
 

homeassistant/components/twitch/strings.json

@@ -61,7 +61,7 @@
   },
   "exceptions": {
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     }
   }
 }

homeassistant/components/ukraine_alarm/__init__.py

@@ -2,23 +2,13 @@
 
 from __future__ import annotations
 
-import logging
-from typing import TYPE_CHECKING
-
-import aiohttp
-from uasiren.client import Client
-
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_NAME, CONF_REGION
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import issue_registry as ir
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .const import DOMAIN, PLATFORMS
 from .coordinator import UkraineAlarmDataUpdateCoordinator
 
-_LOGGER = logging.getLogger(__name__)
-
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Ukraine Alarm as config entry."""
@@ -40,56 +30,3 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         hass.data[DOMAIN].pop(entry.entry_id)
 
     return unload_ok
-
-
-async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
-    """Migrate old entry."""
-    _LOGGER.debug("Migrating from version %s", config_entry.version)
-
-    if config_entry.version == 1:
-        # Version 1 had states as first-class selections
-        # Version 2 only allows states w/o districts, districts and communities
-        region_id = config_entry.data[CONF_REGION]
-
-        websession = async_get_clientsession(hass)
-        try:
-            regions_data = await Client(websession).get_regions()
-        except (aiohttp.ClientError, TimeoutError) as err:
-            _LOGGER.warning(
-                "Could not migrate config entry %s: failed to fetch current regions: %s",
-                config_entry.entry_id,
-                err,
-            )
-            return False
-
-        if TYPE_CHECKING:
-            assert isinstance(regions_data, dict)
-
-        state_with_districts = None
-        for state in regions_data["states"]:
-            if state["regionId"] == region_id and state.get("regionChildIds"):
-                state_with_districts = state
-                break
-
-        if state_with_districts:
-            ir.async_create_issue(
-                hass,
-                DOMAIN,
-                f"deprecated_state_region_{config_entry.entry_id}",
-                is_fixable=False,
-                issue_domain=DOMAIN,
-                severity=ir.IssueSeverity.WARNING,
-                translation_key="deprecated_state_region",
-                translation_placeholders={
-                    "region_name": config_entry.data.get(CONF_NAME, region_id),
-                },
-            )
-
-            return False
-
-        hass.config_entries.async_update_entry(config_entry, version=2)
-        _LOGGER.info("Migration to version %s successful", 2)
-        return True
-
-    _LOGGER.error("Unknown version %s", config_entry.version)
-    return False

homeassistant/components/ukraine_alarm/config_flow.py

@@ -21,7 +21,7 @@ _LOGGER = logging.getLogger(__name__)
 class UkraineAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
     """Config flow for Ukraine Alarm."""
 
-    VERSION = 2
+    VERSION = 1
 
     def __init__(self) -> None:
         """Initialize a new UkraineAlarmConfigFlow."""
@@ -112,7 +112,7 @@ class UkraineAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
             return await self._async_finish_flow()
 
         regions = {}
-        if self.selected_region and step_id != "district":
+        if self.selected_region:
             regions[self.selected_region["regionId"]] = self.selected_region[
                 "regionName"
             ]

homeassistant/components/ukraine_alarm/strings.json

@@ -13,19 +13,19 @@
         "data": {
           "region": "[%key:component::ukraine_alarm::config::step::user::data::region%]"
         },
-        "description": "Choose the district you selected above or select a specific community within that district"
+        "description": "If you want to monitor not only state and district, choose its specific community"
       },
       "district": {
         "data": {
           "region": "[%key:component::ukraine_alarm::config::step::user::data::region%]"
         },
-        "description": "Choose a district to monitor within the selected state"
+        "description": "If you want to monitor not only state, choose its specific district"
       },
       "user": {
         "data": {
           "region": "Region"
         },
-        "description": "Choose a state"
+        "description": "Choose state to monitor"
       }
     }
   },
@@ -50,11 +50,5 @@
         "name": "Urban fights"
       }
     }
-  },
-  "issues": {
-    "deprecated_state_region": {
-      "description": "The region `{region_name}` is a state-level region, which is no longer supported. Please remove this integration entry and add it again, selecting a district or community instead of the entire state.",
-      "title": "State-level region monitoring is no longer supported"
-    }
   }
 }

homeassistant/components/velux/__init__.py

@@ -1,25 +1,17 @@
 """Support for VELUX KLF 200 devices."""
 
-from __future__ import annotations
-
 from pyvlx import PyVLX, PyVLXException
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_MAC,
-    CONF_PASSWORD,
-    EVENT_HOMEASSISTANT_STOP,
-)
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import HomeAssistant, ServiceCall
-from homeassistant.helpers import device_registry as dr, issue_registry as ir
 
 from .const import DOMAIN, LOGGER, PLATFORMS
 
 type VeluxConfigEntry = ConfigEntry[PyVLX]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: VeluxConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up the velux component."""
     host = entry.data[CONF_HOST]
     password = entry.data[CONF_PASSWORD]
@@ -35,44 +27,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: VeluxConfigEntry) -> boo
 
     entry.runtime_data = pyvlx
 
-    connections = None
-    if (mac := entry.data.get(CONF_MAC)) is not None:
-        connections = {(dr.CONNECTION_NETWORK_MAC, mac)}
-
-    device_registry = dr.async_get(hass)
-    device_registry.async_get_or_create(
-        config_entry_id=entry.entry_id,
-        identifiers={(DOMAIN, f"gateway_{entry.entry_id}")},
-        name="KLF 200 Gateway",
-        manufacturer="Velux",
-        model="KLF 200",
-        hw_version=(
-            str(pyvlx.klf200.version.hardwareversion) if pyvlx.klf200.version else None
-        ),
-        sw_version=(
-            str(pyvlx.klf200.version.softwareversion) if pyvlx.klf200.version else None
-        ),
-        connections=connections,
-    )
-
     async def on_hass_stop(event):
         """Close connection when hass stops."""
         LOGGER.debug("Velux interface terminated")
         await pyvlx.disconnect()
 
     async def async_reboot_gateway(service_call: ServiceCall) -> None:
-        """Reboot the gateway (deprecated - use button entity instead)."""
-        ir.async_create_issue(
-            hass,
-            DOMAIN,
-            "deprecated_reboot_service",
-            is_fixable=False,
-            issue_domain=DOMAIN,
-            severity=ir.IssueSeverity.WARNING,
-            translation_key="deprecated_reboot_service",
-            breaks_in_ha_version="2026.6.0",
-        )
-
         await pyvlx.reboot_gateway()
 
     entry.async_on_unload(
@@ -86,6 +46,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: VeluxConfigEntry) -> boo
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: VeluxConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/velux/binary_sensor.py

@@ -24,14 +24,14 @@ SCAN_INTERVAL = timedelta(minutes=5)  # Use standard polling
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: VeluxConfigEntry,
+    config: VeluxConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up rain sensor(s) for Velux platform."""
-    pyvlx = config_entry.runtime_data
+    pyvlx = config.runtime_data
 
     async_add_entities(
-        VeluxRainSensor(node, config_entry.entry_id)
+        VeluxRainSensor(node, config.entry_id)
         for node in pyvlx.nodes
         if isinstance(node, Window) and node.rain_sensor
     )

homeassistant/components/velux/button.py

@@ -1,54 +0,0 @@
-"""Support for VELUX KLF 200 gateway button."""
-
-from __future__ import annotations
-
-from pyvlx import PyVLX, PyVLXException
-
-from homeassistant.components.button import ButtonDeviceClass, ButtonEntity
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import VeluxConfigEntry
-from .const import DOMAIN
-
-PARALLEL_UPDATES = 1
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: VeluxConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up button entities for the Velux integration."""
-    async_add_entities(
-        [VeluxGatewayRebootButton(config_entry.entry_id, config_entry.runtime_data)]
-    )
-
-
-class VeluxGatewayRebootButton(ButtonEntity):
-    """Representation of the Velux Gateway reboot button."""
-
-    _attr_has_entity_name = True
-    _attr_device_class = ButtonDeviceClass.RESTART
-    _attr_entity_category = EntityCategory.CONFIG
-
-    def __init__(self, config_entry_id: str, pyvlx: PyVLX) -> None:
-        """Initialize the gateway reboot button."""
-        self.pyvlx = pyvlx
-        self._attr_unique_id = f"{config_entry_id}_reboot-gateway"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, f"gateway_{config_entry_id}")},
-        )
-
-    async def async_press(self) -> None:
-        """Handle the button press - reboot the gateway."""
-        try:
-            await self.pyvlx.reboot_gateway()
-        except PyVLXException as ex:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="reboot_failed",
-            ) from ex

homeassistant/components/velux/config_flow.py

@@ -85,7 +85,7 @@ class VeluxConfigFlow(ConfigFlow, domain=DOMAIN):
             updates={CONF_HOST: self.discovery_data[CONF_HOST]}
         )
 
-        # Abort if config_entry already exists without unique_id configured.
+        # Abort if config_entry already exists without unigue_id configured.
         for entry in self.hass.config_entries.async_entries(DOMAIN):
             if (
                 entry.data[CONF_HOST] == self.discovery_data[CONF_HOST]

homeassistant/components/velux/const.py

@@ -5,11 +5,5 @@ from logging import getLogger
 from homeassistant.const import Platform
 
 DOMAIN = "velux"
-PLATFORMS = [
-    Platform.BINARY_SENSOR,
-    Platform.BUTTON,
-    Platform.COVER,
-    Platform.LIGHT,
-    Platform.SCENE,
-]
+PLATFORMS = [Platform.BINARY_SENSOR, Platform.COVER, Platform.LIGHT, Platform.SCENE]
 LOGGER = getLogger(__package__)

homeassistant/components/velux/cover.py

@@ -32,13 +32,13 @@ PARALLEL_UPDATES = 1
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: VeluxConfigEntry,
+    config: VeluxConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up cover(s) for Velux platform."""
-    pyvlx = config_entry.runtime_data
+    pyvlx = config.runtime_data
     async_add_entities(
-        VeluxCover(node, config_entry.entry_id)
+        VeluxCover(node, config.entry_id)
         for node in pyvlx.nodes
         if isinstance(node, OpeningDevice)
     )

homeassistant/components/velux/entity.py

@@ -18,23 +18,22 @@ class VeluxEntity(Entity):
     def __init__(self, node: Node, config_entry_id: str) -> None:
         """Initialize the Velux device."""
         self.node = node
-        unique_id = (
+        self._attr_unique_id = (
             node.serial_number
             if node.serial_number
             else f"{config_entry_id}_{node.node_id}"
         )
-        self._attr_unique_id = unique_id
-
         self._attr_device_info = DeviceInfo(
             identifiers={
                 (
                     DOMAIN,
-                    unique_id,
+                    node.serial_number
+                    if node.serial_number
+                    else f"{config_entry_id}_{node.node_id}",
                 )
             },
             name=node.name if node.name else f"#{node.node_id}",
             serial_number=node.serial_number,
-            via_device=(DOMAIN, f"gateway_{config_entry_id}"),
         )
 
     @callback

homeassistant/components/velux/light.py

@@ -18,13 +18,13 @@ PARALLEL_UPDATES = 1
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: VeluxConfigEntry,
+    config: VeluxConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up light(s) for Velux platform."""
-    pyvlx = config_entry.runtime_data
+    pyvlx = config.runtime_data
     async_add_entities(
-        VeluxLight(node, config_entry.entry_id)
+        VeluxLight(node, config.entry_id)
         for node in pyvlx.nodes
         if isinstance(node, LighteningDevice)
     )

homeassistant/components/velux/quality_scale.yaml

@@ -1,74 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: todo
-    comment: needs to move to async_setup
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency:
-    status: todo
-    comment: release-builds need CI
-  docs-actions: done
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: todo
-    comment: subscribe is ok, unsubscribe needs to be added
-  entity-unique-id: done
-  has-entity-name:
-    status: todo
-    comment: scenes need fixing
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup:
-    status: todo
-    comment: needs rework, failure to setup currently only returns false
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions: todo
-  config-entry-unloading: todo
-  docs-configuration-parameters: todo
-  docs-installation-parameters: todo
-  entity-unavailable: todo
-  integration-owner: done
-  log-when-unavailable: todo
-  parallel-updates: done
-  reauthentication-flow: todo
-  test-coverage:
-    status: todo
-    comment: cleanup mock_config_entry vs mock_user_config_entry, cleanup mock_pyvlx vs mock_velux_client, remove unused freezer in test_cover_closed, add tests where missing
-
-  # Gold
-  devices:
-    status: todo
-    comment: scenes need devices
-  diagnostics: todo
-  discovery-update-info: todo
-  discovery: done
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
-  entity-device-class: todo
-  entity-disabled-by-default: todo
-  entity-translations: todo
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: todo
-  repair-issues: todo
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: todo
-  inject-websession: todo
-  strict-typing: todo

homeassistant/components/velux/scene.py

@@ -15,11 +15,11 @@ PARALLEL_UPDATES = 1
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: VeluxConfigEntry,
+    config: VeluxConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the scenes for Velux platform."""
-    pyvlx = config_entry.runtime_data
+    pyvlx = config.runtime_data
 
     entities = [VeluxScene(scene) for scene in pyvlx.scenes]
     async_add_entities(entities)

homeassistant/components/velux/strings.json

@@ -36,20 +36,9 @@
       }
     }
   },
-  "exceptions": {
-    "reboot_failed": {
-      "message": "Failed to reboot gateway. Try again in a few moments or power cycle the device manually"
-    }
-  },
-  "issues": {
-    "deprecated_reboot_service": {
-      "description": "The `velux.reboot_gateway` service is deprecated and will be removed in Home Assistant 2026.6.0. Please use the 'Restart' button entity instead. You can find this button in the device page for your KLF 200 Gateway or by searching for 'restart' in your entity list.",
-      "title": "Velux reboot service is deprecated"
-    }
-  },
   "services": {
     "reboot_gateway": {
-      "description": "Reboots the KLF200 Gateway",
+      "description": "Reboots the KLF200 Gateway.",
       "name": "Reboot gateway"
     }
   }

homeassistant/components/vesync/__init__.py

@@ -11,7 +11,6 @@ from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
 from .const import DOMAIN, SERVICE_UPDATE_DEVS, VS_COORDINATOR, VS_MANAGER
@@ -122,21 +121,3 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
         hass.config_entries.async_update_entry(config_entry, minor_version=2)
 
     return True
-
-
-async def async_remove_config_entry_device(
-    hass: HomeAssistant, config_entry: ConfigEntry, device_entry: DeviceEntry
-) -> bool:
-    """Remove a config entry from a device."""
-    manager = hass.data[DOMAIN][VS_MANAGER]
-    await manager.get_devices()
-    for dev in manager.devices:
-        if isinstance(dev.sub_device_no, int):
-            device_id = f"{dev.cid}{dev.sub_device_no!s}"
-        else:
-            device_id = dev.cid
-        identifier = next(iter(device_entry.identifiers), None)
-        if identifier and device_id == identifier[1]:
-            return False
-
-    return True