Modernize template fan (home-assistant#156470)

Author: Petro31

homeassistant/components/template/fan.py

@@ -210,17 +210,15 @@ def __init__(self, config: dict[str, Any]) -> None:  # pylint: disable=super-ini
         self._oscillating_template = config.get(CONF_OSCILLATING)
         self._direction_template = config.get(CONF_DIRECTION)
 
-        self._state: bool | None = False
-        self._percentage: int | None = None
-        self._preset_mode: str | None = None
-        self._oscillating: bool | None = None
-        self._direction: str | None = None
+        # Required for legacy functionality.
+        self._attr_is_on = False
+        self._attr_percentage = None
 
         # Number of valid speeds
-        self._speed_count = config.get(CONF_SPEED_COUNT)
+        self._attr_speed_count = config.get(CONF_SPEED_COUNT) or 100
 
         # List of valid preset modes
-        self._preset_modes: list[str] | None = config.get(CONF_PRESET_MODES)
+        self._attr_preset_modes: list[str] | None = config.get(CONF_PRESET_MODES)
 
         self._attr_supported_features |= (
             FanEntityFeature.TURN_OFF | FanEntityFeature.TURN_ON
@@ -240,51 +238,21 @@ def _iterate_scripts(
             if (action_config := config.get(action_id)) is not None:
                 yield (action_id, action_config, supported_feature)
 
-    @property
-    def speed_count(self) -> int:
-        """Return the number of speeds the fan supports."""
-        return self._speed_count or 100
-
-    @property
-    def preset_modes(self) -> list[str] | None:
-        """Get the list of available preset modes."""
-        return self._preset_modes
-
     @property
     def is_on(self) -> bool | None:
         """Return true if device is on."""
-        return self._state
-
-    @property
-    def preset_mode(self) -> str | None:
-        """Return the current preset mode."""
-        return self._preset_mode
-
-    @property
-    def percentage(self) -> int | None:
-        """Return the current speed percentage."""
-        return self._percentage
-
-    @property
-    def oscillating(self) -> bool | None:
-        """Return the oscillation state."""
-        return self._oscillating
-
-    @property
-    def current_direction(self) -> str | None:
-        """Return the oscillation state."""
-        return self._direction
+        return self._attr_is_on
 
     def _handle_state(self, result) -> None:
         if isinstance(result, bool):
-            self._state = result
+            self._attr_is_on = result
             return
 
         if isinstance(result, str):
-            self._state = result.lower() in ("true", STATE_ON)
+            self._attr_is_on = result.lower() in ("true", STATE_ON)
             return
 
-        self._state = False
+        self._attr_is_on = False
 
     @callback
     def _update_percentage(self, percentage):
@@ -297,69 +265,69 @@ def _update_percentage(self, percentage):
                 percentage,
                 self.entity_id,
             )
-            self._percentage = 0
+            self._attr_percentage = 0
             return
 
         if 0 <= percentage <= 100:
-            self._percentage = percentage
+            self._attr_percentage = percentage
         else:
             _LOGGER.error(
                 "Received invalid percentage: %s for entity %s",
                 percentage,
                 self.entity_id,
             )
-            self._percentage = 0
+            self._attr_percentage = 0
 
     @callback
     def _update_preset_mode(self, preset_mode):
         # Validate preset mode
         preset_mode = str(preset_mode)
 
         if self.preset_modes and preset_mode in self.preset_modes:
-            self._preset_mode = preset_mode
+            self._attr_preset_mode = preset_mode
         elif preset_mode in (STATE_UNAVAILABLE, STATE_UNKNOWN):
-            self._preset_mode = None
+            self._attr_preset_mode = None
         else:
             _LOGGER.error(
                 "Received invalid preset_mode: %s for entity %s. Expected: %s",
                 preset_mode,
                 self.entity_id,
                 self.preset_mode,
             )
-            self._preset_mode = None
+            self._attr_preset_mode = None
 
     @callback
     def _update_oscillating(self, oscillating):
         # Validate osc
         if oscillating == "True" or oscillating is True:
-            self._oscillating = True
+            self._attr_oscillating = True
         elif oscillating == "False" or oscillating is False:
-            self._oscillating = False
+            self._attr_oscillating = False
         elif oscillating in (STATE_UNAVAILABLE, STATE_UNKNOWN):
-            self._oscillating = None
+            self._attr_oscillating = None
         else:
             _LOGGER.error(
                 "Received invalid oscillating: %s for entity %s. Expected: True/False",
                 oscillating,
                 self.entity_id,
             )
-            self._oscillating = None
+            self._attr_oscillating = None
 
     @callback
     def _update_direction(self, direction):
         # Validate direction
         if direction in _VALID_DIRECTIONS:
-            self._direction = direction
+            self._attr_current_direction = direction
         elif direction in (STATE_UNAVAILABLE, STATE_UNKNOWN):
-            self._direction = None
+            self._attr_current_direction = None
         else:
             _LOGGER.error(
                 "Received invalid direction: %s for entity %s. Expected: %s",
                 direction,
                 self.entity_id,
                 ", ".join(_VALID_DIRECTIONS),
             )
-            self._direction = None
+            self._attr_current_direction = None
 
     async def async_turn_on(
         self,
@@ -383,7 +351,7 @@ async def async_turn_on(
             await self.async_set_percentage(percentage)
 
         if self._attr_assumed_state:
-            self._state = True
+            self._attr_is_on = True
             self.async_write_ha_state()
 
     async def async_turn_off(self, **kwargs: Any) -> None:
@@ -393,46 +361,46 @@ async def async_turn_off(self, **kwargs: Any) -> None:
         )
 
         if self._attr_assumed_state:
-            self._state = False
+            self._attr_is_on = False
             self.async_write_ha_state()
 
     async def async_set_percentage(self, percentage: int) -> None:
         """Set the percentage speed of the fan."""
-        self._percentage = percentage
+        self._attr_percentage = percentage
 
         if script := self._action_scripts.get(CONF_SET_PERCENTAGE_ACTION):
             await self.async_run_script(
                 script,
-                run_variables={ATTR_PERCENTAGE: self._percentage},
+                run_variables={ATTR_PERCENTAGE: self._attr_percentage},
                 context=self._context,
             )
 
         if self._attr_assumed_state:
-            self._state = percentage != 0
+            self._attr_is_on = percentage != 0
 
         if self._attr_assumed_state or self._percentage_template is None:
             self.async_write_ha_state()
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set the preset_mode of the fan."""
-        self._preset_mode = preset_mode
+        self._attr_preset_mode = preset_mode
 
         if script := self._action_scripts.get(CONF_SET_PRESET_MODE_ACTION):
             await self.async_run_script(
                 script,
-                run_variables={ATTR_PRESET_MODE: self._preset_mode},
+                run_variables={ATTR_PRESET_MODE: self._attr_preset_mode},
                 context=self._context,
             )
 
         if self._attr_assumed_state:
-            self._state = True
+            self._attr_is_on = True
 
         if self._attr_assumed_state or self._preset_mode_template is None:
             self.async_write_ha_state()
 
     async def async_oscillate(self, oscillating: bool) -> None:
         """Set oscillation of the fan."""
-        self._oscillating = oscillating
+        self._attr_oscillating = oscillating
         if (
             script := self._action_scripts.get(CONF_SET_OSCILLATING_ACTION)
         ) is not None:
@@ -448,7 +416,7 @@ async def async_oscillate(self, oscillating: bool) -> None:
     async def async_set_direction(self, direction: str) -> None:
         """Set the direction of the fan."""
         if direction in _VALID_DIRECTIONS:
-            self._direction = direction
+            self._attr_current_direction = direction
             if (
                 script := self._action_scripts.get(CONF_SET_DIRECTION_ACTION)
             ) is not None:
@@ -496,7 +464,7 @@ def __init__(
     def _update_state(self, result):
         super()._update_state(result)
         if isinstance(result, TemplateError):
-            self._state = None
+            self._attr_is_on = None
             return
 
         self._handle_state(result)
@@ -506,36 +474,36 @@ def _async_setup_templates(self) -> None:
         """Set up templates."""
         if self._template:
             self.add_template_attribute(
-                "_state", self._template, None, self._update_state
+                "_attr_is_on", self._template, None, self._update_state
             )
 
         if self._preset_mode_template is not None:
             self.add_template_attribute(
-                "_preset_mode",
+                "_attr_preset_mode",
                 self._preset_mode_template,
                 None,
                 self._update_preset_mode,
                 none_on_template_error=True,
             )
         if self._percentage_template is not None:
             self.add_template_attribute(
-                "_percentage",
+                "_attr_percentage",
                 self._percentage_template,
                 None,
                 self._update_percentage,
                 none_on_template_error=True,
             )
         if self._oscillating_template is not None:
             self.add_template_attribute(
-                "_oscillating",
+                "_attr_oscillating",
                 self._oscillating_template,
                 None,
                 self._update_oscillating,
                 none_on_template_error=True,
             )
         if self._direction_template is not None:
             self.add_template_attribute(
-                "_direction",
+                "_attr_current_direction",
                 self._direction_template,
                 None,
                 self._update_direction,