Use entity class attributes for arest (#52678)

homeassistant/components/arest/binary_sensor.py

@@ -73,34 +73,18 @@ class ArestBinarySensor(BinarySensorEntity):
     def __init__(self, arest, resource, name, device_class, pin):
         """Initialize the aREST device."""
         self.arest = arest
-        self._resource = resource
+        self._attr_name = name
-        self._name = name
+        self._attr_device_class = device_class
-        self._device_class = device_class
-        self._pin = pin
 
-        if self._pin is not None:
+        if pin is not None:
-            request = requests.get(f"{self._resource}/mode/{self._pin}/i", timeout=10)
+            request = requests.get(f"{resource}/mode/{pin}/i", timeout=10)
             if request.status_code != HTTP_OK:
-                _LOGGER.error("Can't set mode of %s", self._resource)
+                _LOGGER.error("Can't set mode of %s", resource)
-
-    @property
-    def name(self):
-        """Return the name of the binary sensor."""
-        return self._name
-
-    @property
-    def is_on(self):
-        """Return true if the binary sensor is on."""
-        return bool(self.arest.data.get("state"))
-
-    @property
-    def device_class(self):
-        """Return the class of this sensor."""
-        return self._device_class
 
     def update(self):
         """Get the latest data from aREST API."""
         self.arest.update()
+        self._attr_is_on = bool(self.arest.data.get("state"))
 
 
 class ArestData:

homeassistant/components/arest/sensor.py

@@ -139,48 +139,27 @@ class ArestSensor(SensorEntity):
     ):
         """Initialize the sensor."""
         self.arest = arest
-        self._resource = resource
+        self._attr_name = f"{location.title()} {name.title()}"
-        self._name = f"{location.title()} {name.title()}"
         self._variable = variable
-        self._pin = pin
+        self._attr_unit_of_measurement = unit_of_measurement
-        self._state = None
-        self._unit_of_measurement = unit_of_measurement
         self._renderer = renderer
 
-        if self._pin is not None:
+        if pin is not None:
-            request = requests.get(f"{self._resource}/mode/{self._pin}/i", timeout=10)
+            request = requests.get(f"{resource}/mode/{pin}/i", timeout=10)
             if request.status_code != HTTP_OK:
-                _LOGGER.error("Can't set mode of %s", self._resource)
+                _LOGGER.error("Can't set mode of %s", resource)
-
-    @property
-    def name(self):
-        """Return the name of the sensor."""
-        return self._name
-
-    @property
-    def unit_of_measurement(self):
-        """Return the unit the value is expressed in."""
-        return self._unit_of_measurement
-
-    @property
-    def state(self):
-        """Return the state of the sensor."""
-        values = self.arest.data
-
-        if "error" in values:
-            return values["error"]
-
-        value = self._renderer(values.get("value", values.get(self._variable, None)))
-        return value
 
     def update(self):
         """Get the latest data from aREST API."""
         self.arest.update()
-
+        self._attr_available = self.arest.available
-    @property
+        values = self.arest.data
-    def available(self):
+        if "error" in values:
-        """Could the device be accessed during the last update call."""
+            self._attr_state = values["error"]
-        return self.arest.available
+        else:
+            self._attr_state = self._renderer(
+                values.get("value", values.get(self._variable, None))
+            )
 
 
 class ArestData:
@@ -191,7 +170,7 @@ class ArestData:
         self._resource = resource
         self._pin = pin
         self.data = {}
-        self.available = True
+        self._attr_available = True
 
     @Throttle(MIN_TIME_BETWEEN_UPDATES)
     def update(self):
@@ -212,7 +191,7 @@ class ArestData:
                         f"{self._resource}/digital/{self._pin}", timeout=10
                     )
                     self.data = {"value": response.json()["return_value"]}
-            self.available = True
+            self._attr_available = True
         except requests.exceptions.ConnectionError:
             _LOGGER.error("No route to device %s", self._resource)
