Merge remote-tracking branch 'upstream/dev' into air_quality_ozone_weather

homeassistant/bootstrap.py

@@ -468,7 +468,6 @@ async def async_load_base_functionality(hass: core.HomeAssistant) -> bool:
     translation.async_setup(hass)
 
     recovery = hass.config.recovery_mode
-    device_registry.async_setup(hass)
     try:
         await asyncio.gather(
             create_eager_task(get_internal_store_manager(hass).async_initialize()),

homeassistant/components/air_quality/condition.py

@@ -5,17 +5,23 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
 )
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
+from homeassistant.components.weather import (
+    ATTR_WEATHER_OZONE,
+    DOMAIN as WEATHER_DOMAIN,
+)
 from homeassistant.const import (
+    ATTR_UNIT_OF_MEASUREMENT,
     CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     CONCENTRATION_PARTS_PER_BILLION,
     CONCENTRATION_PARTS_PER_MILLION,
     STATE_OFF,
     STATE_ON,
 )
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.core import HomeAssistant, State
+from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.condition import (
     Condition,
+    EntityNumericalConditionWithUnitBase,
     make_entity_numerical_condition,
     make_entity_numerical_condition_with_unit,
     make_entity_state_condition,
@@ -49,6 +55,28 @@ def _make_cleared_condition(
     )
 
 
+OZONE_DOMAIN_SPECS = {
+    SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.OZONE),
+    WEATHER_DOMAIN: NumericalDomainSpec(value_source=ATTR_WEATHER_OZONE),
+}
+
+
+class OzoneCondition(EntityNumericalConditionWithUnitBase):
+    """Condition for ozone value across sensor and weather domains."""
+
+    _base_unit = CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
+    _domain_specs = OZONE_DOMAIN_SPECS
+    _unit_converter = OzoneConcentrationConverter
+
+    def _get_entity_unit(self, entity_state: State) -> str | None:
+        """Get the ozone unit of an entity from its state."""
+        if entity_state.domain == WEATHER_DOMAIN:
+            # Weather entities report ozone without a unit attribute;
+            # assume the base unit (μg/m³) so no conversion is applied.
+            return self._base_unit
+        return entity_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
+
+
 CONDITIONS: dict[str, type[Condition]] = {
     # Binary sensor conditions (detected/cleared)
     "is_gas_detected": _make_detected_condition(BinarySensorDeviceClass.GAS),
@@ -59,18 +87,14 @@ CONDITIONS: dict[str, type[Condition]] = {
     "is_smoke_cleared": _make_cleared_condition(BinarySensorDeviceClass.SMOKE),
     # Numerical sensor conditions with unit conversion
     "is_co_value": make_entity_numerical_condition_with_unit(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.CO)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.CO)},
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         CarbonMonoxideConcentrationConverter,
     ),
-    "is_ozone_value": make_entity_numerical_condition_with_unit(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.OZONE)},
-        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        OzoneConcentrationConverter,
-    ),
+    "is_ozone_value": OzoneCondition,
     "is_voc_value": make_entity_numerical_condition_with_unit(
         {
-            SENSOR_DOMAIN: DomainSpec(
+            SENSOR_DOMAIN: NumericalDomainSpec(
                 device_class=SensorDeviceClass.VOLATILE_ORGANIC_COMPOUNDS
             )
         },
@@ -79,7 +103,7 @@ CONDITIONS: dict[str, type[Condition]] = {
     ),
     "is_voc_ratio_value": make_entity_numerical_condition_with_unit(
         {
-            SENSOR_DOMAIN: DomainSpec(
+            SENSOR_DOMAIN: NumericalDomainSpec(
                 device_class=SensorDeviceClass.VOLATILE_ORGANIC_COMPOUNDS_PARTS
             )
         },
@@ -87,43 +111,59 @@ CONDITIONS: dict[str, type[Condition]] = {
         UnitlessRatioConverter,
     ),
     "is_no_value": make_entity_numerical_condition_with_unit(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.NITROGEN_MONOXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.NITROGEN_MONOXIDE
+            )
+        },
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         NitrogenMonoxideConcentrationConverter,
     ),
     "is_no2_value": make_entity_numerical_condition_with_unit(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.NITROGEN_DIOXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.NITROGEN_DIOXIDE
+            )
+        },
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         NitrogenDioxideConcentrationConverter,
     ),
     "is_so2_value": make_entity_numerical_condition_with_unit(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.SULPHUR_DIOXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.SULPHUR_DIOXIDE
+            )
+        },
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         SulphurDioxideConcentrationConverter,
     ),
     # Numerical sensor conditions without unit conversion (single-unit device classes)
     "is_co2_value": make_entity_numerical_condition(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.CO2)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.CO2)},
         valid_unit=CONCENTRATION_PARTS_PER_MILLION,
     ),
     "is_pm1_value": make_entity_numerical_condition(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM1)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM1)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "is_pm25_value": make_entity_numerical_condition(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM25)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM25)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "is_pm4_value": make_entity_numerical_condition(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM4)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM4)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "is_pm10_value": make_entity_numerical_condition(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM10)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM10)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "is_n2o_value": make_entity_numerical_condition(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.NITROUS_OXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.NITROUS_OXIDE
+            )
+        },
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
 }

homeassistant/components/air_quality/conditions.yaml

@@ -213,6 +213,7 @@
   entity:
     - domain: sensor
       device_class: ozone
+    - domain: weather
 
 .target_voc: &target_voc
   entity:

homeassistant/components/air_quality/trigger.py

@@ -5,16 +5,24 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
 )
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
+from homeassistant.components.weather import (
+    ATTR_WEATHER_OZONE,
+    DOMAIN as WEATHER_DOMAIN,
+)
 from homeassistant.const import (
+    ATTR_UNIT_OF_MEASUREMENT,
     CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     CONCENTRATION_PARTS_PER_BILLION,
     CONCENTRATION_PARTS_PER_MILLION,
     STATE_OFF,
     STATE_ON,
 )
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.core import HomeAssistant, State
+from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.trigger import (
+    EntityNumericalStateChangedTriggerWithUnitBase,
+    EntityNumericalStateCrossedThresholdTriggerWithUnitBase,
+    EntityNumericalStateTriggerWithUnitBase,
     EntityTargetStateTriggerBase,
     Trigger,
     make_entity_numerical_state_changed_trigger,
@@ -54,6 +62,40 @@ def _make_cleared_trigger(
     )
 
 
+OZONE_DOMAIN_SPECS = {
+    SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.OZONE),
+    WEATHER_DOMAIN: NumericalDomainSpec(value_source=ATTR_WEATHER_OZONE),
+}
+
+
+class _OzoneTriggerMixin(EntityNumericalStateTriggerWithUnitBase):
+    """Mixin for ozone triggers providing entity filtering, value extraction, and unit conversion."""
+
+    _base_unit = CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
+    _domain_specs = OZONE_DOMAIN_SPECS
+    _unit_converter = OzoneConcentrationConverter
+
+    def _get_entity_unit(self, state: State) -> str | None:
+        """Get the ozone unit of an entity from its state."""
+        if state.domain == WEATHER_DOMAIN:
+            # Weather entities report ozone without a unit attribute;
+            # assume the base unit (μg/m³) so no conversion is applied.
+            return self._base_unit
+        return state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
+
+
+class OzoneChangedTrigger(
+    _OzoneTriggerMixin, EntityNumericalStateChangedTriggerWithUnitBase
+):
+    """Trigger for ozone value changes across sensor and weather domains."""
+
+
+class OzoneCrossedThresholdTrigger(
+    _OzoneTriggerMixin, EntityNumericalStateCrossedThresholdTriggerWithUnitBase
+):
+    """Trigger for ozone value crossing a threshold across sensor and weather domains."""
+
+
 TRIGGERS: dict[str, type[Trigger]] = {
     # Binary sensor triggers (detected/cleared)
     "gas_detected": _make_detected_trigger(BinarySensorDeviceClass.GAS),
@@ -64,28 +106,20 @@ TRIGGERS: dict[str, type[Trigger]] = {
     "smoke_cleared": _make_cleared_trigger(BinarySensorDeviceClass.SMOKE),
     # Numerical sensor triggers with unit conversion
     "co_changed": make_entity_numerical_state_changed_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.CO)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.CO)},
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         CarbonMonoxideConcentrationConverter,
     ),
     "co_crossed_threshold": make_entity_numerical_state_crossed_threshold_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.CO)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.CO)},
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         CarbonMonoxideConcentrationConverter,
     ),
-    "ozone_changed": make_entity_numerical_state_changed_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.OZONE)},
-        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        OzoneConcentrationConverter,
-    ),
-    "ozone_crossed_threshold": make_entity_numerical_state_crossed_threshold_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.OZONE)},
-        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        OzoneConcentrationConverter,
-    ),
+    "ozone_changed": OzoneChangedTrigger,
+    "ozone_crossed_threshold": OzoneCrossedThresholdTrigger,
     "voc_changed": make_entity_numerical_state_changed_with_unit_trigger(
         {
-            SENSOR_DOMAIN: DomainSpec(
+            SENSOR_DOMAIN: NumericalDomainSpec(
                 device_class=SensorDeviceClass.VOLATILE_ORGANIC_COMPOUNDS
             )
         },
@@ -94,7 +128,7 @@ TRIGGERS: dict[str, type[Trigger]] = {
     ),
     "voc_crossed_threshold": make_entity_numerical_state_crossed_threshold_with_unit_trigger(
         {
-            SENSOR_DOMAIN: DomainSpec(
+            SENSOR_DOMAIN: NumericalDomainSpec(
                 device_class=SensorDeviceClass.VOLATILE_ORGANIC_COMPOUNDS
             )
         },
@@ -103,7 +137,7 @@ TRIGGERS: dict[str, type[Trigger]] = {
     ),
     "voc_ratio_changed": make_entity_numerical_state_changed_with_unit_trigger(
         {
-            SENSOR_DOMAIN: DomainSpec(
+            SENSOR_DOMAIN: NumericalDomainSpec(
                 device_class=SensorDeviceClass.VOLATILE_ORGANIC_COMPOUNDS_PARTS
             )
         },
@@ -112,7 +146,7 @@ TRIGGERS: dict[str, type[Trigger]] = {
     ),
     "voc_ratio_crossed_threshold": make_entity_numerical_state_crossed_threshold_with_unit_trigger(
         {
-            SENSOR_DOMAIN: DomainSpec(
+            SENSOR_DOMAIN: NumericalDomainSpec(
                 device_class=SensorDeviceClass.VOLATILE_ORGANIC_COMPOUNDS_PARTS
             )
         },
@@ -120,82 +154,114 @@ TRIGGERS: dict[str, type[Trigger]] = {
         UnitlessRatioConverter,
     ),
     "no_changed": make_entity_numerical_state_changed_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.NITROGEN_MONOXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.NITROGEN_MONOXIDE
+            )
+        },
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         NitrogenMonoxideConcentrationConverter,
     ),
     "no_crossed_threshold": make_entity_numerical_state_crossed_threshold_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.NITROGEN_MONOXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.NITROGEN_MONOXIDE
+            )
+        },
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         NitrogenMonoxideConcentrationConverter,
     ),
     "no2_changed": make_entity_numerical_state_changed_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.NITROGEN_DIOXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.NITROGEN_DIOXIDE
+            )
+        },
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         NitrogenDioxideConcentrationConverter,
     ),
     "no2_crossed_threshold": make_entity_numerical_state_crossed_threshold_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.NITROGEN_DIOXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.NITROGEN_DIOXIDE
+            )
+        },
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         NitrogenDioxideConcentrationConverter,
     ),
     "so2_changed": make_entity_numerical_state_changed_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.SULPHUR_DIOXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.SULPHUR_DIOXIDE
+            )
+        },
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         SulphurDioxideConcentrationConverter,
     ),
     "so2_crossed_threshold": make_entity_numerical_state_crossed_threshold_with_unit_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.SULPHUR_DIOXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.SULPHUR_DIOXIDE
+            )
+        },
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         SulphurDioxideConcentrationConverter,
     ),
     # Numerical sensor triggers without unit conversion (single-unit device classes)
     "co2_changed": make_entity_numerical_state_changed_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.CO2)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.CO2)},
         valid_unit=CONCENTRATION_PARTS_PER_MILLION,
     ),
     "co2_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.CO2)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.CO2)},
         valid_unit=CONCENTRATION_PARTS_PER_MILLION,
     ),
     "pm1_changed": make_entity_numerical_state_changed_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM1)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM1)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "pm1_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM1)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM1)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "pm25_changed": make_entity_numerical_state_changed_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM25)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM25)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "pm25_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM25)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM25)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "pm4_changed": make_entity_numerical_state_changed_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM4)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM4)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "pm4_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM4)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM4)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "pm10_changed": make_entity_numerical_state_changed_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM10)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM10)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "pm10_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.PM10)},
