Remove template from sql service schema

.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"

CODEOWNERS

@@ -516,8 +516,6 @@ build.json @home-assistant/supervisor
 /tests/components/flo/ @dmulcahey
 /homeassistant/components/flume/ @ChrisMandich @bdraco @jeeftor
 /tests/components/flume/ @ChrisMandich @bdraco @jeeftor
-/homeassistant/components/fluss/ @fluss
-/tests/components/fluss/ @fluss
 /homeassistant/components/flux_led/ @icemanch
 /tests/components/flux_led/ @icemanch
 /homeassistant/components/forecast_solar/ @klaasnicolaas @frenck

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/emoncms/quality_scale.yaml

@@ -1,84 +0,0 @@
-rules:
-  # todo : add get_feed_list to the library
-  # todo : see if we can drop some extra attributes
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: |
-      This integration does not provide additional actions.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage:
-    status: todo
-    comment: |
-      test_reconfigure_api_error should use a mock config entry fixture
-      test_user_flow_failure should use a mock config entry fixture
-      move test_user_flow_* to the top of the file
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: |
-      This integration does not provide additional actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: |
-      No events are explicitly registered by the integration.
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions: done
-  config-entry-unloading: done
-  docs-configuration-parameters: done
-  docs-installation-parameters: done
-  entity-unavailable: todo
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: todo
-  reauthentication-flow: todo
-  test-coverage:
-    status: todo
-    comment: |
-      test the entry state in test_failure
-
-  # Gold
-  devices: todo
-  diagnostics: todo
-  discovery-update-info: todo
-  discovery: todo
-  docs-data-update: done
-  docs-examples:
-    status: exempt
-    comment: |
-      This integration does not provide any automation
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
-  entity-device-class:
-    status: todo
-    comment: change device_class=SensorDeviceClass.SIGNAL_STRENGTH to SOUND_PRESSURE
-  entity-disabled-by-default: todo
-  entity-translations: done
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: done
-  repair-issues: todo
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo

homeassistant/components/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,
@@ -386,260 +309,11 @@ def _async_validate_auto_generated_cost_entity(
         issues.add_issue(hass, "recorder_untracked", cost_entity_id)
 
 
-def _validate_grid_source(
-    hass: HomeAssistant,
-    source: data.GridSourceType,
-    statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    wanted_statistics_metadata: set[str],
-    source_result: ValidationIssues,
-    validate_calls: list[functools.partial[None]],
-) -> None:
-    """Validate grid energy source."""
-    flow_from: data.FlowFromGridSourceType
-    for flow_from in source["flow_from"]:
-        wanted_statistics_metadata.add(flow_from["stat_energy_from"])
-        validate_calls.append(
-            functools.partial(
-                _async_validate_usage_stat,
-                hass,
-                statistics_metadata,
-                flow_from["stat_energy_from"],
-                ENERGY_USAGE_DEVICE_CLASSES,
-                ENERGY_USAGE_UNITS,
-                ENERGY_UNIT_ERROR,
-                source_result,
-            )
-        )
-
-        if (stat_cost := flow_from.get("stat_cost")) is not None:
-            wanted_statistics_metadata.add(stat_cost)
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_cost_stat,
-                    hass,
-                    statistics_metadata,
-                    stat_cost,
-                    source_result,
-                )
-            )
-        elif (entity_energy_price := flow_from.get("entity_energy_price")) is not None:
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_price_entity,
-                    hass,
-                    entity_energy_price,
-                    source_result,
-                    ENERGY_PRICE_UNITS,
-                    ENERGY_PRICE_UNIT_ERROR,
-                )
-            )
-
-        if (
-            flow_from.get("entity_energy_price") is not None
-            or flow_from.get("number_energy_price") is not None
-        ):
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_auto_generated_cost_entity,
-                    hass,
-                    flow_from["stat_energy_from"],
-                    source_result,
-                )
-            )
-
-    flow_to: data.FlowToGridSourceType
-    for flow_to in source["flow_to"]:
-        wanted_statistics_metadata.add(flow_to["stat_energy_to"])
-        validate_calls.append(
-            functools.partial(
-                _async_validate_usage_stat,
-                hass,
-                statistics_metadata,
-                flow_to["stat_energy_to"],
-                ENERGY_USAGE_DEVICE_CLASSES,
-                ENERGY_USAGE_UNITS,
-                ENERGY_UNIT_ERROR,
-                source_result,
-            )
-        )
-
-        if (stat_compensation := flow_to.get("stat_compensation")) is not None:
-            wanted_statistics_metadata.add(stat_compensation)
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_cost_stat,
-                    hass,
-                    statistics_metadata,
-                    stat_compensation,
-                    source_result,
-                )
-            )
-        elif (entity_energy_price := flow_to.get("entity_energy_price")) is not None:
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_price_entity,
-                    hass,
-                    entity_energy_price,
-                    source_result,
-                    ENERGY_PRICE_UNITS,
-                    ENERGY_PRICE_UNIT_ERROR,
-                )
-            )
-
-        if (
-            flow_to.get("entity_energy_price") is not None
-            or flow_to.get("number_energy_price") is not None
-        ):
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_auto_generated_cost_entity,
-                    hass,
-                    flow_to["stat_energy_to"],
-                    source_result,
-                )
-            )
-
-    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,
-            )
-        )
-
-
-def _validate_gas_source(
-    hass: HomeAssistant,
-    source: data.GasSourceType,
-    statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    wanted_statistics_metadata: set[str],
-    source_result: ValidationIssues,
-    validate_calls: list[functools.partial[None]],
-) -> None:
-    """Validate gas energy source."""
-    wanted_statistics_metadata.add(source["stat_energy_from"])
-    validate_calls.append(
-        functools.partial(
-            _async_validate_usage_stat,
-            hass,
-            statistics_metadata,
-            source["stat_energy_from"],
-            GAS_USAGE_DEVICE_CLASSES,
-            GAS_USAGE_UNITS,
-            GAS_UNIT_ERROR,
-            source_result,
-        )
-    )
-
-    if (stat_cost := source.get("stat_cost")) is not None:
-        wanted_statistics_metadata.add(stat_cost)
-        validate_calls.append(
-            functools.partial(
-                _async_validate_cost_stat,
-                hass,
-                statistics_metadata,
-                stat_cost,
-                source_result,
-            )
-        )
-    elif (entity_energy_price := source.get("entity_energy_price")) is not None:
-        validate_calls.append(
-            functools.partial(
-                _async_validate_price_entity,
-                hass,
-                entity_energy_price,
-                source_result,
-                GAS_PRICE_UNITS,
-                GAS_PRICE_UNIT_ERROR,
-            )
-        )
-
-    if (
-        source.get("entity_energy_price") is not None
-        or source.get("number_energy_price") is not None
-    ):
-        validate_calls.append(
-            functools.partial(
-                _async_validate_auto_generated_cost_entity,
-                hass,
-                source["stat_energy_from"],
-                source_result,
-            )
-        )
-
-
-def _validate_water_source(
-    hass: HomeAssistant,
-    source: data.WaterSourceType,
-    statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    wanted_statistics_metadata: set[str],
-    source_result: ValidationIssues,
-    validate_calls: list[functools.partial[None]],
-) -> None:
-    """Validate water energy source."""
-    wanted_statistics_metadata.add(source["stat_energy_from"])
-    validate_calls.append(
-        functools.partial(
-            _async_validate_usage_stat,
-            hass,
-            statistics_metadata,
-            source["stat_energy_from"],
-            WATER_USAGE_DEVICE_CLASSES,
-            WATER_USAGE_UNITS,
-            WATER_UNIT_ERROR,
-            source_result,
-        )
-    )
-
-    if (stat_cost := source.get("stat_cost")) is not None:
-        wanted_statistics_metadata.add(stat_cost)
-        validate_calls.append(
-            functools.partial(
-                _async_validate_cost_stat,
-                hass,
-                statistics_metadata,
-                stat_cost,
-                source_result,
-            )
-        )
-    elif (entity_energy_price := source.get("entity_energy_price")) is not None:
-        validate_calls.append(
-            functools.partial(
-                _async_validate_price_entity,
-                hass,
-                entity_energy_price,
-                source_result,
-                WATER_PRICE_UNITS,
-                WATER_PRICE_UNIT_ERROR,
-            )
-        )
-
-    if (
-        source.get("entity_energy_price") is not None
-        or source.get("number_energy_price") is not None
-    ):
-        validate_calls.append(
-            functools.partial(
-                _async_validate_auto_generated_cost_entity,
-                hass,
-                source["stat_energy_from"],
-                source_result,
-            )
-        )
-
-
 async def async_validate(hass: HomeAssistant) -> EnergyPreferencesValidation:
     """Validate the energy configuration."""
     manager: data.EnergyManager = await data.async_get_manager(hass)
     statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]] = {}
