Support for hierarchy of water meters

homeassistant/components/accuweather/const.py

@@ -71,4 +71,4 @@ POLLEN_CATEGORY_MAP = {
 }
 UPDATE_INTERVAL_OBSERVATION = timedelta(minutes=10)
 UPDATE_INTERVAL_DAILY_FORECAST = timedelta(hours=6)
-UPDATE_INTERVAL_HOURLY_FORECAST = timedelta(minutes=30)
+UPDATE_INTERVAL_HOURLY_FORECAST = timedelta(hours=30)

homeassistant/components/airthings_ble/sensor.py

@@ -16,12 +16,10 @@ from homeassistant.components.sensor import (
 from homeassistant.const import (
     CONCENTRATION_PARTS_PER_BILLION,
     CONCENTRATION_PARTS_PER_MILLION,
-    LIGHT_LUX,
     PERCENTAGE,
     EntityCategory,
     Platform,
     UnitOfPressure,
-    UnitOfSoundPressure,
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant, callback
@@ -114,21 +112,6 @@ SENSORS_MAPPING_TEMPLATE: dict[str, SensorEntityDescription] = {
         state_class=SensorStateClass.MEASUREMENT,
         suggested_display_precision=0,
     ),
-    "lux": SensorEntityDescription(
-        key="lux",
-        device_class=SensorDeviceClass.ILLUMINANCE,
-        native_unit_of_measurement=LIGHT_LUX,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=0,
-    ),
-    "noise": SensorEntityDescription(
-        key="noise",
-        translation_key="ambient_noise",
-        device_class=SensorDeviceClass.SOUND_PRESSURE,
-        native_unit_of_measurement=UnitOfSoundPressure.WEIGHTED_DECIBEL_A,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=0,
-    ),
 }
 
 PARALLEL_UPDATES = 0

homeassistant/components/airthings_ble/strings.json

@@ -41,9 +41,6 @@
       },
       "illuminance": {
         "name": "[%key:component::sensor::entity_component::illuminance::name%]"
-      },
-      "ambient_noise": {
-        "name": "Ambient noise"
       }
     }
   }

homeassistant/components/conversation/default_agent.py

@@ -38,11 +38,9 @@ from home_assistant_intents import (
     ErrorKey,
     FuzzyConfig,
     FuzzyLanguageResponses,
-    LanguageScores,
     get_fuzzy_config,
     get_fuzzy_language,
     get_intents,
-    get_language_scores,
     get_languages,
 )
 import yaml
