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

homeassistant/components/modbus/cover.py

@@ -23,7 +23,7 @@ from .const import (
     CONF_STATUS_REGISTER,
     CONF_STATUS_REGISTER_TYPE,
 )
-from .entity import BasePlatform
+from .entity import ModbusBaseEntity
 from .modbus import ModbusHub
 
 PARALLEL_UPDATES = 1
@@ -42,7 +42,7 @@ async def async_setup_platform(
     async_add_entities(ModbusCover(hass, hub, config) for config in covers)
 
 
-class ModbusCover(BasePlatform, CoverEntity, RestoreEntity):
+class ModbusCover(ModbusBaseEntity, CoverEntity, RestoreEntity):
     """Representation of a Modbus cover."""
 
     _attr_supported_features = CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
@@ -108,7 +108,10 @@ class ModbusCover(BasePlatform, CoverEntity, RestoreEntity):
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Open cover."""
         result = await self._hub.async_pb_call(
-            self._slave, self._write_address, self._state_open, self._write_type
+            self._device_address,
+            self._write_address,
+            self._state_open,
+            self._write_type,
         )
         self._attr_available = result is not None
         await self.async_local_update(cancel_pending_update=True)
@@ -116,7 +119,10 @@ class ModbusCover(BasePlatform, CoverEntity, RestoreEntity):
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close cover."""
         result = await self._hub.async_pb_call(
-            self._slave, self._write_address, self._state_closed, self._write_type
+            self._device_address,
+            self._write_address,
+            self._state_closed,
+            self._write_type,
         )
         self._attr_available = result is not None
         await self.async_local_update(cancel_pending_update=True)
@@ -124,7 +130,7 @@ class ModbusCover(BasePlatform, CoverEntity, RestoreEntity):
     async def _async_update(self) -> None:
         """Update the state of the cover."""
         result = await self._hub.async_pb_call(
-            self._slave, self._address, 1, self._input_type
+            self._device_address, self._address, 1, self._input_type
         )
         if result is None:
             self._attr_available = False

homeassistant/components/modbus/entity.py

@@ -68,7 +68,7 @@ from .const import (
 from .modbus import ModbusHub
 
 
-class BasePlatform(Entity):
+class ModbusBaseEntity(Entity):
     """Base for readonly platforms."""
 
     _value: str | None = None
@@ -83,9 +83,9 @@ class BasePlatform(Entity):
 
         self._hub = hub
         if (conf_slave := entry.get(CONF_SLAVE)) is not None:
-            self._slave = conf_slave
+            self._device_address = conf_slave
         else:
-            self._slave = entry.get(CONF_DEVICE_ADDRESS, 1)
+            self._device_address = entry.get(CONF_DEVICE_ADDRESS, 1)
         self._address = int(entry[CONF_ADDRESS])
         self._input_type = entry[CONF_INPUT_TYPE]
         self._scan_interval = int(entry[CONF_SCAN_INTERVAL])
@@ -154,7 +154,7 @@ class BasePlatform(Entity):
         )
 
 
-class BaseStructPlatform(BasePlatform, RestoreEntity):
+class ModbusStructEntity(ModbusBaseEntity, RestoreEntity):
     """Base class representing a sensor/climate."""
 
     def __init__(self, hass: HomeAssistant, hub: ModbusHub, config: dict) -> None:
@@ -261,7 +261,7 @@ class BaseStructPlatform(BasePlatform, RestoreEntity):
         return self.__process_raw_value(val[0])
 
 
-class BaseSwitch(BasePlatform, ToggleEntity, RestoreEntity):
+class ModbusToggleEntity(ModbusBaseEntity, ToggleEntity, RestoreEntity):
     """Base class representing a Modbus switch."""
 
     def __init__(self, hass: HomeAssistant, hub: ModbusHub, config: dict) -> None:
@@ -323,7 +323,7 @@ class BaseSwitch(BasePlatform, ToggleEntity, RestoreEntity):
     async def async_turn(self, command: int) -> None:
         """Evaluate switch result."""
         result = await self._hub.async_pb_call(
-            self._slave, self._address, command, self._write_type
+            self._device_address, self._address, command, self._write_type
         )
         if result is None:
             self._attr_available = False
@@ -358,7 +358,7 @@ class BaseSwitch(BasePlatform, ToggleEntity, RestoreEntity):
 
         # do not allow multiple active calls to the same platform
         result = await self._hub.async_pb_call(
-            self._slave, self._verify_address, 1, self._verify_type
+            self._device_address, self._verify_address, 1, self._verify_type
         )
         if result is None:
             self._attr_available = False
@@ -379,7 +379,7 @@ class BaseSwitch(BasePlatform, ToggleEntity, RestoreEntity):
                         "Unexpected response from modbus device slave %s register %s,"
                         " got 0x%2x"
                     ),