-    validate_calls: list[functools.partial[None]] = []
+    validate_calls = []
     wanted_statistics_metadata: set[str] = set()
 
     result = EnergyPreferencesValidation()
@@ -653,35 +327,215 @@ async def async_validate(hass: HomeAssistant) -> EnergyPreferencesValidation:
         result.energy_sources.append(source_result)
 
         if source["type"] == "grid":
-            _validate_grid_source(
-                hass,
-                source,
-                statistics_metadata,
-                wanted_statistics_metadata,
-                source_result,
-                validate_calls,
-            )
+            flow: data.FlowFromGridSourceType | data.FlowToGridSourceType
+            for flow in source["flow_from"]:
+                wanted_statistics_metadata.add(flow["stat_energy_from"])
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_usage_stat,
+                        hass,
+                        statistics_metadata,
+                        flow["stat_energy_from"],
+                        ENERGY_USAGE_DEVICE_CLASSES,
+                        ENERGY_USAGE_UNITS,
+                        ENERGY_UNIT_ERROR,
+                        source_result,
+                    )
+                )
+
+                if (stat_cost := flow.get("stat_cost")) is not None:
+                    wanted_statistics_metadata.add(stat_cost)
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_cost_stat,
+                            hass,
+                            statistics_metadata,
+                            stat_cost,
+                            source_result,
+                        )
+                    )
+                elif (
+                    entity_energy_price := flow.get("entity_energy_price")
+                ) is not None:
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_price_entity,
+                            hass,
+                            entity_energy_price,
+                            source_result,
+                            ENERGY_PRICE_UNITS,
+                            ENERGY_PRICE_UNIT_ERROR,
+                        )
+                    )
+
+                if (
+                    flow.get("entity_energy_price") is not None
+                    or flow.get("number_energy_price") is not None
+                ):
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_auto_generated_cost_entity,
+                            hass,
+                            flow["stat_energy_from"],
+                            source_result,
+                        )
+                    )
+
+            for flow in source["flow_to"]:
+                wanted_statistics_metadata.add(flow["stat_energy_to"])
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_usage_stat,
+                        hass,
+                        statistics_metadata,
+                        flow["stat_energy_to"],
+                        ENERGY_USAGE_DEVICE_CLASSES,
+                        ENERGY_USAGE_UNITS,
+                        ENERGY_UNIT_ERROR,
+                        source_result,
+                    )
+                )
+
+                if (stat_compensation := flow.get("stat_compensation")) is not None:
+                    wanted_statistics_metadata.add(stat_compensation)
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_cost_stat,
+                            hass,
+                            statistics_metadata,
+                            stat_compensation,
+                            source_result,
+                        )
+                    )
+                elif (
+                    entity_energy_price := flow.get("entity_energy_price")
+                ) is not None:
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_price_entity,
+                            hass,
+                            entity_energy_price,
+                            source_result,
+                            ENERGY_PRICE_UNITS,
+                            ENERGY_PRICE_UNIT_ERROR,
+                        )
+                    )
+
+                if (
+                    flow.get("entity_energy_price") is not None
+                    or flow.get("number_energy_price") is not None
+                ):
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_auto_generated_cost_entity,
+                            hass,
+                            flow["stat_energy_to"],
+                            source_result,
+                        )
+                    )
 
         elif source["type"] == "gas":
-            _validate_gas_source(
-                hass,
-                source,
-                statistics_metadata,
-                wanted_statistics_metadata,
-                source_result,
-                validate_calls,
+            wanted_statistics_metadata.add(source["stat_energy_from"])
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_usage_stat,
+                    hass,
+                    statistics_metadata,
+                    source["stat_energy_from"],
+                    GAS_USAGE_DEVICE_CLASSES,
+                    GAS_USAGE_UNITS,
+                    GAS_UNIT_ERROR,
+                    source_result,
+                )
             )
 
+            if (stat_cost := source.get("stat_cost")) is not None:
+                wanted_statistics_metadata.add(stat_cost)
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_cost_stat,
+                        hass,
+                        statistics_metadata,
+                        stat_cost,
+                        source_result,
+                    )
+                )
+            elif (entity_energy_price := source.get("entity_energy_price")) is not None:
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_price_entity,
+                        hass,
+                        entity_energy_price,
+                        source_result,
+                        GAS_PRICE_UNITS,
+                        GAS_PRICE_UNIT_ERROR,
+                    )
+                )
+
+            if (
+                source.get("entity_energy_price") is not None
+                or source.get("number_energy_price") is not None
+            ):
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_auto_generated_cost_entity,
+                        hass,
+                        source["stat_energy_from"],
+                        source_result,
+                    )
+                )
+
         elif source["type"] == "water":
-            _validate_water_source(
-                hass,
-                source,
-                statistics_metadata,
-                wanted_statistics_metadata,
-                source_result,
-                validate_calls,
+            wanted_statistics_metadata.add(source["stat_energy_from"])
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_usage_stat,
+                    hass,
+                    statistics_metadata,
+                    source["stat_energy_from"],
+                    WATER_USAGE_DEVICE_CLASSES,
+                    WATER_USAGE_UNITS,
+                    WATER_UNIT_ERROR,
+                    source_result,
+                )
             )
 