@@ -61,7 +59,6 @@ from homeassistant.core import (
 )
 from homeassistant.helpers import (
     area_registry as ar,
-    config_validation as cv,
     device_registry as dr,
     entity_registry as er,
     floor_registry as fr,
@@ -346,81 +343,6 @@ class DefaultAgent(ConversationEntity):
 
         return result
 
-    async def async_debug_recognize(
-        self, user_input: ConversationInput
-    ) -> dict[str, Any] | None:
-        """Debug recognize from user input."""
-        result_dict: dict[str, Any] | None = None
-
-        if trigger_result := await self.async_recognize_sentence_trigger(user_input):
-            result_dict = {
-                # Matched a user-defined sentence trigger.
-                # We can't provide the response here without executing the
-                # trigger.
-                "match": True,
-                "source": "trigger",
-                "sentence_template": trigger_result.sentence_template or "",
-            }
-        elif intent_result := await self.async_recognize_intent(user_input):
-            successful_match = not intent_result.unmatched_entities
-            result_dict = {
-                # Name of the matching intent (or the closest)
-                "intent": {
-                    "name": intent_result.intent.name,
-                },
-                # Slot values that would be received by the intent
-                "slots": {  # direct access to values
-                    entity_key: entity.text or entity.value
-                    for entity_key, entity in intent_result.entities.items()
-                },
-                # Extra slot details, such as the originally matched text
-                "details": {
-                    entity_key: {
-                        "name": entity.name,
-                        "value": entity.value,
-                        "text": entity.text,
-                    }
-                    for entity_key, entity in intent_result.entities.items()
-                },
-                # Entities/areas/etc. that would be targeted
-                "targets": {},
-                # True if match was successful
-                "match": successful_match,
-                # Text of the sentence template that matched (or was closest)
-                "sentence_template": "",
-                # When match is incomplete, this will contain the best slot guesses
-                "unmatched_slots": _get_unmatched_slots(intent_result),
-                # True if match was not exact
-                "fuzzy_match": False,
-            }
-
-            if successful_match:
-                result_dict["targets"] = {
-                    state.entity_id: {"matched": is_matched}
-                    for state, is_matched in _get_debug_targets(
-                        self.hass, intent_result
-                    )
-                }
-
-            if intent_result.intent_sentence is not None:
-                result_dict["sentence_template"] = intent_result.intent_sentence.text
-
-            if intent_result.intent_metadata:
-                # Inspect metadata to determine if this matched a custom sentence
-                if intent_result.intent_metadata.get(METADATA_CUSTOM_SENTENCE):
-                    result_dict["source"] = "custom"
-                    result_dict["file"] = intent_result.intent_metadata.get(
-                        METADATA_CUSTOM_FILE
-                    )
-                else:
-                    result_dict["source"] = "builtin"
-
-                result_dict["fuzzy_match"] = intent_result.intent_metadata.get(
-                    METADATA_FUZZY_MATCH, False
-                )
-
-        return result_dict
-
     async def _async_handle_message(
         self,
         user_input: ConversationInput,
@@ -1607,10 +1529,6 @@ class DefaultAgent(ConversationEntity):
             return None
         return response
 
-    async def async_get_language_scores(self) -> dict[str, LanguageScores]:
-        """Get support scores per language."""
-        return await self.hass.async_add_executor_job(get_language_scores)
-
 
 def _make_error_result(
     language: str,
@@ -1807,75 +1725,3 @@ def _collect_list_references(expression: Expression, list_names: set[str]) -> No
     elif isinstance(expression, ListReference):
         # {list}
         list_names.add(expression.slot_name)
-
-
-def _get_debug_targets(
-    hass: HomeAssistant,
-    result: RecognizeResult,
-) -> Iterable[tuple[State, bool]]:
-    """Yield state/is_matched pairs for a hassil recognition."""
-    entities = result.entities
-
-    name: str | None = None
-    area_name: str | None = None
-    domains: set[str] | None = None
-    device_classes: set[str] | None = None
-    state_names: set[str] | None = None
-
-    if "name" in entities:
-        name = str(entities["name"].value)
-
-    if "area" in entities:
-        area_name = str(entities["area"].value)
-
-    if "domain" in entities:
-        domains = set(cv.ensure_list(entities["domain"].value))
-
-    if "device_class" in entities:
-        device_classes = set(cv.ensure_list(entities["device_class"].value))
-
-    if "state" in entities:
-        # HassGetState only
-        state_names = set(cv.ensure_list(entities["state"].value))
-
-    if (
-        (name is None)
-        and (area_name is None)
-        and (not domains)
-        and (not device_classes)
-        and (not state_names)
-    ):
-        # Avoid "matching" all entities when there is no filter
-        return
-
-    states = intent.async_match_states(
-        hass,
-        name=name,
-        area_name=area_name,
-        domains=domains,
-        device_classes=device_classes,
-    )
-
-    for state in states:
-        # For queries, a target is "matched" based on its state
-        is_matched = (state_names is None) or (state.state in state_names)
-        yield state, is_matched
-
-
-def _get_unmatched_slots(
-    result: RecognizeResult,
-) -> dict[str, str | int | float]:
-    """Return a dict of unmatched text/range slot entities."""
-    unmatched_slots: dict[str, str | int | float] = {}
-    for entity in result.unmatched_entities_list:
-        if isinstance(entity, UnmatchedTextEntity):
-            if entity.text == MISSING_ENTITY:
-                # Don't report <missing> since these are just missing context
-                # slots.
-                continue
-
-            unmatched_slots[entity.name] = entity.text
-        elif isinstance(entity, UnmatchedRangeEntity):
-            unmatched_slots[entity.name] = entity.value
-
-    return unmatched_slots

homeassistant/components/conversation/http.py

@@ -2,16 +2,21 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterable
 from dataclasses import asdict
 from typing import Any
 
 from aiohttp import web
+from hassil.recognize import MISSING_ENTITY, RecognizeResult
+from hassil.string_matcher import UnmatchedRangeEntity, UnmatchedTextEntity
+from home_assistant_intents import get_language_scores
 import voluptuous as vol
 
 from homeassistant.components import http, websocket_api
 from homeassistant.components.http.data_validator import RequestDataValidator
 from homeassistant.const import MATCH_ALL
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant, State, callback
+from homeassistant.helpers import config_validation as cv, intent
 from homeassistant.util import language as language_util
 
 from .agent_manager import (
@@ -21,6 +26,11 @@ from .agent_manager import (
     get_agent_manager,
 )
 from .const import DATA_COMPONENT
+from .default_agent import (
+    METADATA_CUSTOM_FILE,
+    METADATA_CUSTOM_SENTENCE,
+    METADATA_FUZZY_MATCH,
+)
 from .entity import ConversationEntity
 from .models import ConversationInput
 
@@ -196,12 +206,150 @@ async def websocket_hass_agent_debug(
             language=msg.get("language", hass.config.language),
             agent_id=agent.entity_id,
         )
-        result_dict = await agent.async_debug_recognize(user_input)
+        result_dict: dict[str, Any] | None = None
+
+        if trigger_result := await agent.async_recognize_sentence_trigger(user_input):
+            result_dict = {
+                # Matched a user-defined sentence trigger.
+                # We can't provide the response here without executing the
+                # trigger.
+                "match": True,
+                "source": "trigger",
+                "sentence_template": trigger_result.sentence_template or "",
+            }
+        elif intent_result := await agent.async_recognize_intent(user_input):
+            successful_match = not intent_result.unmatched_entities
+            result_dict = {
+                # Name of the matching intent (or the closest)
+                "intent": {
+                    "name": intent_result.intent.name,
+                },
+                # Slot values that would be received by the intent
+                "slots": {  # direct access to values
+                    entity_key: entity.text or entity.value
+                    for entity_key, entity in intent_result.entities.items()
+                },
+                # Extra slot details, such as the originally matched text
+                "details": {
+                    entity_key: {
+                        "name": entity.name,
+                        "value": entity.value,
+                        "text": entity.text,
+                    }
+                    for entity_key, entity in intent_result.entities.items()
+                },
+                # Entities/areas/etc. that would be targeted
+                "targets": {},
+                # True if match was successful
+                "match": successful_match,
+                # Text of the sentence template that matched (or was closest)
+                "sentence_template": "",
+                # When match is incomplete, this will contain the best slot guesses
+                "unmatched_slots": _get_unmatched_slots(intent_result),
+                # True if match was not exact
+                "fuzzy_match": False,
+            }
+
+            if successful_match:
+                result_dict["targets"] = {
+                    state.entity_id: {"matched": is_matched}
+                    for state, is_matched in _get_debug_targets(hass, intent_result)
+                }
+
+            if intent_result.intent_sentence is not None:
+                result_dict["sentence_template"] = intent_result.intent_sentence.text
+
+            if intent_result.intent_metadata:
+                # Inspect metadata to determine if this matched a custom sentence
+                if intent_result.intent_metadata.get(METADATA_CUSTOM_SENTENCE):
+                    result_dict["source"] = "custom"
+                    result_dict["file"] = intent_result.intent_metadata.get(
+                        METADATA_CUSTOM_FILE
+                    )
+                else:
+                    result_dict["source"] = "builtin"
+
+                result_dict["fuzzy_match"] = intent_result.intent_metadata.get(
+                    METADATA_FUZZY_MATCH, False
+                )
+
         result_dicts.append(result_dict)
 
     connection.send_result(msg["id"], {"results": result_dicts})
 
 
+def _get_debug_targets(
+    hass: HomeAssistant,
+    result: RecognizeResult,
+) -> Iterable[tuple[State, bool]]:
+    """Yield state/is_matched pairs for a hassil recognition."""
+    entities = result.entities
+
+    name: str | None = None
+    area_name: str | None = None
+    domains: set[str] | None = None
+    device_classes: set[str] | None = None
+    state_names: set[str] | None = None
+
+    if "name" in entities:
+        name = str(entities["name"].value)
+
+    if "area" in entities:
+        area_name = str(entities["area"].value)
+
+    if "domain" in entities:
+        domains = set(cv.ensure_list(entities["domain"].value))
+
+    if "device_class" in entities:
+        device_classes = set(cv.ensure_list(entities["device_class"].value))
+
+    if "state" in entities:
+        # HassGetState only
+        state_names = set(cv.ensure_list(entities["state"].value))
+
+    if (
+        (name is None)
+        and (area_name is None)
+        and (not domains)
+        and (not device_classes)
+        and (not state_names)
+    ):
+        # Avoid "matching" all entities when there is no filter
+        return
+
+    states = intent.async_match_states(
+        hass,
+        name=name,
+        area_name=area_name,
+        domains=domains,
+        device_classes=device_classes,
+    )
+
+    for state in states:
+        # For queries, a target is "matched" based on its state
+        is_matched = (state_names is None) or (state.state in state_names)
+        yield state, is_matched
+
+
+def _get_unmatched_slots(
+    result: RecognizeResult,
+) -> dict[str, str | int | float]:
+    """Return a dict of unmatched text/range slot entities."""
+    unmatched_slots: dict[str, str | int | float] = {}
+    for entity in result.unmatched_entities_list:
+        if isinstance(entity, UnmatchedTextEntity):
+            if entity.text == MISSING_ENTITY:
+                # Don't report <missing> since these are just missing context
+                # slots.
+                continue
+
+            unmatched_slots[entity.name] = entity.text
+        elif isinstance(entity, UnmatchedRangeEntity):
+            unmatched_slots[entity.name] = entity.value
+
+    return unmatched_slots
+
+
 @websocket_api.websocket_command(
     {
         vol.Required("type"): "conversation/agent/homeassistant/language_scores",
@@ -216,13 +364,10 @@ async def websocket_hass_agent_language_scores(
     msg: dict[str, Any],
 ) -> None:
     """Get support scores per language."""
-    agent = get_agent_manager(hass).default_agent
-    assert agent is not None
-
     language = msg.get("language", hass.config.language)
     country = msg.get("country", hass.config.country)
 
-    scores = await agent.async_get_language_scores()
+    scores = await hass.async_add_executor_job(get_language_scores)
     matching_langs = language_util.matches(language, scores.keys(), country=country)
     preferred_lang = matching_langs[0] if matching_langs else language
     result = {

homeassistant/components/energy/data.py

@@ -116,6 +116,10 @@ class WaterSourceType(TypedDict):
     # an EnergyCostSensor will be automatically created
     stat_cost: str | None
 
+    # An optional statistic_id identifying a device
+    # that includes this device's consumption in its total
+    included_in_stat: str | None
+
     # Used to generate costs if stat_cost is set to None
     entity_energy_price: str | None  # entity_id of an entity providing price ($/m³)
     number_energy_price: float | None  # Price for energy ($/m³)

homeassistant/components/environment_canada/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/environment_canada",
   "iot_class": "cloud_polling",
   "loggers": ["env_canada"],
-  "requirements": ["env-canada==0.11.3"]
+  "requirements": ["env-canada==0.11.2"]
 }

homeassistant/components/esphome/manifest.json

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

homeassistant/components/holiday/manifest.json

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

homeassistant/components/lamarzocco/manifest.json

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

homeassistant/components/mill/coordinator.py

@@ -10,11 +10,7 @@ from mill import Heater, Mill
 from mill_local import Mill as MillLocal
 
 from homeassistant.components.recorder import get_instance
-from homeassistant.components.recorder.models import (
-    StatisticData,
-    StatisticMeanType,
-    StatisticMetaData,
-)
+from homeassistant.components.recorder.models import StatisticData, StatisticMetaData
 from homeassistant.components.recorder.statistics import (
     async_add_external_statistics,
     get_last_statistics,
@@ -151,7 +147,7 @@ class MillHistoricDataUpdateCoordinator(DataUpdateCoordinator):
                     )
                 )
             metadata = StatisticMetaData(
-                mean_type=StatisticMeanType.NONE,
+                has_mean=False,
                 has_sum=True,
                 name=f"{heater.name}",
                 source=DOMAIN,

homeassistant/components/modbus/modbus.py

@@ -253,7 +253,6 @@ class ModbusHub:
         self._client: (
             AsyncModbusSerialClient | AsyncModbusTcpClient | AsyncModbusUdpClient | None
         ) = None
-        self._lock = asyncio.Lock()
         self.event_connected = asyncio.Event()
         self.hass = hass
         self.name = client_config[CONF_NAME]
@@ -416,9 +415,7 @@ class ModbusHub:
         """Convert async to sync pymodbus call."""
         if not self._client:
             return None
-        async with self._lock:
-            result = await self.low_level_pb_call(unit, address, value, use_call)
-            if self._msg_wait:
-                # small delay until next request/response
-                await asyncio.sleep(self._msg_wait)
-            return result
+        result = await self.low_level_pb_call(unit, address, value, use_call)
+        if self._msg_wait:
+            await asyncio.sleep(self._msg_wait)
+        return result

homeassistant/components/motion_blinds/cover.py

@@ -174,7 +174,7 @@ class MotionBaseDevice(MotionCoordinatorEntity, CoverEntity):
 
     _restore_tilt = False
 
-    def __init__(self, coordinator, blind, device_class) -> None:
+    def __init__(self, coordinator, blind, device_class):
         """Initialize the blind."""
         super().__init__(coordinator, blind)
 
@@ -275,7 +275,7 @@ class MotionTiltDevice(MotionPositionDevice):
         """
         if self._blind.angle is None:
             return None
-        return 100 - (self._blind.angle * 100 / 180)
+        return self._blind.angle * 100 / 180
 
     @property
     def is_closed(self) -> bool | None:
@@ -287,14 +287,14 @@ class MotionTiltDevice(MotionPositionDevice):
     async def async_open_cover_tilt(self, **kwargs: Any) -> None:
         """Open the cover tilt."""
         async with self._api_lock:
-            await self.hass.async_add_executor_job(self._blind.Set_angle, 0)
+            await self.hass.async_add_executor_job(self._blind.Set_angle, 180)
 
         await self.async_request_position_till_stop()
 
     async def async_close_cover_tilt(self, **kwargs: Any) -> None:
         """Close the cover tilt."""
         async with self._api_lock:
-            await self.hass.async_add_executor_job(self._blind.Set_angle, 180)
+            await self.hass.async_add_executor_job(self._blind.Set_angle, 0)
 
         await self.async_request_position_till_stop()
 
@@ -302,7 +302,7 @@ class MotionTiltDevice(MotionPositionDevice):
         """Move the cover tilt to a specific position."""
         angle = kwargs[ATTR_TILT_POSITION] * 180 / 100
         async with self._api_lock:
-            await self.hass.async_add_executor_job(self._blind.Set_angle, 180 - angle)
+            await self.hass.async_add_executor_job(self._blind.Set_angle, angle)
 
         await self.async_request_position_till_stop()
 
@@ -347,9 +347,9 @@ class MotionTiltOnlyDevice(MotionTiltDevice):
         if self._blind.position is None:
             if self._blind.angle is None:
                 return None
-            return 100 - (self._blind.angle * 100 / 180)
+            return self._blind.angle * 100 / 180
 
-        return 100 - self._blind.position
+        return self._blind.position
 
     @property
     def is_closed(self) -> bool | None:
@@ -357,9 +357,9 @@ class MotionTiltOnlyDevice(MotionTiltDevice):
         if self._blind.position is None:
             if self._blind.angle is None:
                 return None
-            return self._blind.angle == 180
+            return self._blind.angle == 0
 
-        return self._blind.position == 100
+        return self._blind.position == 0
 
     async def async_open_cover_tilt(self, **kwargs: Any) -> None:
         """Open the cover tilt."""
@@ -381,14 +381,10 @@ class MotionTiltOnlyDevice(MotionTiltDevice):
         if self._blind.position is None:
             angle = angle * 180 / 100
             async with self._api_lock:
-                await self.hass.async_add_executor_job(
-                    self._blind.Set_angle, 180 - angle
-                )
+                await self.hass.async_add_executor_job(self._blind.Set_angle, angle)
         else:
             async with self._api_lock:
-                await self.hass.async_add_executor_job(
-                    self._blind.Set_position, 100 - angle
-                )
+                await self.hass.async_add_executor_job(self._blind.Set_position, angle)
 
         await self.async_request_position_till_stop()
 
@@ -401,14 +397,10 @@ class MotionTiltOnlyDevice(MotionTiltDevice):
         if self._blind.position is None:
             angle = angle * 180 / 100
             async with self._api_lock:
-                await self.hass.async_add_executor_job(
-                    self._blind.Set_angle, 180 - angle
-                )
+                await self.hass.async_add_executor_job(self._blind.Set_angle, angle)
         else:
             async with self._api_lock:
-                await self.hass.async_add_executor_job(
-                    self._blind.Set_position, 100 - angle
-                )
+                await self.hass.async_add_executor_job(self._blind.Set_position, angle)
 
         await self.async_request_position_till_stop()
 
@@ -416,7 +408,7 @@ class MotionTiltOnlyDevice(MotionTiltDevice):
 class MotionTDBUDevice(MotionBaseDevice):
     """Representation of a Motion Top Down Bottom Up blind Device."""
 
-    def __init__(self, coordinator, blind, device_class, motor) -> None:
+    def __init__(self, coordinator, blind, device_class, motor):
         """Initialize the blind."""
         super().__init__(coordinator, blind, device_class)
         self._motor = motor

homeassistant/components/niko_home_control/light.py

@@ -53,7 +53,7 @@ class NikoHomeControlLight(NikoHomeControlEntity, LightEntity):
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Instruct the light to turn on."""
-        await self._action.turn_on(kwargs.get(ATTR_BRIGHTNESS))
+        await self._action.turn_on(kwargs.get(ATTR_BRIGHTNESS, 255))
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Instruct the light to turn off."""

homeassistant/components/niko_home_control/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/niko_home_control",
   "iot_class": "local_push",
   "loggers": ["nikohomecontrol"],
-  "requirements": ["nhc==0.6.1"]
+  "requirements": ["nhc==0.4.12"]
 }

homeassistant/components/nintendo_parental/manifest.json

@@ -7,5 +7,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["pynintendoparental"],
   "quality_scale": "bronze",
-  "requirements": ["pynintendoparental==1.1.1"]
+  "requirements": ["pynintendoparental==1.0.1"]
 }

homeassistant/components/open_router/manifest.json

@@ -9,5 +9,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["openai==2.2.0", "python-open-router==0.3.1"]
+  "requirements": ["openai==1.99.5", "python-open-router==0.3.1"]
 }

homeassistant/components/openai_conversation/config_flow.py

@@ -316,23 +316,16 @@ class OpenAISubentryFlowHandler(ConfigSubentryFlow):
         options = self.options
         errors: dict[str, str] = {}
 
-        step_schema: VolDictType = {}
+        step_schema: VolDictType = {
+            vol.Optional(
+                CONF_CODE_INTERPRETER,
+                default=RECOMMENDED_CODE_INTERPRETER,
+            ): bool,
+        }
 
         model = options[CONF_CHAT_MODEL]
 
-        if not model.startswith(("gpt-5-pro", "gpt-5-codex")):
-            step_schema.update(
-                {
-                    vol.Optional(
-                        CONF_CODE_INTERPRETER,
-                        default=RECOMMENDED_CODE_INTERPRETER,
-                    ): bool,
-                }
-            )
-        elif CONF_CODE_INTERPRETER in options:
-            options.pop(CONF_CODE_INTERPRETER)
-
-        if model.startswith(("o", "gpt-5")) and not model.startswith("gpt-5-pro"):
+        if model.startswith(("o", "gpt-5")):
             step_schema.update(
                 {
                     vol.Optional(

homeassistant/components/openai_conversation/entity.py

@@ -468,9 +468,7 @@ class OpenAIBaseLLMEntity(Entity):
             model_args["reasoning"] = {
                 "effort": options.get(
                     CONF_REASONING_EFFORT, RECOMMENDED_REASONING_EFFORT
-                )
-                if not model_args["model"].startswith("gpt-5-pro")
-                else "high",  # GPT-5 pro only supports reasoning.effort: high
+                ),
                 "summary": "auto",
             }
             model_args["include"] = ["reasoning.encrypted_content"]
@@ -489,7 +487,7 @@ class OpenAIBaseLLMEntity(Entity):
 
         if options.get(CONF_WEB_SEARCH):
             web_search = WebSearchToolParam(
-                type="web_search",
+                type="web_search_preview",
                 search_context_size=options.get(
                     CONF_WEB_SEARCH_CONTEXT_SIZE, RECOMMENDED_WEB_SEARCH_CONTEXT_SIZE
                 ),

homeassistant/components/openai_conversation/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/openai_conversation",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["openai==2.2.0"]
+  "requirements": ["openai==1.99.5"]
 }

homeassistant/components/portainer/__init__.py

@@ -18,8 +18,7 @@ from homeassistant.helpers.aiohttp_client import async_create_clientsession
 
 from .coordinator import PortainerCoordinator
 
-_PLATFORMS: list[Platform] = [Platform.BINARY_SENSOR, Platform.SENSOR, Platform.SWITCH]
-
+_PLATFORMS: list[Platform] = [Platform.BINARY_SENSOR, Platform.BUTTON, Platform.SWITCH]
 
 type PortainerConfigEntry = ConfigEntry[PortainerCoordinator]
 

homeassistant/components/portainer/icons.json

@@ -1,10 +1,5 @@
 {
   "entity": {
-    "sensor": {
-      "image": {
-        "default": "mdi:docker"
-      }
-    },
     "switch": {
       "container": {
         "default": "mdi:arrow-down-box",

homeassistant/components/portainer/sensor.py

@@ -1,83 +0,0 @@
-"""Sensor platform for Portainer integration."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from pyportainer.models.docker import DockerContainer
-
-from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import PortainerConfigEntry, PortainerCoordinator
-from .entity import PortainerContainerEntity, PortainerCoordinatorData
-
-
-@dataclass(frozen=True, kw_only=True)
-class PortainerSensorEntityDescription(SensorEntityDescription):
-    """Class to hold Portainer sensor description."""
-
-    value_fn: Callable[[DockerContainer], str | None]
-
-
-CONTAINER_SENSORS: tuple[PortainerSensorEntityDescription, ...] = (
-    PortainerSensorEntityDescription(
-        key="image",
-        translation_key="image",
-        value_fn=lambda data: data.image,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: PortainerConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Portainer sensors based on a config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities(
-        PortainerContainerSensor(
-            coordinator,
-            entity_description,
-            container,
-            endpoint,
-        )
-        for endpoint in coordinator.data.values()
-        for container in endpoint.containers.values()
-        for entity_description in CONTAINER_SENSORS
-    )
-
-
-class PortainerContainerSensor(PortainerContainerEntity, SensorEntity):
-    """Representation of a Portainer container sensor."""
-
-    entity_description: PortainerSensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: PortainerCoordinator,
-        entity_description: PortainerSensorEntityDescription,
-        device_info: DockerContainer,
-        via_device: PortainerCoordinatorData,
-    ) -> None:
-        """Initialize the Portainer container sensor."""
-        self.entity_description = entity_description
-        super().__init__(device_info, coordinator, via_device)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_name}_{entity_description.key}"
-
-    @property
-    def available(self) -> bool:
-        """Return if the device is available."""
-        return super().available and self.endpoint_id in self.coordinator.data
-
-    @property
-    def native_value(self) -> str | None:
-        """Return the state of the sensor."""
-        return self.entity_description.value_fn(
-            self.coordinator.data[self.endpoint_id].containers[self.device_id]
-        )

homeassistant/components/portainer/strings.json

@@ -46,11 +46,6 @@
         "name": "Status"
       }
     },
-    "sensor": {
-      "image": {
-        "name": "Image"
-      }
-    },
     "switch": {
       "container": {
         "name": "Container"

homeassistant/components/shelly/button.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Any, Final
 
 from aioshelly.const import BLU_TRV_IDENTIFIER, MODEL_BLU_GATEWAY_G3, RPC_GENERATIONS
 from aioshelly.exceptions import DeviceConnectionError, InvalidAuthError, RpcCallError
+from aioshelly.rpc_device import RpcDevice
 
 from homeassistant.components.button import (
     DOMAIN as BUTTON_PLATFORM,
@@ -23,24 +24,16 @@ from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, LOGGER, MODEL_FRANKEVER_WATER_VALVE, SHELLY_GAS_MODELS
+from .const import DOMAIN, LOGGER, SHELLY_GAS_MODELS
 from .coordinator import ShellyBlockCoordinator, ShellyConfigEntry, ShellyRpcCoordinator
-from .entity import (
-    RpcEntityDescription,
-    ShellyRpcAttributeEntity,
-    async_setup_entry_rpc,
-    get_entity_block_device_info,
-    get_entity_rpc_device_info,
-    rpc_call,
-)
+from .entity import get_entity_block_device_info, get_entity_rpc_device_info
 from .utils import (
     async_remove_orphaned_entities,
     format_ble_addr,
     get_blu_trv_device_info,
     get_device_entry_gen,
+    get_rpc_entity_name,
     get_rpc_key_ids,
-    get_rpc_key_instances,
-    get_rpc_role_by_key,
     get_virtual_component_ids,
 )
 
@@ -58,11 +51,6 @@ class ShellyButtonDescription[
     supported: Callable[[_ShellyCoordinatorT], bool] = lambda _: True
 
 
-@dataclass(frozen=True, kw_only=True)
-class RpcButtonDescription(RpcEntityDescription, ButtonEntityDescription):
-    """Class to describe a RPC button."""
-
-
 BUTTONS: Final[list[ShellyButtonDescription[Any]]] = [
     ShellyButtonDescription[ShellyBlockCoordinator | ShellyRpcCoordinator](
         key="reboot",
@@ -108,24 +96,12 @@ BLU_TRV_BUTTONS: Final[list[ShellyButtonDescription]] = [
     ),
 ]
 
-RPC_VIRTUAL_BUTTONS = {
-    "button_generic": RpcButtonDescription(
+VIRTUAL_BUTTONS: Final[list[ShellyButtonDescription]] = [
+    ShellyButtonDescription[ShellyRpcCoordinator](
         key="button",
-        role="generic",
-    ),
-    "button_open": RpcButtonDescription(
-        key="button",
-        entity_registry_enabled_default=False,
-        role="open",
-        models={MODEL_FRANKEVER_WATER_VALVE},
-    ),
-    "button_close": RpcButtonDescription(
-        key="button",
-        entity_registry_enabled_default=False,
-        role="close",
-        models={MODEL_FRANKEVER_WATER_VALVE},
-    ),
-}
+        press_action="single_push",
+    )
+]
 
 
 @callback
@@ -153,10 +129,8 @@ def async_migrate_unique_ids(
                 )
             }
 
-    if not isinstance(coordinator, ShellyRpcCoordinator):
-        return None
-
     if blutrv_key_ids := get_rpc_key_ids(coordinator.device.status, BLU_TRV_IDENTIFIER):
+        assert isinstance(coordinator.device, RpcDevice)
         for _id in blutrv_key_ids:
             key = f"{BLU_TRV_IDENTIFIER}:{_id}"
             ble_addr: str = coordinator.device.config[key]["addr"]
@@ -175,26 +149,6 @@ def async_migrate_unique_ids(
                     )
                 }
 
-    if virtual_button_keys := get_rpc_key_instances(
-        coordinator.device.config, "button"
-    ):
-        for key in virtual_button_keys:
-            old_unique_id = f"{coordinator.mac}-{key}"
-            if entity_entry.unique_id == old_unique_id:
-                role = get_rpc_role_by_key(coordinator.device.config, key)
-                new_unique_id = f"{coordinator.mac}-{key}-button_{role}"
-                LOGGER.debug(
-                    "Migrating unique_id for %s entity from [%s] to [%s]",
-                    entity_entry.entity_id,
-                    old_unique_id,
-                    new_unique_id,
-                )
-                return {
-                    "new_unique_id": entity_entry.unique_id.replace(
-                        old_unique_id, new_unique_id
-                    )
-                }
-
     return None
 
 
@@ -218,7 +172,7 @@ async def async_setup_entry(
         hass, config_entry.entry_id, partial(async_migrate_unique_ids, coordinator)
     )
 
-    entities: list[ShellyButton | ShellyBluTrvButton] = []
+    entities: list[ShellyButton | ShellyBluTrvButton | ShellyVirtualButton] = []
 
     entities.extend(
         ShellyButton(coordinator, button)
@@ -231,9 +185,12 @@ async def async_setup_entry(
         return
 
     # add virtual buttons
-    async_setup_entry_rpc(
-        hass, config_entry, async_add_entities, RPC_VIRTUAL_BUTTONS, RpcVirtualButton
-    )
+    if virtual_button_ids := get_rpc_key_ids(coordinator.device.status, "button"):
+        entities.extend(
+            ShellyVirtualButton(coordinator, button, id_)
+            for id_ in virtual_button_ids
+            for button in VIRTUAL_BUTTONS
+        )
 
     # add BLU TRV buttons
     if blutrv_key_ids := get_rpc_key_ids(coordinator.device.status, BLU_TRV_IDENTIFIER):
@@ -375,16 +332,30 @@ class ShellyBluTrvButton(ShellyBaseButton):
         await method(self._id)
 
 
-class RpcVirtualButton(ShellyRpcAttributeEntity, ButtonEntity):
-    """Defines a Shelly RPC virtual component button."""
+class ShellyVirtualButton(ShellyBaseButton):
+    """Defines a Shelly virtual component button."""
 
-    entity_description: RpcButtonDescription
-    _id: int
+    def __init__(
+        self,
+        coordinator: ShellyRpcCoordinator,
+        description: ShellyButtonDescription,
+        _id: int,
+    ) -> None:
+        """Initialize Shelly virtual component button."""
+        super().__init__(coordinator, description)
 
-    @rpc_call
-    async def async_press(self) -> None:
-        """Triggers the Shelly button press service."""
+        self._attr_unique_id = f"{coordinator.mac}-{description.key}:{_id}"
+        self._attr_device_info = get_entity_rpc_device_info(coordinator)
+        self._attr_name = get_rpc_entity_name(
+            coordinator.device, f"{description.key}:{_id}"
+        )
+        self._id = _id
+
+    async def _press_method(self) -> None:
+        """Press method."""
         if TYPE_CHECKING:
             assert isinstance(self.coordinator, ShellyRpcCoordinator)
 
-        await self.coordinator.device.button_trigger(self._id, "single_push")
+        await self.coordinator.device.button_trigger(
+            self._id, self.entity_description.press_action
+        )

homeassistant/components/shelly/entity.py

@@ -195,11 +195,9 @@ def async_setup_rpc_attribute_entities(
             ):
                 continue
 
-            if (
-                description.sub_key
-                and description.sub_key not in coordinator.device.status[key]
-                and not description.supported(coordinator.device.status[key])
-            ):
+            if description.sub_key not in coordinator.device.status[
+                key
+            ] and not description.supported(coordinator.device.status[key]):
                 continue
 
             # Filter and remove entities that according to settings/status
@@ -311,7 +309,7 @@ class RpcEntityDescription(EntityDescription):
     # restrict the type to str.
     name: str = ""
 
-    sub_key: str | None = None
+    sub_key: str
 
     value: Callable[[Any, Any], Any] | None = None
     available: Callable[[dict], bool] | None = None

homeassistant/components/shelly/switch.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, cast
+from typing import Any, cast
 
 from aioshelly.block_device import Block
 from aioshelly.const import RPC_GENERATIONS
@@ -37,7 +37,6 @@ from .entity import (
     ShellySleepingBlockAttributeEntity,
     async_setup_entry_attribute_entities,
     async_setup_entry_rpc,
-    rpc_call,
 )
 from .utils import (
     async_remove_orphaned_entities,
@@ -79,7 +78,7 @@ class RpcSwitchDescription(RpcEntityDescription, SwitchEntityDescription):
     is_on: Callable[[dict[str, Any]], bool]
     method_on: str
     method_off: str
-    method_params_fn: Callable[[int | None, bool], tuple]
+    method_params_fn: Callable[[int | None, bool], dict]
 
 
 RPC_RELAY_SWITCHES = {
@@ -88,9 +87,9 @@ RPC_RELAY_SWITCHES = {
         sub_key="output",
         removal_condition=is_rpc_exclude_from_relay,
         is_on=lambda status: bool(status["output"]),
-        method_on="switch_set",
-        method_off="switch_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Switch.Set",
+        method_off="Switch.Set",
+        method_params_fn=lambda id, value: {"id": id, "on": value},
     ),
 }
 
@@ -102,9 +101,9 @@ RPC_SWITCHES = {
             config, key, SWITCH_PLATFORM
         ),
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="generic",
     ),
     "boolean_anti_freeze": RpcSwitchDescription(
@@ -112,9 +111,9 @@ RPC_SWITCHES = {
         sub_key="value",
         entity_registry_enabled_default=False,
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="anti_freeze",
         models={MODEL_LINKEDGO_ST802_THERMOSTAT, MODEL_LINKEDGO_ST1820_THERMOSTAT},
     ),
@@ -122,9 +121,9 @@ RPC_SWITCHES = {
         key="boolean",
         sub_key="value",
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="child_lock",
         models={MODEL_LINKEDGO_ST1820_THERMOSTAT},
     ),
@@ -133,9 +132,9 @@ RPC_SWITCHES = {
         sub_key="value",
         entity_registry_enabled_default=False,
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="enable",
         models={MODEL_LINKEDGO_ST802_THERMOSTAT, MODEL_LINKEDGO_ST1820_THERMOSTAT},
     ),
@@ -143,9 +142,9 @@ RPC_SWITCHES = {
         key="boolean",
         sub_key="value",
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="start_charging",
         models={MODEL_TOP_EV_CHARGER_EVE01},
     ),
@@ -154,9 +153,9 @@ RPC_SWITCHES = {
         sub_key="value",
         entity_registry_enabled_default=False,
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="state",
         models={MODEL_NEO_WATER_VALVE},
     ),
@@ -164,9 +163,9 @@ RPC_SWITCHES = {
         key="boolean",
         sub_key="value",
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="zone0",
         models={MODEL_FRANKEVER_IRRIGATION_CONTROLLER},
     ),
@@ -174,9 +173,9 @@ RPC_SWITCHES = {
         key="boolean",
         sub_key="value",
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="zone1",
         models={MODEL_FRANKEVER_IRRIGATION_CONTROLLER},
     ),
@@ -184,9 +183,9 @@ RPC_SWITCHES = {
         key="boolean",
         sub_key="value",
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="zone2",
         models={MODEL_FRANKEVER_IRRIGATION_CONTROLLER},
     ),
@@ -194,9 +193,9 @@ RPC_SWITCHES = {
         key="boolean",
         sub_key="value",
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="zone3",
         models={MODEL_FRANKEVER_IRRIGATION_CONTROLLER},
     ),
@@ -204,9 +203,9 @@ RPC_SWITCHES = {
         key="boolean",
         sub_key="value",
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="zone4",
         models={MODEL_FRANKEVER_IRRIGATION_CONTROLLER},
     ),
@@ -214,9 +213,9 @@ RPC_SWITCHES = {
         key="boolean",
         sub_key="value",
         is_on=lambda status: bool(status["value"]),
-        method_on="boolean_set",
-        method_off="boolean_set",
-        method_params_fn=lambda id, value: (id, value),
+        method_on="Boolean.Set",
+        method_off="Boolean.Set",
+        method_params_fn=lambda id, value: {"id": id, "value": value},
         role="zone5",
         models={MODEL_FRANKEVER_IRRIGATION_CONTROLLER},
     ),
@@ -224,9 +223,9 @@ RPC_SWITCHES = {
         key="script",
         sub_key="running",
         is_on=lambda status: bool(status["running"]),
-        method_on="script_start",
-        method_off="script_stop",
-        method_params_fn=lambda id, _: (id,),
+        method_on="Script.Start",
+        method_off="Script.Stop",
+        method_params_fn=lambda id, _: {"id": id},
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.CONFIG,
     ),
@@ -423,27 +422,19 @@ class RpcSwitch(ShellyRpcAttributeEntity, SwitchEntity):
         """If switch is on."""
         return self.entity_description.is_on(self.status)
 
-    @rpc_call
     async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn on switch."""
-        method = getattr(self.coordinator.device, self.entity_description.method_on)
+        """Turn on relay."""
+        await self.call_rpc(
+            self.entity_description.method_on,
+            self.entity_description.method_params_fn(self._id, True),
+        )
 
-        if TYPE_CHECKING:
-            assert method is not None
-
-        params = self.entity_description.method_params_fn(self._id, True)
-        await method(*params)
-
-    @rpc_call
     async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn off switch."""
-        method = getattr(self.coordinator.device, self.entity_description.method_off)
-
-        if TYPE_CHECKING:
-            assert method is not None
-
-        params = self.entity_description.method_params_fn(self._id, False)
-        await method(*params)
+        """Turn off relay."""
+        await self.call_rpc(
+            self.entity_description.method_off,
+            self.entity_description.method_params_fn(self._id, False),
+        )
 
 
 class RpcRelaySwitch(RpcSwitch):

homeassistant/components/smartthings/icons.json

@@ -34,17 +34,6 @@
     "climate": {
       "air_conditioner": {
         "state_attributes": {
-          "preset_mode": {
-            "state": {
-              "wind_free": "mdi:weather-dust",
-              "wind_free_sleep": "mdi:sleep",
-              "quiet": "mdi:volume-off",
-              "long_wind": "mdi:weather-windy",
-              "smart": "mdi:leaf",
-              "motion_direct": "mdi:account-arrow-left",
-              "motion_indirect": "mdi:account-arrow-right"
-            }
-          },
           "fan_mode": {
             "state": {
               "turbo": "mdi:wind-power"

homeassistant/components/smartthings/strings.json

@@ -87,7 +87,7 @@
               "wind_free_sleep": "WindFree sleep",
               "quiet": "Quiet",
               "long_wind": "Long wind",
-              "smart": "Smart saver",
+              "smart": "Smart",
               "motion_direct": "Motion direct",
               "motion_indirect": "Motion indirect"
             }

homeassistant/components/suez_water/coordinator.py

@@ -241,6 +241,7 @@ class SuezWaterCoordinator(DataUpdateCoordinator[SuezWaterData]):
     ) -> StatisticMetaData:
         """Build statistics metadata for requested configuration."""
         return StatisticMetaData(
+            has_mean=False,
             mean_type=StatisticMeanType.NONE,
             has_sum=True,
             name=f"Suez water {name} {self._counter_id}",

homeassistant/components/systemmonitor/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/systemmonitor",
   "iot_class": "local_push",
   "loggers": ["psutil"],
-  "requirements": ["psutil-home-assistant==0.0.1", "psutil==7.1.0"],
+  "requirements": ["psutil-home-assistant==0.0.1", "psutil==7.0.0"],
   "single_config_entry": true
 }

homeassistant/components/workday/manifest.json

@@ -7,5 +7,5 @@
   "iot_class": "local_polling",
   "loggers": ["holidays"],
   "quality_scale": "internal",
-  "requirements": ["holidays==0.82"]
+  "requirements": ["holidays==0.81"]
 }

homeassistant/components/zha/config_flow.py

@@ -744,11 +744,8 @@ class ZhaConfigFlowHandler(BaseZhaFlow, ConfigFlow, domain=DOMAIN):
 
         # Without confirmation, discovery can automatically progress into parts of the
         # config flow logic that interacts with hardware.
-        # Ignore Zeroconf discoveries during onboarding, as they may be in use already.
         if user_input is not None or (
-            not onboarding.async_is_onboarded(self.hass)
-            and not zha_config_entries
-            and self.source != SOURCE_ZEROCONF
+            not onboarding.async_is_onboarded(self.hass) and not zha_config_entries
         ):
             # Probe the radio type if we don't have one yet
             if self._radio_mgr.radio_type is None:

homeassistant/const.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Final
 from .generated.entity_platforms import EntityPlatforms
 from .helpers.deprecation import (
     DeprecatedConstantEnum,
+    EnumWithDeprecatedMembers,
     all_with_deprecated_constants,
     check_if_deprecated_constant,
     dir_with_deprecated_constants,
@@ -703,13 +704,35 @@ class UnitOfMass(StrEnum):
     STONES = "st"
 
 
-class UnitOfConductivity(StrEnum):
+class UnitOfConductivity(
+    StrEnum,
+    metaclass=EnumWithDeprecatedMembers,
+    deprecated={
+        "SIEMENS": ("UnitOfConductivity.SIEMENS_PER_CM", "2025.11.0"),
+        "MICROSIEMENS": ("UnitOfConductivity.MICROSIEMENS_PER_CM", "2025.11.0"),
+        "MILLISIEMENS": ("UnitOfConductivity.MILLISIEMENS_PER_CM", "2025.11.0"),
+    },
+):
     """Conductivity units."""
 
     SIEMENS_PER_CM = "S/cm"
     MICROSIEMENS_PER_CM = "μS/cm"
     MILLISIEMENS_PER_CM = "mS/cm"
 
+    # Deprecated aliases
+    SIEMENS = "S/cm"
+    """Deprecated: Please use UnitOfConductivity.SIEMENS_PER_CM"""
+    MICROSIEMENS = "μS/cm"
+    """Deprecated: Please use UnitOfConductivity.MICROSIEMENS_PER_CM"""
+    MILLISIEMENS = "mS/cm"
+    """Deprecated: Please use UnitOfConductivity.MILLISIEMENS_PER_CM"""
+
+
+_DEPRECATED_CONDUCTIVITY: Final = DeprecatedConstantEnum(
+    UnitOfConductivity.MICROSIEMENS_PER_CM,
+    "2025.11",
+)
+"""Deprecated: please use UnitOfConductivity.MICROSIEMENS_PER_CM"""
 
 # Light units
 LIGHT_LUX: Final = "lx"

homeassistant/helpers/event.py

@@ -36,7 +36,7 @@ from homeassistant.core import (
     callback,
     split_entity_id,
 )
-from homeassistant.exceptions import HomeAssistantError, TemplateError
+from homeassistant.exceptions import TemplateError
 from homeassistant.loader import bind_hass
 from homeassistant.util import dt as dt_util
 from homeassistant.util.async_ import run_callback_threadsafe
@@ -1004,9 +1004,12 @@ class TrackTemplateResultInfo:
             if track_template_.template.hass:
                 continue
 
-            raise HomeAssistantError(
-                "Calls async_track_template_result with template without hass"
+            frame.report_usage(
+                "calls async_track_template_result with template without hass",
+                core_behavior=frame.ReportBehavior.LOG,
+                breaks_in_ha_version="2025.10",
             )
+            track_template_.template.hass = hass
 
         self._rate_limit = KeyedRateLimit(hass)
         self._info: dict[Template, RenderInfo] = {}

homeassistant/helpers/trigger.py

@@ -260,11 +260,11 @@ class TriggerConfig:
 class TriggerActionType(Protocol):
     """Protocol type for trigger action callback."""
 
-    def __call__(
+    async def __call__(
         self,
         run_variables: dict[str, Any],
         context: Context | None = None,
-    ) -> Coroutine[Any, Any, Any] | Any:
+    ) -> Any:
         """Define action callback type."""
 
 
@@ -444,8 +444,8 @@ async def async_validate_trigger_config(
 
 
 def _trigger_action_wrapper(
-    hass: HomeAssistant, action: TriggerActionType, conf: ConfigType
-) -> TriggerActionType:
+    hass: HomeAssistant, action: Callable, conf: ConfigType
+) -> Callable:
     """Wrap trigger action with extra vars if configured.
 
     If action is a coroutine function, a coroutine function will be returned.
@@ -477,7 +477,7 @@ def _trigger_action_wrapper(
     else:
 
         @functools.wraps(action)
-        def with_vars(
+        async def with_vars(
             run_variables: dict[str, Any], context: Context | None = None
         ) -> Any:
             """Wrap action with extra vars."""

homeassistant/package_constraints.txt

@@ -130,7 +130,7 @@ multidict>=6.0.2
 backoff>=2.0
 
 # ensure pydantic version does not float since it might have breaking changes
-pydantic==2.12.0
+pydantic==2.11.9
 
 # Required for Python 3.12.4 compatibility (#119223).
 mashumaro>=3.13.1

requirements_all.txt

@@ -247,7 +247,7 @@ aioelectricitymaps==1.1.1
 aioemonitor==1.0.5
 
 # homeassistant.components.esphome
-aioesphomeapi==41.13.0
+aioesphomeapi==41.12.0
 
 # homeassistant.components.flo
 aioflo==2021.11.0
@@ -895,7 +895,7 @@ enocean==0.50
 enturclient==0.2.4
 
 # homeassistant.components.environment_canada
-env-canada==0.11.3
+env-canada==0.11.2
 
 # homeassistant.components.season
 ephem==4.1.6
@@ -1183,7 +1183,7 @@ hole==0.9.0
 
 # homeassistant.components.holiday
 # homeassistant.components.workday
-holidays==0.82
+holidays==0.81
 
 # homeassistant.components.frontend
 home-assistant-frontend==20251001.0
@@ -1545,7 +1545,7 @@ nextcord==3.1.0
 nextdns==4.1.0
 
 # homeassistant.components.niko_home_control
-nhc==0.6.1
+nhc==0.4.12
 
 # homeassistant.components.nibe_heatpump
 nibe==2.19.0
@@ -1628,7 +1628,7 @@ open-meteo==0.3.2
 
 # homeassistant.components.open_router
 # homeassistant.components.openai_conversation
-openai==2.2.0
+openai==1.99.5
 
 # homeassistant.components.openerz
 openerz-api==0.3.0
@@ -1755,7 +1755,7 @@ proxmoxer==2.0.1
 psutil-home-assistant==0.0.1
 
 # homeassistant.components.systemmonitor
-psutil==7.1.0
+psutil==7.0.0
 
 # homeassistant.components.pulseaudio_loopback
 pulsectl==23.5.2
@@ -2135,7 +2135,7 @@ pykwb==0.0.8
 pylacrosse==0.4
 
 # homeassistant.components.lamarzocco
-pylamarzocco==2.1.2
+pylamarzocco==2.1.1
 
 # homeassistant.components.lastfm
 pylast==5.1.0
@@ -2210,7 +2210,7 @@ pynetio==0.1.9.1
 pynina==0.3.6
 
 # homeassistant.components.nintendo_parental
-pynintendoparental==1.1.1
+pynintendoparental==1.0.1
 
 # homeassistant.components.nobo_hub
 pynobo==1.8.1

requirements_test.txt

@@ -15,7 +15,7 @@ license-expression==30.4.3
 mock-open==1.4.0
 mypy-dev==1.19.0a2
 pre-commit==4.2.0
-pydantic==2.12.0
+pydantic==2.11.9
 pylint==3.3.8
 pylint-per-file-ignores==1.4.0
 pipdeptree==2.26.1

requirements_test_all.txt

@@ -235,7 +235,7 @@ aioelectricitymaps==1.1.1
 aioemonitor==1.0.5
 
 # homeassistant.components.esphome
-aioesphomeapi==41.13.0
+aioesphomeapi==41.12.0
 
 # homeassistant.components.flo
 aioflo==2021.11.0
@@ -777,7 +777,7 @@ energyzero==2.1.1
 enocean==0.50
 
 # homeassistant.components.environment_canada
-env-canada==0.11.3
+env-canada==0.11.2
 
 # homeassistant.components.season
 ephem==4.1.6
@@ -1032,7 +1032,7 @@ hole==0.9.0
 
 # homeassistant.components.holiday
 # homeassistant.components.workday
-holidays==0.82
+holidays==0.81
 
 # homeassistant.components.frontend
 home-assistant-frontend==20251001.0
@@ -1328,7 +1328,7 @@ nextcord==3.1.0
 nextdns==4.1.0
 
 # homeassistant.components.niko_home_control
-nhc==0.6.1
+nhc==0.4.12
 
 # homeassistant.components.nibe_heatpump
 nibe==2.19.0
@@ -1399,7 +1399,7 @@ open-meteo==0.3.2
 
 # homeassistant.components.open_router
 # homeassistant.components.openai_conversation
-openai==2.2.0
+openai==1.99.5
 
 # homeassistant.components.openerz
 openerz-api==0.3.0
@@ -1487,7 +1487,7 @@ prowlpy==1.0.2
 psutil-home-assistant==0.0.1
 
 # homeassistant.components.systemmonitor
-psutil==7.1.0
+psutil==7.0.0
 
 # homeassistant.components.pushbullet
 pushbullet.py==0.11.0
@@ -1783,7 +1783,7 @@ pykrakenapi==0.1.8
 pykulersky==0.5.8
 
 # homeassistant.components.lamarzocco
-pylamarzocco==2.1.2
+pylamarzocco==2.1.1
 
 # homeassistant.components.lastfm
 pylast==5.1.0
@@ -1846,7 +1846,7 @@ pynetgear==0.10.10
 pynina==0.3.6
 
 # homeassistant.components.nintendo_parental
-pynintendoparental==1.1.1
+pynintendoparental==1.0.1
 
 # homeassistant.components.nobo_hub
 pynobo==1.8.1

script/gen_requirements_all.py

@@ -155,7 +155,7 @@ multidict>=6.0.2
 backoff>=2.0
 
 # ensure pydantic version does not float since it might have breaking changes
-pydantic==2.12.0
+pydantic==2.11.9
 
 # Required for Python 3.12.4 compatibility (#119223).
 mashumaro>=3.13.1

tests/components/airthings_ble/__init__.py

@@ -9,17 +9,12 @@ from airthings_ble import (
     AirthingsDevice,
     AirthingsDeviceType,
 )
-from bleak.backends.device import BLEDevice
 
 from homeassistant.components.airthings_ble.const import DOMAIN
 from homeassistant.components.bluetooth.models import BluetoothServiceInfoBleak
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import (
-    CONNECTION_BLUETOOTH,
-    DeviceEntry,
-    DeviceRegistry,
-)
+from homeassistant.helpers.device_registry import CONNECTION_BLUETOOTH, DeviceRegistry
 
 from tests.common import MockConfigEntry, MockEntity
 from tests.components.bluetooth import generate_advertisement_data, generate_ble_device
@@ -33,15 +28,7 @@ def patch_async_setup_entry(return_value=True):
     )
 
 
-def patch_async_discovered_service_info(return_value: list[BluetoothServiceInfoBleak]):
-    """Patch async_discovered_service_info to return given list."""
-    return patch(
-        "homeassistant.components.bluetooth.async_discovered_service_info",
-        return_value=return_value,
-    )
-
-
-def patch_async_ble_device_from_address(return_value: BLEDevice | None):
+def patch_async_ble_device_from_address(return_value: BluetoothServiceInfoBleak | None):
     """Patch async ble device from address to return a given value."""
     return patch(
         "homeassistant.components.bluetooth.async_ble_device_from_address",
@@ -114,27 +101,6 @@ WAVE_SERVICE_INFO = BluetoothServiceInfoBleak(
     tx_power=0,
 )
 
-WAVE_ENHANCE_SERVICE_INFO = BluetoothServiceInfoBleak(
-    name="cc-cc-cc-cc-cc-cc",
-    address="cc:cc:cc:cc:cc:cc",
-    device=generate_ble_device(
-        address="cc:cc:cc:cc:cc:cc",
-        name="Airthings Wave Enhance",
-    ),
-    rssi=-61,
-    manufacturer_data={820: b"\xe4/\xa5\xae\t\x00"},
-    service_data={},
-    service_uuids=[],
-    source="local",
-    advertisement=generate_advertisement_data(
-        manufacturer_data={820: b"\xe4/\xa5\xae\t\x00"},
-        service_uuids=[],
-    ),
-    connectable=True,
-    time=0,
-    tx_power=0,
-)
-
 VIEW_PLUS_SERVICE_INFO = BluetoothServiceInfoBleak(
     name="cc-cc-cc-cc-cc-cc",
     address="cc:cc:cc:cc:cc:cc",
@@ -245,26 +211,6 @@ WAVE_DEVICE_INFO = AirthingsDevice(
     address="cc:cc:cc:cc:cc:cc",
 )
 
-WAVE_ENHANCE_DEVICE_INFO = AirthingsDevice(
-    manufacturer="Airthings AS",
-    hw_version="REV X",
-    sw_version="T-SUB-2.6.2-master+0",
-    model=AirthingsDeviceType.WAVE_ENHANCE_EU,
-    name="Airthings Wave Enhance",
-    identifier="123456",
-    sensors={
-        "lux": 25,
-        "battery": 85,
-        "humidity": 60.0,
-        "temperature": 21.0,
-        "co2": 500.0,
-        "voc": 155.0,
-        "pressure": 1020,
-        "noise": 40,
-    },
-    address="cc:cc:cc:cc:cc:cc",
-)
-
 TEMPERATURE_V1 = MockEntity(
     unique_id="Airthings Wave Plus 123456_temperature",
     name="Airthings Wave Plus 123456 Temperature",
@@ -301,32 +247,23 @@ VOC_V3 = MockEntity(
 )
 
 
-def create_entry(
-    hass: HomeAssistant,
-    service_info: BluetoothServiceInfoBleak,
-    device_info: AirthingsDevice,
-) -> MockConfigEntry:
+def create_entry(hass: HomeAssistant) -> MockConfigEntry:
     """Create a config entry."""
     entry = MockConfigEntry(
         domain=DOMAIN,
-        unique_id=service_info.address,
-        title=f"{device_info.name} ({device_info.identifier})",
+        unique_id=WAVE_SERVICE_INFO.address,
+        title="Airthings Wave Plus (123456)",
     )
     entry.add_to_hass(hass)
     return entry
 
 
-def create_device(
-    entry: ConfigEntry,
-    device_registry: DeviceRegistry,
-    service_info: BluetoothServiceInfoBleak,
-    device_info: AirthingsDevice,
-) -> DeviceEntry:
+def create_device(entry: ConfigEntry, device_registry: DeviceRegistry):
     """Create a device for the given entry."""
     return device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
-        connections={(CONNECTION_BLUETOOTH, service_info.address)},
+        connections={(CONNECTION_BLUETOOTH, WAVE_SERVICE_INFO.address)},
         manufacturer="Airthings AS",
-        name=f"{device_info.name} ({device_info.identifier})",
-        model=device_info.model.product_name,
+        name="Airthings Wave Plus (123456)",
+        model="Wave Plus",
     )

tests/components/airthings_ble/test_sensor.py

@@ -2,8 +2,6 @@
 
 import logging
 
-import pytest
-
 from homeassistant.components.airthings_ble.const import DOMAIN
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
@@ -18,15 +16,10 @@ from . import (
     VOC_V2,
     VOC_V3,
     WAVE_DEVICE_INFO,
-    WAVE_ENHANCE_DEVICE_INFO,
-    WAVE_ENHANCE_SERVICE_INFO,
     WAVE_SERVICE_INFO,
     create_device,
     create_entry,
-    patch_airthings_ble,
     patch_airthings_device_update,
-    patch_async_ble_device_from_address,
-    patch_async_discovered_service_info,
 )
 
 from tests.components.bluetooth import inject_bluetooth_service_info
@@ -40,8 +33,8 @@ async def test_migration_from_v1_to_v3_unique_id(
     device_registry: dr.DeviceRegistry,
 ) -> None:
     """Verify that we can migrate from v1 (pre 2023.9.0) to the latest unique id format."""
-    entry = create_entry(hass, WAVE_SERVICE_INFO, WAVE_DEVICE_INFO)
-    device = create_device(entry, device_registry, WAVE_SERVICE_INFO, WAVE_DEVICE_INFO)
+    entry = create_entry(hass)
+    device = create_device(entry, device_registry)
 
     assert entry is not None
     assert device is not None
@@ -81,8 +74,8 @@ async def test_migration_from_v2_to_v3_unique_id(
     device_registry: dr.DeviceRegistry,
 ) -> None:
     """Verify that we can migrate from v2 (introduced in 2023.9.0) to the latest unique id format."""
-    entry = create_entry(hass, WAVE_SERVICE_INFO, WAVE_DEVICE_INFO)
-    device = create_device(entry, device_registry, WAVE_SERVICE_INFO, WAVE_DEVICE_INFO)
+    entry = create_entry(hass)
+    device = create_device(entry, device_registry)
 
     assert entry is not None
     assert device is not None
@@ -122,8 +115,8 @@ async def test_migration_from_v1_and_v2_to_v3_unique_id(
     device_registry: dr.DeviceRegistry,
 ) -> None:
     """Test if migration works when we have both v1 (pre 2023.9.0) and v2 (introduced in 2023.9.0) unique ids."""
-    entry = create_entry(hass, WAVE_SERVICE_INFO, WAVE_DEVICE_INFO)
-    device = create_device(entry, device_registry, WAVE_SERVICE_INFO, WAVE_DEVICE_INFO)
+    entry = create_entry(hass)
+    device = create_device(entry, device_registry)
 
     assert entry is not None
     assert device is not None
@@ -172,8 +165,8 @@ async def test_migration_with_all_unique_ids(
     device_registry: dr.DeviceRegistry,
 ) -> None:
     """Test if migration works when we have all unique ids."""
-    entry = create_entry(hass, WAVE_SERVICE_INFO, WAVE_DEVICE_INFO)
-    device = create_device(entry, device_registry, WAVE_SERVICE_INFO, WAVE_DEVICE_INFO)
+    entry = create_entry(hass)
+    device = create_device(entry, device_registry)
 
     assert entry is not None
     assert device is not None
@@ -222,48 +215,3 @@ async def test_migration_with_all_unique_ids(
     assert entity_registry.async_get(v1.entity_id).unique_id == VOC_V1.unique_id
     assert entity_registry.async_get(v2.entity_id).unique_id == VOC_V2.unique_id
     assert entity_registry.async_get(v3.entity_id).unique_id == VOC_V3.unique_id
-
-
-@pytest.mark.parametrize(
-    ("unique_suffix", "expected_sensor_name"),
-    [
-        ("lux", "Illuminance"),
-        ("noise", "Ambient noise"),
-    ],
-)
-async def test_translation_keys(
-    hass: HomeAssistant,
-    entity_registry: er.EntityRegistry,
-    device_registry: dr.DeviceRegistry,
-    unique_suffix: str,
-    expected_sensor_name: str,
-) -> None:
-    """Test that translated sensor names are correct."""
-    entry = create_entry(hass, WAVE_ENHANCE_SERVICE_INFO, WAVE_DEVICE_INFO)
-    device = create_device(
-        entry, device_registry, WAVE_ENHANCE_SERVICE_INFO, WAVE_ENHANCE_DEVICE_INFO
-    )
-
-    with (
-        patch_async_ble_device_from_address(WAVE_ENHANCE_SERVICE_INFO.device),
-        patch_async_discovered_service_info([WAVE_ENHANCE_SERVICE_INFO]),
-        patch_airthings_ble(WAVE_ENHANCE_DEVICE_INFO),
-    ):
-        await hass.config_entries.async_setup(entry.entry_id)
-        await hass.async_block_till_done()
-
-    assert device is not None
-    assert device.name == "Airthings Wave Enhance (123456)"
-
-    unique_id = f"{WAVE_ENHANCE_DEVICE_INFO.address}_{unique_suffix}"
-    entity_id = entity_registry.async_get_entity_id(Platform.SENSOR, DOMAIN, unique_id)
-    assert entity_id is not None
-
-    state = hass.states.get(entity_id)
-    assert state is not None
-
-    expected_value = WAVE_ENHANCE_DEVICE_INFO.sensors[unique_suffix]
-    assert state.state == str(expected_value)
-
-    expected_name = f"Airthings Wave Enhance (123456) {expected_sensor_name}"
-    assert state.attributes.get("friendly_name") == expected_name

tests/components/niko_home_control/conftest.py

@@ -45,7 +45,7 @@ def dimmable_light() -> NHCLight:
     mock.is_dimmable = True
     mock.name = "dimmable light"
     mock.suggested_area = "room"
-    mock.state = 100
+    mock.state = 255
     return mock
 
 

tests/components/niko_home_control/snapshots/test_light.ambr

@@ -41,7 +41,7 @@
 # name: test_entities[light.dimmable_light-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'brightness': 100,
+      'brightness': 255,
       'color_mode': <ColorMode.BRIGHTNESS: 'brightness'>,
       'friendly_name': 'dimmable light',
       'supported_color_modes': list([

tests/components/niko_home_control/test_light.py

@@ -42,7 +42,7 @@ async def test_entities(
 @pytest.mark.parametrize(
     ("light_id", "data", "set_brightness"),
     [
-        (0, {ATTR_ENTITY_ID: "light.light"}, None),
+        (0, {ATTR_ENTITY_ID: "light.light"}, 255),
         (
             1,
             {ATTR_ENTITY_ID: "light.dimmable_light", ATTR_BRIGHTNESS: 50},
@@ -119,7 +119,7 @@ async def test_updating(
     assert hass.states.get("light.light").state == STATE_OFF
 
     assert hass.states.get("light.dimmable_light").state == STATE_ON
-    assert hass.states.get("light.dimmable_light").attributes[ATTR_BRIGHTNESS] == 100
+    assert hass.states.get("light.dimmable_light").attributes[ATTR_BRIGHTNESS] == 255
 
     dimmable_light.state = 204
     await find_update_callback(mock_niko_home_control_connection, 2)(204)

tests/components/nintendo_parental/conftest.py

@@ -4,6 +4,7 @@ from collections.abc import Generator
 from datetime import datetime
 from unittest.mock import AsyncMock, MagicMock, patch
 
+from pynintendoparental.device import Device
 import pytest
 
 from homeassistant.components.nintendo_parental.const import DOMAIN
@@ -23,6 +24,18 @@ def mock_config_entry() -> MockConfigEntry:
     )
 
 
+@pytest.fixture
+def mock_nintendo_device() -> Device:
+    """Return a mocked device."""
+    mock = AsyncMock(spec=Device)
+    mock.device_id = "testdevid"
+    mock.name = "Home Assistant Test"
+    mock.extra = {"device": {"firmwareVersion": {"displayedVersion": "99.99.99"}}}
+    mock.limit_time = 120
+    mock.today_playing_time = 110
+    return mock
+
+
 @pytest.fixture
 def mock_nintendo_authenticator() -> Generator[MagicMock]:
     """Mock Nintendo Authenticator."""
@@ -53,6 +66,27 @@ def mock_nintendo_authenticator() -> Generator[MagicMock]:
         yield mock_auth
 
 
+@pytest.fixture
+def mock_nintendo_client(
+    mock_nintendo_device: Device,
+) -> Generator[AsyncMock]:
+    """Mock a Nintendo client."""
+    with (
+        patch(
+            "homeassistant.components.nintendo_parental.NintendoParental",
+            autospec=True,
+        ) as mock_client,
+        patch(
+            "homeassistant.components.nintendo_parental.config_flow.NintendoParental",
+            new=mock_client,
+        ),
+    ):
+        client = mock_client.return_value
+        client.update.return_value = True
+        client.devices.return_value = {"testdevid": mock_nintendo_device}
+        yield client
+
+
 @pytest.fixture
 def mock_setup_entry() -> Generator[AsyncMock]:
     """Override async_setup_entry."""

tests/components/nintendo_parental/test_config_flow.py

@@ -77,7 +77,7 @@ async def test_invalid_auth(
 
     # Simulate invalid authentication by raising an exception
     mock_nintendo_authenticator.complete_login.side_effect = (
-        InvalidSessionTokenException(status_code=401, message="Test")
+        InvalidSessionTokenException
     )
 
     result = await hass.config_entries.flow.async_configure(

tests/components/openai_conversation/__init__.py

@@ -157,7 +157,6 @@ def create_function_tool_call_item(
         ResponseFunctionCallArgumentsDoneEvent(
             arguments="".join(arguments),
             item_id=id,
-            name=name,
             output_index=output_index,
             sequence_number=0,
             type="response.function_call_arguments.done",

tests/components/openai_conversation/test_config_flow.py

@@ -569,7 +569,7 @@ async def test_form_invalid_auth(hass: HomeAssistant, side_effect, error) -> Non
                 CONF_PROMPT: "Speak like a pirate",
                 CONF_LLM_HASS_API: ["assist"],
                 CONF_TEMPERATURE: 0.8,
-                CONF_CHAT_MODEL: "gpt-5",
+                CONF_CHAT_MODEL: "o5",
                 CONF_TOP_P: 0.9,
                 CONF_MAX_TOKENS: 1000,
                 CONF_REASONING_EFFORT: "low",
@@ -607,52 +607,6 @@ async def test_form_invalid_auth(hass: HomeAssistant, side_effect, error) -> Non
                 CONF_CODE_INTERPRETER: False,
             },
         ),
-        (  # Case 5: code interpreter supported to not supported model
-            {
-                CONF_RECOMMENDED: False,
-                CONF_PROMPT: "Speak like a pirate",
-                CONF_LLM_HASS_API: ["assist"],
-                CONF_TEMPERATURE: 0.8,
-                CONF_CHAT_MODEL: "gpt-5",
-                CONF_TOP_P: 0.9,
-                CONF_MAX_TOKENS: 1000,
-                CONF_REASONING_EFFORT: "low",
-                CONF_CODE_INTERPRETER: True,
-                CONF_VERBOSITY: "medium",
-                CONF_WEB_SEARCH: True,
-                CONF_WEB_SEARCH_CONTEXT_SIZE: "high",
-                CONF_WEB_SEARCH_USER_LOCATION: False,
-            },
-            (
-                {
-                    CONF_RECOMMENDED: False,
-                    CONF_PROMPT: "Speak like a pirate",
-                },
-                {
-                    CONF_TEMPERATURE: 0.8,
-                    CONF_CHAT_MODEL: "gpt-5-pro",
-                    CONF_TOP_P: 0.9,
-                    CONF_MAX_TOKENS: 1000,
-                },
-                {
-                    CONF_WEB_SEARCH: True,
-                    CONF_WEB_SEARCH_CONTEXT_SIZE: "high",
-                    CONF_WEB_SEARCH_USER_LOCATION: False,
-                },
-            ),
-            {
-                CONF_RECOMMENDED: False,
-                CONF_PROMPT: "Speak like a pirate",
-                CONF_TEMPERATURE: 0.8,
-                CONF_CHAT_MODEL: "gpt-5-pro",
-                CONF_TOP_P: 0.9,
-                CONF_MAX_TOKENS: 1000,
-                CONF_VERBOSITY: "medium",
-                CONF_WEB_SEARCH: True,
-                CONF_WEB_SEARCH_CONTEXT_SIZE: "high",
-                CONF_WEB_SEARCH_USER_LOCATION: False,
-            },
-        ),
     ],
 )
 async def test_subentry_switching(

tests/components/openai_conversation/test_conversation.py

@@ -474,7 +474,7 @@ async def test_web_search(
 
     assert mock_create_stream.mock_calls[0][2]["tools"] == [
         {
-            "type": "web_search",
+            "type": "web_search_preview",
             "search_context_size": "low",
             "user_location": {
                 "type": "approximate",

tests/components/plant/test_init.py

@@ -80,9 +80,7 @@ async def test_low_battery(hass: HomeAssistant) -> None:
 async def test_initial_states(hass: HomeAssistant) -> None:
     """Test plant initialises attributes if sensor already exists."""
     hass.states.async_set(
-        MOISTURE_ENTITY,
-        5,
-        {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS_PER_CM},
+        MOISTURE_ENTITY, 5, {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS}
     )
     plant_name = "some_plant"
     assert await async_setup_component(
@@ -103,9 +101,7 @@ async def test_update_states(hass: HomeAssistant) -> None:
         hass, plant.DOMAIN, {plant.DOMAIN: {plant_name: GOOD_CONFIG}}
     )
     hass.states.async_set(
-        MOISTURE_ENTITY,
-        5,
-        {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS_PER_CM},
+        MOISTURE_ENTITY, 5, {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS}
     )
     await hass.async_block_till_done()
     state = hass.states.get(f"plant.{plant_name}")
@@ -125,7 +121,7 @@ async def test_unavailable_state(hass: HomeAssistant) -> None:
     hass.states.async_set(
         MOISTURE_ENTITY,
         STATE_UNAVAILABLE,
-        {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS_PER_CM},
+        {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS},
     )
     await hass.async_block_till_done()
     state = hass.states.get(f"plant.{plant_name}")
@@ -143,9 +139,7 @@ async def test_state_problem_if_unavailable(hass: HomeAssistant) -> None:
         hass, plant.DOMAIN, {plant.DOMAIN: {plant_name: GOOD_CONFIG}}
     )
     hass.states.async_set(
-        MOISTURE_ENTITY,
-        42,
-        {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS_PER_CM},
+        MOISTURE_ENTITY, 42, {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS}
     )
     await hass.async_block_till_done()
     state = hass.states.get(f"plant.{plant_name}")
@@ -154,7 +148,7 @@ async def test_state_problem_if_unavailable(hass: HomeAssistant) -> None:
     hass.states.async_set(
         MOISTURE_ENTITY,
         STATE_UNAVAILABLE,
-        {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS_PER_CM},
+        {ATTR_UNIT_OF_MEASUREMENT: UnitOfConductivity.MICROSIEMENS},
     )
     await hass.async_block_till_done()
     state = hass.states.get(f"plant.{plant_name}")

tests/components/portainer/snapshots/test_sensor.ambr

@@ -1,241 +0,0 @@
-# serializer version: 1
-# name: test_all_entities[sensor.focused_einstein_image-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.focused_einstein_image',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': None,
-    'original_name': 'Image',
-    'platform': 'portainer',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'image',
-    'unique_id': 'portainer_test_entry_123_focused_einstein_image',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[sensor.focused_einstein_image-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'focused_einstein Image',
-    }),
-    'context': <ANY>,
-    'entity_id': 'sensor.focused_einstein_image',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'docker.io/library/redis:7',
-  })
-# ---
-# name: test_all_entities[sensor.funny_chatelet_image-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.funny_chatelet_image',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': None,
-    'original_name': 'Image',
-    'platform': 'portainer',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'image',
-    'unique_id': 'portainer_test_entry_123_funny_chatelet_image',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[sensor.funny_chatelet_image-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'funny_chatelet Image',
-    }),
-    'context': <ANY>,
-    'entity_id': 'sensor.funny_chatelet_image',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'docker.io/library/ubuntu:latest',
-  })
-# ---
-# name: test_all_entities[sensor.practical_morse_image-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.practical_morse_image',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': None,
-    'original_name': 'Image',
-    'platform': 'portainer',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'image',
-    'unique_id': 'portainer_test_entry_123_practical_morse_image',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[sensor.practical_morse_image-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'practical_morse Image',
-    }),
-    'context': <ANY>,
-    'entity_id': 'sensor.practical_morse_image',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'docker.io/library/python:3.13-slim',
-  })
-# ---
-# name: test_all_entities[sensor.serene_banach_image-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.serene_banach_image',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': None,
-    'original_name': 'Image',
-    'platform': 'portainer',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'image',
-    'unique_id': 'portainer_test_entry_123_serene_banach_image',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[sensor.serene_banach_image-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'serene_banach Image',
-    }),
-    'context': <ANY>,
-    'entity_id': 'sensor.serene_banach_image',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'docker.io/library/nginx:latest',
-  })
-# ---
-# name: test_all_entities[sensor.stoic_turing_image-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.stoic_turing_image',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': None,
-    'original_name': 'Image',
-    'platform': 'portainer',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'image',
-    'unique_id': 'portainer_test_entry_123_stoic_turing_image',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[sensor.stoic_turing_image-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'stoic_turing Image',
-    }),
-    'context': <ANY>,
-    'entity_id': 'sensor.stoic_turing_image',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'docker.io/library/postgres:15',
-  })
-# ---

tests/components/portainer/test_sensor.py

@@ -1,32 +0,0 @@
-"""Tests for the Portainer sensor platform."""
-
-from unittest.mock import patch
-
-import pytest
-from syrupy.assertion import SnapshotAssertion
-
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry as er
-
-from . import setup_integration
-
-from tests.common import MockConfigEntry, snapshot_platform
-
-
-@pytest.mark.usefixtures("mock_portainer_client")
-async def test_all_entities(
-    hass: HomeAssistant,
-    snapshot: SnapshotAssertion,
-    mock_config_entry: MockConfigEntry,
-    entity_registry: er.EntityRegistry,
-) -> None:
-    """Test all entities."""
-    with patch(
-        "homeassistant.components.portainer._PLATFORMS",
-        [Platform.SENSOR],
-    ):
-        await setup_integration(hass, mock_config_entry)
-        await snapshot_platform(
-            hass, entity_registry, snapshot, mock_config_entry.entry_id
-        )

tests/components/sensor/test_init.py

@@ -1785,7 +1785,7 @@ async def test_unit_conversion_priority_suggested_unit_change_2(
             UnitOfBloodGlucoseConcentration.MILLIGRAMS_PER_DECILITER,
             0,
         ),
-        (SensorDeviceClass.CONDUCTIVITY, UnitOfConductivity.MICROSIEMENS_PER_CM, 1),
+        (SensorDeviceClass.CONDUCTIVITY, UnitOfConductivity.MICROSIEMENS, 1),
         (SensorDeviceClass.CURRENT, UnitOfElectricCurrent.MILLIAMPERE, 0),
         (SensorDeviceClass.DATA_RATE, UnitOfDataRate.KILOBITS_PER_SECOND, 0),
         (SensorDeviceClass.DATA_SIZE, UnitOfInformation.KILOBITS, 0),

tests/components/shelly/snapshots/test_button.ambr

@@ -127,7 +127,7 @@
     'suggested_object_id': None,
     'supported_features': 0,
     'translation_key': None,
-    'unique_id': '123456789ABC-button:200-button_generic',
+    'unique_id': '123456789ABC-button:200',
     'unit_of_measurement': None,
   })
 # ---
@@ -175,7 +175,7 @@
     'suggested_object_id': None,
     'supported_features': 0,
     'translation_key': None,
-    'unique_id': '123456789ABC-button:200-button_generic',
+    'unique_id': '123456789ABC-button:200',
     'unit_of_measurement': None,
   })
 # ---

tests/components/shelly/test_button.py

@@ -9,7 +9,7 @@ import pytest
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN, SERVICE_PRESS
-from homeassistant.components.shelly.const import DOMAIN, MODEL_FRANKEVER_WATER_VALVE
+from homeassistant.components.shelly.const import DOMAIN
 from homeassistant.config_entries import SOURCE_REAUTH, ConfigEntryState
 from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN, Platform
 from homeassistant.core import HomeAssistant
@@ -17,13 +17,7 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceRegistry
 from homeassistant.helpers.entity_registry import EntityRegistry
 
-from . import (
-    MOCK_MAC,
-    init_integration,
-    patch_platforms,
-    register_device,
-    register_entity,
-)
+from . import init_integration, patch_platforms, register_device, register_entity
 
 
 @pytest.fixture(autouse=True)
@@ -423,56 +417,3 @@ async def test_migrate_unique_id_blu_trv(
     assert entity_entry.unique_id == "F8447725F0DD-blutrv:200-calibrate"
 
     assert "Migrating unique_id for button.trv_name_calibrate" in caplog.text
-
-
-@pytest.mark.parametrize(
-    ("old_id", "new_id", "role"),
-    [
-        ("button", "button_generic", None),
-        ("button", "button_open", "open"),
-        ("button", "button_close", "close"),
-    ],
-)
-async def test_migrate_unique_id_virtual_components_roles(
-    hass: HomeAssistant,
-    mock_rpc_device: Mock,
-    entity_registry: EntityRegistry,
-    caplog: pytest.LogCaptureFixture,
-    monkeypatch: pytest.MonkeyPatch,
-    old_id: str,
-    new_id: str,
-    role: str | None,
-) -> None:
-    """Test migration of unique_id for virtual components to include role."""
-    entry = await init_integration(
-        hass, 3, model=MODEL_FRANKEVER_WATER_VALVE, skip_setup=True
-    )
-    old_unique_id = f"{MOCK_MAC}-{old_id}:200"
-    new_unique_id = f"{old_unique_id}-{new_id}"
-    config = deepcopy(mock_rpc_device.config)
-    if role:
-        config[f"{old_id}:200"] = {
-            "role": role,
-        }
-    else:
-        config[f"{old_id}:200"] = {}
-    monkeypatch.setattr(mock_rpc_device, "config", config)
-
-    entity = entity_registry.async_get_or_create(
-        suggested_object_id="test_name_test_button",
-        disabled_by=None,
-        domain=BUTTON_DOMAIN,
-        platform=DOMAIN,
-        unique_id=old_unique_id,
-        config_entry=entry,
-    )
-    assert entity.unique_id == old_unique_id
-
-    await hass.config_entries.async_setup(entry.entry_id)
-    await hass.async_block_till_done()
-
-    entity_entry = entity_registry.async_get("button.test_name_test_button")
-    assert entity_entry
-    assert entity_entry.unique_id == new_unique_id
-
-    assert "Migrating unique_id for button.test_name_test_button" in caplog.text

tests/components/shelly/test_switch.py

@@ -404,7 +404,6 @@ async def test_rpc_device_services(
     )
     assert (state := hass.states.get(entity_id))
     assert state.state == STATE_ON
-    mock_rpc_device.switch_set.assert_called_once_with(0, True)
 
     monkeypatch.setitem(mock_rpc_device.status["switch:0"], "output", False)
     await hass.services.async_call(
@@ -416,7 +415,6 @@ async def test_rpc_device_services(
     mock_rpc_device.mock_update()
     assert (state := hass.states.get(entity_id))
     assert state.state == STATE_OFF
-    mock_rpc_device.switch_set.assert_called_with(0, False)
 
 
 async def test_rpc_device_unique_ids(
@@ -509,7 +507,7 @@ async def test_rpc_set_state_errors(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     """Test RPC device set state connection/call errors."""
-    mock_rpc_device.switch_set.side_effect = exc
+    monkeypatch.setattr(mock_rpc_device, "call_rpc", AsyncMock(side_effect=exc))
     monkeypatch.delitem(mock_rpc_device.status, "cover:0")
     monkeypatch.setitem(mock_rpc_device.status["sys"], "relay_in_thermostat", False)
     await init_integration(hass, 2)
@@ -527,7 +525,11 @@ async def test_rpc_auth_error(
     hass: HomeAssistant, mock_rpc_device: Mock, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """Test RPC device set state authentication error."""
-    mock_rpc_device.switch_set.side_effect = InvalidAuthError
+    monkeypatch.setattr(
+        mock_rpc_device,
+        "call_rpc",
+        AsyncMock(side_effect=InvalidAuthError),
+    )
     monkeypatch.delitem(mock_rpc_device.status, "cover:0")
     monkeypatch.setitem(mock_rpc_device.status["sys"], "relay_in_thermostat", False)
     entry = await init_integration(hass, 2)
@@ -655,7 +657,6 @@ async def test_rpc_device_virtual_switch(
     mock_rpc_device.mock_update()
     assert (state := hass.states.get(entity_id))
     assert state.state == STATE_OFF
-    mock_rpc_device.boolean_set.assert_called_once_with(200, False)
 
     monkeypatch.setitem(mock_rpc_device.status["boolean:200"], "value", True)
     await hass.services.async_call(
@@ -667,7 +668,6 @@ async def test_rpc_device_virtual_switch(
     mock_rpc_device.mock_update()
     assert (state := hass.states.get(entity_id))
     assert state.state == STATE_ON
-    mock_rpc_device.boolean_set.assert_called_with(200, True)
 
 
 @pytest.mark.usefixtures("disable_async_remove_shelly_rpc_entities")
@@ -815,7 +815,6 @@ async def test_rpc_device_script_switch(
 
     assert (state := hass.states.get(entity_id))
     assert state.state == STATE_OFF
-    mock_rpc_device.script_stop.assert_called_once_with(1)
 
     monkeypatch.setitem(mock_rpc_device.status[key], "running", True)
     await hass.services.async_call(
@@ -828,4 +827,3 @@ async def test_rpc_device_script_switch(
 
     assert (state := hass.states.get(entity_id))
     assert state.state == STATE_ON
-    mock_rpc_device.script_start.assert_called_once_with(1)

tests/components/youtube/snapshots/test_sensor.ambr

@@ -4,7 +4,7 @@
     'attributes': ReadOnlyDict({
       'entity_picture': 'https://i.ytimg.com/vi/wysukDrMdqU/maxresdefault.jpg',
       'friendly_name': 'Google for Developers Latest upload',
-      'published_at': datetime.datetime(2023, 5, 11, 0, 20, 46, tzinfo=TzInfo(0)),
+      'published_at': datetime.datetime(2023, 5, 11, 0, 20, 46, tzinfo=TzInfo(UTC)),
       'video_id': 'wysukDrMdqU',
     }),
     'context': <ANY>,

tests/components/zha/test_config_flow.py

@@ -952,33 +952,6 @@ async def test_zeroconf_discovery_via_socket_already_setup_with_ip_match(
     assert result["reason"] == "single_instance_allowed"
 
 
-@patch("homeassistant.components.zha.async_setup_entry", AsyncMock(return_value=True))
-async def test_zeroconf_not_onboarded(hass: HomeAssistant) -> None:
-    """Test zeroconf discovery needing confirmation when not onboarded."""
-    service_info = ZeroconfServiceInfo(
-        ip_address=ip_address("192.168.1.100"),
-        ip_addresses=[ip_address("192.168.1.100")],
-        hostname="tube-zigbee-gw.local.",
-        name="mock_name",
-        port=6638,
-        properties={"name": "tube_123456"},
-        type="mock_type",
-    )
-    with patch(
-        "homeassistant.components.onboarding.async_is_onboarded", return_value=False
-    ):
-        result_create = await hass.config_entries.flow.async_init(
-            DOMAIN,
-            context={"source": config_entries.SOURCE_ZEROCONF},
-            data=service_info,
-        )
-        await hass.async_block_till_done()
-
-    # not automatically confirmed
-    assert result_create["type"] is FlowResultType.FORM
-    assert result_create["step_id"] == "confirm"
-
-
 @patch(
     "homeassistant.components.zha.radio_manager.ZhaRadioManager.detect_radio_type",
     mock_detect_radio_type(radio_type=RadioType.deconz),

tests/helpers/test_event.py

@@ -22,7 +22,7 @@ from homeassistant.core import (
     HomeAssistant,
     callback,
 )
-from homeassistant.exceptions import HomeAssistantError, TemplateError
+from homeassistant.exceptions import TemplateError
 from homeassistant.helpers.device_registry import EVENT_DEVICE_REGISTRY_UPDATED
 from homeassistant.helpers.entity_registry import EVENT_ENTITY_REGISTRY_UPDATED
 from homeassistant.helpers.event import (
@@ -4975,25 +4975,43 @@ async def test_async_track_state_report_change_event(hass: HomeAssistant) -> Non
     }
 
 
-async def test_async_track_template_no_hass_fails(hass: HomeAssistant) -> None:
-    """Test async_track_template with a template without hass now fails."""
-    message = "Calls async_track_template_result with template without hass"
+async def test_async_track_template_no_hass_deprecated(
+    hass: HomeAssistant, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Test async_track_template with a template without hass is deprecated."""
+    message = (
+        "Detected code that calls async_track_template_result with template without "
+        "hass. This will stop working in Home Assistant 2025.10, please "
+        "report this issue"
+    )
 
-    with pytest.raises(HomeAssistantError, match=message):
-        async_track_template(hass, Template("blah"), lambda x, y, z: None)
+    async_track_template(hass, Template("blah"), lambda x, y, z: None)
+    assert message in caplog.text
+    caplog.clear()
 
     async_track_template(hass, Template("blah", hass), lambda x, y, z: None)
+    assert message not in caplog.text
+    caplog.clear()
 
 
-async def test_async_track_template_result_no_hass_fails(hass: HomeAssistant) -> None:
-    """Test async_track_template_result with a template without hass now fails."""
-    message = "Calls async_track_template_result with template without hass"
+async def test_async_track_template_result_no_hass_deprecated(
+    hass: HomeAssistant, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Test async_track_template_result with a template without hass is deprecated."""
+    message = (
+        "Detected code that calls async_track_template_result with template without "
+        "hass. This will stop working in Home Assistant 2025.10, please "
+        "report this issue"
+    )
 
-    with pytest.raises(HomeAssistantError, match=message):
-        async_track_template_result(
-            hass, [TrackTemplate(Template("blah"), None)], lambda x, y, z: None
-        )
+    async_track_template_result(
+        hass, [TrackTemplate(Template("blah"), None)], lambda x, y, z: None
+    )
+    assert message in caplog.text
+    caplog.clear()
 
     async_track_template_result(
         hass, [TrackTemplate(Template("blah", hass), None)], lambda x, y, z: None
     )
+    assert message not in caplog.text
+    caplog.clear()

tests/test_const.py

@@ -1,12 +1,19 @@
 """Test const module."""
 
 from enum import Enum
+import logging
+import sys
+from unittest.mock import Mock, patch
 
 import pytest
 
 from homeassistant import const
 
-from .common import help_test_all, import_and_test_deprecated_constant
+from .common import (
+    extract_stack_to_frame,
+    help_test_all,
+    import_and_test_deprecated_constant,
+)
 
 
 def _create_tuples(
@@ -41,3 +48,78 @@ def test_deprecated_constant_name_changes(
         replacement,
         breaks_in_version,
     )
+
+
+def test_deprecated_unit_of_conductivity_alias() -> None:
+    """Test UnitOfConductivity deprecation."""
+
+    # Test the deprecated members are aliases
+    assert set(const.UnitOfConductivity) == {"S/cm", "μS/cm", "mS/cm"}
+
+
+def test_deprecated_unit_of_conductivity_members(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test UnitOfConductivity deprecation."""
+
+    module_name = "config.custom_components.hue.light"
+    filename = f"/home/paulus/{module_name.replace('.', '/')}.py"
+
+    with (
+        patch.dict(sys.modules, {module_name: Mock(__file__=filename)}),
+        patch(
+            "homeassistant.helpers.frame.linecache.getline",
+            return_value="await session.close()",
+        ),
+        patch(
+            "homeassistant.helpers.frame.get_current_frame",
+            return_value=extract_stack_to_frame(
+                [
+                    Mock(
+                        filename="/home/paulus/homeassistant/core.py",
+                        lineno="23",
+                        line="do_something()",
+                    ),
+                    Mock(
+                        filename=filename,
+                        lineno="23",
+                        line="await session.close()",
+                    ),
+                    Mock(
+                        filename="/home/paulus/aiohue/lights.py",
+                        lineno="2",
+                        line="something()",
+                    ),
+                ]
+            ),
+        ),
+    ):
+        const.UnitOfConductivity.SIEMENS  # noqa: B018
+        const.UnitOfConductivity.MICROSIEMENS  # noqa: B018
+        const.UnitOfConductivity.MILLISIEMENS  # noqa: B018
+
+    assert len(caplog.record_tuples) == 3
+
+    def deprecation_message(member: str, replacement: str) -> str:
+        return (
+            f"The deprecated enum member UnitOfConductivity.{member} was used from hue. "
+            "It will be removed in HA Core 2025.11.0. Use UnitOfConductivity."
+            f"{replacement} instead, please report it to the author of the 'hue' custom"
+            " integration"
+        )
+
+    assert (
+        const.__name__,
+        logging.WARNING,
+        deprecation_message("SIEMENS", "SIEMENS_PER_CM"),
+    ) in caplog.record_tuples
+    assert (
+        const.__name__,
+        logging.WARNING,
+        deprecation_message("MICROSIEMENS", "MICROSIEMENS_PER_CM"),
+    ) in caplog.record_tuples
+    assert (
+        const.__name__,
+        logging.WARNING,
+        deprecation_message("MILLISIEMENS", "MILLISIEMENS_PER_CM"),
+    ) in caplog.record_tuples

tests/util/test_unit_conversion.py

@@ -281,6 +281,48 @@ _CONVERTED_VALUE: dict[
         ),
     ],
     ConductivityConverter: [
+        # Deprecated to deprecated
+        (5, UnitOfConductivity.SIEMENS, 5e3, UnitOfConductivity.MILLISIEMENS),
+        (5, UnitOfConductivity.SIEMENS, 5e6, UnitOfConductivity.MICROSIEMENS),
+        (5, UnitOfConductivity.MILLISIEMENS, 5e3, UnitOfConductivity.MICROSIEMENS),
+        (5, UnitOfConductivity.MILLISIEMENS, 5e-3, UnitOfConductivity.SIEMENS),
+        (5e6, UnitOfConductivity.MICROSIEMENS, 5e3, UnitOfConductivity.MILLISIEMENS),
+        (5e6, UnitOfConductivity.MICROSIEMENS, 5, UnitOfConductivity.SIEMENS),
+        # Deprecated to new
+        (5, UnitOfConductivity.SIEMENS, 5e3, UnitOfConductivity.MILLISIEMENS_PER_CM),
+        (5, UnitOfConductivity.SIEMENS, 5e6, UnitOfConductivity.MICROSIEMENS_PER_CM),
+        (
+            5,
+            UnitOfConductivity.MILLISIEMENS,
+            5e3,
+            UnitOfConductivity.MICROSIEMENS_PER_CM,
+        ),
+        (5, UnitOfConductivity.MILLISIEMENS, 5e-3, UnitOfConductivity.SIEMENS_PER_CM),
+        (
+            5e6,
+            UnitOfConductivity.MICROSIEMENS,
+            5e3,
+            UnitOfConductivity.MILLISIEMENS_PER_CM,
+        ),
+        (5e6, UnitOfConductivity.MICROSIEMENS, 5, UnitOfConductivity.SIEMENS_PER_CM),
+        # New to deprecated
+        (5, UnitOfConductivity.SIEMENS_PER_CM, 5e3, UnitOfConductivity.MILLISIEMENS),
+        (5, UnitOfConductivity.SIEMENS_PER_CM, 5e6, UnitOfConductivity.MICROSIEMENS),
+        (
+            5,
+            UnitOfConductivity.MILLISIEMENS_PER_CM,
+            5e3,
+            UnitOfConductivity.MICROSIEMENS,
+        ),
+        (5, UnitOfConductivity.MILLISIEMENS_PER_CM, 5e-3, UnitOfConductivity.SIEMENS),
+        (
+            5e6,
+            UnitOfConductivity.MICROSIEMENS_PER_CM,
+            5e3,
+            UnitOfConductivity.MILLISIEMENS,
+        ),
+        (5e6, UnitOfConductivity.MICROSIEMENS_PER_CM, 5, UnitOfConductivity.SIEMENS),
+        # New to new
         (
             5,
             UnitOfConductivity.SIEMENS_PER_CM,