homeassistant 2025.9.4__py3-none-any.whl → 2025.10.0b0__py3-none-any.whl

homeassistant/components/miele/sensor.py

@@ -35,8 +35,8 @@ from .const import (
     COFFEE_SYSTEM_PROFILE,
     DISABLED_TEMP_ENTITIES,
     DOMAIN,
+    PROGRAM_PHASE,
     STATE_PROGRAM_ID,
-    STATE_PROGRAM_PHASE,
     STATE_STATUS_TAGS,
     MieleAppliance,
     PlatePowerStep,
@@ -270,6 +270,7 @@ SENSOR_TYPES: Final[tuple[MieleSensorDefinition, ...]] = (
             device_class=SensorDeviceClass.ENERGY,
             state_class=SensorStateClass.TOTAL_INCREASING,
             native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+            suggested_display_precision=1,
             entity_category=EntityCategory.DIAGNOSTIC,
         ),
     ),
@@ -307,6 +308,7 @@ SENSOR_TYPES: Final[tuple[MieleSensorDefinition, ...]] = (
             device_class=SensorDeviceClass.WATER,
             state_class=SensorStateClass.TOTAL_INCREASING,
             native_unit_of_measurement=UnitOfVolume.LITERS,
+            suggested_display_precision=0,
             entity_category=EntityCategory.DIAGNOSTIC,
         ),
     ),