+            if (stat_cost := source.get("stat_cost")) is not None:
+                wanted_statistics_metadata.add(stat_cost)
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_cost_stat,
+                        hass,
+                        statistics_metadata,
+                        stat_cost,
+                        source_result,
+                    )
+                )
+            elif (entity_energy_price := source.get("entity_energy_price")) is not None:
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_price_entity,
+                        hass,
+                        entity_energy_price,
+                        source_result,
+                        WATER_PRICE_UNITS,
+                        WATER_PRICE_UNIT_ERROR,
+                    )
+                )
+
+            if (
+                source.get("entity_energy_price") is not None
+                or source.get("number_energy_price") is not None
+            ):
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_auto_generated_cost_entity,
+                        hass,
+                        source["stat_energy_from"],
+                        source_result,
+                    )
+                )
+
         elif source["type"] == "solar":
             wanted_statistics_metadata.add(source["stat_energy_from"])
             validate_calls.append(

homeassistant/components/enphase_envoy/diagnostics.py

@@ -147,8 +147,6 @@ async def async_get_config_entry_diagnostics(
         "ctmeter_production_phases": envoy_data.ctmeter_production_phases,
         "ctmeter_consumption_phases": envoy_data.ctmeter_consumption_phases,
         "ctmeter_storage_phases": envoy_data.ctmeter_storage_phases,
-        "ctmeters": envoy_data.ctmeters,
-        "ctmeters_phases": envoy_data.ctmeters_phases,
         "dry_contact_status": envoy_data.dry_contact_status,
         "dry_contact_settings": envoy_data.dry_contact_settings,
         "inverters": envoy_data.inverters,
@@ -181,7 +179,6 @@ async def async_get_config_entry_diagnostics(
         "ct_consumption_meter": envoy.consumption_meter_type,
         "ct_production_meter": envoy.production_meter_type,
         "ct_storage_meter": envoy.storage_meter_type,
-        "ct_meters": list(envoy_data.ctmeters.keys()),
     }
 
     fixture_data: dict[str, Any] = {}

homeassistant/components/enphase_envoy/sensor.py

@@ -399,189 +399,117 @@ class EnvoyCTSensorEntityDescription(SensorEntityDescription):
     cttype: str | None = None
 
 
-# All ct types unified in common setup
-CT_SENSORS = (
-    [
-        EnvoyCTSensorEntityDescription(
-            key=key,
-            translation_key=key,
-            native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-            state_class=SensorStateClass.TOTAL_INCREASING,
-            device_class=SensorDeviceClass.ENERGY,
-            suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-            suggested_display_precision=3,
-            value_fn=attrgetter("energy_delivered"),
-            on_phase=None,
-            cttype=cttype,
-        )
-        for cttype, key in (
-            (CtType.NET_CONSUMPTION, "lifetime_net_consumption"),
-            # Production CT energy_delivered is not used
-            (CtType.STORAGE, "lifetime_battery_discharged"),
-        )
-    ]
-    + [
-        EnvoyCTSensorEntityDescription(
-            key=key,
-            translation_key=key,
-            native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-            state_class=SensorStateClass.TOTAL_INCREASING,
-            device_class=SensorDeviceClass.ENERGY,
-            suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-            suggested_display_precision=3,
-            value_fn=attrgetter("energy_received"),
-            on_phase=None,
-            cttype=cttype,
-        )
-        for cttype, key in (
-            (CtType.NET_CONSUMPTION, "lifetime_net_production"),
-            # Production CT energy_received is not used
-            (CtType.STORAGE, "lifetime_battery_charged"),
-        )
-    ]
-    + [
-        EnvoyCTSensorEntityDescription(
-            key=key,
-            translation_key=key,
-            native_unit_of_measurement=UnitOfPower.WATT,
-            state_class=SensorStateClass.MEASUREMENT,
-            device_class=SensorDeviceClass.POWER,
-            suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
-            suggested_display_precision=3,
-            value_fn=attrgetter("active_power"),
-            on_phase=None,
-            cttype=cttype,
-        )
-        for cttype, key in (
-            (CtType.NET_CONSUMPTION, "net_consumption"),
-            # Production CT active_power is not used
-            (CtType.STORAGE, "battery_discharge"),
-        )
-    ]
-    + [
-        EnvoyCTSensorEntityDescription(
-            key=key,
-            translation_key=(translation_key if translation_key != "" else key),
-            native_unit_of_measurement=UnitOfFrequency.HERTZ,
-            state_class=SensorStateClass.MEASUREMENT,
-            device_class=SensorDeviceClass.FREQUENCY,
-            suggested_display_precision=1,
-            entity_registry_enabled_default=False,
-            value_fn=attrgetter("frequency"),
-            on_phase=None,
-            cttype=cttype,
-        )
-        for cttype, key, translation_key in (
-            (CtType.NET_CONSUMPTION, "frequency", "net_ct_frequency"),
-            (CtType.PRODUCTION, "production_ct_frequency", ""),
-            (CtType.STORAGE, "storage_ct_frequency", ""),
-        )
-    ]
-    + [
-        EnvoyCTSensorEntityDescription(
-            key=key,
-            translation_key=(translation_key if translation_key != "" else key),
-            native_unit_of_measurement=UnitOfElectricPotential.VOLT,
-            state_class=SensorStateClass.MEASUREMENT,
-            device_class=SensorDeviceClass.VOLTAGE,
-            suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
-            suggested_display_precision=1,
-            entity_registry_enabled_default=False,
-            value_fn=attrgetter("voltage"),
-            on_phase=None,
-            cttype=cttype,
-        )
-        for cttype, key, translation_key in (
-            (CtType.NET_CONSUMPTION, "voltage", "net_ct_voltage"),
-            (CtType.PRODUCTION, "production_ct_voltage", ""),
-            (CtType.STORAGE, "storage_voltage", "storage_ct_voltage"),
-        )
-    ]
-    + [
-        EnvoyCTSensorEntityDescription(
-            key=key,
-            translation_key=key,
-            native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-            state_class=SensorStateClass.MEASUREMENT,
-            device_class=SensorDeviceClass.CURRENT,
-            suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-            suggested_display_precision=3,
-            entity_registry_enabled_default=False,
-            value_fn=attrgetter("current"),
-            on_phase=None,
-            cttype=cttype,
-        )
-        for cttype, key in (
-            (CtType.NET_CONSUMPTION, "net_ct_current"),
-            (CtType.PRODUCTION, "production_ct_current"),
-            (CtType.STORAGE, "storage_ct_current"),
-        )
-    ]
-    + [
-        EnvoyCTSensorEntityDescription(
-            key=key,
-            translation_key=key,
-            device_class=SensorDeviceClass.POWER_FACTOR,
-            state_class=SensorStateClass.MEASUREMENT,
-            suggested_display_precision=2,
-            entity_registry_enabled_default=False,
-            value_fn=attrgetter("power_factor"),
-            on_phase=None,
-            cttype=cttype,
-        )
-        for cttype, key in (
-            (CtType.NET_CONSUMPTION, "net_ct_powerfactor"),
-            (CtType.PRODUCTION, "production_ct_powerfactor"),
-            (CtType.STORAGE, "storage_ct_powerfactor"),
-        )
-    ]
-    + [
-        EnvoyCTSensorEntityDescription(
-            key=key,
-            translation_key=(translation_key if translation_key != "" else key),
-            device_class=SensorDeviceClass.ENUM,
-            entity_category=EntityCategory.DIAGNOSTIC,
-            options=list(CtMeterStatus),
-            entity_registry_enabled_default=False,
-            value_fn=attrgetter("metering_status"),
-            on_phase=None,
-            cttype=cttype,
-        )
-        for cttype, key, translation_key in (
-            (
-                CtType.NET_CONSUMPTION,
-                "net_consumption_ct_metering_status",
-                "net_ct_metering_status",
-            ),
-            (CtType.PRODUCTION, "production_ct_metering_status", ""),
-            (CtType.STORAGE, "storage_ct_metering_status", ""),
-        )
-    ]
-    + [
-        EnvoyCTSensorEntityDescription(
-            key=key,
-            translation_key=(translation_key if translation_key != "" else key),
-            state_class=None,
-            entity_category=EntityCategory.DIAGNOSTIC,
-            entity_registry_enabled_default=False,
-            value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
-            on_phase=None,
-            cttype=cttype,
-        )
-        for cttype, key, translation_key in (
-            (
-                CtType.NET_CONSUMPTION,
-                "net_consumption_ct_status_flags",
-                "net_ct_status_flags",
-            ),
-            (CtType.PRODUCTION, "production_ct_status_flags", ""),
-            (CtType.STORAGE, "storage_ct_status_flags", ""),
-        )
-    ]
+CT_NET_CONSUMPTION_SENSORS = (
+    EnvoyCTSensorEntityDescription(
+        key="lifetime_net_consumption",
+        translation_key="lifetime_net_consumption",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        device_class=SensorDeviceClass.ENERGY,
+        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
+        suggested_display_precision=3,
+        value_fn=attrgetter("energy_delivered"),
+        on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="lifetime_net_production",
+        translation_key="lifetime_net_production",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        device_class=SensorDeviceClass.ENERGY,
+        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
+        suggested_display_precision=3,
+        value_fn=attrgetter("energy_received"),
+        on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="net_consumption",
+        translation_key="net_consumption",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.POWER,
+        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+        suggested_display_precision=3,
+        value_fn=attrgetter("active_power"),
+        on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="frequency",
+        translation_key="net_ct_frequency",
+        native_unit_of_measurement=UnitOfFrequency.HERTZ,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.FREQUENCY,
+        suggested_display_precision=1,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("frequency"),
+        on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="voltage",
+        translation_key="net_ct_voltage",
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.VOLTAGE,
+        suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        suggested_display_precision=1,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("voltage"),
+        on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="net_ct_current",
+        translation_key="net_ct_current",
+        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.CURRENT,
+        suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        suggested_display_precision=3,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("current"),
+        on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="net_ct_powerfactor",
+        translation_key="net_ct_powerfactor",
+        device_class=SensorDeviceClass.POWER_FACTOR,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=2,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("power_factor"),
+        on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="net_consumption_ct_metering_status",
+        translation_key="net_ct_metering_status",
+        device_class=SensorDeviceClass.ENUM,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        options=list(CtMeterStatus),
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("metering_status"),
+        on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="net_consumption_ct_status_flags",
+        translation_key="net_ct_status_flags",
+        state_class=None,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
+        on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
+    ),
 )
 
 
-CT_PHASE_SENSORS = {
+CT_NET_CONSUMPTION_PHASE_SENSORS = {
     (on_phase := PHASENAMES[phase]): [
         replace(
             sensor,
@@ -591,7 +519,220 @@ CT_PHASE_SENSORS = {
             on_phase=on_phase,
             translation_placeholders={"phase_name": f"l{phase + 1}"},
         )
-        for sensor in list(CT_SENSORS)
+        for sensor in list(CT_NET_CONSUMPTION_SENSORS)
+    ]
+    for phase in range(3)
+}
+
+CT_PRODUCTION_SENSORS = (
+    EnvoyCTSensorEntityDescription(
+        key="production_ct_frequency",
+        translation_key="production_ct_frequency",
+        native_unit_of_measurement=UnitOfFrequency.HERTZ,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.FREQUENCY,
+        suggested_display_precision=1,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("frequency"),
+        on_phase=None,
+        cttype=CtType.PRODUCTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="production_ct_voltage",
+        translation_key="production_ct_voltage",
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.VOLTAGE,
+        suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        suggested_display_precision=1,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("voltage"),
+        on_phase=None,
+        cttype=CtType.PRODUCTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="production_ct_current",
+        translation_key="production_ct_current",
+        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.CURRENT,
+        suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        suggested_display_precision=3,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("current"),
+        on_phase=None,
+        cttype=CtType.PRODUCTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="production_ct_powerfactor",
+        translation_key="production_ct_powerfactor",
+        device_class=SensorDeviceClass.POWER_FACTOR,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=2,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("power_factor"),
+        on_phase=None,
+        cttype=CtType.PRODUCTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="production_ct_metering_status",
+        translation_key="production_ct_metering_status",
+        device_class=SensorDeviceClass.ENUM,
+        options=list(CtMeterStatus),
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("metering_status"),
+        on_phase=None,
+        cttype=CtType.PRODUCTION,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="production_ct_status_flags",
+        translation_key="production_ct_status_flags",
+        state_class=None,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
+        on_phase=None,
+        cttype=CtType.PRODUCTION,
+    ),
+)
+
+CT_PRODUCTION_PHASE_SENSORS = {
+    (on_phase := PHASENAMES[phase]): [
+        replace(
+            sensor,
+            key=f"{sensor.key}_l{phase + 1}",
+            translation_key=f"{sensor.translation_key}_phase",
+            entity_registry_enabled_default=False,
+            on_phase=on_phase,
+            translation_placeholders={"phase_name": f"l{phase + 1}"},
+        )
+        for sensor in list(CT_PRODUCTION_SENSORS)
+    ]
+    for phase in range(3)
+}
+
+CT_STORAGE_SENSORS = (
+    EnvoyCTSensorEntityDescription(
+        key="lifetime_battery_discharged",
+        translation_key="lifetime_battery_discharged",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        device_class=SensorDeviceClass.ENERGY,
+        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
+        suggested_display_precision=3,
+        value_fn=attrgetter("energy_delivered"),
+        on_phase=None,
+        cttype=CtType.STORAGE,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="lifetime_battery_charged",
+        translation_key="lifetime_battery_charged",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        device_class=SensorDeviceClass.ENERGY,
+        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
+        suggested_display_precision=3,
+        value_fn=attrgetter("energy_received"),
+        on_phase=None,
+        cttype=CtType.STORAGE,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="battery_discharge",
+        translation_key="battery_discharge",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.POWER,
+        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+        suggested_display_precision=3,
+        value_fn=attrgetter("active_power"),
+        on_phase=None,
+        cttype=CtType.STORAGE,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="storage_ct_frequency",
+        translation_key="storage_ct_frequency",
+        native_unit_of_measurement=UnitOfFrequency.HERTZ,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.FREQUENCY,
+        suggested_display_precision=1,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("frequency"),
+        on_phase=None,
+        cttype=CtType.STORAGE,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="storage_voltage",
+        translation_key="storage_ct_voltage",
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.VOLTAGE,
+        suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        suggested_display_precision=1,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("voltage"),
+        on_phase=None,
+        cttype=CtType.STORAGE,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="storage_ct_current",
+        translation_key="storage_ct_current",
+        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.CURRENT,
+        suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        suggested_display_precision=3,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("current"),
+        on_phase=None,
+        cttype=CtType.STORAGE,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="storage_ct_powerfactor",
+        translation_key="storage_ct_powerfactor",
+        device_class=SensorDeviceClass.POWER_FACTOR,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=2,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("power_factor"),
+        on_phase=None,
+        cttype=CtType.STORAGE,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="storage_ct_metering_status",
+        translation_key="storage_ct_metering_status",
+        device_class=SensorDeviceClass.ENUM,
+        options=list(CtMeterStatus),
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        value_fn=attrgetter("metering_status"),
+        on_phase=None,
+        cttype=CtType.STORAGE,
+    ),
+    EnvoyCTSensorEntityDescription(
+        key="storage_ct_status_flags",
+        translation_key="storage_ct_status_flags",
+        state_class=None,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
+        on_phase=None,
+        cttype=CtType.STORAGE,
+    ),
+)
+
+
+CT_STORAGE_PHASE_SENSORS = {
+    (on_phase := PHASENAMES[phase]): [
+        replace(
+            sensor,
+            key=f"{sensor.key}_l{phase + 1}",
+            translation_key=f"{sensor.translation_key}_phase",
+            entity_registry_enabled_default=False,
+            on_phase=on_phase,
+            translation_placeholders={"phase_name": f"l{phase + 1}"},
+        )
+        for sensor in list(CT_STORAGE_SENSORS)
     ]
     for phase in range(3)
 }
@@ -919,14 +1060,24 @@ async def async_setup_entry(
     if envoy_data.ctmeters:
         entities.extend(
             EnvoyCTEntity(coordinator, description)
-            for description in CT_SENSORS
+            for sensors in (
+                CT_NET_CONSUMPTION_SENSORS,
+                CT_PRODUCTION_SENSORS,
+                CT_STORAGE_SENSORS,
+            )
+            for description in sensors
             if description.cttype in envoy_data.ctmeters
         )
     # Add Current Transformer phase entities
     if ctmeters_phases := envoy_data.ctmeters_phases:
         entities.extend(
             EnvoyCTPhaseEntity(coordinator, description)
-            for phase, descriptions in CT_PHASE_SENSORS.items()
+            for sensors in (
+                CT_NET_CONSUMPTION_PHASE_SENSORS,
+                CT_PRODUCTION_PHASE_SENSORS,
+                CT_STORAGE_PHASE_SENSORS,
+            )
+            for phase, descriptions in sensors.items()
             for description in descriptions
             if (cttype := description.cttype) in ctmeters_phases
             and phase in ctmeters_phases[cttype]

homeassistant/components/fluss/__init__.py

@@ -1,31 +0,0 @@
-"""The Fluss+ integration."""
-
-from __future__ import annotations
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_KEY, Platform
-from homeassistant.core import HomeAssistant
-
-from .coordinator import FlussDataUpdateCoordinator
-
-PLATFORMS: list[Platform] = [Platform.BUTTON]
-
-
-type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: FlussConfigEntry,
-) -> bool:
-    """Set up Fluss+ from a config entry."""
-    coordinator = FlussDataUpdateCoordinator(hass, entry, entry.data[CONF_API_KEY])
-    await coordinator.async_config_entry_first_refresh()
-    entry.runtime_data = coordinator
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: FlussConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/fluss/button.py

@@ -1,38 +0,0 @@
-"""Support for Fluss Devices."""
-
-from homeassistant.components.button import ButtonEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import FlussApiClientError, FlussDataUpdateCoordinator
-from .entity import FlussEntity
-
-type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: FlussConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the Fluss Devices, filtering out any invalid payloads."""
-    coordinator = entry.runtime_data
-    devices = coordinator.data
-
-    async_add_entities(
-        FlussButton(coordinator, device_id, device)
-        for device_id, device in devices.items()
-    )
-
-
-class FlussButton(FlussEntity, ButtonEntity):
-    """Representation of a Fluss button device."""
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-        try:
-            await self.coordinator.api.async_trigger_device(self.device_id)
-        except FlussApiClientError as err:
-            raise HomeAssistantError(f"Failed to trigger device: {err}") from err

homeassistant/components/fluss/config_flow.py

@@ -1,54 +0,0 @@
-"""Config flow for Fluss+ integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from fluss_api import (
-    FlussApiClient,
-    FlussApiClientAuthenticationError,
-    FlussApiClientCommunicationError,
-)
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN, LOGGER
-
-STEP_USER_DATA_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): cv.string})
-
-
-class FlussConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Fluss+."""
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            api_key = user_input[CONF_API_KEY]
-            self._async_abort_entries_match({CONF_API_KEY: api_key})
-            try:
-                FlussApiClient(
-                    user_input[CONF_API_KEY], session=async_get_clientsession(self.hass)
-                )
-            except FlussApiClientCommunicationError:
-                errors["base"] = "cannot_connect"
-            except FlussApiClientAuthenticationError:
-                errors["base"] = "invalid_auth"
-            except Exception:  # noqa: BLE001
-                LOGGER.exception("Unexpected exception occurred")
-                errors["base"] = "unknown"
-            if not errors:
-                return self.async_create_entry(
-                    title="My Fluss+ Devices", data=user_input
-                )
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )

homeassistant/components/fluss/const.py

@@ -1,9 +0,0 @@
-"""Constants for the Fluss+ integration."""
-
-from datetime import timedelta
-import logging
-
-DOMAIN = "fluss"
-LOGGER = logging.getLogger(__name__)
-UPDATE_INTERVAL = 60  # seconds
-UPDATE_INTERVAL_TIMEDELTA = timedelta(seconds=UPDATE_INTERVAL)

homeassistant/components/fluss/coordinator.py

@@ -1,50 +0,0 @@
-"""DataUpdateCoordinator for Fluss+ integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from fluss_api import (
-    FlussApiClient,
-    FlussApiClientAuthenticationError,
-    FlussApiClientError,
-)
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-from homeassistant.util import slugify
-
-from .const import LOGGER, UPDATE_INTERVAL_TIMEDELTA
-
-type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
-
-
-class FlussDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
-    """Manages fetching Fluss device data on a schedule."""
-
-    def __init__(
-        self, hass: HomeAssistant, config_entry: FlussConfigEntry, api_key: str
-    ) -> None:
-        """Initialize the coordinator."""
-        self.api = FlussApiClient(api_key, session=async_get_clientsession(hass))
-        super().__init__(
-            hass,
-            LOGGER,
-            name=f"Fluss+ ({slugify(api_key[:8])})",
-            config_entry=config_entry,
-            update_interval=UPDATE_INTERVAL_TIMEDELTA,
-        )
-
-    async def _async_update_data(self) -> dict[str, dict[str, Any]]:
-        """Fetch data from the Fluss API and return as a dictionary keyed by deviceId."""
-        try:
-            devices = await self.api.async_get_devices()
-        except FlussApiClientAuthenticationError as err:
-            raise ConfigEntryAuthFailed(f"Authentication failed: {err}") from err
-        except FlussApiClientError as err:
-            raise UpdateFailed(f"Error fetching Fluss devices: {err}") from err
-
-        return {device["deviceId"]: device for device in devices.get("devices", [])}

homeassistant/components/fluss/entity.py

@@ -1,36 +0,0 @@
-"""Base entities for the Fluss+ integration."""
-
-from homeassistant.helpers.entity import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .coordinator import FlussDataUpdateCoordinator
-
-
-class FlussEntity(CoordinatorEntity[FlussDataUpdateCoordinator]):
-    """Base class for Fluss entities."""
-
-    _attr_has_entity_name = True
-    _attr_name = None
-
-    def __init__(
-        self,
-        coordinator: FlussDataUpdateCoordinator,
-        device_id: str,
-        device: dict,
-    ) -> None:
-        """Initialize the entity with a device ID and device data."""
-        super().__init__(coordinator)
-        self.device_id = device_id
-        self._device = device
-        self._attr_unique_id = f"{device_id}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={("fluss", device_id)},
-            name=device.get("deviceName"),
-            manufacturer="Fluss",
-            model="Fluss+ Device",
-        )
-
-    @property
-    def device(self) -> dict:
-        """Return the stored device data."""
-        return self._device

homeassistant/components/fluss/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "fluss",
-  "name": "Fluss+",
-  "codeowners": ["@fluss"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/fluss",
-  "iot_class": "cloud_polling",
-  "loggers": ["fluss-api"],
-  "quality_scale": "bronze",
-  "requirements": ["fluss-api==0.1.9.17"]
-}

homeassistant/components/fluss/quality_scale.yaml

@@ -1,69 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: |
-      No actions present
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions: done
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup: done
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-  # Silver
-  action-exceptions: todo
-  config-entry-unloading: done
-  docs-configuration-parameters: done
-  docs-installation-parameters: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: todo
-  reauthentication-flow: todo
-  test-coverage: todo
-  # Gold
-  entity-translations: done
-  entity-device-class: done
-  devices: done
-  entity-category: done
-  entity-disabled-by-default:
-    status: exempt
-    comment: |
-      Not needed
-  discovery: todo
-  stale-devices: todo
-  diagnostics: todo
-  exception-translations: todo
-  icon-translations:
-    status: exempt
-    comment: |
-      No icons used
-  reconfiguration-flow: todo
-  dynamic-devices: todo
-  discovery-update-info: todo
-  repair-issues:
-    status: exempt
-    comment: |
-      No issues to repair
-  docs-use-cases: done
-  docs-supported-devices: todo
-  docs-supported-functions: done
-  docs-data-update: todo
-  docs-known-limitations: done
-  docs-troubleshooting: todo
-  docs-examples: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo

homeassistant/components/fluss/strings.json

@@ -1,20 +0,0 @@
-{
-  "config": {
-    "step": {
-      "user": {
-        "description": "Your Fluss API key, available in the profile page of the Fluss+ app",
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]"
-        },
-        "data_description": {
-          "api_key": "The API key found in the profile page of the Fluss+ app."
-        }
-      }
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    }
-  }
-}

