Improve type hint in flexit climate entity (#77159)

homeassistant/components/flexit/climate.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import logging
+from typing import Any
 
 import voluptuous as vol
 
@@ -60,35 +61,36 @@ class Flexit(ClimateEntity):
     """Representation of a Flexit AC unit."""
 
     _attr_fan_modes = ["Off", "Low", "Medium", "High"]
+    _attr_hvac_mode = HVACMode.COOL
+    _attr_hvac_modes = [HVACMode.COOL]
     _attr_supported_features = (
         ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.FAN_MODE
     )
+    _attr_temperature_unit = TEMP_CELSIUS
 
     def __init__(
         self, hub: ModbusHub, modbus_slave: int | None, name: str | None
     ) -> None:
         """Initialize the unit."""
         self._hub = hub
-        self._name = name
+        self._attr_name = name
         self._slave = modbus_slave
-        self._target_temperature = None
-        self._current_temperature = None
         self._attr_fan_mode = None
-        self._filter_hours = None
+        self._filter_hours: int | None = None
-        self._filter_alarm = None
+        self._filter_alarm: int | None = None
-        self._heat_recovery = None
+        self._heat_recovery: int | None = None
-        self._heater_enabled = False
+        self._heater_enabled: int | None = None
-        self._heating = None
+        self._heating: int | None = None
-        self._cooling = None
+        self._cooling: int | None = None
         self._alarm = False
-        self._outdoor_air_temp = None
+        self._outdoor_air_temp: float | None = None
 
-    async def async_update(self):
+    async def async_update(self) -> None:
         """Update unit attributes."""
-        self._target_temperature = await self._async_read_temp_from_register(
+        self._attr_target_temperature = await self._async_read_temp_from_register(
             CALL_TYPE_REGISTER_HOLDING, 8
         )
-        self._current_temperature = await self._async_read_temp_from_register(
+        self._attr_current_temperature = await self._async_read_temp_from_register(
             CALL_TYPE_REGISTER_INPUT, 9
         )
         res = await self._async_read_int16_from_register(CALL_TYPE_REGISTER_HOLDING, 17)
@@ -137,7 +139,7 @@ class Flexit(ClimateEntity):
             self._attr_hvac_action = HVACAction.OFF
 
     @property
-    def extra_state_attributes(self):
+    def extra_state_attributes(self) -> dict[str, Any]:
         """Return device specific state attributes."""
         return {
             "filter_hours": self._filter_hours,
@@ -149,54 +151,14 @@ class Flexit(ClimateEntity):
             "outdoor_air_temp": self._outdoor_air_temp,
         }
 
-    @property
+    async def async_set_temperature(self, **kwargs: Any) -> None:
-    def should_poll(self):
-        """Return the polling state."""
-        return True
-
-    @property
-    def name(self):
-        """Return the name of the climate device."""
-        return self._name
-
-    @property
-    def temperature_unit(self):
-        """Return the unit of measurement."""
-        return TEMP_CELSIUS
-
-    @property
-    def current_temperature(self):
-        """Return the current temperature."""
-        return self._current_temperature
-
-    @property
-    def target_temperature(self):
-        """Return the temperature we try to reach."""
-        return self._target_temperature
-
-    @property
-    def hvac_mode(self):
-        """Return current operation ie. heat, cool, idle."""
-        return HVACMode.COOL
-
-    @property
-    def hvac_modes(self) -> list[str]:
-        """Return the list of available hvac operation modes.
-
-        Need to be a subset of HVAC_MODES.
-        """
-        return [HVACMode.COOL]
-
-    async def async_set_temperature(self, **kwargs):
         """Set new target temperature."""
-        if kwargs.get(ATTR_TEMPERATURE) is not None:
+        if (target_temperature := kwargs.get(ATTR_TEMPERATURE)) is None:
-            target_temperature = kwargs.get(ATTR_TEMPERATURE)
-        else:
             _LOGGER.error("Received invalid temperature")
             return
 
-        if await self._async_write_int16_to_register(8, target_temperature * 10):
+        if await self._async_write_int16_to_register(8, int(target_temperature * 10)):
-            self._target_temperature = target_temperature
+            self._attr_target_temperature = target_temperature
         else:
             _LOGGER.error("Modbus error setting target temperature to Flexit")
 
@@ -210,7 +172,9 @@ class Flexit(ClimateEntity):
             _LOGGER.error("Modbus error setting fan mode to Flexit")
 
     # Based on _async_read_register in ModbusThermostat class
-    async def _async_read_int16_from_register(self, register_type, register) -> int:
+    async def _async_read_int16_from_register(
+        self, register_type: str, register: int
+    ) -> int:
         """Read register using the Modbus hub slave."""
         result = await self._hub.async_pymodbus_call(
             self._slave, register, 1, register_type
@@ -221,7 +185,9 @@ class Flexit(ClimateEntity):
 
         return int(result.registers[0])
 
-    async def _async_read_temp_from_register(self, register_type, register) -> float:
+    async def _async_read_temp_from_register(
+        self, register_type: str, register: int
+    ) -> float:
         result = float(
             await self._async_read_int16_from_register(register_type, register)
         )
@@ -229,8 +195,7 @@ class Flexit(ClimateEntity):
             return -1
         return result / 10.0
 
-    async def _async_write_int16_to_register(self, register, value) -> bool:
+    async def _async_write_int16_to_register(self, register: int, value: int) -> bool:
-        value = int(value)
         result = await self._hub.async_pymodbus_call(
             self._slave, register, value, CALL_TYPE_WRITE_REGISTER
         )