@@ -364,6 +366,7 @@ SENSOR_TYPES: Final[tuple[MieleSensorDefinition, ...]] = (
             key="state_remaining_time",
             translation_key="remaining_time",
             value_fn=lambda value: _convert_duration(value.state_remaining_time),
+            end_value_fn=lambda last_value: 0,
             device_class=SensorDeviceClass.DURATION,
             native_unit_of_measurement=UnitOfTime.MINUTES,
             entity_category=EntityCategory.DIAGNOSTIC,
@@ -417,6 +420,7 @@ SENSOR_TYPES: Final[tuple[MieleSensorDefinition, ...]] = (
             key="state_start_time",
             translation_key="start_time",
             value_fn=lambda value: _convert_duration(value.state_start_time),
+            end_value_fn=lambda last_value: None,
             native_unit_of_measurement=UnitOfTime.MINUTES,
             device_class=SensorDeviceClass.DURATION,
             entity_category=EntityCategory.DIAGNOSTIC,
@@ -614,6 +618,10 @@ async def async_setup_entry(
             "state_program_phase": MielePhaseSensor,
             "state_plate_step": MielePlateSensor,
             "state_elapsed_time": MieleTimeSensor,
+            "state_remaining_time": MieleTimeSensor,
+            "state_start_time": MieleTimeSensor,
+            "current_energy_consumption": MieleConsumptionSensor,
+            "current_water_consumption": MieleConsumptionSensor,
         }.get(definition.description.key, MieleSensor)
 
     def _is_entity_registered(unique_id: str) -> bool:
@@ -769,7 +777,7 @@ class MieleRestorableSensor(MieleSensor, RestoreSensor):
         """When entity is added to hass."""
         await super().async_added_to_hass()
 
-        # recover last value from cache
+        # recover last value from cache when adding entity
         last_value = await self.async_get_last_state()
         if last_value and last_value.state != STATE_UNKNOWN:
             self._last_value = last_value.state
@@ -779,6 +787,16 @@ class MieleRestorableSensor(MieleSensor, RestoreSensor):
         """Return the state of the sensor."""
         return self._last_value
 
+    def _update_last_value(self) -> None:
+        """Update the last value of the sensor."""
+        self._last_value = self.entity_description.value_fn(self.device)
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        self._update_last_value()
+        super()._handle_coordinator_update()
+
 
 class MielePlateSensor(MieleSensor):
     """Representation of a Sensor."""
@@ -833,29 +851,36 @@ class MieleStatusSensor(MieleSensor):
         return True
 
 
+# Some phases have names that are not valid python identifiers, so we need to translate
+# them in order to avoid breaking changes
+PROGRAM_PHASE_TRANSLATION = {
+    "second_espresso": "2nd_espresso",
+    "second_grinding": "2nd_grinding",
+    "second_pre_brewing": "2nd_pre_brewing",
+}
+
+
 class MielePhaseSensor(MieleSensor):
     """Representation of the program phase sensor."""
 
     @property
     def native_value(self) -> StateType:
-        """Return the state of the sensor."""
-        ret_val = STATE_PROGRAM_PHASE.get(self.device.device_type, {}).get(
+        """Return the state of the phase sensor."""
+        program_phase = PROGRAM_PHASE[self.device.device_type](
             self.device.state_program_phase
+        ).name
+
+        return (
+            PROGRAM_PHASE_TRANSLATION.get(program_phase, program_phase)
+            if program_phase is not None
+            else None
         )
-        if ret_val is None:
-            _LOGGER.debug(
-                "Unknown program phase: %s on device type: %s",
-                self.device.state_program_phase,
-                self.device.device_type,
-            )
-        return ret_val
 
     @property
     def options(self) -> list[str]:
         """Return the options list for the actual device type."""
-        return sorted(
-            set(STATE_PROGRAM_PHASE.get(self.device.device_type, {}).values())
-        )
+        phases = PROGRAM_PHASE[self.device.device_type].keys()
+        return sorted([PROGRAM_PHASE_TRANSLATION.get(phase, phase) for phase in phases])
 
 
 class MieleProgramIdSensor(MieleSensor):
@@ -886,9 +911,8 @@ class MieleProgramIdSensor(MieleSensor):
 class MieleTimeSensor(MieleRestorableSensor):
     """Representation of time sensors keeping state from cache."""
 
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
+    def _update_last_value(self) -> None:
+        """Update the last value of the sensor."""
 
         current_value = self.entity_description.value_fn(self.device)
         current_status = StateStatus(self.device.state_status)
@@ -912,4 +936,57 @@ class MieleTimeSensor(MieleRestorableSensor):
         else:
             self._last_value = current_value
 
-        super()._handle_coordinator_update()
+
+class MieleConsumptionSensor(MieleRestorableSensor):
+    """Representation of consumption sensors keeping state from cache."""
+
+    _is_reporting: bool = False
+
+    def _update_last_value(self) -> None:
+        """Update the last value of the sensor."""
+        current_value = self.entity_description.value_fn(self.device)
+        current_status = StateStatus(self.device.state_status)
+        last_value = (
+            float(cast(str, self._last_value))
+            if self._last_value is not None and self._last_value != STATE_UNKNOWN
+            else 0
+        )
+
+        # force unknown when appliance is not able to report consumption
+        if current_status in (
+            StateStatus.ON,
+            StateStatus.OFF,
+            StateStatus.PROGRAMMED,
+            StateStatus.WAITING_TO_START,
+            StateStatus.IDLE,
+            StateStatus.SERVICE,
+        ):
+            self._is_reporting = False
+            self._last_value = None
+
+        # appliance might report the last value for consumption of previous cycle and it will report 0
+        # only after a while, so it is necessary to force 0 until we see the 0 value coming from API, unless
+        # we already saw a valid value in this cycle from cache
+        elif (
+            current_status in (StateStatus.IN_USE, StateStatus.PAUSE)
+            and not self._is_reporting
+            and last_value > 0
+        ):
+            self._last_value = current_value
+            self._is_reporting = True
+
+        elif (
+            current_status in (StateStatus.IN_USE, StateStatus.PAUSE)
+            and not self._is_reporting
+            and current_value is not None
+            and cast(int, current_value) > 0
+        ):
+            self._last_value = 0
+
+        # keep value when program ends
+        elif current_status == StateStatus.PROGRAM_ENDED:
+            pass
+
+        else:
+            self._last_value = current_value
+            self._is_reporting = True

homeassistant/components/miele/services.py

@@ -58,11 +58,12 @@ _LOGGER = logging.getLogger(__name__)
 
 async def _extract_config_entry(service_call: ServiceCall) -> MieleConfigEntry:
     """Extract config entry from the service call."""
-    hass = service_call.hass
-    target_entry_ids = await async_extract_config_entry_ids(hass, service_call)
+    target_entry_ids = await async_extract_config_entry_ids(service_call)
     target_entries: list[MieleConfigEntry] = [
         loaded_entry
-        for loaded_entry in hass.config_entries.async_loaded_entries(DOMAIN)
+        for loaded_entry in service_call.hass.config_entries.async_loaded_entries(
+            DOMAIN
+        )
         if loaded_entry.entry_id in target_entry_ids
     ]
     if not target_entries:

homeassistant/components/miele/strings.json

@@ -291,6 +291,7 @@
           "not_running": "Not running",
           "pre_brewing": "Pre-brewing",
           "pre_dishwash": "Pre-cleaning",
+          "pre_heating": "Pre-heating",
           "pre_wash": "Pre-wash",
           "process_finished": "Process finished",
           "process_running": "Process running",

homeassistant/components/miele/translations/cs.json

@@ -965,6 +965,7 @@
                     "not_running": "Neb\u011b\u017e\u00ed",
                     "pre_brewing": "P\u0159edva\u0159en\u00ed",
                     "pre_dishwash": "P\u0159ed\u010di\u0161t\u011bn\u00ed",
+                    "pre_heating": "P\u0159edeh\u0159ev",
                     "pre_wash": "P\u0159edmyt\u00ed",
                     "process_finished": "Proces dokon\u010den",
                     "process_running": "Proces b\u011b\u017e\u00ed",

homeassistant/components/miele/translations/de.json

@@ -965,6 +965,7 @@
                     "not_running": "Au\u00dfer Betrieb",
                     "pre_brewing": "Vorbr\u00fchen",
                     "pre_dishwash": "Vorreinigung",
+                    "pre_heating": "Vorheizen",
                     "pre_wash": "Vorw\u00e4sche",
                     "process_finished": "Vorgang abgeschlossen",
                     "process_running": "Vorgang l\u00e4uft",

homeassistant/components/miele/translations/en-GB.json

@@ -965,6 +965,7 @@
                     "not_running": "Not running",
                     "pre_brewing": "Pre-brewing",
                     "pre_dishwash": "Pre-cleaning",
+                    "pre_heating": "Pre-heating",
                     "pre_wash": "Pre-wash",
                     "process_finished": "Process finished",
                     "process_running": "Process running",

homeassistant/components/miele/translations/en.json

@@ -964,6 +964,7 @@
                     "not_running": "Not running",
                     "pre_brewing": "Pre-brewing",
                     "pre_dishwash": "Pre-cleaning",
+                    "pre_heating": "Pre-heating",
                     "pre_wash": "Pre-wash",
                     "process_finished": "Process finished",
                     "process_running": "Process running",

homeassistant/components/miele/translations/es.json

@@ -965,6 +965,7 @@
                     "not_running": "No se est\u00e1 ejecutando",
                     "pre_brewing": "Pre elaboraci\u00f3n de cerveza",
                     "pre_dishwash": "Prelimpieza",
+                    "pre_heating": "Precalentamiento",
                     "pre_wash": "Prelavado",
                     "process_finished": "Proceso finalizado",
                     "process_running": "Proceso en ejecuci\u00f3n",

homeassistant/components/miele/translations/et.json

@@ -965,6 +965,7 @@
                     "not_running": "Ei t\u00f6\u00f6ta",
                     "pre_brewing": "Eelpruulimine",
                     "pre_dishwash": "Eelpuhastus",
+                    "pre_heating": "Eelsoojendus",
                     "pre_wash": "Eelpesu",
                     "process_finished": "Protsess on l\u00f5ppenud",
                     "process_running": "Protsess k\u00e4ib",

homeassistant/components/miele/translations/he.json

@@ -819,6 +819,7 @@
                     "not_running": "\u05dc\u05d0 \u05e4\u05e2\u05d9\u05dc\u05d4",
                     "pre_brewing": "\u05d7\u05dc\u05d9\u05d8\u05d4 \u05de\u05d5\u05e7\u05d3\u05de\u05ea",
                     "pre_dishwash": "\u05e0\u05d9\u05e7\u05d5\u05d9 \u05de\u05e7\u05d3\u05d9\u05dd",
+                    "pre_heating": "\u05d7\u05d9\u05de\u05d5\u05dd \u05de\u05e7\u05d3\u05d9\u05dd",
                     "pre_wash": "\u05e9\u05d8\u05d9\u05e4\u05d4 \u05de\u05d5\u05e7\u05d3\u05de\u05ea",
                     "process_finished": "\u05ea\u05d4\u05dc\u05d9\u05da \u05d4\u05e1\u05ea\u05d9\u05d9\u05dd",
                     "process_running": "\u05ea\u05d4\u05dc\u05d9\u05da \u05e4\u05e2\u05d9\u05dc",

homeassistant/components/miele/translations/lt.json

@@ -965,6 +965,7 @@
                     "not_running": "Neveikia",
                     "pre_brewing": "Prie\u0161 virim\u0105",
                     "pre_dishwash": "I\u0161ankstinis valymas",
+                    "pre_heating": "I\u0161ankstinis pa\u0161ildymas",
                     "pre_wash": "I\u0161ankstinis skalbimas",
                     "process_finished": "Procesas baigtas",
                     "process_running": "Vykdomas procesas",

homeassistant/components/miele/translations/nl.json

@@ -223,6 +223,7 @@
                     "cleaning": "Schoonmaken",
                     "hot_milk": "Warme melk",
                     "main_dishwash": "Schoonmaken",
+                    "pre_heating": "Voorverwarmen",
                     "rinse": "Spoelen",
                     "vacuum_cleaning": "Schoonmaken",
                     "warm_air": "Warme lucht"

homeassistant/components/miele/translations/pt.json

@@ -574,7 +574,7 @@
                     "moisture_plus_conventional_heat": "Humidade mais + Calor convencional",
                     "moisture_plus_fan_plus": "Humidade plus + Ventoinha plus",
                     "moisture_plus_intensive_bake": "Hidrata\u00e7\u00e3o plus + cozedura intensiva",
-                    "multigrain_rolls": "P\u00e3ezinhos multigr\u00e3os",
+                    "multigrain_rolls": "P\u00e3ezinhos multigr\u00e3o",
                     "mushrooms_diced": "Cogumelos (cortados em cubos)",
                     "mushrooms_halved": "Cogumelos (cortados ao meio)",
                     "mushrooms_quartered": "Cogumelos (cortados em quartos)",
@@ -965,6 +965,7 @@
                     "not_running": "Parado",
                     "pre_brewing": "Pr\u00e9-fermenta\u00e7\u00e3o",
                     "pre_dishwash": "Pr\u00e9-limpeza",
+                    "pre_heating": "Pr\u00e9 aquecimento",
                     "pre_wash": "Pr\u00e9-lavagem",
                     "process_finished": "Processo conclu\u00eddo",
                     "process_running": "Processo em curso",

homeassistant/components/miele/translations/ru.json

@@ -673,6 +673,11 @@
                     "tall_items": "\u0412\u044b\u0441\u043e\u043a\u0438\u0435 \u043f\u0440\u0435\u0434\u043c\u0435\u0442\u044b"
                 }
             },
+            "program_phase": {
+                "state": {
+                    "pre_heating": "\u041f\u0440\u0435\u0434\u0432\u0430\u0440\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u0439 \u043d\u0430\u0433\u0440\u0435\u0432"
+                }
+            },
             "status": {
                 "name": "\u0421\u0442\u0430\u0442\u0443\u0441",
                 "state": {

homeassistant/components/miele/translations/sk.json

@@ -965,6 +965,7 @@
                     "not_running": "Nie je spusten\u00e9",
                     "pre_brewing": "Predvarenie",
                     "pre_dishwash": "Pred\u010distenie",
+                    "pre_heating": "Predhrievanie",
                     "pre_wash": "Predpranie",
                     "process_finished": "Proces dokon\u010den\u00fd",
                     "process_running": "Spusten\u00fd proces",

homeassistant/components/miele/translations/zh-Hans.json

@@ -965,6 +965,7 @@
                     "not_running": "\u672a\u5728\u8fd0\u884c",
                     "pre_brewing": "\u9884\u51b2\u6ce1",
                     "pre_dishwash": "\u9884\u6e05\u6d01",
+                    "pre_heating": "\u9884\u70ed",
                     "pre_wash": "\u9884\u6d17",
                     "process_finished": "\u6d41\u7a0b\u5b8c\u6210",
                     "process_running": "\u6d41\u7a0b\u8fd0\u884c",

homeassistant/components/miele/translations/zh-Hant.json

@@ -965,6 +965,7 @@
                     "not_running": "\u672a\u57f7\u884c",
                     "pre_brewing": "\u9810\u6c96\u6ce1",
                     "pre_dishwash": "\u9810\u5148\u6e05\u6f54",
+                    "pre_heating": "\u9810\u71b1",
                     "pre_wash": "\u9810\u6d17",
                     "process_finished": "\u7a0b\u5e8f\u5df2\u5b8c\u6210",
                     "process_running": "\u7a0b\u5e8f\u57f7\u884c\u4e2d",

homeassistant/components/miele/vacuum.py

@@ -64,7 +64,7 @@ PROGRAM_TO_SPEED: dict[int, str] = {
 }
 
 
-class MieleVacuumStateCode(MieleEnum):
+class MieleVacuumStateCode(MieleEnum, missing_to_none=True):
     """Define vacuum state codes."""
 
     idle = 0
@@ -82,7 +82,6 @@ class MieleVacuumStateCode(MieleEnum):
     blocked_front_wheel = 5900
     docked = 5903, 5904
     remote_controlled = 5910
-    missing2none = -9999
 
 
 SUPPORTED_FEATURES = (

homeassistant/components/min_max/sensor.py

@@ -16,6 +16,7 @@ from homeassistant.components.sensor import (
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
+    ATTR_ENTITY_ID,
     ATTR_UNIT_OF_MEASUREMENT,
     CONF_NAME,
     CONF_TYPE,
@@ -278,13 +279,18 @@ class MinMaxSensor(SensorEntity):
     @property
     def extra_state_attributes(self) -> dict[str, Any] | None:
         """Return the state attributes of the sensor."""
+        attributes: dict[str, list[str] | str | None] = {
+            ATTR_ENTITY_ID: self._entity_ids
+        }
+
         if self._sensor_type == "min":
-            return {ATTR_MIN_ENTITY_ID: self.min_entity_id}
-        if self._sensor_type == "max":
-            return {ATTR_MAX_ENTITY_ID: self.max_entity_id}
-        if self._sensor_type == "last":
-            return {ATTR_LAST_ENTITY_ID: self.last_entity_id}
-        return None
+            attributes[ATTR_MIN_ENTITY_ID] = self.min_entity_id
+        elif self._sensor_type == "max":
+            attributes[ATTR_MAX_ENTITY_ID] = self.max_entity_id
+        elif self._sensor_type == "last":
+            attributes[ATTR_LAST_ENTITY_ID] = self.last_entity_id
+
+        return attributes
 
     @callback
     def _async_min_max_sensor_state_listener(

homeassistant/components/mobile_app/manifest.json

@@ -16,5 +16,5 @@
   "iot_class": "local_push",
   "loggers": ["nacl"],
   "quality_scale": "internal",
-  "requirements": ["PyNaCl==1.5.0"]
+  "requirements": ["PyNaCl==1.6.0"]
 }

homeassistant/components/modbus/__init__.py

@@ -148,7 +148,7 @@ from .const import (
     DEFAULT_HVAC_ON_VALUE,
     DEFAULT_SCAN_INTERVAL,
     DEFAULT_TEMP_UNIT,
-    MODBUS_DOMAIN as DOMAIN,
+    DOMAIN,
     RTUOVERTCP,
     SERIAL,
     TCP,
@@ -479,7 +479,8 @@ MODBUS_SCHEMA = vol.Schema(
         ),
         vol.Optional(CONF_SWITCHES): vol.All(cv.ensure_list, [SWITCH_SCHEMA]),
         vol.Optional(CONF_FANS): vol.All(cv.ensure_list, [FAN_SCHEMA]),
-    }
+    },
+    extra=vol.ALLOW_EXTRA,
 )
 
 SERIAL_SCHEMA = MODBUS_SCHEMA.extend(

homeassistant/components/modbus/binary_sensor.py

@@ -29,7 +29,7 @@ from .const import (
     CONF_SLAVE_COUNT,
     CONF_VIRTUAL_COUNT,
 )
-from .entity import BasePlatform
+from .entity import ModbusBaseEntity
 from .modbus import ModbusHub
 
 PARALLEL_UPDATES = 1
@@ -59,7 +59,7 @@ async def async_setup_platform(
     async_add_entities(sensors)
 
 
-class ModbusBinarySensor(BasePlatform, RestoreEntity, BinarySensorEntity):
+class ModbusBinarySensor(ModbusBaseEntity, RestoreEntity, BinarySensorEntity):
     """Modbus binary sensor."""
 
     def __init__(
@@ -106,7 +106,7 @@ class ModbusBinarySensor(BasePlatform, RestoreEntity, BinarySensorEntity):
 
         # do not allow multiple active calls to the same platform
         result = await self._hub.async_pb_call(
-            self._slave, self._address, self._count, self._input_type
+            self._device_address, self._address, self._count, self._input_type
         )
         if result is None:
             self._attr_available = False

homeassistant/components/modbus/climate.py

@@ -101,7 +101,7 @@ from .const import (
     CONF_WRITE_REGISTERS,
     DataType,
 )
-from .entity import BaseStructPlatform
+from .entity import ModbusStructEntity
 from .modbus import ModbusHub
 
 PARALLEL_UPDATES = 1
@@ -131,7 +131,7 @@ async def async_setup_platform(
     async_add_entities(ModbusThermostat(hass, hub, config) for config in climates)
 
 
-class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
+class ModbusThermostat(ModbusStructEntity, RestoreEntity, ClimateEntity):
     """Representation of a Modbus Thermostat."""
 
     _attr_supported_features = (
@@ -315,7 +315,7 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
             # register, or self._hvac_on_value otherwise.
             if self._hvac_onoff_write_registers:
                 await self._hub.async_pb_call(
-                    self._slave,
+                    self._device_address,
                     self._hvac_onoff_register,
                     [
                         self._hvac_off_value
@@ -326,7 +326,7 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
                 )
             else:
                 await self._hub.async_pb_call(
-                    self._slave,
+                    self._device_address,
                     self._hvac_onoff_register,
                     self._hvac_off_value
                     if hvac_mode == HVACMode.OFF
@@ -337,7 +337,7 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
         if self._hvac_onoff_coil is not None:
             # Turn HVAC Off by writing 0 to the On/Off coil, or 1 otherwise.
             await self._hub.async_pb_call(
-                self._slave,
+                self._device_address,
                 self._hvac_onoff_coil,
                 0 if hvac_mode == HVACMode.OFF else 1,
                 CALL_TYPE_WRITE_COIL,
@@ -349,14 +349,14 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
                 if mode == hvac_mode:
                     if self._hvac_mode_write_registers:
                         await self._hub.async_pb_call(
-                            self._slave,
+                            self._device_address,
                             self._hvac_mode_register,
                             [value],
                             CALL_TYPE_WRITE_REGISTERS,
                         )
                     else:
                         await self._hub.async_pb_call(
-                            self._slave,
+                            self._device_address,
                             self._hvac_mode_register,
                             value,
                             CALL_TYPE_WRITE_REGISTER,
@@ -372,14 +372,14 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
             value = self._fan_mode_mapping_to_modbus[fan_mode]
             if isinstance(self._fan_mode_register, list):
                 await self._hub.async_pb_call(
-                    self._slave,
+                    self._device_address,
                     self._fan_mode_register[0],
                     [value],
                     CALL_TYPE_WRITE_REGISTERS,
                 )
             else:
                 await self._hub.async_pb_call(
-                    self._slave,
+                    self._device_address,
                     self._fan_mode_register,
                     value,
                     CALL_TYPE_WRITE_REGISTER,
@@ -395,14 +395,14 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
                 if swing_mode == smode:
                     if isinstance(self._swing_mode_register, list):
                         await self._hub.async_pb_call(
-                            self._slave,
+                            self._device_address,
                             self._swing_mode_register[0],
                             [value],
                             CALL_TYPE_WRITE_REGISTERS,
                         )
                     else:
                         await self._hub.async_pb_call(
-                            self._slave,
+                            self._device_address,
                             self._swing_mode_register,
                             value,
                             CALL_TYPE_WRITE_REGISTER,
@@ -437,7 +437,7 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
         ):
             if self._target_temperature_write_registers:
                 result = await self._hub.async_pb_call(
-                    self._slave,
+                    self._device_address,
                     self._target_temperature_register[
                         HVACMODE_TO_TARG_TEMP_REG_INDEX_ARRAY[self._attr_hvac_mode]
                     ],
@@ -446,7 +446,7 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
                 )
             else:
                 result = await self._hub.async_pb_call(
-                    self._slave,
+                    self._device_address,
                     self._target_temperature_register[
                         HVACMODE_TO_TARG_TEMP_REG_INDEX_ARRAY[self._attr_hvac_mode]
                     ],
@@ -455,7 +455,7 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
                 )
         else:
             result = await self._hub.async_pb_call(
-                self._slave,
+                self._device_address,
                 self._target_temperature_register[
                     HVACMODE_TO_TARG_TEMP_REG_INDEX_ARRAY[self._attr_hvac_mode]
                 ],
@@ -566,7 +566,7 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
     ) -> float | None:
         """Read register using the Modbus hub slave."""
         result = await self._hub.async_pb_call(
-            self._slave, register, self._count, register_type
+            self._device_address, register, self._count, register_type
         )
         if result is None:
             self._attr_available = False
@@ -587,7 +587,9 @@ class ModbusThermostat(BaseStructPlatform, RestoreEntity, ClimateEntity):
         return float(self._value)
 
     async def _async_read_coil(self, address: int) -> int | None:
-        result = await self._hub.async_pb_call(self._slave, address, 1, CALL_TYPE_COIL)
+        result = await self._hub.async_pb_call(
+            self._device_address, address, 1, CALL_TYPE_COIL
+        )
         if result is not None and result.bits is not None:
             self._attr_available = True
             return int(result.bits[0])

homeassistant/components/modbus/const.py

@@ -159,6 +159,7 @@ DEFAULT_TEMP_UNIT = "C"
 DEFAULT_HVAC_ON_VALUE = 1
 DEFAULT_HVAC_OFF_VALUE = 0
 MODBUS_DOMAIN = "modbus"
+DOMAIN = "modbus"
 
 ACTIVE_SCAN_INTERVAL = 2  # limit to force an extra update