homeassistant/components/foscam/camera.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-from urllib.parse import quote
 
 import voluptuous as vol
 
@@ -153,9 +152,7 @@ class HassFoscamCamera(FoscamEntity, Camera):
     async def stream_source(self) -> str | None:
         """Return the stream source."""
         if self._rtsp_port:
-            _username = quote(self._username)
-            _password = quote(self._password)
-            return f"rtsp://{_username}:{_password}@{self._foscam_session.host}:{self._rtsp_port}/video{self._stream}"
+            return f"rtsp://{self._username}:{self._password}@{self._foscam_session.host}:{self._rtsp_port}/video{self._stream}"
 
         return None
 

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/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/manifest.json

@@ -6,12 +6,6 @@
   "dependencies": ["hardware", "usb", "homeassistant_hardware"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_connect_zbt2",
   "integration_type": "hardware",
-  "loggers": [
-    "bellows",
-    "universal_silabs_flasher",
-    "zigpy.serial",
-    "serial_asyncio_fast"
-  ],
   "quality_scale": "bronze",
   "usb": [
     {

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/manifest.json

@@ -6,12 +6,6 @@
   "dependencies": ["hardware", "usb", "homeassistant_hardware"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_sky_connect",
   "integration_type": "hardware",
-  "loggers": [
-    "bellows",
-    "universal_silabs_flasher",
-    "zigpy.serial",
-    "serial_asyncio_fast"
-  ],
   "usb": [
     {
       "description": "*skyconnect v1.0*",

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/manifest.json

@@ -7,11 +7,5 @@
   "dependencies": ["hardware", "homeassistant_hardware"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_yellow",
   "integration_type": "hardware",
-  "loggers": [
-    "bellows",
-    "universal_silabs_flasher",
-    "zigpy.serial",
-    "serial_asyncio_fast"
-  ],
   "single_config_entry": true
 }

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/manifest.json

@@ -37,5 +37,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pylamarzocco"],
   "quality_scale": "platinum",
-  "requirements": ["pylamarzocco==2.1.3"]
+  "requirements": ["pylamarzocco==2.1.2"]
 }

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/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/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/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/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/ruuvitag_ble/__init__.py

@@ -22,7 +22,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up Ruuvi BLE device from a config entry."""
+    """Set up Ruuvitag BLE device from a config entry."""
     address = entry.unique_id
     assert address is not None
     data = RuuvitagBluetoothDeviceData()

homeassistant/components/ruuvitag_ble/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "ruuvitag_ble",
-  "name": "Ruuvi BLE",
+  "name": "RuuviTag BLE",
   "bluetooth": [
     {
       "connectable": false,

homeassistant/components/ruuvitag_ble/sensor.py

@@ -191,7 +191,7 @@ async def async_setup_entry(
     entry: config_entries.ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the Ruuvi BLE sensors."""
+    """Set up the Ruuvitag BLE sensors."""
     coordinator: PassiveBluetoothProcessorCoordinator = hass.data[DOMAIN][
         entry.entry_id
     ]
@@ -210,7 +210,7 @@ class RuuvitagBluetoothSensorEntity(
     ],
     SensorEntity,
 ):
-    """Representation of a Ruuvi BLE sensor."""
+    """Representation of a Ruuvitag BLE sensor."""
 
     @property
     def native_value(self) -> int | float | None:

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,
@@ -13,7 +14,7 @@ from homeassistant.components.alarm_control_panel import (
     AlarmControlPanelState,
     CodeFormat,
 )
-from homeassistant.config_entries import ConfigSubentry
+from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -25,19 +26,6 @@ from .const import (
     SUBENTRY_TYPE_PARTITION,
     SatelConfigEntry,
 )
-from .entity import SatelIntegraEntity
-
-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__)
 
@@ -57,54 +45,48 @@ async def async_setup_entry(
     )
 
     for subentry in partition_subentries:
-        partition_num: int = subentry.data[CONF_PARTITION_NUMBER]
-        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(
             [
                 SatelIntegraAlarmPanel(
                     controller,
-                    config_entry.entry_id,
-                    subentry,
-                    partition_num,
+                    zone_name,
                     arm_home_mode,
+                    partition_num,
+                    config_entry.entry_id,
                 )
             ],
             config_subentry_id=subentry.subentry_id,
         )
 
 
-class SatelIntegraAlarmPanel(SatelIntegraEntity, AlarmControlPanelEntity):
+class SatelIntegraAlarmPanel(AlarmControlPanelEntity):
     """Representation of an AlarmDecoder-based alarm panel."""
 
     _attr_code_format = CodeFormat.NUMBER
+    _attr_should_poll = False
     _attr_supported_features = (
         AlarmControlPanelEntityFeature.ARM_HOME
         | AlarmControlPanelEntityFeature.ARM_AWAY
     )
 
     def __init__(
-        self,
-        controller: AsyncSatel,
-        config_entry_id: str,
-        subentry: ConfigSubentry,
-        device_number: int,
-        arm_home_mode: int,
+        self, controller, name, arm_home_mode, partition_id, config_entry_id
     ) -> None:
         """Initialize the alarm panel."""
-        super().__init__(
-            controller,
-            config_entry_id,
-            subentry,
-            device_number,
-        )
-
+        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
 
     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
@@ -112,29 +94,55 @@ class SatelIntegraAlarmPanel(SatelIntegraEntity, 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._device_number in self._satel.partition_states[satel_state]
+                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."""
@@ -146,21 +154,25 @@ class SatelIntegraAlarmPanel(SatelIntegraEntity, AlarmControlPanelEntity):
             self._attr_alarm_state == AlarmControlPanelState.TRIGGERED
         )
 
-        await self._satel.disarm(code, [self._device_number])
+        _LOGGER.debug("Disarming, self._attr_alarm_state: %s", self._attr_alarm_state)
+
+        await self._satel.disarm(code, [self._partition_id])
 
         if clear_alarm_necessary:
             # Wait 1s before clearing the alarm
             await asyncio.sleep(1)
-            await self._satel.clear_alarm(code, [self._device_number])
+            await self._satel.clear_alarm(code, [self._partition_id])
 
     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._device_number])
+            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._device_number], self._arm_home_mode)
+            await self._satel.arm(code, [self._partition_id], self._arm_home_mode)

homeassistant/components/satel_integra/binary_sensor.py

@@ -8,22 +8,25 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
-from homeassistant.config_entries import ConfigSubentry
+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_OUTPUT_NUMBER,
+    CONF_OUTPUTS,
     CONF_ZONE_NUMBER,
     CONF_ZONE_TYPE,
+    CONF_ZONES,
+    DOMAIN,
     SIGNAL_OUTPUTS_UPDATED,
     SIGNAL_ZONES_UPDATED,
     SUBENTRY_TYPE_OUTPUT,
     SUBENTRY_TYPE_ZONE,
     SatelConfigEntry,
 )
-from .entity import SatelIntegraEntity
 
 
 async def async_setup_entry(
@@ -43,16 +46,18 @@ async def async_setup_entry(
     for subentry in zone_subentries:
         zone_num: int = subentry.data[CONF_ZONE_NUMBER]
         zone_type: BinarySensorDeviceClass = subentry.data[CONF_ZONE_TYPE]
+        zone_name: str = subentry.data[CONF_NAME]
 
         async_add_entities(
             [
                 SatelIntegraBinarySensor(
                     controller,
-                    config_entry.entry_id,
-                    subentry,
                     zone_num,
+                    zone_name,
                     zone_type,
+                    CONF_ZONES,
                     SIGNAL_ZONES_UPDATED,
+                    config_entry.entry_id,
                 )
             ],
             config_subentry_id=subentry.subentry_id,
@@ -66,44 +71,51 @@ async def async_setup_entry(
     for subentry in output_subentries:
         output_num: int = subentry.data[CONF_OUTPUT_NUMBER]
         ouput_type: BinarySensorDeviceClass = subentry.data[CONF_ZONE_TYPE]
+        output_name: str = subentry.data[CONF_NAME]
 
         async_add_entities(
             [
                 SatelIntegraBinarySensor(
                     controller,
-                    config_entry.entry_id,
-                    subentry,
                     output_num,
+                    output_name,
                     ouput_type,
+                    CONF_OUTPUTS,
                     SIGNAL_OUTPUTS_UPDATED,
+                    config_entry.entry_id,
                 )
             ],
             config_subentry_id=subentry.subentry_id,
         )
 
 
-class SatelIntegraBinarySensor(SatelIntegraEntity, BinarySensorEntity):
+class SatelIntegraBinarySensor(BinarySensorEntity):
     """Representation of an Satel Integra binary sensor."""
 
+    _attr_should_poll = False
+    _attr_has_entity_name = True
+    _attr_name = None
+
     def __init__(
         self,
         controller: AsyncSatel,
-        config_entry_id: str,
-        subentry: ConfigSubentry,
         device_number: int,
+        device_name: str,
         device_class: BinarySensorDeviceClass,
+        sensor_type: str,
         react_to_signal: str,
+        config_entry_id: str,
     ) -> None:
         """Initialize the binary_sensor."""
-        super().__init__(
-            controller,
-            config_entry_id,
-            subentry,
-            device_number,
-        )
+        self._device_number = device_number
+        self._attr_unique_id = f"{config_entry_id}_{sensor_type}_{device_number}"
+        self._react_to_signal = react_to_signal
+        self._satel = controller
 
         self._attr_device_class = device_class
-        self._react_to_signal = react_to_signal
+        self._attr_device_info = DeviceInfo(
+            name=device_name, identifiers={(DOMAIN, self._attr_unique_id)}
+        )
 
     async def async_added_to_hass(self) -> None:
         """Register callbacks."""

homeassistant/components/satel_integra/entity.py

@@ -1,58 +0,0 @@
-"""Satel Integra base entity."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from satel_integra.satel_integra import AsyncSatel
-
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.const import CONF_NAME
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity import Entity
-
-from .const import (
-    DOMAIN,
-    SUBENTRY_TYPE_OUTPUT,
-    SUBENTRY_TYPE_PARTITION,
-    SUBENTRY_TYPE_SWITCHABLE_OUTPUT,
-    SUBENTRY_TYPE_ZONE,
-)
-
-SubentryTypeToEntityType: dict[str, str] = {
-    SUBENTRY_TYPE_PARTITION: "alarm_panel",
-    SUBENTRY_TYPE_SWITCHABLE_OUTPUT: "switch",
-    SUBENTRY_TYPE_ZONE: "zones",
-    SUBENTRY_TYPE_OUTPUT: "outputs",
-}
-
-
-class SatelIntegraEntity(Entity):
-    """Defines a base Satel Integra entity."""
-
-    _attr_should_poll = False
-    _attr_has_entity_name = True
-    _attr_name = None
-
-    def __init__(
-        self,
-        controller: AsyncSatel,
-        config_entry_id: str,
-        subentry: ConfigSubentry,
-        device_number: int,
-    ) -> None:
-        """Initialize the Satel Integra entity."""
-
-        self._satel = controller
-        self._device_number = device_number
-
-        entity_type = SubentryTypeToEntityType[subentry.subentry_type]
-
-        if TYPE_CHECKING:
-            assert entity_type is not None
-
-        self._attr_unique_id = f"{config_entry_id}_{entity_type}_{device_number}"
-
-        self._attr_device_info = DeviceInfo(
-            name=subentry.data[CONF_NAME], identifiers={(DOMAIN, self._attr_unique_id)}
-        )

homeassistant/components/satel_integra/switch.py

@@ -7,19 +7,19 @@ from typing import Any
 from satel_integra.satel_integra import AsyncSatel
 
 from homeassistant.components.switch import SwitchEntity
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.const import CONF_CODE
+from homeassistant.const import CONF_CODE, 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_SWITCHABLE_OUTPUT_NUMBER,
+    DOMAIN,
     SIGNAL_OUTPUTS_UPDATED,
     SUBENTRY_TYPE_SWITCHABLE_OUTPUT,
     SatelConfigEntry,
 )
-from .entity import SatelIntegraEntity
 
 
 async def async_setup_entry(
@@ -38,41 +38,46 @@ async def async_setup_entry(
 
     for subentry in switchable_output_subentries:
         switchable_output_num: int = subentry.data[CONF_SWITCHABLE_OUTPUT_NUMBER]
+        switchable_output_name: str = subentry.data[CONF_NAME]
 
         async_add_entities(
             [
                 SatelIntegraSwitch(
                     controller,
-                    config_entry.entry_id,
-                    subentry,
                     switchable_output_num,
+                    switchable_output_name,
                     config_entry.options.get(CONF_CODE),
+                    config_entry.entry_id,
                 ),
             ],
             config_subentry_id=subentry.subentry_id,
         )
 
 
-class SatelIntegraSwitch(SatelIntegraEntity, SwitchEntity):
-    """Representation of an Satel Integra switch."""
+class SatelIntegraSwitch(SwitchEntity):
+    """Representation of an Satel switch."""
+
+    _attr_should_poll = False
+    _attr_has_entity_name = True
+    _attr_name = None
 
     def __init__(
         self,
         controller: AsyncSatel,
-        config_entry_id: str,
-        subentry: ConfigSubentry,
         device_number: int,
+        device_name: str,
         code: str | None,
+        config_entry_id: str,
     ) -> None:
         """Initialize the switch."""
-        super().__init__(
-            controller,
-            config_entry_id,
-            subentry,
-            device_number,
-        )
-
+        self._device_number = device_number
+        self._attr_unique_id = f"{config_entry_id}_switch_{device_number}"
         self._code = code
+        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:
         """Register callbacks."""

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

@@ -3,22 +3,19 @@
 from __future__ import annotations
 
 from datetime import timedelta
-from http import HTTPStatus
 import logging
 
 from aiosenz import SENZAPI, Thermostat
-from httpx import HTTPStatusError, RequestError
-import jwt
+from httpx import RequestError
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, 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.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import (
+    config_entry_oauth2_flow,
+    config_validation as cv,
+    httpx_client,
 )
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -31,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)
 
@@ -60,21 +54,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: SENZConfigEntry) -> bool
 
     try:
         account = await senz_api.get_account()
-    except HTTPStatusError as err:
-        if err.response.status_code == HTTPStatus.UNAUTHORIZED:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="config_entry_auth_failed",
-            ) from err
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="config_entry_not_ready",
-        ) from err
     except RequestError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="config_entry_not_ready",
-        ) from err
+        raise ConfigEntryNotReady from err
 
     coordinator: SENZDataUpdateCoordinator = DataUpdateCoordinator(
         hass,
@@ -87,37 +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)
 
