Use attributes in zerproc light (#75951)

homeassistant/components/zerproc/light.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 from datetime import timedelta
 import logging
+from typing import Any
 
 import pyzerproc
 
@@ -14,7 +15,7 @@ from homeassistant.components.light import (
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EVENT_HOMEASSISTANT_STOP
-from homeassistant.core import HomeAssistant
+from homeassistant.core import Event, HomeAssistant
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.event import async_track_time_interval
@@ -79,26 +80,24 @@ class ZerprocLight(LightEntity):
     """Representation of an Zerproc Light."""
 
     _attr_color_mode = ColorMode.HS
+    _attr_icon = "mdi:string-lights"
     _attr_supported_color_modes = {ColorMode.HS}
 
-    def __init__(self, light):
+    def __init__(self, light) -> None:
         """Initialize a Zerproc light."""
         self._light = light
-        self._name = None
-        self._is_on = None
-        self._hs_color = None
-        self._brightness = None
-        self._available = True
 
     async def async_added_to_hass(self) -> None:
         """Run when entity about to be added to hass."""
         self.async_on_remove(
-            self.hass.bus.async_listen_once(
-                EVENT_HOMEASSISTANT_STOP, self.async_will_remove_from_hass
-            )
+            self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self._hass_stop)
         )
 
-    async def async_will_remove_from_hass(self, *args) -> None:
+    async def _hass_stop(self, event: Event) -> None:
+        """Run on EVENT_HOMEASSISTANT_STOP."""
+        await self.async_will_remove_from_hass()
+
+    async def async_will_remove_from_hass(self) -> None:
         """Run when entity will be removed from hass."""
         try:
             await self._light.disconnect()
@@ -126,64 +125,41 @@ class ZerprocLight(LightEntity):
             name=self.name,
         )
 
-    @property
-    def icon(self) -> str | None:
-        """Return the icon to use in the frontend."""
-        return "mdi:string-lights"
-
-    @property
-    def brightness(self):
-        """Return the brightness of the light."""
-        return self._brightness
-
-    @property
-    def hs_color(self):
-        """Return the hs color."""
-        return self._hs_color
-
-    @property
-    def is_on(self):
-        """Return true if light is on."""
-        return self._is_on
-
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        return self._available
-
-    async def async_turn_on(self, **kwargs):
+    async def async_turn_on(self, **kwargs: Any) -> None:
         """Instruct the light to turn on."""
         if ATTR_BRIGHTNESS in kwargs or ATTR_HS_COLOR in kwargs:
-            default_hs = (0, 0) if self._hs_color is None else self._hs_color
+            default_hs = (0, 0) if self.hs_color is None else self.hs_color
             hue_sat = kwargs.get(ATTR_HS_COLOR, default_hs)
 
-            default_brightness = 255 if self._brightness is None else self._brightness
+            default_brightness = 255 if self.brightness is None else self.brightness
             brightness = kwargs.get(ATTR_BRIGHTNESS, default_brightness)
 
-            rgb = color_util.color_hsv_to_RGB(*hue_sat, brightness / 255 * 100)
+            rgb = color_util.color_hsv_to_RGB(
+                hue_sat[0], hue_sat[1], brightness / 255 * 100
+            )
             await self._light.set_color(*rgb)
         else:
             await self._light.turn_on()
 
-    async def async_turn_off(self, **kwargs):
+    async def async_turn_off(self, **kwargs: Any) -> None:
         """Instruct the light to turn off."""
         await self._light.turn_off()
 
-    async def async_update(self):
+    async def async_update(self) -> None:
         """Fetch new state data for this light."""
         try:
-            if not self._available:
+            if not self.available:
                 await self._light.connect()
             state = await self._light.get_state()
         except pyzerproc.ZerprocException:
-            if self._available:
+            if self.available:
                 _LOGGER.warning("Unable to connect to %s", self._light.address)
-            self._available = False
+            self._attr_available = False
             return
-        if self._available is False:
+        if not self.available:
             _LOGGER.info("Reconnected to %s", self._light.address)
-            self._available = True
-        self._is_on = state.is_on
+            self._attr_available = True
+        self._attr_is_on = state.is_on
         hsv = color_util.color_RGB_to_hsv(*state.color)
-        self._hs_color = hsv[:2]
-        self._brightness = int(round((hsv[2] / 100) * 255))
+        self._attr_hs_color = hsv[:2]
+        self._attr_brightness = int(round((hsv[2] / 100) * 255))