-            self.available = False
+            self._attr_available = False

homeassistant/components/arest/switch.py

@@ -86,24 +86,8 @@ class ArestSwitchBase(SwitchEntity):
     def __init__(self, resource, location, name):
         """Initialize the switch."""
         self._resource = resource
-        self._name = f"{location.title()} {name.title()}"
+        self._attr_name = f"{location.title()} {name.title()}"
-        self._state = None
+        self._attr_available = True
-        self._available = True
-
-    @property
-    def name(self):
-        """Return the name of the switch."""
-        return self._name
-
-    @property
-    def is_on(self):
-        """Return true if device is on."""
-        return self._state
-
-    @property
-    def available(self):
-        """Could the device be accessed during the last update call."""
-        return self._available
 
 
 class ArestSwitchFunction(ArestSwitchBase):
@@ -134,7 +118,7 @@ class ArestSwitchFunction(ArestSwitchBase):
         )
 
         if request.status_code == HTTP_OK:
-            self._state = True
+            self._attr_is_on = True
         else:
             _LOGGER.error("Can't turn on function %s at %s", self._func, self._resource)
 
@@ -145,7 +129,7 @@ class ArestSwitchFunction(ArestSwitchBase):
         )
 
         if request.status_code == HTTP_OK:
-            self._state = False
+            self._attr_is_on = False
         else:
             _LOGGER.error(
                 "Can't turn off function %s at %s", self._func, self._resource
@@ -155,11 +139,11 @@ class ArestSwitchFunction(ArestSwitchBase):
         """Get the latest data from aREST API and update the state."""
         try:
             request = requests.get(f"{self._resource}/{self._func}", timeout=10)
-            self._state = request.json()["return_value"] != 0
+            self._attr_is_on = request.json()["return_value"] != 0
-            self._available = True
+            self._attr_available = True
         except requests.exceptions.ConnectionError:
             _LOGGER.warning("No route to device %s", self._resource)
-            self._available = False
+            self._attr_available = False
 
 
 class ArestSwitchPin(ArestSwitchBase):
@@ -171,10 +155,10 @@ class ArestSwitchPin(ArestSwitchBase):
         self._pin = pin
         self.invert = invert
 
-        request = requests.get(f"{self._resource}/mode/{self._pin}/o", timeout=10)
+        request = requests.get(f"{resource}/mode/{pin}/o", timeout=10)
         if request.status_code != HTTP_OK:
             _LOGGER.error("Can't set mode")
-            self._available = False
+            self._attr_available = False
 
     def turn_on(self, **kwargs):
         """Turn the device on."""
@@ -183,7 +167,7 @@ class ArestSwitchPin(ArestSwitchBase):
             f"{self._resource}/digital/{self._pin}/{turn_on_payload}", timeout=10
         )
         if request.status_code == HTTP_OK:
-            self._state = True
+            self._attr_is_on = True
         else:
             _LOGGER.error("Can't turn on pin %s at %s", self._pin, self._resource)
 
@@ -194,7 +178,7 @@ class ArestSwitchPin(ArestSwitchBase):
             f"{self._resource}/digital/{self._pin}/{turn_off_payload}", timeout=10
         )
         if request.status_code == HTTP_OK:
-            self._state = False
+            self._attr_is_on = False
         else:
             _LOGGER.error("Can't turn off pin %s at %s", self._pin, self._resource)
 
@@ -203,8 +187,8 @@ class ArestSwitchPin(ArestSwitchBase):
         try:
             request = requests.get(f"{self._resource}/digital/{self._pin}", timeout=10)
             status_value = int(self.invert)
-            self._state = request.json()["return_value"] != status_value
+            self._attr_is_on = request.json()["return_value"] != status_value
-            self._available = True
+            self._attr_available = True
         except requests.exceptions.ConnectionError:
             _LOGGER.warning("No route to device %s", self._resource)
-            self._available = False
+            self._attr_available = False