+        {SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.PM10)},
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "n2o_changed": make_entity_numerical_state_changed_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.NITROUS_OXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.NITROUS_OXIDE
+            )
+        },
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
     "n2o_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.NITROUS_OXIDE)},
+        {
+            SENSOR_DOMAIN: NumericalDomainSpec(
+                device_class=SensorDeviceClass.NITROUS_OXIDE
+            )
+        },
         valid_unit=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
 }

homeassistant/components/air_quality/triggers.yaml

@@ -217,6 +217,7 @@
   entity:
     - domain: sensor
       device_class: ozone
+    - domain: weather
 
 .target_voc: &target_voc
   entity:

homeassistant/components/aladdin_connect/__init__.py

@@ -13,9 +13,6 @@ from homeassistant.helpers import (
     config_entry_oauth2_flow,
     device_registry as dr,
 )
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
-)
 
 from . import api
 from .const import CONFIG_FLOW_MINOR_VERSION, CONFIG_FLOW_VERSION, DOMAIN
@@ -28,17 +25,11 @@ async def async_setup_entry(
     hass: HomeAssistant, entry: AladdinConnectConfigEntry
 ) -> bool:
     """Set up Aladdin Connect Genie from a config entry."""
-    try:
-        implementation = (
-            await config_entry_oauth2_flow.async_get_config_entry_implementation(
-                hass, entry
-            )
+    implementation = (
+        await config_entry_oauth2_flow.async_get_config_entry_implementation(
+            hass, entry
         )
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
+    )
 
     session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
 

homeassistant/components/aladdin_connect/strings.json

@@ -37,9 +37,6 @@
     "close_door_failed": {
       "message": "Failed to close the garage door"
     },
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    },
     "open_door_failed": {
       "message": "Failed to open the garage door"
     }

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/auth/login_flow.py

@@ -142,13 +142,6 @@ class WellKnownOAuthInfoView(HomeAssistantView):
             "authorization_endpoint": f"{url_prefix}/auth/authorize",
             "token_endpoint": f"{url_prefix}/auth/token",
             "revocation_endpoint": f"{url_prefix}/auth/revoke",
-            # Home Assistant already accepts URL-based client_ids via
-            # IndieAuth without prior registration, which is compatible with
-            # draft-ietf-oauth-client-id-metadata-document. This flag
-            # advertises that support to encourage clients to use it. The
-            # metadata document is not actually fetched as IndieAuth doesn't
-            # require it.
-            "client_id_metadata_document_supported": True,
             "response_types_supported": ["code"],
             "service_documentation": (
                 "https://developers.home-assistant.io/docs/auth_api"

homeassistant/components/automation/__init__.py

@@ -122,7 +122,6 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "alarm_control_panel",
     "assist_satellite",
     "battery",
-    "calendar",
     "climate",
     "cover",
     "device_tracker",
@@ -143,14 +142,11 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "person",
     "power",
     "schedule",
-    "select",
     "siren",
     "switch",
     "temperature",
     "text",
-    "timer",
     "vacuum",
-    "valve",
     "water_heater",
     "window",
 }
@@ -159,7 +155,6 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "air_quality",
     "alarm_control_panel",
     "assist_satellite",
-    "battery",
     "button",
     "climate",
     "counter",
@@ -190,7 +185,6 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "switch",
     "temperature",
     "text",
-    "todo",
     "update",
     "vacuum",
     "water_heater",

homeassistant/components/battery/__init__.py

@@ -1,4 +1,4 @@
-"""Integration for battery triggers and conditions."""
+"""Integration for battery conditions."""
 
 from __future__ import annotations
 

homeassistant/components/battery/condition.py

@@ -6,6 +6,7 @@ from homeassistant.components.binary_sensor import (
     DOMAIN as BINARY_SENSOR_DOMAIN,
     BinarySensorDeviceClass,
 )
+from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN, NumberDeviceClass
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
 from homeassistant.const import PERCENTAGE, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
@@ -26,6 +27,7 @@ BATTERY_CHARGING_DOMAIN_SPECS = {
 }
 BATTERY_PERCENTAGE_DOMAIN_SPECS = {
     SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.BATTERY),
+    NUMBER_DOMAIN: DomainSpec(device_class=NumberDeviceClass.BATTERY),
 }
 
 CONDITIONS: dict[str, type[Condition]] = {

homeassistant/components/battery/conditions.yaml

@@ -53,6 +53,8 @@ is_level:
     entity:
       - domain: sensor
         device_class: battery
+      - domain: number
+        device_class: battery
   fields:
     behavior: *condition_behavior
     threshold:

homeassistant/components/battery/icons.json

@@ -15,25 +15,5 @@
     "is_not_low": {
       "condition": "mdi:battery"
     }
-  },
-  "triggers": {
-    "level_changed": {
-      "trigger": "mdi:battery-unknown"
-    },
-    "level_crossed_threshold": {
-      "trigger": "mdi:battery-alert"
-    },
-    "low": {
-      "trigger": "mdi:battery-alert"
-    },
-    "not_low": {
-      "trigger": "mdi:battery"
-    },
-    "started_charging": {
-      "trigger": "mdi:battery-charging"
-    },
-    "stopped_charging": {
-      "trigger": "mdi:battery"
-    }
   }
 }

homeassistant/components/battery/strings.json

@@ -3,12 +3,7 @@
     "condition_behavior_description": "How the state should match on the targeted batteries.",
     "condition_behavior_name": "Behavior",
     "condition_threshold_description": "What to test for and threshold values.",
-    "condition_threshold_name": "Threshold configuration",
-    "trigger_behavior_description": "The behavior of the targeted batteries to trigger on.",
-    "trigger_behavior_name": "Behavior",
-    "trigger_threshold_changed_description": "Which changes to trigger on and threshold values.",
-    "trigger_threshold_crossed_description": "Which threshold crossing to trigger on and threshold values.",
-    "trigger_threshold_name": "Threshold configuration"
+    "condition_threshold_name": "Threshold configuration"
   },
   "conditions": {
     "is_charging": {
@@ -72,80 +67,7 @@
         "all": "All",
         "any": "Any"
       }
-    },
-    "trigger_behavior": {
-      "options": {
-        "any": "Any",
-        "first": "First",
-        "last": "Last"
-      }
     }
   },
-  "title": "Battery",
-  "triggers": {
-    "level_changed": {
-      "description": "Triggers after the battery level of one or more batteries changes.",
-      "fields": {
-        "threshold": {
-          "description": "[%key:component::battery::common::trigger_threshold_changed_description%]",
-          "name": "[%key:component::battery::common::trigger_threshold_name%]"
-        }
-      },
-      "name": "Battery level changed"
-    },
-    "level_crossed_threshold": {
-      "description": "Triggers after the battery level of one or more batteries crosses a threshold.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::battery::common::trigger_behavior_description%]",
-          "name": "[%key:component::battery::common::trigger_behavior_name%]"
-        },
-        "threshold": {
-          "description": "[%key:component::battery::common::trigger_threshold_crossed_description%]",
-          "name": "[%key:component::battery::common::trigger_threshold_name%]"
-        }
-      },
-      "name": "Battery level crossed threshold"
-    },
-    "low": {
-      "description": "Triggers after one or more batteries become low.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::battery::common::trigger_behavior_description%]",
-          "name": "[%key:component::battery::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "Battery low"
-    },
-    "not_low": {
-      "description": "Triggers after one or more batteries are no longer low.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::battery::common::trigger_behavior_description%]",
-          "name": "[%key:component::battery::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "Battery not low"
-    },
-    "started_charging": {
-      "description": "Triggers after one or more batteries start charging.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::battery::common::trigger_behavior_description%]",
-          "name": "[%key:component::battery::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "Battery started charging"
-    },
-    "stopped_charging": {
-      "description": "Triggers after one or more batteries stop charging.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::battery::common::trigger_behavior_description%]",
-          "name": "[%key:component::battery::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "Battery stopped charging"
-    }
-  }
+  "title": "Battery"
 }

homeassistant/components/battery/trigger.py

