Rework energy_log_update() by combining previously used and recent code

Author: bouwew

plugwise_usb/nodes/circle.py

@@ -401,9 +401,10 @@ async def energy_update(self) -> EnergyStatistics | None:  # noqa: PLR0911 PLR09
                 self._log_no_energy_stats_update()
                 return None
 
-        # Always request last energy log records at initial startup
+        # Always request the most recent energy log records at initial startup, check if the current
+        # address is acutally reported by the node even when all slots at that address are empty.
         if not self._last_energy_log_requested:
-            self._last_energy_log_requested = await self.energy_log_update(
+            self._last_energy_log_requested, _ = await self.energy_log_update(
                 self._current_log_address, save_cache=False
             )
 
@@ -416,8 +417,8 @@ async def energy_update(self) -> EnergyStatistics | None:  # noqa: PLR0911 PLR09
                 )
                 return None
 
-            # Try collecting energy-stats for _current_log_address
-            result = await self.energy_log_update(
+            # Try collecting energy-stats from _current_log_address
+            result, _ = await self.energy_log_update(
                 self._current_log_address, save_cache=False
             )
             if not result:
@@ -428,20 +429,17 @@ async def energy_update(self) -> EnergyStatistics | None:  # noqa: PLR0911 PLR09
                 )
                 return None
 
