Continues pull->push refactoring

Author: bergdahl

custom_components/growcube/binary_sensor.py

@@ -2,7 +2,6 @@
 from homeassistant.core import callback, HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant import config_entries
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from .coordinator import GrowcubeDataCoordinator
 from homeassistant.components.binary_sensor import BinarySensorEntity, BinarySensorDeviceClass
@@ -56,9 +55,10 @@ def device_info(self) -> DeviceInfo | None:
         return self._coordinator.device.device_info
 
     @callback
-    def update(self, new_state: bool) -> None:
-        _LOGGER.debug("%s: Update device_locked %s",
+    def update(self, new_state: bool | None) -> None:
+        _LOGGER.debug("%s: Update device_locked %s -> %s",
                       self._coordinator.data.device_id,
+                      self._attr_is_on,
                       new_state
                       )
         if new_state != self._attr_is_on:
@@ -89,7 +89,7 @@ def icon(self) -> str:
             return "mdi:water-check"
 
     @callback
-    def update(self, new_state: bool) -> None:
+    def update(self, new_state: bool | None) -> None:
         _LOGGER.debug("%s: Update water_state %s -> %s",
                       self._coordinator.data.device_id,
                       self._attr_is_on,
@@ -125,7 +125,7 @@ def icon(self) -> str:
             return "mdi:water-off"
 
     @callback
-    def update(self, new_state: bool) -> None:
+    def update(self, new_state: bool | None) -> None:
         _LOGGER.debug("%s: Update pump_state[%s] %s -> %s",
                       self._coordinator.data.device_id,
                       self._channel,
@@ -161,7 +161,7 @@ def icon(self) -> str:
             return "mdi:pump"
 
     @callback
-    def update(self, new_state: bool) -> None:
+    def update(self, new_state: bool | None) -> None:
         _LOGGER.debug("%s: Update pump_lock_state[%s] %s -> %s",
                       self._coordinator.data.device_id,
                       self._channel,
@@ -197,7 +197,7 @@ def icon(self) -> str:
             return "mdi:water-pump"
 
     @callback
-    def update(self, new_state: bool) -> None:
+    def update(self, new_state: bool | None) -> None:
         _LOGGER.debug("%s: Update pump_lock_state[%s] %s -> %s",
                       self._coordinator.data.device_id,
                       self._channel,
@@ -233,10 +233,11 @@ def icon(self) -> str:
             return "mdi:thermometer-probe"
 
     @callback
-    def update(self, new_state: bool) -> None:
-        _LOGGER.debug("%s: Update sensor_state[%s] %s",
+    def update(self, new_state: bool | None) -> None:
+        _LOGGER.debug("%s: Update sensor_state[%s] %s -> %s",
                       self._coordinator.data.device_id,
                       self._channel,
+                      self._attr_is_on,
                       new_state
                       )
         if new_state != self._attr_is_on:
@@ -268,10 +269,11 @@ def icon(self) -> str:
             return "mdi:thermometer-probe"
 
     @callback
-    def update(self, new_state: bool) -> None:
-        _LOGGER.debug("%s: Update sensor_state[%s] %s",
+    def update(self, new_state: bool | None) -> None:
+        _LOGGER.debug("%s: Update sensor_state[%s] %s -> %s",
                       self._coordinator.data.device_id,
                       self._channel,
+                      self._attr_is_on,
                       new_state
                       )
         if new_state != self._attr_is_on:

custom_components/growcube/coordinator.py

@@ -57,19 +57,19 @@ def __init__(self, host: str, hass: HomeAssistant):
         self._outlet_blocked_callbacks: dict[int, Callable[[bool], None]] = {}
         self._sensor_fault_callbacks: dict[int, Callable[[bool], None]] = {}
         self._sensor_disconnected_callbacks: dict[int, Callable[[bool], None]] = {}
-        self._temperature_value_callback: Callable[[int], None] | None = None
-        self._humidity_value_callback: Callable[[int], None] | None = None
-        self._moisture_value_callbacks: dict[int, Callable[[bool], None]] = {}
+        self._temperature_value_callback: Callable[[int | None], None] | None = None
+        self._humidity_value_callback: Callable[[int | None], None] | None = None
+        self._moisture_value_callbacks: dict[int, Callable[[bool | None], None]] = {}
 
     def set_device_id(self, device_id: str) -> None:
         self.device_id = hex(int(device_id))[2:]
-        self.data.device_id = "growcube_{}".format(self.device_id)
-        self.data.device_info = {
+        self.device.device_id = "growcube_{}".format(self.device_id)
+        self.device.device_info = {
             "name": "GrowCube " + self.device_id,
-            "identifiers": {(DOMAIN, self.data.device_id)},
+            "identifiers": {(DOMAIN, self.device.device_id)},
             "manufacturer": "Elecrow",
             "model": "Growcube",
-            "sw_version": self.data.version,
+            "sw_version": self.device.version,
         }
 
     async def connect(self) -> Tuple[bool, str]:
@@ -79,17 +79,17 @@ async def connect(self) -> Tuple[bool, str]:
 
         self.shutting_down = False
         # Wait for the device to send back the DeviceVersionGrowcubeReport
-        while not self.data.device_id:
+        while not self.device.device_id:
             await asyncio.sleep(0.1)
         _LOGGER.debug(
             "Growcube device id: %s",
-            self.data.device_id
+            self.device_id
         )
 
         time_command = SyncTimeCommand(datetime.now())
         _LOGGER.debug(
             "%s: Sending SyncTimeCommand",
-            self.data.device_id
+            self.device_id
         )
         self.client.send_command(time_command)
         return True, ""
@@ -106,15 +106,15 @@ async def reconnect(self) -> None:
                 if result:
                     _LOGGER.debug(
                         "Reconnect to %s succeeded",
-                        self.data.host
+                        self.host
                     )
                     self.shutting_down = False
                     await asyncio.sleep(10)
                     return
 
                 _LOGGER.debug(
                     "Reconnect failed for %s with error '%s', retrying in 10 seconds",
-                    self.data.host,
+                    self.host,
                     error)
                 await asyncio.sleep(10)
 
@@ -155,9 +155,9 @@ def on_connected(self, host: str) -> None:
 
     async def on_disconnected(self, host: str) -> None:
         _LOGGER.debug("Connection to %s lost", host)
-        if self.data.device_id is not None:
+        if self.device.device_id is not None:
             self.hass.states.async_set(
-                DOMAIN + "." + self.data.device_id, STATE_UNAVAILABLE
+                DOMAIN + "." + self.device.device_id, STATE_UNAVAILABLE
             )
             self.reset_sensor_data()
         if not self.shutting_down:
@@ -173,16 +173,62 @@ def disconnect(self) -> None:
         self.client.disconnect()
 
     def reset_sensor_data(self) -> None:
-        self.data.temperature = None
-        self.data.humidity = None
-        self.data.moisture = [None, None, None, None]
-        self.data.pump_open = [False, False, False, False]
-        self.data.device_locked = False
-        self.data.water_warning = False
-        self.data.sensor_abnormal = [False, False, False, False]
-        self.data.sensor_disconnected = [False, False, False, False]
-        self.data.outlet_blocked_state = [False, False, False, False]
-        self.data.outlet_locked_state = [False, False, False, False]
+        if self._device_locked_callback is not None:
+            self._device_locked_callback(False)
+        if self._water_warning_callback is not None:
+            self._water_warning_callback(False)
+        if self._pump_open_callbacks[0] is not None:
+            self._pump_open_callbacks[0](False)
+        if self._pump_open_callbacks[1] is not None:
+            self._pump_open_callbacks[1](False)
+        if self._pump_open_callbacks[2] is not None:
+            self._pump_open_callbacks[2](False)
+        if self._pump_open_callbacks[3] is not None:
+            self._pump_open_callbacks[3](False)
+        if self._outlet_locked_callbacks[0] is not None:
+            self._outlet_locked_callbacks[0](False)
+        if self._outlet_locked_callbacks[1] is not None:
+            self._outlet_locked_callbacks[1](False)
+        if self._outlet_locked_callbacks[2] is not None:
+            self._outlet_locked_callbacks[2](False)
+        if self._outlet_locked_callbacks[3] is not None:
+            self._outlet_locked_callbacks[3](False)
+        if self._outlet_blocked_callbacks[0] is not None:
+            self._outlet_blocked_callbacks[0](False)
+        if self._outlet_blocked_callbacks[1] is not None:
+            self._outlet_blocked_callbacks[1](False)
+        if self._outlet_blocked_callbacks[2] is not None:
+            self._outlet_blocked_callbacks[2](False)
+        if self._outlet_blocked_callbacks[3] is not None:
+            self._outlet_blocked_callbacks[3](False)
+        if self._sensor_fault_callbacks[0] is not None:
+            self._sensor_fault_callbacks[0](False)
+        if self._sensor_fault_callbacks[1] is not None:
+            self._sensor_fault_callbacks[1](False)
+        if self._sensor_fault_callbacks[2] is not None:
+            self._sensor_fault_callbacks[2](False)
+        if self._sensor_fault_callbacks[3] is not None:
+            self._sensor_fault_callbacks[3](False)
+        if self._sensor_disconnected_callbacks[0] is not None:
+            self._sensor_disconnected_callbacks[0](False)
+        if self._sensor_disconnected_callbacks[1] is not None:
+            self._sensor_disconnected_callbacks[1](False)
+        if self._sensor_disconnected_callbacks[2] is not None:
+            self._sensor_disconnected_callbacks[2](False)
+        if self._sensor_disconnected_callbacks[3] is not None:
+            self._sensor_disconnected_callbacks[3](False)
+        if self._temperature_value_callback is not None:
+            self._temperature_value_callback(None)
+        if self._humidity_value_callback is not None:
+            self._humidity_value_callback(None)
+        if self._moisture_value_callbacks[0] is not None:
+            self._moisture_value_callbacks[0](None)
+        if self._moisture_value_callbacks[1] is not None:
+            self._moisture_value_callbacks[1](None)
+        if self._moisture_value_callbacks[2] is not None:
+            self._moisture_value_callbacks[2](None)
+        if self._moisture_value_callbacks[3] is not None:
+            self._moisture_value_callbacks[3](None)
 
     def register_device_locked_state_callback(self, callback: Callable[[bool], None]) -> None:
         self._device_locked_callback = callback
@@ -254,13 +300,13 @@ def handle_report(self, report: GrowcubeReport) -> None:
                 report.version
             )
             self.reset_sensor_data()
-            self.data.version = report.version
+            self.device.version = report.version
             self.set_device_id(report.device_id)
         # 20 - RepWaterState
         elif isinstance(report, WaterStateGrowcubeReport):
             _LOGGER.debug(
                 "%s: Water state %s",
-                self.data.device_id,
+                self.device_id,
                 report.water_warning
             )
             if self._water_warning_callback is not None:
@@ -269,7 +315,7 @@ def handle_report(self, report: GrowcubeReport) -> None:
         elif isinstance(report, MoistureHumidityStateGrowcubeReport):
             _LOGGER.debug(
                 "%s: Sensor reading, channel %s, humidity %s, temperature %s, moisture %s",
-                self.data.device_id,
+                self.device_id,
                 report.channel,
                 report.humidity,
                 report.temperature,
@@ -285,7 +331,7 @@ def handle_report(self, report: GrowcubeReport) -> None:
         elif isinstance(report, PumpOpenGrowcubeReport):
             _LOGGER.debug(
                 "%s: Pump open, channel %s",
-                self.data.device_id,
+                self.device_id,
                 report.channel
             )
             if report.channel.value in self._pump_open_callbacks:
@@ -294,7 +340,7 @@ def handle_report(self, report: GrowcubeReport) -> None:
         elif isinstance(report, PumpCloseGrowcubeReport):
             _LOGGER.debug(
                 "%s: Pump closed, channel %s",
-                self.data.device_id,
+                self.device_id,
                 report.channel
             )
             if report.channel.value in self._pump_open_callbacks:
@@ -303,7 +349,7 @@ def handle_report(self, report: GrowcubeReport) -> None:
         elif isinstance(report, CheckSensorGrowcubeReport):
             _LOGGER.debug(
                 "%s: Sensor abnormal, channel %s",
-                self.data.device_id,
+                self.device_id,
                 report.channel
             )
             if report.channel.value in self._sensor_fault_callbacks:
@@ -312,7 +358,7 @@ def handle_report(self, report: GrowcubeReport) -> None:
         elif isinstance(report, CheckOutletBlockedGrowcubeReport):
             _LOGGER.debug(
                 "%s: Outlet blocked, channel %s",
-                self.data.device_id,
+                self.device_id,
                 report.channel
             )
             if report.channel.value in self._outlet_blocked_callbacks:
@@ -321,7 +367,7 @@ def handle_report(self, report: GrowcubeReport) -> None:
         elif isinstance(report, CheckSensorNotConnectedGrowcubeReport):
             _LOGGER.debug(
                 "%s: Check sensor, channel %s",
-                self.data.device_id,
+                self.device_id,
                 report.channel
             )
             if report.channel.value in self._sensor_disconnected_callbacks:
@@ -330,12 +376,12 @@ def handle_report(self, report: GrowcubeReport) -> None:
         elif isinstance(report, LockStateGrowcubeReport):
             _LOGGER.debug(
                 "%s: Lock state, %s",
-                self.data.device_id,
+                self.device_id,
                 report.lock_state
             )
             # Handle case where the button on the device was pressed, this should do a reconnect
             # to read any problems still present
-            if not report.lock_state and self.data.device_locked:
+            if not report.lock_state:
                 self.reset_sensor_data()
                 self.reconnect()
             if self._device_locked_callback is not None:
@@ -344,7 +390,7 @@ def handle_report(self, report: GrowcubeReport) -> None:
         elif isinstance(report, CheckOutletLockedGrowcubeReport):
             _LOGGER.debug(
                 "%s Check outlet, channel %s",
-                self.data.device_id,
+                self.device_id,
                 report.channel
             )
             if report.channel.value in self._outlet_locked_callbacks:
@@ -356,7 +402,7 @@ async def water_plant(self, channel: int) -> None:
     async def handle_water_plant(self, channel: Channel, duration: int) -> None:
         _LOGGER.debug(
             "%s: Service water_plant called, %s, %s",
-            self.data.device_id,
+            self.device_id,
             channel,
             duration
         )
@@ -369,7 +415,7 @@ async def handle_set_smart_watering(self, channel: Channel,
 
         _LOGGER.debug(
             "%s: Service set_smart_watering called, %s, %s, %s, %s",
-            self.data.device_id,
+            self.device_id,
             channel,
             all_day,
             min_moisture,
@@ -384,7 +430,7 @@ async def handle_set_manual_watering(self, channel: Channel, duration: int, inte
 
         _LOGGER.debug(
             "%s: Service set_manual_watering called, %s, %s, %s",
-            self.data.device_id,
+            self.device_id,
             channel,
             duration,
             interval,
@@ -397,7 +443,7 @@ async def handle_delete_watering(self, channel: Channel) -> None:
 
         _LOGGER.debug(
             "%s: Service delete_watering called, %s,",
-            self.data.device_id,
+            self.device_id,
             channel
         )
         command = PlantEndCommand(channel)