@@ -1,54 +0,0 @@
-"""Provides triggers for batteries."""
-
-from __future__ import annotations
-
-from homeassistant.components.binary_sensor import (
-    DOMAIN as BINARY_SENSOR_DOMAIN,
-    BinarySensorDeviceClass,
-)
-from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
-from homeassistant.const import STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.trigger import (
-    Trigger,
-    make_entity_numerical_state_changed_trigger,
-    make_entity_numerical_state_crossed_threshold_trigger,
-    make_entity_target_state_trigger,
-)
-
-BATTERY_LOW_DOMAIN_SPECS: dict[str, DomainSpec] = {
-    BINARY_SENSOR_DOMAIN: DomainSpec(device_class=BinarySensorDeviceClass.BATTERY),
-}
-
-BATTERY_CHARGING_DOMAIN_SPECS: dict[str, DomainSpec] = {
-    BINARY_SENSOR_DOMAIN: DomainSpec(
-        device_class=BinarySensorDeviceClass.BATTERY_CHARGING
-    ),
-}
-
-BATTERY_PERCENTAGE_DOMAIN_SPECS: dict[str, DomainSpec] = {
-    SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.BATTERY),
-}
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "low": make_entity_target_state_trigger(BATTERY_LOW_DOMAIN_SPECS, STATE_ON),
-    "not_low": make_entity_target_state_trigger(BATTERY_LOW_DOMAIN_SPECS, STATE_OFF),
-    "started_charging": make_entity_target_state_trigger(
-        BATTERY_CHARGING_DOMAIN_SPECS, STATE_ON
-    ),
-    "stopped_charging": make_entity_target_state_trigger(
-        BATTERY_CHARGING_DOMAIN_SPECS, STATE_OFF
-    ),
-    "level_changed": make_entity_numerical_state_changed_trigger(
-        BATTERY_PERCENTAGE_DOMAIN_SPECS, valid_unit="%"
-    ),
-    "level_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        BATTERY_PERCENTAGE_DOMAIN_SPECS, valid_unit="%"
-    ),
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for batteries."""
-    return TRIGGERS

homeassistant/components/battery/triggers.yaml

@@ -1,83 +0,0 @@
-.trigger_common_fields:
-  behavior: &trigger_behavior
-    required: true
-    default: any
-    selector:
-      select:
-        translation_key: trigger_behavior
-        options:
-          - first
-          - last
-          - any
-
-.battery_threshold_entity: &battery_threshold_entity
-  - domain: input_number
-    unit_of_measurement: "%"
-  - domain: number
-    device_class: battery
-  - domain: sensor
-    device_class: battery
-
-.battery_threshold_number: &battery_threshold_number
-  min: 0
-  max: 100
-  mode: box
-  unit_of_measurement: "%"
-
-.trigger_target_battery: &trigger_target_battery
-  entity:
-    - domain: binary_sensor
-      device_class: battery
-
-.trigger_target_charging: &trigger_target_charging
-  entity:
-    - domain: binary_sensor
-      device_class: battery_charging
-
-.trigger_target_percentage: &trigger_target_percentage
-  entity:
-    - domain: sensor
-      device_class: battery
-
-low:
-  fields:
-    behavior: *trigger_behavior
-  target: *trigger_target_battery
-
-not_low:
-  fields:
-    behavior: *trigger_behavior
-  target: *trigger_target_battery
-
-started_charging:
-  fields:
-    behavior: *trigger_behavior
-  target: *trigger_target_charging
-
-stopped_charging:
-  fields:
-    behavior: *trigger_behavior
-  target: *trigger_target_charging
-
-level_changed:
-  target: *trigger_target_percentage
-  fields:
-    threshold:
-      required: true
-      selector:
-        numeric_threshold:
-          entity: *battery_threshold_entity
-          mode: changed
-          number: *battery_threshold_number
-
-level_crossed_threshold:
-  target: *trigger_target_percentage
-  fields:
-    behavior: *trigger_behavior
-    threshold:
-      required: true
-      selector:
-        numeric_threshold:
-          entity: *battery_threshold_entity
-          mode: crossed
-          number: *battery_threshold_number

homeassistant/components/calendar/__init__.py

@@ -578,13 +578,13 @@ class CalendarEntity(Entity):
         return STATE_OFF
 
     @callback
-    def _async_write_ha_state(self) -> None:
+    def async_write_ha_state(self) -> None:
         """Write the state to the state machine.
 
         This sets up listeners to handle state transitions for start or end of
         the current or upcoming event.
         """
-        super()._async_write_ha_state()
+        super().async_write_ha_state()
         if self._alarm_unsubs is None:
             self._alarm_unsubs = []
         _LOGGER.debug(

homeassistant/components/calendar/condition.py

@@ -1,16 +0,0 @@
-"""Provides conditions for calendars."""
-
-from homeassistant.const import STATE_ON
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.condition import Condition, make_entity_state_condition
-
-from .const import DOMAIN
-
-CONDITIONS: dict[str, type[Condition]] = {
-    "is_event_active": make_entity_state_condition(DOMAIN, STATE_ON),
-}
-
-
-async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
-    """Return the calendar conditions."""
-    return CONDITIONS

homeassistant/components/calendar/conditions.yaml

@@ -1,14 +0,0 @@
-is_event_active:
-  target:
-    entity:
-      - domain: calendar
-  fields:
-    behavior:
-      required: true
-      default: any
-      selector:
-        select:
-          translation_key: condition_behavior
-          options:
-            - all
-            - any

homeassistant/components/calendar/icons.json

@@ -1,9 +1,4 @@
 {
-  "conditions": {
-    "is_event_active": {
-      "condition": "mdi:calendar-check"
-    }
-  },
   "entity_component": {
     "_": {
       "default": "mdi:calendar",

homeassistant/components/calendar/strings.json

@@ -1,20 +1,4 @@
 {
-  "common": {
-    "condition_behavior_description": "How the state should match on the targeted calendars.",
-    "condition_behavior_name": "Behavior"
-  },
-  "conditions": {
-    "is_event_active": {
-      "description": "Tests if one or more calendars have an active event.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::calendar::common::condition_behavior_description%]",
-          "name": "[%key:component::calendar::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Calendar event is active"
-    }
-  },
   "entity_component": {
     "_": {
       "name": "[%key:component::calendar::title%]",
@@ -62,12 +46,6 @@
     }
   },
   "selector": {
-    "condition_behavior": {
-      "options": {
-        "all": "All",
-        "any": "Any"
-      }
-    },
     "trigger_offset_type": {
       "options": {
         "after": "After",

homeassistant/components/camera/__init__.py

@@ -760,12 +760,12 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         return CameraCapabilities(frontend_stream_types)
 
     @callback
-    def _async_write_ha_state(self) -> None:
+    def async_write_ha_state(self) -> None:
         """Write the state to the state machine.
 
         Schedules async_refresh_providers if support of streams have changed.
         """
-        super()._async_write_ha_state()
+        super().async_write_ha_state()
         if self.__supports_stream != (
             supports_stream := self.supported_features & CameraEntityFeature.STREAM
         ):

homeassistant/components/climate/condition.py

@@ -1,18 +1,10 @@
 """Provides conditions for climates."""
 
-from typing import TYPE_CHECKING
-
-import voluptuous as vol
-
-from homeassistant.const import ATTR_TEMPERATURE, CONF_OPTIONS, UnitOfTemperature
+from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant, State
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.condition import (
-    ENTITY_STATE_CONDITION_SCHEMA_ANY_ALL,
     Condition,
-    ConditionConfig,
-    EntityConditionBase,
     EntityNumericalConditionWithUnitBase,
     make_entity_numerical_condition,
     make_entity_state_condition,
@@ -21,42 +13,12 @@ from homeassistant.util.unit_conversion import TemperatureConverter
 
 from .const import ATTR_HUMIDITY, ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode
 
-CONF_HVAC_MODE = "hvac_mode"
-
-_HVAC_MODE_CONDITION_SCHEMA = ENTITY_STATE_CONDITION_SCHEMA_ANY_ALL.extend(
-    {
-        vol.Required(CONF_OPTIONS): {
-            vol.Required(CONF_HVAC_MODE): vol.All(
-                cv.ensure_list, vol.Length(min=1), [vol.Coerce(HVACMode)]
-            ),
-        },
-    }
-)
-
-
-class ClimateHVACModeCondition(EntityConditionBase):
-    """Condition for climate HVAC mode."""
-
-    _domain_specs = {DOMAIN: DomainSpec()}
-    _schema = _HVAC_MODE_CONDITION_SCHEMA
-
-    def __init__(self, hass: HomeAssistant, config: ConditionConfig) -> None:
-        """Initialize the HVAC mode condition."""
-        super().__init__(hass, config)
-        if TYPE_CHECKING:
-            assert config.options is not None
-        self._hvac_modes: set[str] = set(config.options[CONF_HVAC_MODE])
-
-    def is_valid_state(self, entity_state: State) -> bool:
-        """Check if the state matches any of the expected HVAC modes."""
-        return entity_state.state in self._hvac_modes
-
 
 class ClimateTargetTemperatureCondition(EntityNumericalConditionWithUnitBase):
     """Mixin for climate target temperature conditions with unit conversion."""
 
     _base_unit = UnitOfTemperature.CELSIUS
-    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_TEMPERATURE)}
+    _domain_specs = {DOMAIN: NumericalDomainSpec(value_source=ATTR_TEMPERATURE)}
     _unit_converter = TemperatureConverter
 
     def _get_entity_unit(self, entity_state: State) -> str | None:
@@ -66,7 +28,6 @@ class ClimateTargetTemperatureCondition(EntityNumericalConditionWithUnitBase):
 
 
 CONDITIONS: dict[str, type[Condition]] = {
-    "is_hvac_mode": ClimateHVACModeCondition,
     "is_off": make_entity_state_condition(DOMAIN, HVACMode.OFF),
     "is_on": make_entity_state_condition(
         DOMAIN,
@@ -89,7 +50,7 @@ CONDITIONS: dict[str, type[Condition]] = {
         {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.HEATING
     ),
     "target_humidity": make_entity_numerical_condition(
-        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
+        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)},
         valid_unit="%",
     ),
     "target_temperature": ClimateTargetTemperatureCondition,

homeassistant/components/climate/conditions.yaml

@@ -45,21 +45,6 @@ is_cooling: *condition_common
 is_drying: *condition_common
 is_heating: *condition_common
 
-is_hvac_mode:
-  target: *condition_climate_target
-  fields:
-    behavior: *condition_behavior
-    hvac_mode:
-      context:
-        filter_target: target
-      required: true
-      selector:
-        state:
-          hide_states:
-            - unavailable
-            - unknown
-          multiple: true
-
 target_humidity:
   target: *condition_climate_target
   fields:

homeassistant/components/climate/icons.json

@@ -9,9 +9,6 @@
     "is_heating": {
       "condition": "mdi:fire"
     },
-    "is_hvac_mode": {
-      "condition": "mdi:thermostat"
-    },
     "is_off": {
       "condition": "mdi:power-off"
     },

homeassistant/components/climate/strings.json

@@ -41,20 +41,6 @@
       },
       "name": "Climate-control device is heating"
     },
-    "is_hvac_mode": {
-      "description": "Tests if one or more climate-control devices are set to a specific HVAC mode.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::climate::common::condition_behavior_description%]",
-          "name": "[%key:component::climate::common::condition_behavior_name%]"
-        },
-        "hvac_mode": {
-          "description": "The HVAC modes to test for.",
-          "name": "Modes"
-        }
-      },
-      "name": "Climate-control device HVAC mode"
-    },
     "is_off": {
       "description": "Tests if one or more climate-control devices are off.",
       "fields": {

homeassistant/components/climate/trigger.py

@@ -5,7 +5,7 @@ import voluptuous as vol
 from homeassistant.const import ATTR_TEMPERATURE, CONF_OPTIONS, UnitOfTemperature
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.trigger import (
     ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
     EntityNumericalStateChangedTriggerWithUnitBase,
@@ -52,7 +52,7 @@ class _ClimateTargetTemperatureTriggerMixin(EntityNumericalStateTriggerWithUnitB
     """Mixin for climate target temperature triggers with unit conversion."""
 
     _base_unit = UnitOfTemperature.CELSIUS
-    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_TEMPERATURE)}
+    _domain_specs = {DOMAIN: NumericalDomainSpec(value_source=ATTR_TEMPERATURE)}
     _unit_converter = TemperatureConverter
 
     def _get_entity_unit(self, state: State) -> str | None:
@@ -84,11 +84,11 @@ TRIGGERS: dict[str, type[Trigger]] = {
         {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.DRYING
     ),
     "target_humidity_changed": make_entity_numerical_state_changed_trigger(
-        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
+        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)},
         valid_unit="%",
     ),
     "target_humidity_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
+        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)},
         valid_unit="%",
     ),
     "target_temperature_changed": ClimateTargetTemperatureChangedTrigger,

homeassistant/components/cover/condition.py

@@ -1,7 +1,5 @@
 """Provides conditions for covers."""
 
-from collections.abc import Mapping
-
 from homeassistant.const import STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.condition import Condition, EntityConditionBase
@@ -10,11 +8,9 @@ from .const import ATTR_IS_CLOSED, DOMAIN, CoverDeviceClass
 from .models import CoverDomainSpec
 
 
-class CoverConditionBase(EntityConditionBase):
+class CoverConditionBase(EntityConditionBase[CoverDomainSpec]):
     """Base condition for cover state checks."""
 
-    _domain_specs: Mapping[str, CoverDomainSpec]
-
     def is_valid_state(self, entity_state: State) -> bool:
         """Check if the state matches the expected cover state."""
         domain_spec = self._domain_specs[entity_state.domain]

homeassistant/components/cover/trigger.py

@@ -1,7 +1,5 @@
 """Provides triggers for covers."""
 
-from collections.abc import Mapping
-
 from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.trigger import EntityTriggerBase, Trigger
@@ -10,11 +8,9 @@ from .const import ATTR_IS_CLOSED, DOMAIN, CoverDeviceClass
 from .models import CoverDomainSpec
 
 
-class CoverTriggerBase(EntityTriggerBase):
+class CoverTriggerBase(EntityTriggerBase[CoverDomainSpec]):
     """Base trigger for cover state changes."""
 
-    _domain_specs: Mapping[str, CoverDomainSpec]
-
     def _get_value(self, state: State) -> str | bool | None:
         """Extract the relevant value from state based on domain spec."""
         domain_spec = self._domain_specs[state.domain]

homeassistant/components/demo/remote.py

@@ -44,18 +44,18 @@ class DemoRemote(RemoteEntity):
             return {"last_command_sent": self._last_command_sent}
         return None
 
-    async def async_turn_on(self, **kwargs: Any) -> None:
+    def turn_on(self, **kwargs: Any) -> None:
         """Turn the remote on."""
         self._attr_is_on = True
-        self.async_write_ha_state()
+        self.schedule_update_ha_state()
 
-    async def async_turn_off(self, **kwargs: Any) -> None:
+    def turn_off(self, **kwargs: Any) -> None:
         """Turn the remote off."""
         self._attr_is_on = False
-        self.async_write_ha_state()
+        self.schedule_update_ha_state()
 
-    async def async_send_command(self, command: Iterable[str], **kwargs: Any) -> None:
+    def send_command(self, command: Iterable[str], **kwargs: Any) -> None:
         """Send a command to a device."""
         for com in command:
             self._last_command_sent = com
-        self.async_write_ha_state()
+        self.schedule_update_ha_state()

homeassistant/components/demo/switch.py

@@ -61,12 +61,12 @@ class DemoSwitch(SwitchEntity):
             name=device_name,
         )
 
-    async def async_turn_on(self, **kwargs: Any) -> None:
+    def turn_on(self, **kwargs: Any) -> None:
         """Turn the switch on."""
         self._attr_is_on = True
-        self.async_write_ha_state()
+        self.schedule_update_ha_state()
 
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the switch off."""
+    def turn_off(self, **kwargs: Any) -> None:
+        """Turn the device off."""
         self._attr_is_on = False
-        self.async_write_ha_state()
+        self.schedule_update_ha_state()

homeassistant/components/diagnostics/util.py

@@ -51,6 +51,7 @@ def _entity_entry_filter(a: attr.Attribute, _: Any) -> bool:
     return a.name not in (
         "_cache",
         "compat_aliases",
+        "compat_name",
         "original_name_unprefixed",
     )
 

homeassistant/components/dlna_dmr/media_player.py

@@ -353,10 +353,10 @@ class DlnaDmrEntity(MediaPlayerEntity):
         # Device was de/re-connected, state might have changed
         self.async_write_ha_state()
 
-    def _async_write_ha_state(self) -> None:
+    def async_write_ha_state(self) -> None:
         """Write the state."""
         self._attr_supported_features = self._supported_features()
-        super()._async_write_ha_state()
+        super().async_write_ha_state()
 
     async def _device_connect(self, location: str) -> None:
         """Connect to the device now that it's available."""

homeassistant/components/emulated_kasa/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "local_push",
   "loggers": ["sense_energy"],
   "quality_scale": "internal",
-  "requirements": ["sense-energy==0.14.0"]
+  "requirements": ["sense-energy==0.13.8"]
 }

homeassistant/components/fitbit/__init__.py

@@ -4,12 +4,9 @@ from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_entry_oauth2_flow
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
-)
 
 from . import api
-from .const import DOMAIN, FitbitScope
+from .const import FitbitScope
 from .coordinator import FitbitConfigEntry, FitbitData, FitbitDeviceCoordinator
 from .exceptions import FitbitApiException, FitbitAuthException
 from .model import config_from_entry_data
@@ -19,17 +16,11 @@ PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 async def async_setup_entry(hass: HomeAssistant, entry: FitbitConfigEntry) -> bool:
     """Set up fitbit from a config entry."""