-                    self._slave,
+                    self._device_address,
                     self._verify_address,
                     value,
                 )

homeassistant/components/modbus/fan.py

@@ -12,7 +12,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import get_hub
 from .const import CONF_FANS
-from .entity import BaseSwitch
+from .entity import ModbusToggleEntity
 from .modbus import ModbusHub
 
 PARALLEL_UPDATES = 1
@@ -31,7 +31,7 @@ async def async_setup_platform(
     async_add_entities(ModbusFan(hass, hub, config) for config in fans)
 
 
-class ModbusFan(BaseSwitch, FanEntity):
+class ModbusFan(ModbusToggleEntity, FanEntity):
     """Class representing a Modbus fan."""
 
     def __init__(

homeassistant/components/modbus/light.py

@@ -30,7 +30,7 @@ from .const import (
     LIGHT_MODBUS_SCALE_MAX,
     LIGHT_MODBUS_SCALE_MIN,
 )
-from .entity import BaseSwitch
+from .entity import ModbusToggleEntity
 from .modbus import ModbusHub
 
 PARALLEL_UPDATES = 1
@@ -49,7 +49,7 @@ async def async_setup_platform(
     async_add_entities(ModbusLight(hass, hub, config) for config in lights)
 
 
-class ModbusLight(BaseSwitch, LightEntity):
+class ModbusLight(ModbusToggleEntity, LightEntity):
     """Class representing a Modbus light."""
 
     def __init__(
@@ -117,7 +117,7 @@ class ModbusLight(BaseSwitch, LightEntity):
         conv_brightness = self._convert_brightness_to_modbus(brightness)
 
         await self._hub.async_pb_call(
-            unit=self._slave,
+            unit=self._device_address,
             address=self._brightness_address,
             value=conv_brightness,
             use_call=CALL_TYPE_WRITE_REGISTER,
@@ -133,7 +133,7 @@ class ModbusLight(BaseSwitch, LightEntity):
         conv_color_temp_kelvin = self._convert_color_temp_to_modbus(color_temp_kelvin)
 
         await self._hub.async_pb_call(
-            unit=self._slave,
+            unit=self._device_address,
             address=self._color_temp_address,
             value=conv_color_temp_kelvin,
             use_call=CALL_TYPE_WRITE_REGISTER,
@@ -150,7 +150,7 @@ class ModbusLight(BaseSwitch, LightEntity):
 
         if self._brightness_address:
             brightness_result = await self._hub.async_pb_call(
-                unit=self._slave,
+                unit=self._device_address,
                 value=1,
                 address=self._brightness_address,
                 use_call=CALL_TYPE_REGISTER_HOLDING,
@@ -167,7 +167,7 @@ class ModbusLight(BaseSwitch, LightEntity):
 
         if self._color_temp_address:
             color_result = await self._hub.async_pb_call(
-                unit=self._slave,
+                unit=self._device_address,
                 value=1,
                 address=self._color_temp_address,
                 use_call=CALL_TYPE_REGISTER_HOLDING,

homeassistant/components/modbus/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/modbus",
   "iot_class": "local_polling",
   "loggers": ["pymodbus"],
-  "requirements": ["pymodbus==3.11.1"]
+  "requirements": ["pymodbus==3.11.2"]
 }

homeassistant/components/modbus/modbus.py

@@ -56,7 +56,7 @@ from .const import (
     CONF_STOPBITS,
     DEFAULT_HUB,
     DEVICE_ID,
-    MODBUS_DOMAIN as DOMAIN,
+    DOMAIN,
     PLATFORMS,
     RTUOVERTCP,
     SERIAL,
@@ -169,43 +169,43 @@ async def async_modbus_setup(
 
     hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, async_stop_modbus)
 
+    def _get_service_call_details(
+        service: ServiceCall,
+    ) -> tuple[ModbusHub, int, int]:
+        """Return the details required to process the service call."""
+        device_address = service.data.get(ATTR_SLAVE, service.data.get(ATTR_UNIT, 1))
+        address = service.data[ATTR_ADDRESS]
+        hub = hub_collect[service.data[ATTR_HUB]]
+        return (hub, device_address, address)
+
     async def async_write_register(service: ServiceCall) -> None:
         """Write Modbus registers."""
-        slave = 1
-        if ATTR_UNIT in service.data:
-            slave = int(float(service.data[ATTR_UNIT]))
+        hub, device_address, address = _get_service_call_details(service)
 
-        if ATTR_SLAVE in service.data:
-            slave = int(float(service.data[ATTR_SLAVE]))
-        address = int(float(service.data[ATTR_ADDRESS]))
         value = service.data[ATTR_VALUE]
-        hub = hub_collect[service.data.get(ATTR_HUB, DEFAULT_HUB)]
         if isinstance(value, list):
             await hub.async_pb_call(
-                slave,
-                address,
-                [int(float(i)) for i in value],
-                CALL_TYPE_WRITE_REGISTERS,
+                device_address, address, value, CALL_TYPE_WRITE_REGISTERS
             )
         else:
             await hub.async_pb_call(
-                slave, address, int(float(value)), CALL_TYPE_WRITE_REGISTER
+                device_address, address, value, CALL_TYPE_WRITE_REGISTER
             )
 
     async def async_write_coil(service: ServiceCall) -> None:
         """Write Modbus coil."""
-        slave = 1
-        if ATTR_UNIT in service.data:
-            slave = int(float(service.data[ATTR_UNIT]))
-        if ATTR_SLAVE in service.data:
-            slave = int(float(service.data[ATTR_SLAVE]))
-        address = service.data[ATTR_ADDRESS]
+        hub, device_address, address = _get_service_call_details(service)
+
         state = service.data[ATTR_STATE]
-        hub = hub_collect[service.data.get(ATTR_HUB, DEFAULT_HUB)]
+
         if isinstance(state, list):
-            await hub.async_pb_call(slave, address, state, CALL_TYPE_WRITE_COILS)
+            await hub.async_pb_call(
+                device_address, address, state, CALL_TYPE_WRITE_COILS
+            )
         else:
-            await hub.async_pb_call(slave, address, state, CALL_TYPE_WRITE_COIL)
+            await hub.async_pb_call(
+                device_address, address, state, CALL_TYPE_WRITE_COIL
+            )
 
     for x_write in (
         (SERVICE_WRITE_REGISTER, async_write_register, ATTR_VALUE, cv.positive_int),
@@ -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]
@@ -362,16 +361,13 @@ class ModbusHub:
         if not self._connect_task.done():
             self._connect_task.cancel()
 
-        async with self._lock:
-            if self._client:
-                try:
-                    self._client.close()
-                except ModbusException as exception_error:
-                    self._log_error(str(exception_error))
-                del self._client
-                self._client = None
-                message = f"modbus {self.name} communication closed"
-                _LOGGER.info(message)
+        if self._client:
+            try:
+                self._client.close()
+            except ModbusException as exception_error:
+                self._log_error(str(exception_error))
+            self._client = None
+            _LOGGER.info(f"modbus {self.name} communication closed")
 
     async def low_level_pb_call(
         self, slave: int | None, address: int, value: int | list[int], use_call: str
@@ -417,11 +413,9 @@ class ModbusHub:
         use_call: str,
     ) -> ModbusPDU | None:
         """Convert async to sync pymodbus call."""
-        async with self._lock:
-            if not self._client:
-                return None
-            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
+        if not self._client:
+            return None
+        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/modbus/sensor.py

@@ -26,7 +26,7 @@ from homeassistant.helpers.update_coordinator import (
 
 from . import get_hub
 from .const import _LOGGER, CONF_SLAVE_COUNT, CONF_VIRTUAL_COUNT
-from .entity import BaseStructPlatform
+from .entity import ModbusStructEntity
 from .modbus import ModbusHub
 
 PARALLEL_UPDATES = 1
@@ -56,7 +56,7 @@ async def async_setup_platform(
     async_add_entities(sensors)
 
 
-class ModbusRegisterSensor(BaseStructPlatform, RestoreSensor, SensorEntity):
+class ModbusRegisterSensor(ModbusStructEntity, RestoreSensor, SensorEntity):
     """Modbus register sensor."""
 
     def __init__(
@@ -107,7 +107,7 @@ class ModbusRegisterSensor(BaseStructPlatform, RestoreSensor, SensorEntity):
     async def _async_update(self) -> None:
         """Update the state of the sensor."""
         raw_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 raw_result is None:
             self._attr_available = False

homeassistant/components/modbus/switch.py

@@ -11,7 +11,7 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import get_hub
-from .entity import BaseSwitch
+from .entity import ModbusToggleEntity
 
 PARALLEL_UPDATES = 1
 
@@ -29,7 +29,7 @@ async def async_setup_platform(
     async_add_entities(ModbusSwitch(hass, hub, config) for config in switches)
 
 
-class ModbusSwitch(BaseSwitch, SwitchEntity):
+class ModbusSwitch(ModbusToggleEntity, SwitchEntity):
     """Base class representing a Modbus switch."""
 
     async def async_turn_on(self, **kwargs: Any) -> None:

homeassistant/components/modbus/validators.py

@@ -36,7 +36,7 @@ from .const import (
     CONF_VIRTUAL_COUNT,
     DEFAULT_HUB,
     DEFAULT_SCAN_INTERVAL,
-    MODBUS_DOMAIN as DOMAIN,
+    DOMAIN,
     PLATFORMS,
     SERIAL,
     DataType,

homeassistant/components/monoprice/media_player.py

@@ -89,7 +89,7 @@ async def async_setup_entry(
             elif service_call.service == SERVICE_RESTORE:
                 entity.restore()
 
-    @service.verify_domain_control(hass, DOMAIN)
+    @service.verify_domain_control(DOMAIN)
     async def async_service_handle(service_call: core.ServiceCall) -> None:
         """Handle for services."""
         entities = await platform.async_extract_from_service(service_call)

homeassistant/components/motionmount/select.py

@@ -36,6 +36,7 @@ class MotionMountPresets(MotionMountEntity, SelectEntity):
 
     _attr_should_poll = True
     _attr_translation_key = "motionmount_preset"
+    _name_to_index: dict[str, int]
 
     def __init__(
         self,
@@ -50,8 +51,12 @@ class MotionMountPresets(MotionMountEntity, SelectEntity):
 
     def _update_options(self, presets: list[motionmount.Preset]) -> None:
         """Convert presets to select options."""
-        options = [f"{preset.index}: {preset.name}" for preset in presets]
-        options.insert(0, WALL_PRESET_NAME)
+        # Ordered list of options (wall first, then presets)
+        options = [WALL_PRESET_NAME] + [preset.name for preset in presets]
+
+        # Build mapping name → index (wall = 0)
+        self._name_to_index = {WALL_PRESET_NAME: 0}
+        self._name_to_index.update({preset.name: preset.index for preset in presets})
 
         self._attr_options = options
 
@@ -123,7 +128,10 @@ class MotionMountPresets(MotionMountEntity, SelectEntity):
 
     async def async_select_option(self, option: str) -> None:
         """Set the new option."""
-        index = int(option[:1])
+        index = self._name_to_index.get(option)
+        if index is None:
+            raise HomeAssistantError(f"Unknown preset selected: {option}")
+
         try:
             await self.mm.go_to_preset(index)
         except (TimeoutError, socket.gaierror) as ex:

homeassistant/components/motionmount/strings.json

@@ -83,7 +83,7 @@
       "motionmount_preset": {
         "name": "Preset",
         "state": {
-          "0_wall": "0: Wall"
+          "0_wall": "Wall"
         }
       }
     }

homeassistant/components/motionmount/translations/ru.json

@@ -68,7 +68,10 @@
         },
         "select": {
             "motionmount_preset": {
-                "name": "\u041f\u0440\u0435\u0434\u0443\u0441\u0442\u0430\u043d\u043e\u0432\u043a\u0430"
+                "name": "\u041f\u0440\u0435\u0434\u0443\u0441\u0442\u0430\u043d\u043e\u0432\u043a\u0430",
+                "state": {
+                    "0_wall": "\u0421\u0442\u0435\u043d\u0430"
+                }
             }
         },
         "sensor": {

homeassistant/components/mqtt/abbreviations.py

@@ -41,6 +41,7 @@ ABBREVIATIONS = {
     "curr_hum_tpl": "current_humidity_template",
     "curr_temp_t": "current_temperature_topic",
     "curr_temp_tpl": "current_temperature_template",
+    "def_ent_id": "default_entity_id",
     "dev": "device",
     "dev_cla": "device_class",
     "dir_cmd_t": "direction_command_topic",