-
-async def async_migrate_entry(
-    hass: HomeAssistant, config_entry: SENZConfigEntry
-) -> bool:
-    """Migrate old entry."""
-
-    # Use sub(ject) from access_token as unique_id
-    if config_entry.version == 1 and config_entry.minor_version == 1:
-        token = jwt.decode(
-            config_entry.data["token"]["access_token"],
-            options={"verify_signature": False},
-        )
-        uid = token["sub"]
-        hass.config_entries.async_update_entry(
-            config_entry, unique_id=uid, minor_version=2
-        )
-        _LOGGER.info(
-            "Migration to version %s.%s successful",
-            config_entry.version,
-            config_entry.minor_version,
-        )
-
-    return True
+    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/config_flow.py

@@ -1,16 +1,7 @@
 """Config flow for nVent RAYCHEM SENZ."""
 
-from collections.abc import Mapping
 import logging
-from typing import Any
 
-import jwt
-
-from homeassistant.config_entries import (
-    SOURCE_REAUTH,
-    SOURCE_RECONFIGURE,
-    ConfigFlowResult,
-)
 from homeassistant.helpers import config_entry_oauth2_flow
 
 from .const import DOMAIN
@@ -21,8 +12,6 @@ class OAuth2FlowHandler(
 ):
     """Config flow to handle SENZ OAuth2 authentication."""
 