-            if self._current_log_address is not None:
-                # Retry with previous log address as Circle node pointer to self._current_log_address
-                # could be rolled over while the last log is at previous address/slot
-                prev_log_address, _ = calc_log_address(self._current_log_address, 1, -4)
-                result = await self.energy_log_update(
-                    prev_log_address, save_cache=False
+            # Retry with previous log address as Circle node pointer to self._current_log_address
+            # could be rolled over while the last log is at previous address
+            prev_log_address, _ = calc_log_address(self._current_log_address, 1, -4)
+            result, _ = await self.energy_log_update(prev_log_address, save_cache=False)
+            if not result:
+                _LOGGER.debug(
+                    "async_energy_update | %s | Log rollover | energy_log_update from address %s failed",
+                    self._mac_in_str,
+                    prev_log_address,
                 )
-                if not result:
-                    _LOGGER.debug(
-                        "async_energy_update | %s | Log rollover | energy_log_update from address %s failed",
-                        self._mac_in_str,
-                        prev_log_address,
-                    )
-                    return None
+                return None
 
             if self._cache_enabled:
                 await self.save_cache()
@@ -458,7 +456,7 @@ async def energy_update(self) -> EnergyStatistics | None:  # noqa: PLR0911 PLR09
                 return self._energy_counters.energy_statistics
 
             if len(missing_addresses) == 1:
-                result = await self.energy_log_update(
+                result, _ = await self.energy_log_update(
                     missing_addresses[0], save_cache=True
                 )
                 if result:
@@ -521,8 +519,11 @@ async def _get_initial_energy_logs(self) -> None:
         )
         log_address = self._current_log_address
         while total_addresses > 0:
-            result = await self.energy_log_update(log_address, save_cache=False)
-            if not result:
+            result, slots_empty = await self.energy_log_update(
+                log_address, save_cache=False
+            )
+            if result and not slots_empty:
+                # (address with outdated data in slots is stored as with None data!)
                 # Stop initial log collection when an address contains no (None) or outdated data
                 # Outdated data can indicate a EnergyLog address rollover: from address 6014 to 0
                 _LOGGER.debug(
@@ -575,14 +576,17 @@ async def get_missing_energy_logs(self) -> None:
 
     async def energy_log_update(
         self, address: int | None, save_cache: bool = True
-    ) -> bool:
+    ) -> tuple[bool, bool]:
         """Request energy logs from node and store them.
 
-        Return True if processing succeeded: records stored in memory, also for empty slots.
-        Return False on transport or address errors.
+        Return first bool as True if processing succeeded: records stored in memory, also with empty slots.
+        Return fist bool as False on transport or address errors.
+        Return second bool as False when all slots are empty otherwise as True
         """
+        result = False
+        slots_empty = True
         if address is None:
-            return False
+            return result, slots_empty
 
         _LOGGER.debug(
             "Requesting EnergyLogs from node %s address %s",
@@ -595,48 +599,50 @@ async def energy_log_update(
                 "Retrieving EnergyLogs data from node %s failed",
                 self._mac_in_str,
             )
-            return False
+            return result, slots_empty
 
+        result = True
         _LOGGER.debug("EnergyLogs from node %s, address=%s:", self._mac_in_str, address)
         await self._available_update_state(True, response.timestamp)
 
         # Forward historical energy log information to energy counters
         # Each response message contains 4 log counters (slots) of the
         # energy pulses collected during the previous hour of given timestamp
         cache_updated = False
+        slot_updated = False
         for _slot in range(4, 0, -1):
             log_timestamp, log_pulses = response.log_data[_slot]
             _LOGGER.debug(
                 "In slot=%s: pulses=%s, timestamp=%s", _slot, log_pulses, log_timestamp
             )
-            if (
-                log_timestamp is None
-                or log_pulses is None
-                # Don't store an old log record; store an empty record instead
-                or not self._check_timestamp_is_recent(address, _slot, log_timestamp)
-            ):
+            if log_timestamp is None or log_pulses is None:
                 self._energy_counters.add_empty_log(response.log_address, _slot)
-                continue
-
-            slot_updated = await self._energy_log_record_update_state(
-                response.log_address,
-                _slot,
-                log_timestamp.replace(tzinfo=UTC),
-                log_pulses,
-                import_only=True,
-            )
+            elif self._check_timestamp_is_recent(
+                response.log_address, _slot, log_timestamp.replace(tzinfo=UTC)
+            ):
+                self._energy_counters.add_pulse_log(
+                    response.log_address,
+                    _slot,
+                    log_timestamp.replace(tzinfo=UTC),
+                    log_pulses,
+                    import_only=True,
+                )
+                slot_updated = True
+
             cache_updated |= slot_updated
 
         self._energy_counters.update()
         if cache_updated:
+            slots_empty = False
             await self._energy_log_records_save_to_cache()
             if save_cache:
                 _LOGGER.debug(
                     "Saving and storing energy cache for %s", self._mac_in_str
                 )
                 await self.save_cache()
+            return result, slots_empty
 
-        return True
+        return result, slots_empty
 
     def _check_timestamp_is_recent(
         self, address: int, slot: int, timestamp: datetime
@@ -726,48 +732,6 @@ async def _energy_log_records_save_to_cache(self) -> None:
         _LOGGER.debug("Updating in-memory energy log records for %s", self._mac_in_str)
         self._set_cache(CACHE_ENERGY_COLLECTION, cached_logs)
 
-    async def _energy_log_record_update_state(
-        self,
-        address: int,
-        slot: int,
-        timestamp: datetime,
-        pulses: int,
-        import_only: bool = False,
-    ) -> bool:
-        """Process new energy log record. Returns true if record is new or changed."""
-        self._energy_counters.add_pulse_log(
-            address, slot, timestamp, pulses, import_only=import_only
-        )
-        if not self._cache_enabled:
-            return False
-
-        log_cache_record = (
-            f"{address}:{slot}:{timestamp.strftime('%Y-%m-%d-%H-%M-%S')}:{pulses}"
-        )
-        if (cached_logs := self._get_cache(CACHE_ENERGY_COLLECTION)) is not None:
-            entries = cached_logs.split("|") if cached_logs else []
-            if log_cache_record not in entries:
-                _LOGGER.debug(
-                    "Adding logrecord (%s, %s) to cache of %s",
-                    str(address),
-                    str(slot),
-                    self._mac_in_str,
-                )
-                return True
-
-            _LOGGER.debug(
-                "Energy logrecord already present for %s, ignoring", self._mac_in_str
-            )
-            return False
-
-        _LOGGER.debug(
-            "Cache is empty, adding new logrecord (%s, %s) for %s",
-            str(address),
-            str(slot),
-            self._mac_in_str,
-        )
-        return True
-
     @raise_not_loaded
     async def set_relay(self, state: bool) -> bool:
         """Change the state of the relay."""