Refactor Satel Integra platforms to use shared base entity (#156499)

2025-12-24 12:59:34 +00:00 · 2025-11-13 12:20:32 +01:00
parent 49e050cc60
commit c2d462c1e7
4 changed files with 119 additions and 84 deletions
--- a/homeassistant/components/satel_integra/alarm_control_panel.py
+++ b/homeassistant/components/satel_integra/alarm_control_panel.py
@@ -13,20 +13,19 @@ from homeassistant.components.alarm_control_panel import (
    AlarmControlPanelState,
    CodeFormat,
 )
-from homeassistant.const import CONF_NAME
+from homeassistant.config_entries import ConfigSubentry
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

 from .const import (
    CONF_ARM_HOME_MODE,
    CONF_PARTITION_NUMBER,
-    DOMAIN,
    SIGNAL_PANEL_MESSAGE,
    SUBENTRY_TYPE_PARTITION,
    SatelConfigEntry,
 )
+from .entity import SatelIntegraEntity

 ALARM_STATE_MAP = {
    AlarmState.TRIGGERED: AlarmControlPanelState.TRIGGERED,
@@ -59,54 +58,49 @@ async def async_setup_entry(

    for subentry in partition_subentries:
        partition_num: int = subentry.data[CONF_PARTITION_NUMBER]
-        zone_name: str = subentry.data[CONF_NAME]
        arm_home_mode: int = subentry.data[CONF_ARM_HOME_MODE]

        async_add_entities(
            [
                SatelIntegraAlarmPanel(
                    controller,
-                    zone_name,
-                    arm_home_mode,
-                    partition_num,
                    config_entry.entry_id,
+                    subentry,
+                    partition_num,
+                    arm_home_mode,
                )
            ],
            config_subentry_id=subentry.subentry_id,
        )


-class SatelIntegraAlarmPanel(AlarmControlPanelEntity):
+class SatelIntegraAlarmPanel(SatelIntegraEntity, AlarmControlPanelEntity):
    """Representation of an AlarmDecoder-based alarm panel."""

    _attr_code_format = CodeFormat.NUMBER
-    _attr_should_poll = False
    _attr_supported_features = (
        AlarmControlPanelEntityFeature.ARM_HOME
        | AlarmControlPanelEntityFeature.ARM_AWAY
    )

-    _attr_has_entity_name = True
-    _attr_name = None
-
    def __init__(
        self,
        controller: AsyncSatel,
-        device_name: str,
-        arm_home_mode: int,
-        partition_id: int,
        config_entry_id: str,
+        subentry: ConfigSubentry,
+        device_number: int,
+        arm_home_mode: int,
    ) -> None:
        """Initialize the alarm panel."""
-        self._attr_unique_id = f"{config_entry_id}_alarm_panel_{partition_id}"
-        self._arm_home_mode = arm_home_mode
-        self._partition_id = partition_id
-        self._satel = controller
-
-        self._attr_device_info = DeviceInfo(
-            name=device_name, identifiers={(DOMAIN, self._attr_unique_id)}
+        super().__init__(
+            controller,
+            config_entry_id,
+            subentry,
+            device_number,
        )

+        self._arm_home_mode = arm_home_mode
+
    async def async_added_to_hass(self) -> None:
        """Update alarm status and register callbacks for future updates."""
        self._attr_alarm_state = self._read_alarm_state()
@@ -136,7 +130,7 @@ class SatelIntegraAlarmPanel(AlarmControlPanelEntity):
        for satel_state, ha_state in ALARM_STATE_MAP.items():
            if (
                satel_state in self._satel.partition_states
-                and self._partition_id in self._satel.partition_states[satel_state]
+                and self._device_number in self._satel.partition_states[satel_state]
            ):
                return ha_state

@@ -152,21 +146,21 @@ class SatelIntegraAlarmPanel(AlarmControlPanelEntity):
            self._attr_alarm_state == AlarmControlPanelState.TRIGGERED
        )

-        await self._satel.disarm(code, [self._partition_id])
+        await self._satel.disarm(code, [self._device_number])

        if clear_alarm_necessary:
            # Wait 1s before clearing the alarm
            await asyncio.sleep(1)
-            await self._satel.clear_alarm(code, [self._partition_id])
+            await self._satel.clear_alarm(code, [self._device_number])

    async def async_alarm_arm_away(self, code: str | None = None) -> None:
        """Send arm away command."""

        if code:
-            await self._satel.arm(code, [self._partition_id])
+            await self._satel.arm(code, [self._device_number])

    async def async_alarm_arm_home(self, code: str | None = None) -> None:
        """Send arm home command."""

        if code:
-            await self._satel.arm(code, [self._partition_id], self._arm_home_mode)
+            await self._satel.arm(code, [self._device_number], self._arm_home_mode)
--- a/homeassistant/components/satel_integra/binary_sensor.py
+++ b/homeassistant/components/satel_integra/binary_sensor.py
@@ -8,25 +8,22 @@ from homeassistant.components.binary_sensor import (
    BinarySensorDeviceClass,
    BinarySensorEntity,
 )
-from homeassistant.const import CONF_NAME
+from homeassistant.config_entries import ConfigSubentry
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

 from .const import (
    CONF_OUTPUT_NUMBER,
-    CONF_OUTPUTS,
    CONF_ZONE_NUMBER,
    CONF_ZONE_TYPE,
-    CONF_ZONES,
-    DOMAIN,
    SIGNAL_OUTPUTS_UPDATED,
    SIGNAL_ZONES_UPDATED,
    SUBENTRY_TYPE_OUTPUT,
    SUBENTRY_TYPE_ZONE,
    SatelConfigEntry,
 )
+from .entity import SatelIntegraEntity


 async def async_setup_entry(
@@ -46,18 +43,16 @@ async def async_setup_entry(
    for subentry in zone_subentries:
        zone_num: int = subentry.data[CONF_ZONE_NUMBER]
        zone_type: BinarySensorDeviceClass = subentry.data[CONF_ZONE_TYPE]
-        zone_name: str = subentry.data[CONF_NAME]

        async_add_entities(
            [
                SatelIntegraBinarySensor(
                    controller,
-                    zone_num,
-                    zone_name,
-                    zone_type,
-                    CONF_ZONES,
-                    SIGNAL_ZONES_UPDATED,
                    config_entry.entry_id,
+                    subentry,
+                    zone_num,
+                    zone_type,
+                    SIGNAL_ZONES_UPDATED,
                )
            ],
            config_subentry_id=subentry.subentry_id,
@@ -71,51 +66,44 @@ async def async_setup_entry(
    for subentry in output_subentries:
        output_num: int = subentry.data[CONF_OUTPUT_NUMBER]
        ouput_type: BinarySensorDeviceClass = subentry.data[CONF_ZONE_TYPE]
-        output_name: str = subentry.data[CONF_NAME]

        async_add_entities(
            [
                SatelIntegraBinarySensor(
                    controller,
-                    output_num,
-                    output_name,
-                    ouput_type,
-                    CONF_OUTPUTS,
-                    SIGNAL_OUTPUTS_UPDATED,
                    config_entry.entry_id,
+                    subentry,
+                    output_num,
+                    ouput_type,
+                    SIGNAL_OUTPUTS_UPDATED,
                )
            ],
            config_subentry_id=subentry.subentry_id,
        )


-class SatelIntegraBinarySensor(BinarySensorEntity):
+class SatelIntegraBinarySensor(SatelIntegraEntity, BinarySensorEntity):
    """Representation of an Satel Integra binary sensor."""

-    _attr_should_poll = False
-    _attr_has_entity_name = True
-    _attr_name = None
-
    def __init__(
        self,
        controller: AsyncSatel,
-        device_number: int,
-        device_name: str,
-        device_class: BinarySensorDeviceClass,
-        sensor_type: str,
-        react_to_signal: str,
        config_entry_id: str,
+        subentry: ConfigSubentry,
+        device_number: int,
+        device_class: BinarySensorDeviceClass,
+        react_to_signal: str,
    ) -> None:
        """Initialize the binary_sensor."""
-        self._device_number = device_number
-        self._attr_unique_id = f"{config_entry_id}_{sensor_type}_{device_number}"
-        self._react_to_signal = react_to_signal
-        self._satel = controller
+        super().__init__(
+            controller,
+            config_entry_id,
+            subentry,
+            device_number,
+        )

        self._attr_device_class = device_class
-        self._attr_device_info = DeviceInfo(
-            name=device_name, identifiers={(DOMAIN, self._attr_unique_id)}
-        )
+        self._react_to_signal = react_to_signal

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

 from homeassistant.components.switch import SwitchEntity
-from homeassistant.const import CONF_CODE, CONF_NAME
+from homeassistant.config_entries import ConfigSubentry
+from homeassistant.const import CONF_CODE
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

 from .const import (
    CONF_SWITCHABLE_OUTPUT_NUMBER,
-    DOMAIN,
    SIGNAL_OUTPUTS_UPDATED,
    SUBENTRY_TYPE_SWITCHABLE_OUTPUT,
    SatelConfigEntry,
 )
+from .entity import SatelIntegraEntity


 async def async_setup_entry(
@@ -38,47 +38,42 @@ async def async_setup_entry(

    for subentry in switchable_output_subentries:
        switchable_output_num: int = subentry.data[CONF_SWITCHABLE_OUTPUT_NUMBER]
-        switchable_output_name: str = subentry.data[CONF_NAME]

        async_add_entities(
            [
                SatelIntegraSwitch(
                    controller,
-                    switchable_output_num,
-                    switchable_output_name,
-                    config_entry.options.get(CONF_CODE),
                    config_entry.entry_id,
+                    subentry,
+                    switchable_output_num,
+                    config_entry.options.get(CONF_CODE),
                ),
            ],
            config_subentry_id=subentry.subentry_id,
        )


-class SatelIntegraSwitch(SwitchEntity):
-    """Representation of an Satel switch."""
-
-    _attr_should_poll = False
-    _attr_has_entity_name = True
-    _attr_name = None
+class SatelIntegraSwitch(SatelIntegraEntity, SwitchEntity):
+    """Representation of an Satel Integra switch."""

    def __init__(
        self,
        controller: AsyncSatel,
-        device_number: int,
-        device_name: str,
-        code: str | None,
        config_entry_id: str,
+        subentry: ConfigSubentry,
+        device_number: int,
+        code: str | None,
    ) -> None:
        """Initialize the switch."""
-        self._device_number = device_number
-        self._attr_unique_id = f"{config_entry_id}_switch_{device_number}"
-        self._code = code
-        self._satel = controller
-
-        self._attr_device_info = DeviceInfo(
-            name=device_name, identifiers={(DOMAIN, self._attr_unique_id)}
+        super().__init__(
+            controller,
+            config_entry_id,
+            subentry,
+            device_number,
        )

+        self._code = code
+
    async def async_added_to_hass(self) -> None:
        """Register callbacks."""
        self._attr_is_on = self._device_number in self._satel.violated_outputs