Modernize entity state via _attr_ pattern instead of @Property (#120)

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: skynet <tim@bond.casa>

Author: shbatm

custom_components/isy994/climate.py

@@ -160,11 +160,6 @@ def current_temperature(self) -> float | None:
             self._node.status, self._uom, self._node.precision, 1
         )
 
-    @property
-    def target_temperature_step(self) -> float | None:
-        """Return the supported step of target temperature."""
-        return 1.0
-
     @property
     def target_temperature(self) -> float | None:
         """Return the temperature we try to reach."""
@@ -190,11 +185,6 @@ def target_temperature_low(self) -> float | None:
             return None
         return convert_isy_value_to_hass(target.value, target.uom, target.precision, 1)
 
-    @property
-    def fan_modes(self) -> list[str]:
-        """Return the list of available fan modes."""
-        return [FAN_AUTO, FAN_ON]
-
     @property
     def fan_mode(self) -> str:
         """Return the current fan mode ie. auto, on."""

custom_components/isy994/cover.py

@@ -10,15 +10,15 @@
     CoverEntityFeature,
 )
 from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from pyisyox.nodes import Node
 from pyisyox.programs import Program
 
 from .const import UOM_8_BIT_RANGE
-from .entity import ISYNodeEntity, ISYProgramEntity
+from .entity import ISYNodeEntity, ISYProgramEntity, NodeEventType
 from .models import IsyConfigEntry
 
 
@@ -52,21 +52,31 @@ class ISYCoverEntity(ISYNodeEntity, CoverEntity):
     )
     _node: Node
 
-    @property
-    def current_cover_position(self) -> int | None:
-        """Return the current cover position."""
+    def _update_cover_attrs(self) -> None:
         if self._node.status is None:
-            return None
+            self._attr_current_cover_position = None
+            self._attr_is_closed = None
+            return
         if self._node.uom == UOM_8_BIT_RANGE:
-            return round(cast(float, self._node.status) * 100.0 / 255.0)
-        return int(sorted((0, self._node.status, 100))[1])
+            self._attr_current_cover_position = round(
+                cast(float, self._node.status) * 100.0 / 255.0
+            )
+        else:
+            self._attr_current_cover_position = int(
+                sorted((0, self._node.status, 100))[1]
+            )
+        self._attr_is_closed = bool(self._node.status == 0)
 
-    @property
-    def is_closed(self) -> bool | None:
-        """Get whether the ISY cover device is closed."""
-        if self._node.status is None:
-            return None
-        return bool(self._node.status == 0)
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to events and set initial state."""
+        await super().async_added_to_hass()
+        self._update_cover_attrs()
+
+    @callback
+    def async_on_update(self, event: NodeEventType, key: str) -> None:
+        """Handle a control event from the ISY Node."""
+        self._update_cover_attrs()
+        super().async_on_update(event, key)
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Send the open cover command to the ISY cover device."""
@@ -94,10 +104,16 @@ class ISYCoverProgramEntity(ISYProgramEntity, CoverEntity):
 
     _actions: Program
 
-    @property
-    def is_closed(self) -> bool:
-        """Get whether the ISY cover program is closed."""
-        return bool(self._node.status)
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to events and set initial state."""
+        await super().async_added_to_hass()
+        self._attr_is_closed = bool(self._node.status)
+
+    @callback
+    def async_on_update(self, event: NodeEventType, key: str) -> None:
+        """Handle the update event from the ISY Node."""
+        self._attr_is_closed = bool(self._node.status)
+        super().async_on_update(event, key)
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Send the open cover command to the ISY cover program."""

custom_components/isy994/entity.py

