fix(#303): address PR review comments

- Normalize trailing 'Z' in ISO timestamps before fromisoformat() for
  Python 3.9/3.10 compatibility
- Use floor division (// 3600) for hour_offset so negative deltas
  between -1h and 0h stay negative and get skipped correctly
- Scan all forecast list entries for expected keys instead of only
  checking the first element (avoids skipping valid data if first
  entry is malformed)
- Cache _base_hour_start in _hour_str() helper to prevent flaky tests
  near hour boundaries
- Fix misleading docstring in test_auto_detect_none_unit_defaults_to_wh

Author: MaStr

src/batcontrol/forecastsolar/forecast_homeassistant_ml.py

@@ -472,8 +472,11 @@ def _parse_forecast_from_attributes(
         # Format 1: forecast list with {start, end, value} - evcc Solar Forecast style
         forecast_list = attributes.get("forecast")
         if forecast_list and isinstance(forecast_list, list):
-            first = forecast_list[0] if forecast_list else {}
-            if isinstance(first, dict) and "start" in first and "value" in first:
+            has_expected_entry = any(
+                isinstance(entry, dict) and "start" in entry and "value" in entry
+                for entry in forecast_list
+            )
+            if has_expected_entry:
                 logger_ha_details.debug(
                     "Parsing forecast from 'forecast' list (%d entries)",
                     len(forecast_list)
@@ -492,16 +495,20 @@ def _parse_forecast_from_attributes(
                         continue
 
                     try:
-                        entry_start = datetime.datetime.fromisoformat(
-                            start_str)
+                        # Normalize UTC timestamps with trailing 'Z' for Python 3.9/3.10
+                        if isinstance(start_str, str) and start_str.endswith("Z"):
+                            start_str = start_str[:-1] + "+00:00"
+
+                        entry_start = datetime.datetime.fromisoformat(start_str)
                         # If the timestamp is naive, assume it is in the local timezone
                         if entry_start.tzinfo is None:
                             entry_start = self.timezone.localize(entry_start)
                         else:
                             entry_start = entry_start.astimezone(self.timezone)
 
                         delta = entry_start - current_hour
-                        hour_offset = int(delta.total_seconds() / 3600)
+                        # Use floor division so negative deltas stay negative
+                        hour_offset = int(delta.total_seconds() // 3600)
 
                         if hour_offset < 0:
                             # Past hour - skip

tests/test_forecast_solar_homeassistant_ml.py

@@ -572,10 +572,16 @@ def _make_provider_wh(self, pv_installations, timezone):
         )
 
     def _hour_str(self, tz, offset_hours: int) -> str:
-        """Return an ISO timestamp string for current-hour + offset_hours in local tz."""
-        now = datetime.datetime.now(tz)
-        hour_start = now.replace(minute=0, second=0, microsecond=0)
-        target = hour_start + datetime.timedelta(hours=offset_hours)
+        """Return an ISO timestamp string for current-hour + offset_hours in local tz.
+
+        Caches a single base-hour per instance to avoid flakiness when tests
+        run near an hour boundary (successive calls to datetime.now() could
+        return different hours otherwise).
+        """
+        if not hasattr(self, "_base_hour_start"):
+            now = datetime.datetime.now(tz)
+            self._base_hour_start = now.replace(minute=0, second=0, microsecond=0)
+        target = self._base_hour_start + datetime.timedelta(hours=offset_hours)
         # Return naive local time (as the sensor provides)
         return target.strftime("%Y-%m-%dT%H:%M:%S")
 
@@ -733,8 +739,9 @@ def test_auto_detect_none_unit_defaults_to_wh(self, pv_installations, timezone):
             }
         }
 
-        # Build a provider with explicit Wh unit, then directly test the async
-        # unit-check by calling _check_sensor_unit_async with a mocked WebSocket.
+        # Build a provider with explicit Wh unit, then directly exercise
+        # _check_sensor_unit_async() to verify that a None unit_of_measurement
+        # is handled gracefully (returns 1.0 with a warning instead of raising).
         provider = ForecastSolarHomeAssistantML(
             pvinstallations=pv_installations,
             timezone=timezone,