-    try:
-        implementation = (
-            await config_entry_oauth2_flow.async_get_config_entry_implementation(
-                hass, entry
-            )
+    implementation = (
+        await config_entry_oauth2_flow.async_get_config_entry_implementation(
+            hass, entry
         )
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
+    )
     session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
     fitbit_api = api.OAuthFitbitApi(
         hass, session, unit_system=entry.data.get("unit_system")

homeassistant/components/fitbit/strings.json

@@ -121,10 +121,5 @@
         "name": "Water"
       }
     }
-  },
-  "exceptions": {
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    }
   }
 }

homeassistant/components/fritzbox/climate.py

@@ -97,7 +97,7 @@ class FritzboxThermostat(FritzBoxDeviceEntity, ClimateEntity):
         super().__init__(coordinator, ain)
 
     @callback
-    def _async_write_ha_state(self) -> None:
+    def async_write_ha_state(self) -> None:
         """Write the state to the HASS state machine."""
         if self.data.holiday_active:
             self._attr_supported_features = ClimateEntityFeature.PRESET_MODE
@@ -109,7 +109,7 @@ class FritzboxThermostat(FritzBoxDeviceEntity, ClimateEntity):
             self._attr_supported_features = SUPPORTED_FEATURES
             self._attr_hvac_modes = HVAC_MODES
             self._attr_preset_modes = PRESET_MODES
-        return super()._async_write_ha_state()
+        return super().async_write_ha_state()
 
     @property
     def current_temperature(self) -> float:

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260325.2"]
+  "requirements": ["home-assistant-frontend==20260325.0"]
 }

homeassistant/components/gardena_bluetooth/manifest.json

@@ -15,5 +15,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bleak", "bleak_esphome", "gardena_bluetooth"],
-  "requirements": ["gardena-bluetooth==2.3.0"]
+  "requirements": ["gardena-bluetooth==2.1.0"]
 }

homeassistant/components/google/__init__.py

@@ -24,9 +24,6 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_entry_oauth2_flow, config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
-)
 from homeassistant.helpers.entity import generate_entity_id
 
 from .api import ApiAuthImpl, get_feature_access
@@ -91,17 +88,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: GoogleConfigEntry) -> bo
         _LOGGER.error("Configuration error in %s: %s", YAML_DEVICES, str(err))
         return False
 