-    VERSION = 1
-    MINOR_VERSION = 2
     DOMAIN = DOMAIN
 
     @property
@@ -34,49 +23,3 @@ class OAuth2FlowHandler(
     def extra_authorize_data(self) -> dict:
         """Extra data that needs to be appended to the authorize url."""
         return {"scope": "restapi offline_access"}
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Perform reauth upon an API authentication error."""
-
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Dialog that informs the user that reauth is required."""
-        if user_input is None:
-            return self.async_show_form(step_id="reauth_confirm")
-
-        return await self.async_step_user()
-
-    async def async_step_reconfigure(
-        self, user_input: Mapping[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """User initiated reconfiguration."""
-        return await self.async_step_user()
-
-    async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
-        """Create or update the config entry."""
-
-        token = jwt.decode(
-            data["token"]["access_token"], options={"verify_signature": False}
-        )
-        uid = token["sub"]
-        await self.async_set_unique_id(uid)
-
-        if self.source == SOURCE_REAUTH:
-            self._abort_if_unique_id_mismatch(reason="account_mismatch")
-            return self.async_update_reload_and_abort(
-                self._get_reauth_entry(), data=data
-            )
-
-        if self.source == SOURCE_RECONFIGURE:
-            self._abort_if_unique_id_mismatch(reason="account_mismatch")
-            return self.async_update_reload_and_abort(
-                self._get_reconfigure_entry(), data=data
-            )
-
-        self._abort_if_unique_id_configured()
-        return await super().async_oauth_create_entry(data)

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

@@ -1,7 +1,6 @@
 {
   "config": {
     "abort": {
-      "account_mismatch": "The used account does not match the original account",
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
       "authorize_url_timeout": "[%key:common::config_flow::abort::oauth2_authorize_url_timeout%]",
@@ -10,9 +9,7 @@
       "oauth_error": "[%key:common::config_flow::abort::oauth2_error%]",
       "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
       "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
-      "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+      "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]"
     },
     "create_entry": {
       "default": "[%key:common::config_flow::create_entry::authenticated%]"
@@ -26,22 +23,7 @@
           "implementation": "[%key:common::config_flow::description::implementation%]"
         },
         "title": "[%key:common::config_flow::title::oauth2_pick_implementation%]"
-      },
-      "reauth_confirm": {
-        "description": "The SENZ integration needs to re-authenticate your account",
-        "title": "[%key:common::config_flow::title::reauth%]"
       }
     }
-  },
-  "exceptions": {
-    "config_entry_auth_failed": {
-      "message": "Authentication failed. Please log in again."
-    },
-    "config_entry_not_ready": {
-      "message": "Error while loading the integration."
-    },
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    }
   }
 }