@@ -121,6 +121,7 @@ def __init__(
             self._attr_has_entity_name = True
 
         self._attr_name = name
+        self._attr_available = node.enabled
 
     async def async_added_to_hass(self) -> None:
         """Subscribe to the node control change events."""
@@ -146,13 +147,9 @@ async def async_will_remove_from_hass(self) -> None:
     @callback
     def async_on_update(self, event: NodeEventType, key: str) -> None:
         """Handle a control event from the ISY Node."""
+        self._attr_available = self._node.enabled
         self.async_write_ha_state()
 
-    @property
-    def available(self) -> bool:
-        """Return entity availability."""
-        return self._node.enabled
-
     async def async_send_node_command(self, command: str) -> None:
         """Respond to an entity service command call."""
         if not hasattr(self._node, command):

custom_components/isy994/fan.py

@@ -7,7 +7,7 @@
 
 from homeassistant.components.fan import FanEntity, FanEntityFeature
 from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.util.percentage import (
@@ -20,7 +20,7 @@
 from pyisyox.programs import Program
 
 from .const import _LOGGER
-from .entity import ISYNodeEntity, ISYProgramEntity
+from .entity import ISYNodeEntity, ISYProgramEntity, NodeEventType
 from .models import IsyConfigEntry
 
 SPEED_RANGE = (1, 255)  # off is not included
@@ -57,26 +57,33 @@ class ISYFanEntity(ISYNodeEntity, FanEntity):
     )
     _node: Node
 
-    @property
-    def percentage(self) -> int | None:
-        """Return the current speed percentage."""
-        if self._node.status is None:
-            return None
-        return ranged_value_to_percentage(SPEED_RANGE, self._node.status)
-
-    @property
-    def speed_count(self) -> int:
-        """Return the number of speeds the fan supports."""
-        if self._node.protocol == Protocol.INSTEON:
-            return 3
-        return int_states_in_range(SPEED_RANGE)
-
-    @property
-    def is_on(self) -> bool | None:
-        """Get if the fan is on."""
+    def __init__(self, node: Node, device_info: DeviceInfo | None = None) -> None:
+        """Initialize the ISY fan entity."""
+        super().__init__(node=node, device_info=device_info)
+        self._attr_speed_count = (
+            3 if node.protocol == Protocol.INSTEON else int_states_in_range(SPEED_RANGE)
+        )
+
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to events and set initial state."""
+        await super().async_added_to_hass()
+        self._update_fan_attrs()
+
+    def _update_fan_attrs(self) -> None:
         if self._node.status is None:
-            return None
-        return bool(self._node.status != 0)
+            self._attr_is_on = None
+            self._attr_percentage = None
+        else:
+            self._attr_is_on = bool(self._node.status != 0)
+            self._attr_percentage = ranged_value_to_percentage(
+                SPEED_RANGE, self._node.status
+            )
+
+    @callback
+    def async_on_update(self, event: NodeEventType, key: str) -> None:
+        """Handle a control event from the ISY Node."""
+        self._update_fan_attrs()
+        super().async_on_update(event, key)
 
     async def async_set_percentage(self, percentage: int) -> None:
         """Set node to speed percentage for the ISY fan device."""
@@ -106,24 +113,29 @@ class ISYFanProgramEntity(ISYProgramEntity, FanEntity):
     """Representation of an ISY fan program."""
 
     _attr_supported_features = FanEntityFeature.TURN_OFF | FanEntityFeature.TURN_ON
+    _attr_speed_count = int_states_in_range(SPEED_RANGE)
     _actions: Program
 
-    @property
-    def percentage(self) -> int | None:
-        """Return the current speed percentage."""
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to events and set initial state."""
+        await super().async_added_to_hass()
+        self._update_fan_attrs()
+
+    def _update_fan_attrs(self) -> None:
         if self._node.status is None:
-            return None
-        return ranged_value_to_percentage(SPEED_RANGE, float(self._node.status))
-
-    @property
-    def speed_count(self) -> int:
-        """Return the number of speeds the fan supports."""
-        return int_states_in_range(SPEED_RANGE)
-
-    @property
-    def is_on(self) -> bool:
-        """Get if the fan is on."""
-        return bool(self._node.status != 0)
+            self._attr_is_on = None
+            self._attr_percentage = None
+        else:
+            self._attr_is_on = bool(self._node.status != 0)
+            self._attr_percentage = ranged_value_to_percentage(
+                SPEED_RANGE, float(self._node.status)
+            )
+
+    @callback
+    def async_on_update(self, event: NodeEventType, key: str) -> None:
+        """Handle the update event from the ISY Node."""
+        self._update_fan_attrs()
+        super().async_on_update(event, key)
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Send the turn on command to ISY fan program."""

custom_components/isy994/lock.py

@@ -6,14 +6,14 @@
 
 from homeassistant.components.lock import LockEntity
 from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from pyisyox.nodes import Node
 from pyisyox.programs import Program
 
-from .entity import ISYNodeEntity, ISYProgramEntity
+from .entity import ISYNodeEntity, ISYProgramEntity, NodeEventType
 from .models import IsyConfigEntry
 from .services import async_setup_lock_services
 
@@ -46,12 +46,22 @@ class ISYLockEntity(ISYNodeEntity, LockEntity):
 
     _node: Node
 
-    @property
-    def is_locked(self) -> bool | None:
-        """Get whether the lock is in locked state."""
-        if self._node.status is None:
-            return None
-        return VALUE_TO_STATE.get(self._node.status)
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to events and set initial state."""
+        await super().async_added_to_hass()
+        status = self._node.status
+        self._attr_is_locked = (
+            VALUE_TO_STATE.get(status) if status is not None else None
+        )
+
+    @callback
+    def async_on_update(self, event: NodeEventType, key: str) -> None:
+        """Handle a control event from the ISY Node."""
+        status = self._node.status
+        self._attr_is_locked = (
+            VALUE_TO_STATE.get(status) if status is not None else None
+        )
+        super().async_on_update(event, key)
 
     async def async_lock(self, **kwargs: Any) -> None:
         """Send the lock command to the ISY device."""
@@ -83,10 +93,16 @@ class ISYLockProgramEntity(ISYProgramEntity, LockEntity):
 
     _actions: Program
 
-    @property
-    def is_locked(self) -> bool:
-        """Return true if the device is locked."""
-        return bool(self._node.status)
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to events and set initial state."""
+        await super().async_added_to_hass()
+        self._attr_is_locked = bool(self._node.status)
+
+    @callback
+    def async_on_update(self, event: NodeEventType, key: str) -> None:
+        """Handle the update event from the ISY Node."""
+        self._attr_is_locked = bool(self._node.status)
+        super().async_on_update(event, key)
 
     async def async_lock(self, **kwargs: Any) -> None:
         """Lock the device."""

custom_components/isy994/switch.py

@@ -11,15 +11,15 @@
     SwitchEntityDescription,
 )
 from homeassistant.const import EntityCategory, Platform
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from pyisyox.nodes import Group, Node
 from pyisyox.nodes.nodebase import NodeBase
 from pyisyox.programs import Program
 
-from .entity import ISYGroupEntity, ISYNodeEntity, ISYProgramEntity
+from .entity import ISYGroupEntity, ISYNodeEntity, ISYProgramEntity, NodeEventType
 from .models import IsyConfigEntry
 
 
@@ -165,11 +165,13 @@ def __init__(
             device_info=device_info,
         )
         self._attr_name = description.name  # Override super
+        # Always available; must follow super().__init__ which sets node.enabled
+        self._attr_available = True
 
-    @property
-    def available(self) -> bool:
-        """Return entity availability."""
-        return True  # Enable switch is always available
+    @callback
+    def async_on_update(self, event: NodeEventType, key: str) -> None:
+        """Handle a control event — availability is always True for enable switches."""
+        self.async_write_ha_state()
 
     @property
     def is_on(self) -> bool | None: