Use shorthand attributes for Elkm1 (#99275)

homeassistant/components/elkm1/climate.py

@@ -5,7 +5,6 @@ from typing import Any
 
 from elkm1_lib.const import ThermostatFan, ThermostatMode, ThermostatSetting
 from elkm1_lib.elements import Element
-from elkm1_lib.elk import Elk
 from elkm1_lib.thermostats import Thermostat
 
 from homeassistant.components.climate import (
@@ -80,13 +79,14 @@ class ElkThermostat(ElkEntity, ClimateEntity):
         | ClimateEntityFeature.AUX_HEAT
         | ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
     )
+    _attr_min_temp = 1
+    _attr_max_temp = 99
+    _attr_hvac_modes = SUPPORT_HVAC
+    _attr_hvac_mode: HVACMode | None = None
+    _attr_target_temperature_step = 1
+    _attr_fan_modes = [FAN_AUTO, FAN_ON]
     _element: Thermostat
 
-    def __init__(self, element: Element, elk: Elk, elk_data: dict[str, Any]) -> None:
-        """Initialize climate entity."""
-        super().__init__(element, elk, elk_data)
-        self._state: HVACMode | None = None
-
     @property
     def temperature_unit(self) -> str:
         """Return the temperature unit."""
@@ -119,41 +119,16 @@ class ElkThermostat(ElkEntity, ClimateEntity):
         """Return the low target temperature."""
         return self._element.heat_setpoint
 
-    @property
-    def target_temperature_step(self) -> float:
-        """Return the supported step of target temperature."""
-        return 1
-
     @property
     def current_humidity(self) -> int | None:
         """Return the current humidity."""
         return self._element.humidity
 
-    @property
-    def hvac_mode(self) -> HVACMode | None:
-        """Return current operation ie. heat, cool, idle."""
-        return self._state
-
-    @property
-    def hvac_modes(self) -> list[HVACMode]:
-        """Return the list of available operation modes."""
-        return SUPPORT_HVAC
-
     @property
     def is_aux_heat(self) -> bool:
         """Return if aux heater is on."""
         return self._element.mode == ThermostatMode.EMERGENCY_HEAT
 
-    @property
-    def min_temp(self) -> float:
-        """Return the minimum temperature supported."""
-        return 1
-
-    @property
-    def max_temp(self) -> float:
-        """Return the maximum temperature supported."""
-        return 99
-
     @property
     def fan_mode(self) -> str | None:
         """Return the fan setting."""
@@ -180,11 +155,6 @@ class ElkThermostat(ElkEntity, ClimateEntity):
         """Turn auxiliary heater off."""
         self._elk_set(ThermostatMode.HEAT, None)
 
-    @property
-    def fan_modes(self) -> list[str]:
-        """Return the list of available fan modes."""
-        return [FAN_AUTO, FAN_ON]
-
     async def async_set_fan_mode(self, fan_mode: str) -> None:
         """Set new target fan mode."""
         thermostat_mode, elk_fan_mode = HASS_TO_ELK_FAN_MODES[fan_mode]
@@ -201,8 +171,11 @@ class ElkThermostat(ElkEntity, ClimateEntity):
 
     def _element_changed(self, element: Element, changeset: Any) -> None:
         if self._element.mode is None:
-            self._state = None
+            self._attr_hvac_mode = None
         else:
-            self._state = ELK_TO_HASS_HVAC_MODES[self._element.mode]
+            self._attr_hvac_mode = ELK_TO_HASS_HVAC_MODES[self._element.mode]
-            if self._state == HVACMode.OFF and self._element.fan == ThermostatFan.ON:
+            if (
-                self._state = HVACMode.FAN_ONLY
+                self._attr_hvac_mode == HVACMode.OFF
+                and self._element.fan == ThermostatFan.ON
+            ):
+                self._attr_hvac_mode = HVACMode.FAN_ONLY

homeassistant/components/elkm1/sensor.py

@@ -6,7 +6,6 @@ from typing import Any
 from elkm1_lib.const import SettingFormat, ZoneType
 from elkm1_lib.counters import Counter
 from elkm1_lib.elements import Element
-from elkm1_lib.elk import Elk
 from elkm1_lib.keypads import Keypad
 from elkm1_lib.panel import Panel
 from elkm1_lib.settings import Setting
@@ -84,15 +83,7 @@ def temperature_to_state(temperature: int, undefined_temperature: int) -> str |
 class ElkSensor(ElkAttachedEntity, SensorEntity):
     """Base representation of Elk-M1 sensor."""
 
-    def __init__(self, element: Element, elk: Elk, elk_data: dict[str, Any]) -> None:
+    _attr_native_value: str | None = None
-        """Initialize the base of all Elk sensors."""
-        super().__init__(element, elk, elk_data)
-        self._state: str | None = None
-
-    @property
-    def native_value(self) -> str | None:
-        """Return the state of the sensor."""
-        return self._state
 
     async def async_counter_refresh(self) -> None:
         """Refresh the value of a counter from the panel."""
@@ -124,20 +115,17 @@ class ElkSensor(ElkAttachedEntity, SensorEntity):
 class ElkCounter(ElkSensor):
     """Representation of an Elk-M1 Counter."""
 
+    _attr_icon = "mdi:numeric"
     _element: Counter
 
-    @property
-    def icon(self) -> str:
-        """Icon to use in the frontend."""
-        return "mdi:numeric"
-
     def _element_changed(self, _: Element, changeset: Any) -> None:
-        self._state = self._element.value
+        self._attr_native_value = self._element.value
 
 
 class ElkKeypad(ElkSensor):
     """Representation of an Elk-M1 Keypad."""
 
+    _attr_icon = "mdi:thermometer-lines"
     _element: Keypad
 
     @property
@@ -150,17 +138,12 @@ class ElkKeypad(ElkSensor):
         """Return the unit of measurement."""
         return self._temperature_unit
 
-    @property
-    def icon(self) -> str:
-        """Icon to use in the frontend."""
-        return "mdi:thermometer-lines"
-
     @property
     def extra_state_attributes(self) -> dict[str, Any]:
         """Attributes of the sensor."""
         attrs: dict[str, Any] = self.initial_attrs()
         attrs["area"] = self._element.area + 1
-        attrs["temperature"] = self._state
+        attrs["temperature"] = self._attr_native_value
         attrs["last_user_time"] = self._element.last_user_time.isoformat()
         attrs["last_user"] = self._element.last_user + 1
         attrs["code"] = self._element.code
@@ -169,7 +152,7 @@ class ElkKeypad(ElkSensor):
         return attrs
 
     def _element_changed(self, _: Element, changeset: Any) -> None:
-        self._state = temperature_to_state(
+        self._attr_native_value = temperature_to_state(
             self._element.temperature, UNDEFINED_TEMPERATURE
         )
 
@@ -177,14 +160,10 @@ class ElkKeypad(ElkSensor):
 class ElkPanel(ElkSensor):
     """Representation of an Elk-M1 Panel."""
 
+    _attr_icon = "mdi:home"
     _attr_entity_category = EntityCategory.DIAGNOSTIC
     _element: Panel
 
-    @property
-    def icon(self) -> str:
-        """Icon to use in the frontend."""
-        return "mdi:home"
-
     @property
     def extra_state_attributes(self) -> dict[str, Any]:
         """Attributes of the sensor."""
@@ -194,25 +173,21 @@ class ElkPanel(ElkSensor):
 
     def _element_changed(self, _: Element, changeset: Any) -> None:
         if self._elk.is_connected():
-            self._state = (
+            self._attr_native_value = (
                 "Paused" if self._element.remote_programming_status else "Connected"
             )
         else:
-            self._state = "Disconnected"
+            self._attr_native_value = "Disconnected"
 
 
 class ElkSetting(ElkSensor):
     """Representation of an Elk-M1 Setting."""
 
+    _attr_icon = "mdi:numeric"
     _element: Setting
 
-    @property
-    def icon(self) -> str:
-        """Icon to use in the frontend."""
-        return "mdi:numeric"
-
     def _element_changed(self, _: Element, changeset: Any) -> None:
-        self._state = self._element.value
+        self._attr_native_value = self._element.value
 
     @property
     def extra_state_attributes(self) -> dict[str, Any]:
@@ -282,10 +257,10 @@ class ElkZone(ElkSensor):
 
     def _element_changed(self, _: Element, changeset: Any) -> None:
         if self._element.definition == ZoneType.TEMPERATURE:
-            self._state = temperature_to_state(
+            self._attr_native_value = temperature_to_state(
                 self._element.temperature, UNDEFINED_TEMPERATURE
             )
         elif self._element.definition == ZoneType.ANALOG_ZONE:
-            self._state = f"{self._element.voltage}"
+            self._attr_native_value = f"{self._element.voltage}"
         else:
-            self._state = pretty_const(self._element.logical_status.name)
+            self._attr_native_value = pretty_const(self._element.logical_status.name)