homeassistant/components/smartthings/manifest.json

@@ -30,5 +30,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pysmartthings"],
   "quality_scale": "bronze",
-  "requirements": ["pysmartthings==3.3.3"]
+  "requirements": ["pysmartthings==3.3.2"]
 }

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/sql/services.py

@@ -19,13 +19,11 @@ from homeassistant.core import (
 )
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.trigger_template_entity import ValueTemplate
 from homeassistant.util.json import JsonValueType
 
 from .const import CONF_QUERY, DOMAIN
 from .util import (
     async_create_sessionmaker,
-    check_and_render_sql_query,
     convert_value,
     generate_lambda_stmt,
     redact_credentials,
@@ -39,9 +37,7 @@ _LOGGER = logging.getLogger(__name__)
 SERVICE_QUERY = "query"
 SERVICE_QUERY_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_QUERY): vol.All(
-            cv.template, ValueTemplate.from_template, validate_sql_select
-        ),
+        vol.Required(CONF_QUERY): vol.All(cv.string, validate_sql_select),
         vol.Optional(CONF_DB_URL): cv.string,
     }
 )
@@ -76,9 +72,8 @@ async def _async_query_service(
     def _execute_and_convert_query() -> list[JsonValueType]:
         """Execute the query and return the results with converted types."""
         sess: Session = sessmaker()
-        rendered_query = check_and_render_sql_query(call.hass, query_str)
         try:
-            result: Result = sess.execute(generate_lambda_stmt(rendered_query))
+            result: Result = sess.execute(generate_lambda_stmt(query_str))
         except SQLAlchemyError as err:
             _LOGGER.debug(
                 "Error executing query %s: %s",

homeassistant/components/sql/util.py

@@ -18,7 +18,7 @@ import voluptuous as vol
 
 from homeassistant.components.recorder import SupportedDialect, get_instance
 from homeassistant.const import EVENT_HOMEASSISTANT_STOP
-from homeassistant.core import Event, HomeAssistant, callback
+from homeassistant.core import Event, HomeAssistant, async_get_hass, callback
 from homeassistant.exceptions import HomeAssistantError, TemplateError
 from homeassistant.helpers import issue_registry as ir
 from homeassistant.helpers.template import Template
@@ -46,11 +46,15 @@ def resolve_db_url(hass: HomeAssistant, db_url: str | None) -> str:
     return get_instance(hass).db_url
 
 
-def validate_sql_select(value: Template) -> Template:
+def validate_sql_select(value: Template | str) -> Template | str:
     """Validate that value is a SQL SELECT query."""
+    hass: HomeAssistant
+    if isinstance(value, str):
+        hass = async_get_hass()
+    else:
+        hass = value.hass  # type: ignore[assignment]
     try:
-        assert value.hass
-        check_and_render_sql_query(value.hass, value)
+        check_and_render_sql_query(hass, value)
     except (TemplateError, InvalidSqlQuery) as err:
         raise vol.Invalid(str(err)) from err
     return value

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/template/alarm_control_panel.py

@@ -219,6 +219,7 @@ class AbstractTemplateAlarmControlPanel(
         self._attr_code_arm_required: bool = config[CONF_CODE_ARM_REQUIRED]
         self._attr_code_format = config[CONF_CODE_FORMAT].value
 
+        self._state: AlarmControlPanelState | None = None
         self._attr_supported_features: AlarmControlPanelEntityFeature = (
             AlarmControlPanelEntityFeature(0)
         )
@@ -243,6 +244,11 @@ class AbstractTemplateAlarmControlPanel(
             if (action_config := config.get(action_id)) is not None:
                 yield (action_id, action_config, supported_feature)
 
+    @property
+    def alarm_state(self) -> AlarmControlPanelState | None:
+        """Return the state of the device."""
+        return self._state
+
     async def _async_handle_restored_state(self) -> None:
         if (
             (last_state := await self.async_get_last_state()) is not None
@@ -250,14 +256,14 @@ class AbstractTemplateAlarmControlPanel(
             and last_state.state in _VALID_STATES
             # The trigger might have fired already while we waited for stored data,
             # then we should not restore state
-            and self._attr_alarm_state is None
+            and self._state is None
         ):
-            self._attr_alarm_state = AlarmControlPanelState(last_state.state)
+            self._state = AlarmControlPanelState(last_state.state)
 
     def _handle_state(self, result: Any) -> None:
         # Validate state
         if result in _VALID_STATES:
-            self._attr_alarm_state = result
+            self._state = result
             _LOGGER.debug("Valid state - %s", result)
             return
 
@@ -267,7 +273,7 @@ class AbstractTemplateAlarmControlPanel(
             self.entity_id,
             ", ".join(_VALID_STATES),
         )
-        self._attr_alarm_state = None
+        self._state = None
 
     async def _async_alarm_arm(self, state: Any, script: Script | None, code: Any):
         """Arm the panel to specified state with supplied script."""
@@ -278,7 +284,7 @@ class AbstractTemplateAlarmControlPanel(
             )
 
         if self._attr_assumed_state:
-            self._attr_alarm_state = state
+            self._state = state
             self.async_write_ha_state()
 
     async def async_alarm_arm_away(self, code: str | None = None) -> None:
@@ -370,7 +376,7 @@ class StateAlarmControlPanelEntity(TemplateEntity, AbstractTemplateAlarmControlP
     @callback
     def _update_state(self, result):
         if isinstance(result, TemplateError):
-            self._attr_alarm_state = None
+            self._state = None
             return
 
         self._handle_state(result)
@@ -380,7 +386,7 @@ class StateAlarmControlPanelEntity(TemplateEntity, AbstractTemplateAlarmControlP
         """Set up templates."""
         if self._template:
             self.add_template_attribute(
-                "_attr_alarm_state", self._template, None, self._update_state
+                "_state", self._template, None, self._update_state
             )
         super()._async_setup_templates()
 

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/const.py

@@ -709,7 +709,6 @@ class DPCode(StrEnum):
     DEW_POINT_TEMP = "dew_point_temp"
     DISINFECTION = "disinfection"
     DO_NOT_DISTURB = "do_not_disturb"
-    DOORBELL_PIC = "doorbell_pic"
     DOORCONTACT_STATE = "doorcontact_state"  # Status of door window sensor
     DOORCONTACT_STATE_2 = "doorcontact_state_2"
     DOORCONTACT_STATE_3 = "doorcontact_state_3"

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
 
@@ -15,13 +17,6 @@ from homeassistant.util import dt as dt_util
 from . import TuyaConfigEntry
 from .const import DOMAIN, DPCode
 
-_REDACTED_DPCODES = {
-    DPCode.ALARM_MESSAGE,
-    DPCode.ALARM_MSG,
-    DPCode.DOORBELL_PIC,
-    DPCode.MOVEMENT_DETECT_PIC,
-}
-
 
 async def async_get_config_entry_diagnostics(
     hass: HomeAssistant, entry: TuyaConfigEntry
@@ -102,24 +97,34 @@ def _async_device_as_dict(
     # Gather Tuya states
     for dpcode, value in device.status.items():
         # These statuses may contain sensitive information, redact these..
-        if dpcode in _REDACTED_DPCODES:
+        if dpcode in {DPCode.ALARM_MESSAGE, DPCode.MOVEMENT_DETECT_PIC}:
             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
@@ -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/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"
             ]