fix: Fix Today/Yesterday readings

Author: GuyKh

custom_components/iec/coordinator.py

@@ -292,12 +292,11 @@ async def _get_readings(
     async def _verify_daily_readings_exist(
         self,
         daily_readings: list[RemoteReading],
-        desired_date: datetime,
+        desired_date: date,
         device: Device,
         contract_id: int,
         prefetched_reading: RemoteReadingResponse | None = None,
     ):
-        desired_date = desired_date.replace(hour=0, minute=0, second=0, microsecond=0)
         daily_reading = next(
             filter(lambda x: find_reading_by_date(x, desired_date), daily_readings),
             None,
@@ -312,29 +311,38 @@ async def _verify_daily_readings_exist(
                     contract_id,
                     device.device_number,
                     device.device_code,
-                    desired_date,
+                    datetime.fromordinal(desired_date.toordinal()),
                     ReadingResolution.MONTHLY,
                 )
             else:
                 _LOGGER.debug(
                     f'Daily reading for date: {desired_date.strftime("%Y-%m-%d")} - using existing prefetched readings'
                 )
 
-            desired_date_reading = next(
-                filter(
-                    lambda reading: reading.date.date() == desired_date.date(),
-                    readings.data,
-                ),
-                0,
-            )
-            if desired_date_reading == 0 or desired_date_reading.value <= 0:
-                _LOGGER.debug(
-                    f'Couldn\'t find daily reading for: {desired_date.strftime("%Y-%m-%d")}'
-                )
-            else:
-                daily_readings.append(
-                    RemoteReading(0, desired_date, desired_date_reading.value)
+            if readings and readings.data:
+                daily_readings[device.device_number] += readings.data
+
+                # Remove duplicates
+                daily_readings[device.device_number] = list(dict.fromkeys(daily_readings[device.device_number]))
+
+                # Sort by Date
+                daily_readings[device.device_number].sort(key=lambda x: x.date)
+
+                desired_date_reading = next(
+                    filter(
+                        lambda reading: reading.date.date() == desired_date,
+                        readings.data,
+                    ),
+                    0,
                 )
+                if desired_date_reading == 0 or desired_date_reading.value <= 0:
+                    _LOGGER.debug(
+                        f'Couldn\'t find daily reading for: {desired_date.strftime("%Y-%m-%d")}'
+                    )
+                else:
+                    daily_readings.append(
+                        RemoteReading(0, desired_date, desired_date_reading.value)
+                    )
         else:
             _LOGGER.debug(
                 f'Daily reading for date: {daily_reading.date.strftime("%Y-%m-%d")}'
@@ -362,6 +370,7 @@ async def _update_data(
             if c.status == 1 and int(c.contract_id) in self._contract_ids
         }
         localized_today = TIMEZONE.localize(datetime.now())
+        localized_first_of_month = localized_today.replace(day=1)
         kwh_tariff = await self._get_kwh_tariff()
         kva_tariff = await self._get_kva_tariff()
 
@@ -432,63 +441,49 @@ async def _update_data(
                 for device in devices:
                     attributes_to_add[METER_ID_ATTR_NAME] = device.device_number
 
-                    remote_reading = await self._get_readings(
+                    reading_type: ReadingResolution | None = None
+                    reading_date: date | None = None
+
+                    if localized_today.date() != localized_first_of_month.date():
+                        reading_type: ReadingResolution | None = ReadingResolution.MONTHLY
+                        reading_date: date | None = localized_first_of_month
+                    elif localized_today.date().isoweekday() != 1:
+                        # If today's the 1st of the month, but not sunday, get weekly from tomorrow
+                        yesterday = localized_today - timedelta(days=1)
+                        reading_type: ReadingResolution | None = ReadingResolution.WEEKLY
+                        reading_date: date | None = yesterday
+                    else:
+                        # Today is the 1st and is Monday (since monday.isoweekday==1)
+                        last_month_first_of_the_month = (
+                            localized_first_of_month - timedelta(days=1)
+                        ).replace(day=1)
+
+                        reading_type: ReadingResolution | None = ReadingResolution.MONTHLY
+                        reading_date: date | None = last_month_first_of_the_month
+
+                    remote_rading = await self._get_readings(
                         contract_id,
                         device.device_number,
                         device.device_code,
-                        localized_today,
-                        ReadingResolution.MONTHLY,
+                        reading_date,
+                        reading_type
                     )
-                    if (
-                        remote_reading and remote_reading.total_import
-                    ):  # use total_import as validation that reading is OK
-                        future_consumption[device.device_number] = (
-                            remote_reading.future_consumption_info
-                        )
-
                     if remote_reading and remote_reading.data:
                         daily_readings[device.device_number] = remote_reading.data
                     else:
                         _LOGGER.warning(
-                            "No Monthly readings returned for device %s in contract %s on %s",
+                            f"No %s readings returned for device %s in contract %s on %s",
+                            reading_type,
                             device.device_number,
                             contract_id,
-                            localized_today.strftime("%Y-%m-%d"),
+                            reading_date,
                         )
                         daily_readings[device.device_number] = []
 
-                    weekly_future_consumption = None
-                    if localized_today.day == 1:
-                        # if today's the 1st of the month, "yesterday" is on a different month
-                        yesterday: datetime = localized_today - timedelta(days=1)
-                        remote_reading = await self._get_readings(
-                            contract_id,
-                            device.device_number,
-                            device.device_code,
-                            yesterday,
-                            ReadingResolution.WEEKLY,
-                        )
-                        if (
-                            remote_reading and remote_reading.total_import
-                        ):  # use total_import as validation that reading OK
-                            daily_readings[device.device_number] += remote_reading.data
-                            weekly_future_consumption = (
-                                remote_reading.future_consumption_info
-                            )
-
-                            # Remove duplicates
-                            daily_readings[device.device_number] = list(
-                                dict.fromkeys(daily_readings[device.device_number])
-                            )
-
-                            # Sort by Date
-                            daily_readings[device.device_number].sort(
-                                key=lambda x: x.date
-                            )
-
+                    # Verify today's date appears
                     await self._verify_daily_readings_exist(
                         daily_readings[device.device_number],
-                        localized_today - timedelta(days=1),
+                        localized_today.date(),
                         device,
                         contract_id,
                     )
@@ -514,13 +509,6 @@ async def _update_data(
                         ].future_consumption
                     ):
                         if (
-                            weekly_future_consumption
-                            and weekly_future_consumption.future_consumption
-                        ):
-                            future_consumption[device.device_number] = (
-                                weekly_future_consumption
-                            )
-                        elif (
                             self._today_readings.get(today_reading_key)
                             and self._today_readings.get(
                                 today_reading_key