-    try:
-        implementation = (
-            await config_entry_oauth2_flow.async_get_config_entry_implementation(
-                hass, entry
-            )
+    implementation = (
+        await config_entry_oauth2_flow.async_get_config_entry_implementation(
+            hass, entry
         )
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
+    )
     session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
     # Force a token refresh to fix a bug where tokens were persisted with
     # expires_in (relative time delta) and expires_at (absolute time) swapped.

homeassistant/components/google/strings.json

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

homeassistant/components/google_assistant_sdk/__init__.py

@@ -2,19 +2,14 @@
 
 from __future__ import annotations
 
-from aiohttp import ClientError
+import aiohttp
 from gassist_text import TextAssistant
 from google.oauth2.credentials import Credentials
 
 from homeassistant.components import conversation
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_NAME, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import (
-    ConfigEntryAuthFailed,
-    ConfigEntryNotReady,
-    OAuth2TokenRequestError,
-    OAuth2TokenRequestReauthError,
-)
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, discovery, intent
 from homeassistant.helpers.config_entry_oauth2_flow import (
     OAuth2Session,
@@ -56,11 +51,13 @@ async def async_setup_entry(
     session = OAuth2Session(hass, entry, implementation)
     try:
         await session.async_ensure_token_valid()
-    except OAuth2TokenRequestReauthError as err:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN, translation_key="reauth_required"
-        ) from err
-    except (OAuth2TokenRequestError, ClientError) as err:
+    except aiohttp.ClientResponseError as err:
+        if 400 <= err.status < 500:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN, translation_key="reauth_required"
+            ) from err
+        raise ConfigEntryNotReady from err
+    except aiohttp.ClientError as err:
         raise ConfigEntryNotReady from err
 
     mem_storage = InMemoryStorage(hass)

homeassistant/components/google_assistant_sdk/helpers.py

@@ -8,6 +8,7 @@ import logging
 from typing import Any
 import uuid
 
+import aiohttp
 from aiohttp import web
 from gassist_text import TextAssistant
 from google.oauth2.credentials import Credentials
@@ -25,11 +26,7 @@ from homeassistant.components.media_player import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_ENTITY_ID, CONF_ACCESS_TOKEN
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import (
-    HomeAssistantError,
-    OAuth2TokenRequestReauthError,
-    ServiceValidationError,
-)
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.config_entry_oauth2_flow import OAuth2Session
 from homeassistant.helpers.event import async_call_later
 
@@ -82,8 +79,9 @@ async def async_send_text_commands(
     session = entry.runtime_data.session
     try:
         await session.async_ensure_token_valid()
-    except OAuth2TokenRequestReauthError:
-        entry.async_start_reauth(hass)
+    except aiohttp.ClientResponseError as err:
+        if 400 <= err.status < 500:
+            entry.async_start_reauth(hass)
         raise
 
     credentials = Credentials(session.token[CONF_ACCESS_TOKEN])  # type: ignore[no-untyped-call]

homeassistant/components/google_drive/backup.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections.abc import AsyncIterator, Callable, Coroutine
-from functools import wraps
 import logging
 from typing import Any
 
@@ -85,22 +84,8 @@ class GoogleDriveBackupAgent(BackupAgent):
         :param open_stream: A function returning an async iterator that yields bytes.
         :param backup: Metadata about the backup that should be uploaded.
         """
-
-        @wraps(open_stream)
-        async def wrapped_open_stream() -> AsyncIterator[bytes]:
-            stream = await open_stream()
-
-            async def _progress_stream() -> AsyncIterator[bytes]:
-                bytes_uploaded = 0
-                async for chunk in stream:
-                    yield chunk
-                    bytes_uploaded += len(chunk)
-                    on_progress(bytes_uploaded=bytes_uploaded)
-
-            return _progress_stream()
-
         try:
-            await self._client.async_upload_backup(wrapped_open_stream, backup)
+            await self._client.async_upload_backup(open_stream, backup)
         except (GoogleDriveApiError, HomeAssistantError, TimeoutError) as err:
             raise BackupAgentError(f"Failed to upload backup: {err}") from err
 

homeassistant/components/google_photos/__init__.py

@@ -33,18 +33,11 @@ async def async_setup_entry(
     hass: HomeAssistant, entry: GooglePhotosConfigEntry
 ) -> bool:
     """Set up Google Photos from a config entry."""
-    try:
-        implementation = (
-            await config_entry_oauth2_flow.async_get_config_entry_implementation(
-                hass, entry
-            )
+    implementation = (
+        await config_entry_oauth2_flow.async_get_config_entry_implementation(
+            hass, entry
         )
-    except config_entry_oauth2_flow.ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
-
+    )
     web_session = async_get_clientsession(hass)
     oauth_session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
     auth = api.AsyncConfigEntryAuth(web_session, oauth_session)

homeassistant/components/google_photos/strings.json

@@ -68,9 +68,6 @@
     "no_access_to_path": {
       "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%]"
-    },
     "upload_error": {
       "message": "Failed to upload content: {message}"
     }

homeassistant/components/humidifier/condition.py

@@ -1,73 +1,15 @@
 """Provides conditions for humidifiers."""
 
-from typing import TYPE_CHECKING
-
-import voluptuous as vol
-
-from homeassistant.const import ATTR_MODE, CONF_OPTIONS, PERCENTAGE, STATE_OFF, STATE_ON
+from homeassistant.const import PERCENTAGE, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.condition import (
-    ENTITY_STATE_CONDITION_SCHEMA_ANY_ALL,
     Condition,
-    ConditionConfig,
-    EntityStateConditionBase,
     make_entity_numerical_condition,
     make_entity_state_condition,
 )
-from homeassistant.helpers.entity import get_supported_features
-
-from .const import (
-    ATTR_ACTION,
-    ATTR_HUMIDITY,
-    DOMAIN,
-    HumidifierAction,
-    HumidifierEntityFeature,
-)
-
-CONF_MODE = "mode"
-
-IS_MODE_CONDITION_SCHEMA = ENTITY_STATE_CONDITION_SCHEMA_ANY_ALL.extend(
-    {
-        vol.Required(CONF_OPTIONS): {
-            vol.Required(CONF_MODE): vol.All(cv.ensure_list, vol.Length(min=1), [str]),
-        },
-    }
-)
-
-
-def _supports_feature(hass: HomeAssistant, entity_id: str, features: int) -> bool:
-    """Test if an entity supports the specified features."""
-    try:
-        return bool(get_supported_features(hass, entity_id) & features)
-    except HomeAssistantError:
-        return False
-
-
-class IsModeCondition(EntityStateConditionBase):
-    """Condition for humidifier mode."""
-
-    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_MODE)}
-    _schema = IS_MODE_CONDITION_SCHEMA
-
-    def __init__(self, hass: HomeAssistant, config: ConditionConfig) -> None:
-        """Initialize the mode condition."""
-        super().__init__(hass, config)
-        if TYPE_CHECKING:
-            assert config.options is not None
-        self._states = set(config.options[CONF_MODE])
-
-    def entity_filter(self, entities: set[str]) -> set[str]:
-        """Filter entities of this domain."""
-        entities = super().entity_filter(entities)
-        return {
-            entity_id
-            for entity_id in entities
-            if _supports_feature(self._hass, entity_id, HumidifierEntityFeature.MODES)
-        }
 
+from .const import ATTR_ACTION, ATTR_HUMIDITY, DOMAIN, HumidifierAction
 
 CONDITIONS: dict[str, type[Condition]] = {
     "is_off": make_entity_state_condition(DOMAIN, STATE_OFF),
@@ -78,9 +20,8 @@ CONDITIONS: dict[str, type[Condition]] = {
     "is_humidifying": make_entity_state_condition(
         {DOMAIN: DomainSpec(value_source=ATTR_ACTION)}, HumidifierAction.HUMIDIFYING
     ),
-    "is_mode": IsModeCondition,
     "is_target_humidity": make_entity_numerical_condition(
-        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
+        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)},
         valid_unit=PERCENTAGE,
     ),
 }

homeassistant/components/humidifier/conditions.yaml

@@ -32,19 +32,6 @@ is_on: *condition_common
 is_drying: *condition_common
 is_humidifying: *condition_common
 
-is_mode:
-  target: *condition_humidifier_target
-  fields:
-    behavior: *condition_behavior
-    mode:
-      context:
-        filter_target: target
-      required: true
-      selector:
-        state:
-          attribute: available_modes
-          multiple: true
-
 is_target_humidity:
   target: *condition_humidifier_target
   fields:

homeassistant/components/humidifier/icons.json

@@ -6,9 +6,6 @@
     "is_humidifying": {
       "condition": "mdi:arrow-up-bold"
     },
-    "is_mode": {
-      "condition": "mdi:air-humidifier"
-    },
     "is_off": {
       "condition": "mdi:air-humidifier-off"
     },
@@ -70,9 +67,6 @@
     }
   },
   "triggers": {
-    "mode_changed": {
-      "trigger": "mdi:air-humidifier"
-    },
     "started_drying": {
       "trigger": "mdi:arrow-down-bold"
     },

homeassistant/components/humidifier/strings.json

@@ -28,20 +28,6 @@
       },
       "name": "Humidifier is humidifying"
     },
-    "is_mode": {
-      "description": "Tests if one or more humidifiers are set to a specific mode.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::humidifier::common::condition_behavior_description%]",
-          "name": "[%key:component::humidifier::common::condition_behavior_name%]"
-        },
-        "mode": {
-          "description": "The operation modes to check for.",
-          "name": "Mode"
-        }
-      },
-      "name": "Humidifier is in mode"
-    },
     "is_off": {
       "description": "Tests if one or more humidifiers are off.",
       "fields": {
@@ -215,20 +201,6 @@
   },
   "title": "Humidifier",
   "triggers": {
-    "mode_changed": {
-      "description": "Triggers after the operation mode of one or more humidifiers changes.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::humidifier::common::trigger_behavior_description%]",
-          "name": "[%key:component::humidifier::common::trigger_behavior_name%]"
-        },
-        "mode": {
-          "description": "The operation modes to trigger on.",
-          "name": "Mode"
-        }
-      },
-      "name": "Humidifier mode changed"
-    },
     "started_drying": {
       "description": "Triggers after one or more humidifiers start drying.",
       "fields": {

homeassistant/components/humidifier/trigger.py

@@ -1,65 +1,13 @@
 """Provides triggers for humidifiers."""
 
-import voluptuous as vol
-
-from homeassistant.const import ATTR_MODE, CONF_OPTIONS, STATE_OFF, STATE_ON
+from homeassistant.const import STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.entity import get_supported_features
-from homeassistant.helpers.trigger import (
-    ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
-    EntityTargetStateTriggerBase,
-    Trigger,
-    TriggerConfig,
-    make_entity_target_state_trigger,
-)
-
-from .const import ATTR_ACTION, DOMAIN, HumidifierAction, HumidifierEntityFeature
-
-CONF_MODE = "mode"
-
-MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend(
-    {
-        vol.Required(CONF_OPTIONS): {
-            vol.Required(CONF_MODE): vol.All(cv.ensure_list, vol.Length(min=1), [str]),
-        },
-    }
-)
-
-
-def _supports_feature(hass: HomeAssistant, entity_id: str, features: int) -> bool:
-    """Test if an entity supports the specified features."""
-    try:
-        return bool(get_supported_features(hass, entity_id) & features)
-    except HomeAssistantError:
-        return False
-
-
-class ModeChangedTrigger(EntityTargetStateTriggerBase):
-    """Trigger for humidifier mode changes."""
-
-    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_MODE)}
-    _schema = MODE_CHANGED_TRIGGER_SCHEMA
-
-    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
-        """Initialize the mode trigger."""
-        super().__init__(hass, config)
-        self._to_states = set(self._options[CONF_MODE])
-
-    def entity_filter(self, entities: set[str]) -> set[str]:
-        """Filter entities of this domain."""
-        entities = super().entity_filter(entities)
-        return {
-            entity_id
-            for entity_id in entities
-            if _supports_feature(self._hass, entity_id, HumidifierEntityFeature.MODES)
-        }
+from homeassistant.helpers.trigger import Trigger, make_entity_target_state_trigger
 
+from .const import ATTR_ACTION, DOMAIN, HumidifierAction
 
 TRIGGERS: dict[str, type[Trigger]] = {
-    "mode_changed": ModeChangedTrigger,
     "started_drying": make_entity_target_state_trigger(
         {DOMAIN: DomainSpec(value_source=ATTR_ACTION)}, HumidifierAction.DRYING
     ),

homeassistant/components/humidifier/triggers.yaml

@@ -1,9 +1,9 @@
 .trigger_common: &trigger_common
-  target: &trigger_humidifier_target
+  target:
     entity:
       domain: humidifier
   fields:
-    behavior: &trigger_behavior
+    behavior:
       required: true
       default: any
       selector:
@@ -18,16 +18,3 @@ started_drying: *trigger_common
 started_humidifying: *trigger_common
 turned_on: *trigger_common
 turned_off: *trigger_common
-
-mode_changed:
-  target: *trigger_humidifier_target
-  fields:
-    behavior: *trigger_behavior
-    mode:
-      context:
-        filter_target: target
-      required: true
-      selector:
-        state:
-          attribute: available_modes
-          multiple: true

homeassistant/components/humidity/condition.py

@@ -10,27 +10,22 @@ from homeassistant.components.humidifier import (
     ATTR_CURRENT_HUMIDITY as HUMIDIFIER_ATTR_CURRENT_HUMIDITY,
     DOMAIN as HUMIDIFIER_DOMAIN,
 )
+from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN, NumberDeviceClass
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
-from homeassistant.components.weather import (
-    ATTR_WEATHER_HUMIDITY,
-    DOMAIN as WEATHER_DOMAIN,
-)
 from homeassistant.const import PERCENTAGE
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.condition import Condition, make_entity_numerical_condition
 
 HUMIDITY_DOMAIN_SPECS = {
-    CLIMATE_DOMAIN: DomainSpec(
+    CLIMATE_DOMAIN: NumericalDomainSpec(
         value_source=CLIMATE_ATTR_CURRENT_HUMIDITY,
     ),
-    HUMIDIFIER_DOMAIN: DomainSpec(
+    HUMIDIFIER_DOMAIN: NumericalDomainSpec(
         value_source=HUMIDIFIER_ATTR_CURRENT_HUMIDITY,
     ),
     SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.HUMIDITY),
-    WEATHER_DOMAIN: DomainSpec(
-        value_source=ATTR_WEATHER_HUMIDITY,
-    ),
+    NUMBER_DOMAIN: DomainSpec(device_class=NumberDeviceClass.HUMIDITY),
 }
 
 CONDITIONS: dict[str, type[Condition]] = {

homeassistant/components/humidity/conditions.yaml

@@ -17,9 +17,10 @@ is_value:
     entity:
       - domain: sensor
         device_class: humidity
+      - domain: number
+        device_class: humidity
       - domain: climate
       - domain: humidifier
-      - domain: weather
   fields:
     behavior:
       required: true

homeassistant/components/humidity/trigger.py

@@ -16,24 +16,24 @@ from homeassistant.components.weather import (
     DOMAIN as WEATHER_DOMAIN,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.automation import NumericalDomainSpec
 from homeassistant.helpers.trigger import (
     Trigger,
     make_entity_numerical_state_changed_trigger,
     make_entity_numerical_state_crossed_threshold_trigger,
 )
 
-HUMIDITY_DOMAIN_SPECS: dict[str, DomainSpec] = {
-    CLIMATE_DOMAIN: DomainSpec(
+HUMIDITY_DOMAIN_SPECS: dict[str, NumericalDomainSpec] = {
+    CLIMATE_DOMAIN: NumericalDomainSpec(
         value_source=CLIMATE_ATTR_CURRENT_HUMIDITY,
     ),
-    HUMIDIFIER_DOMAIN: DomainSpec(
+    HUMIDIFIER_DOMAIN: NumericalDomainSpec(
         value_source=HUMIDIFIER_ATTR_CURRENT_HUMIDITY,
     ),
-    SENSOR_DOMAIN: DomainSpec(
+    SENSOR_DOMAIN: NumericalDomainSpec(
         device_class=SensorDeviceClass.HUMIDITY,
     ),
-    WEATHER_DOMAIN: DomainSpec(
+    WEATHER_DOMAIN: NumericalDomainSpec(
         value_source=ATTR_WEATHER_HUMIDITY,
     ),
 }

homeassistant/components/husqvarna_automower_ble/manifest.json

@@ -13,5 +13,5 @@
   "documentation": "https://www.home-assistant.io/integrations/husqvarna_automower_ble",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.3.0"]
+  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.1.0"]
 }

homeassistant/components/idasen_desk/manifest.json

@@ -13,5 +13,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "quality_scale": "bronze",
-  "requirements": ["idasen-ha==2.6.5"]
+  "requirements": ["idasen-ha==2.6.4"]
 }

homeassistant/components/illuminance/condition.py

@@ -6,6 +6,7 @@ from homeassistant.components.binary_sensor import (
     DOMAIN as BINARY_SENSOR_DOMAIN,
     BinarySensorDeviceClass,
 )
+from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN, NumberDeviceClass
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
 from homeassistant.const import LIGHT_LUX, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
@@ -21,6 +22,7 @@ ILLUMINANCE_DETECTED_DOMAIN_SPECS = {
 }
 ILLUMINANCE_VALUE_DOMAIN_SPECS = {
     SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.ILLUMINANCE),
+    NUMBER_DOMAIN: DomainSpec(device_class=NumberDeviceClass.ILLUMINANCE),
 }
 
 CONDITIONS: dict[str, type[Condition]] = {

homeassistant/components/illuminance/conditions.yaml

@@ -23,6 +23,8 @@ is_value:
     entity:
       - domain: sensor
         device_class: illuminance
+      - domain: number
+        device_class: illuminance
   fields:
     behavior: *condition_behavior
     threshold:

homeassistant/components/illuminance/trigger.py

@@ -6,10 +6,11 @@ from homeassistant.components.binary_sensor import (
     DOMAIN as BINARY_SENSOR_DOMAIN,
     BinarySensorDeviceClass,
 )
+from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN, NumberDeviceClass
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
 from homeassistant.const import LIGHT_LUX, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.trigger import (
     Trigger,
     make_entity_numerical_state_changed_trigger,
@@ -17,8 +18,9 @@ from homeassistant.helpers.trigger import (
     make_entity_target_state_trigger,
 )
 
-ILLUMINANCE_DOMAIN_SPECS: dict[str, DomainSpec] = {
-    SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.ILLUMINANCE),
+ILLUMINANCE_DOMAIN_SPECS: dict[str, NumericalDomainSpec] = {
+    NUMBER_DOMAIN: NumericalDomainSpec(device_class=NumberDeviceClass.ILLUMINANCE),
+    SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.ILLUMINANCE),
 }
 
 TRIGGERS: dict[str, type[Trigger]] = {

homeassistant/components/illuminance/triggers.yaml

@@ -29,6 +29,8 @@
 
 .trigger_numerical_target: &trigger_numerical_target
   entity:
+    - domain: number
+      device_class: illuminance
     - domain: sensor
       device_class: illuminance
 

homeassistant/components/lg_thinq/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["thinqconnect"],
-  "requirements": ["thinqconnect==1.0.11"]
+  "requirements": ["thinqconnect==1.0.9"]
 }

homeassistant/components/light/condition.py

@@ -1,43 +1,12 @@
 """Provides conditions for lights."""
 
-from typing import Any
-
 from homeassistant.const import STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant, State
-from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.condition import (
-    Condition,
-    EntityNumericalConditionBase,
-    make_entity_state_condition,
-)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition, make_entity_state_condition
 
-from . import ATTR_BRIGHTNESS
 from .const import DOMAIN
 
-BRIGHTNESS_DOMAIN_SPECS = {
-    DOMAIN: DomainSpec(value_source=ATTR_BRIGHTNESS),
-}
-
-
-class BrightnessCondition(EntityNumericalConditionBase):
-    """Condition for light brightness with uint8 to percentage conversion."""
-
-    _domain_specs = BRIGHTNESS_DOMAIN_SPECS
-    _valid_unit = "%"
-
-    def _get_tracked_value(self, entity_state: State) -> Any:
-        """Get the brightness value converted from uint8 (0-255) to percentage (0-100)."""
-        raw = super()._get_tracked_value(entity_state)
-        if raw is None:
-            return None
-        try:
-            return (float(raw) / 255.0) * 100.0
-        except TypeError, ValueError:
-            return None
-
-
 CONDITIONS: dict[str, type[Condition]] = {
-    "is_brightness": BrightnessCondition,
     "is_off": make_entity_state_condition(DOMAIN, STATE_OFF),
     "is_on": make_entity_state_condition(DOMAIN, STATE_ON),
 }

homeassistant/components/light/conditions.yaml

@@ -1,9 +1,9 @@
 .condition_common: &condition_common
-  target: &condition_light_target
+  target:
     entity:
       domain: light
   fields:
-    behavior: &condition_behavior
+    behavior:
       required: true
       default: any
       selector:
@@ -13,31 +13,5 @@
             - all
             - any
 
-.brightness_threshold_entity: &brightness_threshold_entity
-  - domain: input_number
-    unit_of_measurement: "%"
-  - domain: number
-    unit_of_measurement: "%"
-  - domain: sensor
-    unit_of_measurement: "%"
-
-.brightness_threshold_number: &brightness_threshold_number
-  min: 0
-  max: 100
-  mode: box
-  unit_of_measurement: "%"
-
 is_off: *condition_common
 is_on: *condition_common
-
-is_brightness:
-  target: *condition_light_target
-  fields:
-    behavior: *condition_behavior
-    threshold:
-      required: true
-      selector:
-        numeric_threshold:
-          entity: *brightness_threshold_entity
-          mode: is
-          number: *brightness_threshold_number

homeassistant/components/light/icons.json

@@ -1,8 +1,5 @@
 {
   "conditions": {
-    "is_brightness": {
-      "condition": "mdi:lightbulb-on-50"
-    },
     "is_off": {
       "condition": "mdi:lightbulb-off"
     },

homeassistant/components/light/strings.json

@@ -2,8 +2,6 @@
   "common": {
     "condition_behavior_description": "How the state should match on the targeted lights.",
     "condition_behavior_name": "Behavior",
-    "condition_threshold_description": "What to test for and threshold values.",
-    "condition_threshold_name": "Threshold configuration",
     "field_brightness_description": "Number indicating brightness, where 0 turns the light off, 1 is the minimum brightness, and 255 is the maximum brightness.",
     "field_brightness_name": "Brightness value",
     "field_brightness_pct_description": "Number indicating the percentage of full brightness, where 0 turns the light off, 1 is the minimum brightness, and 100 is the maximum brightness.",
@@ -44,20 +42,6 @@
     "trigger_threshold_name": "Threshold configuration"
   },
   "conditions": {
-    "is_brightness": {
-      "description": "Tests the brightness of one or more lights.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::light::common::condition_behavior_description%]",
-          "name": "[%key:component::light::common::condition_behavior_name%]"
-        },
-        "threshold": {
-          "description": "[%key:component::light::common::condition_threshold_description%]",
-          "name": "[%key:component::light::common::condition_threshold_name%]"
-        }
-      },
-      "name": "Light brightness"
-    },
     "is_off": {
       "description": "Tests if one or more lights are off.",
       "fields": {

homeassistant/components/light/trigger.py

@@ -1,54 +1,40 @@
 """Provides triggers for lights."""
 
+from typing import Any
+
 from homeassistant.const import STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant, State
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.automation import NumericalDomainSpec
 from homeassistant.helpers.trigger import (
-    EntityNumericalStateChangedTriggerBase,
-    EntityNumericalStateCrossedThresholdTriggerBase,
-    EntityNumericalStateTriggerBase,
     Trigger,
+    make_entity_numerical_state_changed_trigger,
+    make_entity_numerical_state_crossed_threshold_trigger,
     make_entity_target_state_trigger,
 )
 
 from . import ATTR_BRIGHTNESS
 from .const import DOMAIN
 
+
+def _convert_uint8_to_percentage(value: Any) -> float:
+    """Convert a uint8 value (0-255) to a percentage (0-100)."""
+    return (float(value) / 255.0) * 100.0
+
+
 BRIGHTNESS_DOMAIN_SPECS = {
-    DOMAIN: DomainSpec(value_source=ATTR_BRIGHTNESS),
+    DOMAIN: NumericalDomainSpec(
+        value_source=ATTR_BRIGHTNESS,
+        value_converter=_convert_uint8_to_percentage,
+    ),
 }
 
-
-class BrightnessTriggerMixin(EntityNumericalStateTriggerBase):
-    """Mixin for brightness triggers."""
-
-    _domain_specs = BRIGHTNESS_DOMAIN_SPECS
-    _valid_unit = "%"
-
-    def _get_tracked_value(self, state: State) -> float | None:
-        """Get tracked brightness as a percentage."""
-        value = super()._get_tracked_value(state)
-        if value is None:
-            return None
-        # Convert uint8 value (0-255) to a percentage (0-100)
-        return (value / 255.0) * 100.0
-
-
-class BrightnessChangedTrigger(
-    EntityNumericalStateChangedTriggerBase, BrightnessTriggerMixin
-):
-    """Trigger for light brightness changes."""
-
-
-class BrightnessCrossedThresholdTrigger(
-    EntityNumericalStateCrossedThresholdTriggerBase, BrightnessTriggerMixin
-):
-    """Trigger for light brightness crossing a threshold."""
-
-
 TRIGGERS: dict[str, type[Trigger]] = {
-    "brightness_changed": BrightnessChangedTrigger,
-    "brightness_crossed_threshold": BrightnessCrossedThresholdTrigger,
+    "brightness_changed": make_entity_numerical_state_changed_trigger(
+        BRIGHTNESS_DOMAIN_SPECS, valid_unit="%"
+    ),
+    "brightness_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
+        BRIGHTNESS_DOMAIN_SPECS, valid_unit="%"
+    ),
     "turned_off": make_entity_target_state_trigger(DOMAIN, STATE_OFF),
     "turned_on": make_entity_target_state_trigger(DOMAIN, STATE_ON),
 }

homeassistant/components/lojack/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["lojack_api"],
   "quality_scale": "silver",
-  "requirements": ["lojack-api==0.7.2"]
+  "requirements": ["lojack-api==0.7.1"]
 }

homeassistant/components/matter/climate.py

@@ -16,10 +16,6 @@ from homeassistant.components.climate import (
     ATTR_TARGET_TEMP_LOW,
     DEFAULT_MAX_TEMP,
     DEFAULT_MIN_TEMP,
-    PRESET_AWAY,
-    PRESET_HOME,
-    PRESET_NONE,
-    PRESET_SLEEP,
     ClimateEntity,
     ClimateEntityDescription,
     ClimateEntityFeature,
@@ -46,18 +42,6 @@ HVAC_SYSTEM_MODE_MAP = {
     HVACMode.FAN_ONLY: 7,
 }
 
-# Map of Matter PresetScenarioEnum to HA standard preset constants or custom names
-# This ensures presets are translated correctly using HA's translation system.
-# kUserDefined scenarios always use device-provided names.
-PRESET_SCENARIO_TO_HA_PRESET: dict[int, str] = {
-    clusters.Thermostat.Enums.PresetScenarioEnum.kOccupied: PRESET_HOME,
-    clusters.Thermostat.Enums.PresetScenarioEnum.kUnoccupied: PRESET_AWAY,
-    clusters.Thermostat.Enums.PresetScenarioEnum.kSleep: PRESET_SLEEP,
-    clusters.Thermostat.Enums.PresetScenarioEnum.kWake: "wake",
-    clusters.Thermostat.Enums.PresetScenarioEnum.kVacation: "vacation",
-    clusters.Thermostat.Enums.PresetScenarioEnum.kGoingToSleep: "going_to_sleep",
-}
-
 SINGLE_SETPOINT_DEVICES: set[tuple[int, int]] = {
     # Some devices only have a single setpoint while the matter spec
     # assumes that you need separate setpoints for heating and cooling.
@@ -175,6 +159,7 @@ SUPPORT_FAN_MODE_DEVICES: set[tuple[int, int]] = {
 }
 
 SystemModeEnum = clusters.Thermostat.Enums.SystemModeEnum
+ControlSequenceEnum = clusters.Thermostat.Enums.ControlSequenceOfOperationEnum
 ThermostatFeature = clusters.Thermostat.Bitmaps.Feature
 
 
@@ -210,22 +195,10 @@ class MatterClimate(MatterEntity, ClimateEntity):
 
     _attr_temperature_unit: str = UnitOfTemperature.CELSIUS
     _attr_hvac_mode: HVACMode = HVACMode.OFF
-    _matter_presets: list[clusters.Thermostat.Structs.PresetStruct]
-    _attr_preset_mode: str | None = None
-    _attr_preset_modes: list[str] | None = None
     _feature_map: int | None = None
 
     _platform_translation_key = "thermostat"
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        """Initialize the climate entity."""
-        # Initialize preset handle mapping as instance attribute before calling super().__init__()
-        # because MatterEntity.__init__() calls _update_from_device() which needs this attribute
-        self._matter_presets = []
-        self._preset_handle_by_name: dict[str, bytes | None] = {}
-        self._preset_name_by_handle: dict[bytes | None, str] = {}
-        super().__init__(*args, **kwargs)
-
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
         target_hvac_mode: HVACMode | None = kwargs.get(ATTR_HVAC_MODE)
@@ -270,34 +243,6 @@ class MatterClimate(MatterEntity, ClimateEntity):
                     matter_attribute=clusters.Thermostat.Attributes.OccupiedCoolingSetpoint,
                 )
 
-    async def async_set_preset_mode(self, preset_mode: str) -> None:
-        """Set new preset mode."""
-        preset_handle = self._preset_handle_by_name[preset_mode]
-
-        command = clusters.Thermostat.Commands.SetActivePresetRequest(
-            presetHandle=preset_handle
-        )
-        await self.send_device_command(command)
-
-        # Optimistic update is required because Matter devices usually confirm
-        # preset changes asynchronously via a later attribute subscription.
-        # Additionally, some devices based on connectedhomeip do not send a
-        # subscription report for ActivePresetHandle after SetActivePresetRequest
-        # because thermostat-server-presets.cpp/SetActivePreset() updates the
-        # value without notifying the reporting engine. Keep this optimistic
-        # update as a workaround for that SDK bug and for normal report delays.
-        # Reference: project-chip/connectedhomeip,
-        # src/app/clusters/thermostat-server/thermostat-server-presets.cpp.
-        self._attr_preset_mode = preset_mode
-        self.async_write_ha_state()
-
-        # Keep the local ActivePresetHandle in sync until subscription update.
-        active_preset_path = create_attribute_path_from_attribute(
-            endpoint_id=self._endpoint.endpoint_id,
-            attribute=clusters.Thermostat.Attributes.ActivePresetHandle,
-        )
-        self._endpoint.set_attribute_value(active_preset_path, preset_handle)
-
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
         """Set new target hvac mode."""
 
@@ -322,10 +267,10 @@ class MatterClimate(MatterEntity, ClimateEntity):
     def _update_from_device(self) -> None:
         """Update from device."""
         self._calculate_features()
-
         self._attr_current_temperature = self._get_temperature_in_degrees(
             clusters.Thermostat.Attributes.LocalTemperature
         )
+
         self._attr_current_humidity = (
             int(raw_measured_humidity) / HUMIDITY_SCALING_FACTOR
             if (
@@ -337,81 +282,6 @@ class MatterClimate(MatterEntity, ClimateEntity):
             else None
         )
 
-        self._update_presets()
-
-        self._update_hvac_mode_and_action()
-        self._update_target_temperatures()
-        self._update_temperature_limits()
-
-    @callback
-    def _update_presets(self) -> None:
-        """Update preset modes and active preset."""
-        # Check if the device supports presets feature before attempting to load.
-        # Use the already computed supported features instead of re-reading
-        # the FeatureMap attribute to keep a single source of truth and avoid
-        # casting None when the attribute is temporarily unavailable.
-        supported_features = self._attr_supported_features or 0
-        if not (supported_features & ClimateEntityFeature.PRESET_MODE):
-            # Device does not support presets, skip preset update
-            self._preset_handle_by_name.clear()
-            self._preset_name_by_handle.clear()
-            self._attr_preset_modes = []
-            self._attr_preset_mode = None
-            return
-
-        self._matter_presets = (
-            self.get_matter_attribute_value(clusters.Thermostat.Attributes.Presets)
-            or []
-        )
-        # Build preset mapping: use device-provided name if available, else generate unique name
-        self._preset_handle_by_name.clear()
-        self._preset_name_by_handle.clear()
-        if self._matter_presets:
-            used_names = set()
-            for i, preset in enumerate(self._matter_presets, start=1):
-                preset_translation = PRESET_SCENARIO_TO_HA_PRESET.get(
-                    preset.presetScenario
-                )
-                if preset_translation:
-                    preset_name = preset_translation.lower()
-                else:
-                    name = str(preset.name) if preset.name is not None else ""
-                    name = name.strip()
-                    if name:
-                        preset_name = name
-                    else:
-                        # Ensure fallback name is unique
-                        j = i
-                        preset_name = f"Preset{j}"
-                        while preset_name in used_names:
-                            j += 1
-                            preset_name = f"Preset{j}"
-                used_names.add(preset_name)
-                preset_handle = (
-                    preset.presetHandle
-                    if isinstance(preset.presetHandle, (bytes, type(None)))
-                    else None
-                )
-                self._preset_handle_by_name[preset_name] = preset_handle
-                self._preset_name_by_handle[preset_handle] = preset_name
-
-        # Always include PRESET_NONE to allow users to clear the preset
-        self._preset_handle_by_name[PRESET_NONE] = None
-        self._preset_name_by_handle[None] = PRESET_NONE
-
-        self._attr_preset_modes = list(self._preset_handle_by_name)
-
-        # Update active preset mode
-        active_preset_handle = self.get_matter_attribute_value(
-            clusters.Thermostat.Attributes.ActivePresetHandle
-        )
-        self._attr_preset_mode = self._preset_name_by_handle.get(
-            active_preset_handle, PRESET_NONE
-        )
-
-    @callback
-    def _update_hvac_mode_and_action(self) -> None:
-        """Update HVAC mode and action from device."""
         if self.get_matter_attribute_value(clusters.OnOff.Attributes.OnOff) is False:
             # special case: the appliance has a dedicated Power switch on the OnOff cluster
             # if the mains power is off - treat it as if the HVAC mode is off
@@ -463,10 +333,7 @@ class MatterClimate(MatterEntity, ClimateEntity):
                     self._attr_hvac_action = HVACAction.FAN
                 else:
                     self._attr_hvac_action = HVACAction.OFF
-
-    @callback
-    def _update_target_temperatures(self) -> None:
-        """Update target temperature or temperature range."""
+        # update target temperature high/low
         supports_range = (
             self._attr_supported_features
             & ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
@@ -492,9 +359,6 @@ class MatterClimate(MatterEntity, ClimateEntity):
                     clusters.Thermostat.Attributes.OccupiedHeatingSetpoint
                 )
 
-    @callback
-    def _update_temperature_limits(self) -> None:
-        """Update min and max temperature limits."""
         # update min_temp
         if self._attr_hvac_mode == HVACMode.COOL:
             attribute = clusters.Thermostat.Attributes.AbsMinCoolSetpointLimit
@@ -534,9 +398,6 @@ class MatterClimate(MatterEntity, ClimateEntity):
         self._attr_supported_features = (
             ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.TURN_OFF
         )
-        if feature_map & ThermostatFeature.kPresets:
-            self._attr_supported_features |= ClimateEntityFeature.PRESET_MODE
-        # determine supported hvac modes
         if feature_map & ThermostatFeature.kHeating:
             self._attr_hvac_modes.append(HVACMode.HEAT)
         if feature_map & ThermostatFeature.kCooling:
@@ -579,13 +440,9 @@ DISCOVERY_SCHEMAS = [
         optional_attributes=(
             clusters.Thermostat.Attributes.FeatureMap,
             clusters.Thermostat.Attributes.ControlSequenceOfOperation,
-            clusters.Thermostat.Attributes.NumberOfPresets,
             clusters.Thermostat.Attributes.Occupancy,
             clusters.Thermostat.Attributes.OccupiedCoolingSetpoint,
             clusters.Thermostat.Attributes.OccupiedHeatingSetpoint,
-            clusters.Thermostat.Attributes.Presets,
-            clusters.Thermostat.Attributes.PresetTypes,
-            clusters.Thermostat.Attributes.ActivePresetHandle,
             clusters.Thermostat.Attributes.SystemMode,
             clusters.Thermostat.Attributes.ThermostatRunningMode,
             clusters.Thermostat.Attributes.ThermostatRunningState,

homeassistant/components/matter/const.py

@@ -1,7 +1,6 @@
 """Constants for the Matter integration."""
 
 import logging
-from typing import Final
 
 from chip.clusters import Objects as clusters
 
@@ -115,5 +114,3 @@ SERVICE_CREDENTIAL_TYPES = [
     CRED_TYPE_FINGER_VEIN,
     CRED_TYPE_FACE,
 ]
-
-CONCENTRATION_BECQUERELS_PER_CUBIC_METER: Final = "Bq/m³"

homeassistant/components/matter/icons.json

@@ -140,9 +140,6 @@
       "pump_status": {
         "default": "mdi:pump"
       },
-      "radon_concentration": {
-        "default": "mdi:radioactive"
-      },
       "tank_percentage": {
         "default": "mdi:water-boiler"
       },

homeassistant/components/matter/sensor.py

@@ -48,7 +48,6 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util, slugify
 
-from .const import CONCENTRATION_BECQUERELS_PER_CUBIC_METER
 from .entity import MatterEntity, MatterEntityDescription
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
@@ -745,19 +744,6 @@ DISCOVERY_SCHEMAS = [
             clusters.OzoneConcentrationMeasurement.Attributes.MeasuredValue,
         ),
     ),
-    MatterDiscoverySchema(
-        platform=Platform.SENSOR,
-        entity_description=MatterSensorEntityDescription(
-            key="RadonSensor",
-            native_unit_of_measurement=CONCENTRATION_BECQUERELS_PER_CUBIC_METER,
-            state_class=SensorStateClass.MEASUREMENT,
-            translation_key="radon_concentration",
-        ),
-        entity_class=MatterSensor,
-        required_attributes=(
-            clusters.RadonConcentrationMeasurement.Attributes.MeasuredValue,
-        ),
-    ),
     MatterDiscoverySchema(
         platform=Platform.SENSOR,
         entity_description=MatterSensorEntityDescription(

homeassistant/components/matter/strings.json

@@ -145,16 +145,7 @@
     },
     "climate": {
       "thermostat": {
-        "name": "Thermostat",
-        "state_attributes": {
-          "preset_mode": {
-            "state": {
-              "going_to_sleep": "Going to sleep",
-              "vacation": "Vacation",
-              "wake": "Wake"
-            }
-          }
-        }
+        "name": "Thermostat"
       }
     },
     "cover": {
@@ -558,9 +549,6 @@
       "pump_speed": {
         "name": "Rotation speed"
       },
-      "radon_concentration": {
-        "name": "Radon concentration"
-      },
       "reactive_current": {
         "name": "Reactive current"
       },

homeassistant/components/mcp/__init__.py

@@ -7,7 +7,6 @@ from typing import cast
 
 from homeassistant.components.application_credentials import AuthorizationServer
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_entry_oauth2_flow, llm
 
 from .application_credentials import authorization_server_context
@@ -43,14 +42,7 @@ async def _create_token_manager(
     hass: HomeAssistant, entry: ModelContextProtocolConfigEntry
 ) -> TokenManager | None:
     """Create a OAuth token manager for the config entry if the server requires authentication."""
-    try:
-        implementation = await async_get_config_entry_implementation(hass, entry)
-    except config_entry_oauth2_flow.ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
-    if not implementation:
+    if not (implementation := await async_get_config_entry_implementation(hass, entry)):
         return None
 
     session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)

homeassistant/components/mcp/strings.json

@@ -56,10 +56,5 @@
         }
       }
     }
-  },
-  "exceptions": {
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    }
   }
 }

homeassistant/components/miele/const.py

@@ -270,7 +270,6 @@ class ProgramPhaseOven(MieleEnum, missing_to_none=True):
     process_finished = 3078
     searing = 3080
     roasting = 3081
-    cooling_down = 3083
     energy_save = 3084
     pre_heating = 3099
 
@@ -453,7 +452,6 @@ class WashingMachineProgramId(MieleEnum, missing_to_none=True):
     proofing = 27, 10057
     sportswear = 29, 10052
     automatic_plus = 31
-    table_linen = 33
     outerwear = 37
     pillows = 39
     cool_air = 45  # washer-dryer
@@ -588,7 +586,6 @@ class OvenProgramId(MieleEnum, missing_to_none=True):
     microwave_fan_grill = 23
     conventional_heat = 24
     top_heat = 25
-    booster = 27
     fan_grill = 29
     bottom_heat = 31
     moisture_plus_auto_roast = 35, 48
@@ -597,7 +594,6 @@ class OvenProgramId(MieleEnum, missing_to_none=True):
     moisture_plus_conventional_heat = 51, 76
     popcorn = 53
     quick_microwave = 54
-    airfry = 95
     custom_program_1 = 97
     custom_program_2 = 98
     custom_program_3 = 99

homeassistant/components/miele/strings.json

@@ -273,7 +273,6 @@
       "program_id": {
         "name": "Program",
         "state": {
-          "airfry": "AirFry",
           "almond_macaroons_1_tray": "Almond macaroons (1 tray)",
           "almond_macaroons_2_trays": "Almond macaroons (2 trays)",
           "amaranth": "Amaranth",
@@ -335,7 +334,6 @@
           "blanching": "Blanching",
           "blueberry_muffins": "Blueberry muffins",
           "bologna_sausage": "Bologna sausage",
-          "booster": "Booster",
           "bottling": "Bottling",
           "bottling_hard": "Bottling (hard)",
           "bottling_medium": "Bottling (medium)",
@@ -883,7 +881,6 @@
           "swiss_roll": "Swiss roll",
           "swiss_toffee_cream_100_ml": "Swiss toffee cream (100 ml)",
           "swiss_toffee_cream_150_ml": "Swiss toffee cream (150 ml)",
-          "table_linen": "Table linen",
           "tagliatelli_fresh": "Tagliatelli (fresh)",
           "tall_items": "Tall items",
           "tart_flambe": "Tart flambè",

homeassistant/components/moisture/condition.py

@@ -6,6 +6,7 @@ from homeassistant.components.binary_sensor import (
     DOMAIN as BINARY_SENSOR_DOMAIN,
     BinarySensorDeviceClass,
 )
+from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN, NumberDeviceClass
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
 from homeassistant.const import PERCENTAGE, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
@@ -24,6 +25,7 @@ _MOISTURE_BINARY_DOMAIN_SPECS = {
 
 _MOISTURE_NUMERICAL_DOMAIN_SPECS = {
     SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.MOISTURE),
+    NUMBER_DOMAIN: DomainSpec(device_class=NumberDeviceClass.MOISTURE),
 }
 
 CONDITIONS: dict[str, type[Condition]] = {

homeassistant/components/moisture/conditions.yaml

@@ -37,6 +37,8 @@ is_value:
     entity:
       - domain: sensor
         device_class: moisture
+      - domain: number
+        device_class: moisture
   fields:
     behavior: *condition_behavior
     threshold:

homeassistant/components/moisture/trigger.py

@@ -6,10 +6,11 @@ from homeassistant.components.binary_sensor import (
     DOMAIN as BINARY_SENSOR_DOMAIN,
     BinarySensorDeviceClass,
 )
+from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN, NumberDeviceClass
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
 from homeassistant.const import PERCENTAGE, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.trigger import (
     Trigger,
     make_entity_numerical_state_changed_trigger,
@@ -21,8 +22,9 @@ MOISTURE_BINARY_DOMAIN_SPECS: dict[str, DomainSpec] = {
     BINARY_SENSOR_DOMAIN: DomainSpec(device_class=BinarySensorDeviceClass.MOISTURE),
 }
 
-MOISTURE_NUMERICAL_DOMAIN_SPECS: dict[str, DomainSpec] = {
-    SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.MOISTURE),
+MOISTURE_NUMERICAL_DOMAIN_SPECS: dict[str, NumericalDomainSpec] = {
+    NUMBER_DOMAIN: NumericalDomainSpec(device_class=NumberDeviceClass.MOISTURE),
+    SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.MOISTURE),
 }
 
 

homeassistant/components/moisture/triggers.yaml

@@ -31,6 +31,8 @@
 
 .trigger_numerical_target: &trigger_numerical_target
   entity:
+    - domain: number
+      device_class: moisture
     - domain: sensor
       device_class: moisture
 

homeassistant/components/netatmo/__init__.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
+from http import HTTPStatus
 import logging
 import secrets
 from typing import Any
 
-from aiohttp import ClientError
+import aiohttp
 import pyatmo
 
 from homeassistant.components import cloud
@@ -18,12 +19,7 @@ from homeassistant.components.webhook import (
 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,
-    OAuth2TokenRequestError,
-    OAuth2TokenRequestReauthError,
-)
+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,
@@ -93,9 +89,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     session = OAuth2Session(hass, entry, implementation)
     try:
         await session.async_ensure_token_valid()
-    except OAuth2TokenRequestReauthError as ex:
-        raise ConfigEntryAuthFailed("Token not valid, trigger renewal") from ex
-    except (OAuth2TokenRequestError, ClientError) as ex:
+    except aiohttp.ClientResponseError as ex:
+        _LOGGER.warning("API error: %s (%s)", ex.status, ex.message)
+        if ex.status in (
+            HTTPStatus.BAD_REQUEST,
+            HTTPStatus.UNAUTHORIZED,
+            HTTPStatus.FORBIDDEN,
+        ):
+            raise ConfigEntryAuthFailed("Token not valid, trigger renewal") from ex
         raise ConfigEntryNotReady from ex
 
     required_scopes = api.get_api_scopes(entry.data["auth_implementation"])

homeassistant/components/nina/binary_sensor.py

@@ -8,8 +8,11 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import (
     ATTR_AFFECTED_AREAS,
@@ -25,13 +28,13 @@ from .const import (
     ATTR_WEB,
     CONF_MESSAGE_SLOTS,
     CONF_REGIONS,
+    DOMAIN,
 )
 from .coordinator import NinaConfigEntry, NINADataUpdateCoordinator
-from .entity import NinaEntity
 
 
 async def async_setup_entry(
-    _: HomeAssistant,
+    hass: HomeAssistant,
     config_entry: NinaConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
@@ -43,7 +46,7 @@ async def async_setup_entry(
     message_slots: int = config_entry.data[CONF_MESSAGE_SLOTS]
 
     async_add_entities(
-        NINAMessage(coordinator, ent, regions[ent], i + 1)
+        NINAMessage(coordinator, ent, regions[ent], i + 1, config_entry)
         for ent in coordinator.data
         for i in range(message_slots)
     )
@@ -52,7 +55,7 @@ async def async_setup_entry(
 PARALLEL_UPDATES = 0
 
 
-class NINAMessage(NinaEntity, BinarySensorEntity):
+class NINAMessage(CoordinatorEntity[NINADataUpdateCoordinator], BinarySensorEntity):
     """Representation of an NINA warning."""
 
     _attr_device_class = BinarySensorDeviceClass.SAFETY
@@ -64,20 +67,31 @@ class NINAMessage(NinaEntity, BinarySensorEntity):
         region: str,
         region_name: str,
         slot_id: int,
+        config_entry: ConfigEntry,
     ) -> None:
         """Initialize."""
-        super().__init__(coordinator, region, region_name, slot_id)
+        super().__init__(coordinator)
 
-        self._attr_translation_key = "warning"
+        self._region = region
+        self._warning_index = slot_id - 1
+
+        self._attr_name = f"Warning: {region_name} {slot_id}"
         self._attr_unique_id = f"{region}-{slot_id}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, config_entry.entry_id)},
+            manufacturer="NINA",
+            entry_type=DeviceEntryType.SERVICE,
+        )
 
     @property
     def is_on(self) -> bool:
         """Return the state of the sensor."""
-        if self._get_active_warnings_count() <= self._warning_index:
+        if len(self.coordinator.data[self._region]) <= self._warning_index:
             return False
 
-        return self._get_warning_data().is_valid
+        data = self.coordinator.data[self._region][self._warning_index]
+
+        return data.is_valid
 
     @property
     def extra_state_attributes(self) -> dict[str, Any]:
@@ -85,7 +99,7 @@ class NINAMessage(NinaEntity, BinarySensorEntity):
         if not self.is_on:
             return {}
 
-        data = self._get_warning_data()
+        data = self.coordinator.data[self._region][self._warning_index]
 
         return {
             ATTR_HEADLINE: data.headline,

homeassistant/components/nina/coordinator.py

@@ -12,7 +12,6 @@ from pynina import ApiError, Nina
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import (
@@ -65,12 +64,6 @@ class NINADataUpdateCoordinator(
         ]
         self.area_filter: str = config_entry.data[CONF_FILTERS][CONF_AREA_FILTER]
 
-        self.device_info = DeviceInfo(
-            identifiers={(DOMAIN, config_entry.entry_id)},
-            manufacturer="NINA",
-            entry_type=DeviceEntryType.SERVICE,
-        )
-
         regions: dict[str, str] = config_entry.data[CONF_REGIONS]
         for region in regions:
             self._nina.add_region(region)

homeassistant/components/nina/entity.py

@@ -1,36 +0,0 @@
-"""NINA common entity."""
-
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .coordinator import NINADataUpdateCoordinator, NinaWarningData
-
-
-class NinaEntity(CoordinatorEntity[NINADataUpdateCoordinator]):
-    """Base class for NINA entities."""
-
-    def __init__(
-        self,
-        coordinator: NINADataUpdateCoordinator,
-        region: str,
-        region_name: str,
-        slot_id: int,
-    ) -> None:
-        """Initialize."""
-        super().__init__(coordinator)
-
-        self._region = region
-        self._warning_index = slot_id - 1
-
-        self._attr_translation_placeholders = {
-            "region_name": region_name,
-            "slot_id": str(slot_id),
-        }
-        self._attr_device_info = coordinator.device_info
-
-    def _get_active_warnings_count(self) -> int:
-        """Return the number of active warnings for the region."""
-        return len(self.coordinator.data[self._region])
-
-    def _get_warning_data(self) -> NinaWarningData:
-        """Return warning data."""
-        return self.coordinator.data[self._region][self._warning_index]

homeassistant/components/nina/strings.json

@@ -45,13 +45,6 @@
       }
     }
   },
-  "entity": {
-    "binary_sensor": {
-      "warning": {
-        "name": "Warning: {region_name} {slot_id}"
-      }
-    }
-  },
   "options": {
     "abort": {
       "no_fetch": "[%key:component::nina::config::abort::no_fetch%]",

homeassistant/components/pooldose/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "platinum",
-  "requirements": ["python-pooldose==0.9.0"]
+  "requirements": ["python-pooldose==0.8.6"]
 }

homeassistant/components/power/condition.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
+from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN, NumberDeviceClass
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
 from homeassistant.const import UnitOfPower
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.automation import NumericalDomainSpec
 from homeassistant.helpers.condition import (
     Condition,
     make_entity_numerical_condition_with_unit,
@@ -13,7 +14,8 @@ from homeassistant.helpers.condition import (
 from homeassistant.util.unit_conversion import PowerConverter
 
 POWER_DOMAIN_SPECS = {
-    SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.POWER),
+    NUMBER_DOMAIN: NumericalDomainSpec(device_class=NumberDeviceClass.POWER),
+    SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.POWER),
 }
 
 

homeassistant/components/power/conditions.yaml

@@ -28,6 +28,8 @@
 is_value:
   target:
     entity:
+      - domain: number
+        device_class: power
       - domain: sensor
         device_class: power
   fields:

homeassistant/components/power/trigger.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
+from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN, NumberDeviceClass
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
 from homeassistant.const import UnitOfPower
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.automation import NumericalDomainSpec
 from homeassistant.helpers.trigger import (
     Trigger,
     make_entity_numerical_state_changed_with_unit_trigger,
@@ -13,8 +14,9 @@ from homeassistant.helpers.trigger import (
 )
 from homeassistant.util.unit_conversion import PowerConverter
 
-POWER_DOMAIN_SPECS: dict[str, DomainSpec] = {
-    SENSOR_DOMAIN: DomainSpec(device_class=SensorDeviceClass.POWER),
+POWER_DOMAIN_SPECS: dict[str, NumericalDomainSpec] = {
+    NUMBER_DOMAIN: NumericalDomainSpec(device_class=NumberDeviceClass.POWER),
+    SENSOR_DOMAIN: NumericalDomainSpec(device_class=SensorDeviceClass.POWER),
 }
 
 

homeassistant/components/power/triggers.yaml

@@ -29,6 +29,8 @@
 
 .trigger_target: &trigger_target
   entity:
+    - domain: number
+      device_class: power
     - domain: sensor
       device_class: power
 

homeassistant/components/proxmoxve/button.py

@@ -23,7 +23,7 @@ from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util
 
-from .const import DOMAIN, ProxmoxPermission
+from .const import DOMAIN
 from .coordinator import ProxmoxConfigEntry, ProxmoxCoordinator, ProxmoxNodeData
 from .entity import ProxmoxContainerEntity, ProxmoxNodeEntity, ProxmoxVMEntity
 from .helpers import is_granted
@@ -34,8 +34,6 @@ class ProxmoxNodeButtonNodeEntityDescription(ButtonEntityDescription):
     """Class to hold Proxmox node button description."""
 
     press_action: Callable[[ProxmoxCoordinator, str], None]
-    permission: ProxmoxPermission = ProxmoxPermission.POWER
-    permission_raise: str = "no_permission_node_power"
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -43,8 +41,6 @@ class ProxmoxVMButtonEntityDescription(ButtonEntityDescription):
     """Class to hold Proxmox VM button description."""
 
     press_action: Callable[[ProxmoxCoordinator, str, int], None]
-    permission: ProxmoxPermission = ProxmoxPermission.POWER
-    permission_raise: str = "no_permission_vm_lxc_power"
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -52,8 +48,6 @@ class ProxmoxContainerButtonEntityDescription(ButtonEntityDescription):
     """Class to hold Proxmox container button description."""
 
     press_action: Callable[[ProxmoxCoordinator, str, int], None]
-    permission: ProxmoxPermission = ProxmoxPermission.POWER
-    permission_raise: str = "no_permission_vm_lxc_power"
 
 
 NODE_BUTTONS: tuple[ProxmoxNodeButtonNodeEntityDescription, ...] = (
@@ -162,8 +156,6 @@ VM_BUTTONS: tuple[ProxmoxVMButtonEntityDescription, ...] = (
                 )
             )
         ),
-        permission=ProxmoxPermission.SNAPSHOT,
-        permission_raise="no_permission_snapshot",
         entity_category=EntityCategory.CONFIG,
     ),
 )
@@ -207,8 +199,6 @@ CONTAINER_BUTTONS: tuple[ProxmoxContainerButtonEntityDescription, ...] = (
                 )
             )
         ),
-        permission=ProxmoxPermission.SNAPSHOT,
-        permission_raise="no_permission_snapshot",
         entity_category=EntityCategory.CONFIG,
     ),
 )
@@ -325,15 +315,10 @@ class ProxmoxNodeButtonEntity(ProxmoxNodeEntity, ProxmoxBaseButton):
     async def _async_press_call(self) -> None:
         """Execute the node button action via executor."""
         node_id = self._node_data.node["node"]
-        if not is_granted(
-            self.coordinator.permissions,
-            p_type="nodes",
-            p_id=node_id,
-            permission=self.entity_description.permission,
-        ):
+        if not is_granted(self.coordinator.permissions, p_type="nodes", p_id=node_id):
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
-                translation_key=self.entity_description.permission_raise,
+                translation_key="no_permission_node_power",
             )
         await self.hass.async_add_executor_job(
             self.entity_description.press_action,
@@ -350,15 +335,10 @@ class ProxmoxVMButtonEntity(ProxmoxVMEntity, ProxmoxBaseButton):
     async def _async_press_call(self) -> None:
         """Execute the VM button action via executor."""
         vmid = self.vm_data["vmid"]
-        if not is_granted(
-            self.coordinator.permissions,
-            p_type="vms",
-            p_id=vmid,
-            permission=self.entity_description.permission,
-        ):
+        if not is_granted(self.coordinator.permissions, p_type="vms", p_id=vmid):
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
-                translation_key=self.entity_description.permission_raise,
+                translation_key="no_permission_vm_lxc_power",
             )
         await self.hass.async_add_executor_job(
             self.entity_description.press_action,
@@ -377,15 +357,10 @@ class ProxmoxContainerButtonEntity(ProxmoxContainerEntity, ProxmoxBaseButton):
         """Execute the container button action via executor."""
         vmid = self.container_data["vmid"]
         # Container power actions fall under vms
-        if not is_granted(
-            self.coordinator.permissions,
-            p_type="vms",
-            p_id=vmid,
-            permission=self.entity_description.permission,
-        ):
+        if not is_granted(self.coordinator.permissions, p_type="vms", p_id=vmid):
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
-                translation_key=self.entity_description.permission_raise,
+                translation_key="no_permission_vm_lxc_power",
             )
         await self.hass.async_add_executor_job(
             self.entity_description.press_action,

homeassistant/components/proxmoxve/const.py

@@ -1,7 +1,5 @@
 """Constants for ProxmoxVE."""
 
-from enum import StrEnum
-
 DOMAIN = "proxmoxve"
 CONF_AUTH_METHOD = "auth_method"
 CONF_REALM = "realm"
@@ -35,9 +33,4 @@ TYPE_VM = 0
 TYPE_CONTAINER = 1
 UPDATE_INTERVAL = 60
 
-
-class ProxmoxPermission(StrEnum):
-    """Proxmox permissions."""
-
-    POWER = "VM.PowerMgmt"
-    SNAPSHOT = "VM.Snapshot"
+PERM_POWER = "VM.PowerMgmt"

homeassistant/components/proxmoxve/helpers.py

@@ -1,13 +1,13 @@
 """Helpers for Proxmox VE."""
 
-from .const import ProxmoxPermission
+from .const import PERM_POWER
 
 
 def is_granted(
     permissions: dict[str, dict[str, int]],
     p_type: str = "vms",
     p_id: str | int | None = None,  # can be str for nodes
-    permission: ProxmoxPermission = ProxmoxPermission.POWER,
+    permission: str = PERM_POWER,
 ) -> bool:
     """Validate user permissions for the given type and permission."""
     paths = [f"/{p_type}/{p_id}", f"/{p_type}", "/"]

homeassistant/components/proxmoxve/strings.json

@@ -315,9 +315,6 @@
     "no_permission_node_power": {
       "message": "The configured Proxmox VE user does not have permission to manage the power state of nodes. Please grant the user the 'VM.PowerMgmt' permission and try again."
     },
-    "no_permission_snapshot": {
-      "message": "The configured Proxmox VE user does not have permission to create snapshots of VMs and containers. Please grant the user the 'VM.Snapshot' permission and try again."
-    },
     "no_permission_vm_lxc_power": {
       "message": "The configured Proxmox VE user does not have permission to manage the power state of VMs and containers. Please grant the user the 'VM.PowerMgmt' permission and try again."
     },

homeassistant/components/radarr/calendar.py

@@ -56,7 +56,7 @@ class RadarrCalendarEntity(RadarrEntity, CalendarEntity):
         return await self.coordinator.async_get_events(start_date, end_date)
 
     @callback
-    def _async_write_ha_state(self) -> None:
+    def async_write_ha_state(self) -> None:
         """Write the state to the state machine."""
         if self.coordinator.event:
             self._attr_extra_state_attributes = {
@@ -64,4 +64,4 @@ class RadarrCalendarEntity(RadarrEntity, CalendarEntity):
             }
         else:
             self._attr_extra_state_attributes = {}
-        super()._async_write_ha_state()
+        super().async_write_ha_state()

homeassistant/components/rainmachine/__init__.py

@@ -102,7 +102,7 @@ CV_WX_DATA_VALID_TEMP_RANGE = vol.All(vol.Coerce(float), vol.Range(min=-40.0, ma
 CV_WX_DATA_VALID_RAIN_RANGE = vol.All(vol.Coerce(float), vol.Range(min=0.0, max=1000.0))
 CV_WX_DATA_VALID_WIND_SPEED = vol.All(vol.Coerce(float), vol.Range(min=0.0, max=65.0))
 CV_WX_DATA_VALID_PRESSURE = vol.All(vol.Coerce(float), vol.Range(min=60.0, max=110.0))
-CV_WX_DATA_VALID_SOLARRAD = vol.All(vol.Coerce(float), vol.Range(min=0.0, max=100.0))
+CV_WX_DATA_VALID_SOLARRAD = vol.All(vol.Coerce(float), vol.Range(min=0.0, max=5.0))
 
 SERVICE_NAME_PAUSE_WATERING = "pause_watering"
 SERVICE_NAME_PUSH_FLOW_METER_DATA = "push_flow_meter_data"

homeassistant/components/rainmachine/services.yaml

@@ -131,9 +131,9 @@ push_weather_data:
       selector:
         number:
           min: 0
-          max: 100
+          max: 5
           step: 0.1
-          unit_of_measurement: "MJ/m²/d"
+          unit_of_measurement: "MJ/m²/h"
     et:
       selector:
         number:

homeassistant/components/rainmachine/strings.json

@@ -175,7 +175,7 @@
           "name": "Measured rainfall"
         },
         "solarrad": {
-          "description": "Daily solar radiation (MJ/m²/d).",
+          "description": "Current solar radiation (MJ/m²/h).",
           "name": "Solar radiation"
         },
         "temperature": {