fix(#303): support evcc Solar-Prognose forecast format and handle None unit

- Add Format 1 parser in _parse_forecast_from_attributes for the
  sensor.solar_forecast_ml_evcc_solar_prognose style data:
  {"forecast": [{"start": ISO_TS, "end": ISO_TS, "value": WH}]}
  Absolute timestamps are converted to hour offsets relative to current hour.
- Handle unit_of_measurement=None in _check_sensor_unit_async: log a
  warning and assume Wh (factor 1.0) instead of raising ValueError.
- Add TestEvccForecastFormat with 7 tests covering the new parser.

Author: MaStr

src/batcontrol/forecastsolar/forecast_homeassistant_ml.py

@@ -4,11 +4,14 @@
 HomeAssistant Solar Forecast ML integration (HACS).
 
 Based on HACS integration: https://zara-toorox.github.io/
-Sensor: sensor.solar_forecast_ml_prognose_nachste_stunde
+Supported sensors:
+  - sensor.solar_forecast_ml_prognose_nachste_stunde  (hours_list / hour_N format)
+  - sensor.solar_forecast_ml_evcc_solar_prognose      (forecast list with start/end/value)
 
 """
 
 import asyncio
+import datetime
 import json
 import logging
 from typing import Dict, Optional
@@ -224,6 +227,16 @@ async def _check_sensor_unit_async(self) -> float:
                     "Unit is kWh, will multiply values by 1000 to convert to Wh")
                 return 1000.0
 
+            if unit is None:
+                logger.warning(
+                    "Entity '%s' has no unit_of_measurement. "
+                    "Assuming values are already in Wh "
+                    "(typical for evcc Solar-Prognose sensor). "
+                    "Set 'sensor_unit: Wh' in config to suppress this warning.",
+                    self.entity_id
+                )
+                return 1.0
+
             raise ValueError(
                 f"Unsupported unit_of_measurement '{unit}' for entity "
                 f"'{self.entity_id}'. Only 'Wh' and 'kWh' are supported.")
@@ -407,10 +420,10 @@ def get_forecast_from_raw_data(self) -> Dict[int, float]:
 
         # Parse forecast data from attributes
         attributes = raw_data.get("attributes", {})
-        
+
         try:
             forecast_dict = self._parse_forecast_from_attributes(attributes)
-            
+
             if forecast_dict:
                 values = list(forecast_dict.values())
                 logger.debug(
@@ -422,7 +435,8 @@ def get_forecast_from_raw_data(self) -> Dict[int, float]:
                 )
             else:
                 logger.error("Parsed empty forecast from attributes")
-                raise RuntimeError("No solar forecast data available in entity attributes")
+                raise RuntimeError(
+                    "No solar forecast data available in entity attributes")
 
             return forecast_dict
 
@@ -437,8 +451,12 @@ def _parse_forecast_from_attributes(
         """Parse forecast data from sensor attributes
 
         Supports multiple formats:
-        1. Primary: hours_list array with {time, kwh} objects
-        2. Fallback: hour_1, hour_2, ... attributes with times
+        1. Primary: forecast array with {start, end, value} objects (evcc Solar Forecast style)
+           - Uses absolute timestamps; values are mapped to hour offsets from now
+           - Typically used with sensor.solar_forecast_ml_evcc_solar_prognose
+        2. Secondary: hours_list array with {time, kwh} objects
+           - Used with sensor.solar_forecast_ml_prognose_nachste_stunde
+        3. Fallback: hour_1, hour_2, ... attributes
 
         Args:
             attributes: Sensor attributes dict from HomeAssistant
@@ -451,6 +469,72 @@ def _parse_forecast_from_attributes(
         """
         forecast_dict: Dict[int, float] = {}
 
+        # 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:
+                logger_ha_details.debug(
+                    "Parsing forecast from 'forecast' list (%d entries)",
+                    len(forecast_list)
+                )
+                now = datetime.datetime.now(self.timezone)
+                current_hour = now.replace(minute=0, second=0, microsecond=0)
+
+                for entry in forecast_list:
+                    if not isinstance(entry, dict):
+                        continue
+
+                    start_str = entry.get("start")
+                    value = entry.get("value")
+
+                    if start_str is None or value is None:
+                        continue
+
+                    try:
+                        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)
+
+                        if hour_offset < 0:
+                            # Past hour - skip
+                            continue
+
+                        wh_value = float(value) * self.unit_conversion_factor
+                        forecast_dict[hour_offset] = wh_value
+                        logger_ha_details.debug(
+                            "Offset %d (start=%s): %.2f Wh",
+                            hour_offset, start_str, wh_value
+                        )
+                    except (ValueError, TypeError, OverflowError) as exc:
+                        logger_ha_details.debug(
+                            "Skipping entry with start=%s: %s", start_str, exc
+                        )
+                        continue
+
+                if forecast_dict:
+                    values = list(forecast_dict.values())
+                    logger.debug(
+                        "Parsed %d slots from 'forecast' list: "
+                        "avg=%.1f Wh, min=%.1f Wh, max=%.1f Wh",
+                        len(forecast_dict),
+                        sum(values) / len(values),
+                        min(values),
+                        max(values)
+                    )
+                    return forecast_dict
+
+                logger_ha_details.warning(
+                    "'forecast' list present but no valid future entries found")
+
+        # Format 2: hours_list (existing primary format)
         # Try primary format: hours_list
         hours_list = attributes.get("hours_list")
         if hours_list and isinstance(hours_list, list) and len(hours_list) > 0:

tests/test_forecast_solar_homeassistant_ml.py

@@ -3,6 +3,7 @@
 Comprehensive test coverage for HomeAssistant Solar Forecast ML integration.
 """
 
+import datetime
 import json
 from unittest.mock import AsyncMock, patch
 
@@ -544,5 +545,227 @@ def test_large_forecast_values(self, pv_installations, timezone):
         assert forecast[1] == 50500.0
 
 
+# Tests for evcc Solar Forecast format (start/end/value with absolute timestamps)
+
+class TestEvccForecastFormat:
+    """Tests for the evcc Solar Forecast sensor format with absolute timestamps.
+
+    The sensor sensor.solar_forecast_ml_evcc_solar_prognose provides data as:
+    {
+        "forecast": [
+            {"start": "2026-03-21T14:00:00", "end": "2026-03-21T15:00:00", "value": 3613.0},
+            ...
+        ]
+    }
+    Values are in Wh (no unit_of_measurement on the sensor).
+    """
+
+    def _make_provider_wh(self, pv_installations, timezone):
+        """Helper: create a provider configured for Wh (evcc sensor)"""
+        return ForecastSolarHomeAssistantML(
+            pvinstallations=pv_installations,
+            timezone=timezone,
+            base_url="http://homeassistant.local:8123",
+            api_token="test_token",
+            entity_id="sensor.solar_forecast_ml_evcc_solar_prognose",
+            sensor_unit="Wh"
+        )
+
+    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 naive local time (as the sensor provides)
+        return target.strftime("%Y-%m-%dT%H:%M:%S")
+
+    def test_parse_forecast_list_basic(self, pv_installations, timezone):
+        """Test parsing evcc-style forecast list - current and future entries mapped correctly"""
+        provider = self._make_provider_wh(pv_installations, timezone)
+
+        attributes = {
+            "forecast": [
+                {"start": self._hour_str(timezone, 0), "end": self._hour_str(timezone, 1),
+                 "value": 3613.0},
+                {"start": self._hour_str(timezone, 1), "end": self._hour_str(timezone, 2),
+                 "value": 1540.0},
+                {"start": self._hour_str(timezone, 2), "end": self._hour_str(timezone, 3),
+                 "value": 800.0},
+            ]
+        }
+
+        forecast = provider._parse_forecast_from_attributes(attributes)
+
+        assert forecast[0] == 3613.0
+        assert forecast[1] == 1540.0
+        assert forecast[2] == 800.0
+
+    def test_parse_forecast_list_skips_past_entries(self, pv_installations, timezone):
+        """Test that past entries (before current hour) are skipped"""
+        provider = self._make_provider_wh(pv_installations, timezone)
+
+        attributes = {
+            "forecast": [
+                # Past entries
+                {"start": self._hour_str(timezone, -3), "end": self._hour_str(timezone, -2),
+                 "value": 9999.0},
+                {"start": self._hour_str(timezone, -1), "end": self._hour_str(timezone, 0),
+                 "value": 8888.0},
+                # Current and future
+                {"start": self._hour_str(timezone, 0), "end": self._hour_str(timezone, 1),
+                 "value": 800.0},
+                {"start": self._hour_str(timezone, 1), "end": self._hour_str(timezone, 2),
+                 "value": 200.0},
+            ]
+        }
+
+        forecast = provider._parse_forecast_from_attributes(attributes)
+
+        assert forecast[0] == 800.0
+        assert forecast[1] == 200.0
+        # Past hours must not appear
+        assert -3 not in forecast
+        assert -1 not in forecast
+        assert len(forecast) == 2
+
+    def test_parse_forecast_list_multi_day(self, pv_installations, timezone):
+        """Test that forecast entries 12 and 24 hours ahead map to correct offsets.
+
+        We deliberately avoid 48h offsets here because the test date (March 27)
+        is 2 days before the DST transition (March 29) in Europe/Berlin,
+        which would cause wall-clock vs absolute-time discrepancy.
+        """
+        provider = self._make_provider_wh(pv_installations, timezone)
+
+        attributes = {
+            "forecast": [
+                {"start": self._hour_str(timezone, 0),  "end": self._hour_str(timezone, 1),
+                 "value": 0.0},
+                {"start": self._hour_str(timezone, 12), "end": self._hour_str(timezone, 13),
+                 "value": 5000.0},
+                {"start": self._hour_str(timezone, 24), "end": self._hour_str(timezone, 25),
+                 "value": 3000.0},
+            ]
+        }
+
+        forecast = provider._parse_forecast_from_attributes(attributes)
+
+        assert forecast[0] == 0.0
+        assert forecast[12] == 5000.0
+        assert forecast[24] == 3000.0
+
+    def test_parse_forecast_list_wh_no_conversion(self, pv_installations, timezone):
+        """Test that Wh values from forecast list are NOT multiplied (factor=1.0)"""
+        provider = self._make_provider_wh(pv_installations, timezone)
+
+        attributes = {
+            "forecast": [
+                {"start": self._hour_str(timezone, 0), "end": self._hour_str(timezone, 1),
+                 "value": 7835.0},
+            ]
+        }
+
+        forecast = provider._parse_forecast_from_attributes(attributes)
+
+        # sensor_unit=Wh → unit_conversion_factor=1.0 → no multiplication
+        assert forecast[0] == 7835.0
+
+    def test_parse_forecast_list_invalid_entries_skipped(self, pv_installations, timezone):
+        """Test that entries with invalid start timestamps or missing values are skipped"""
+        provider = self._make_provider_wh(pv_installations, timezone)
+
+        attributes = {
+            "forecast": [
+                # Valid
+                {"start": self._hour_str(timezone, 0), "end": self._hour_str(timezone, 1),
+                 "value": 1000.0},
+                # Invalid start timestamp
+                {"start": "not-a-date",
+                    "end": self._hour_str(timezone, 2), "value": 500.0},
+                # Valid (no 'end' key is fine)
+                {"start": self._hour_str(timezone, 2), "value": 2000.0},
+                # Missing start → skipped
+                {"end": self._hour_str(timezone, 3), "value": 300.0},
+                # Missing value → skipped
+                {"start": self._hour_str(timezone, 4),
+                 "end": self._hour_str(timezone, 5)},
+            ]
+        }
+
+        forecast = provider._parse_forecast_from_attributes(attributes)
+
+        assert forecast[0] == 1000.0   # valid entry at offset 0
+        assert forecast[2] == 2000.0   # valid entry at offset 2
+        assert 4 not in forecast        # no value
+        # no start entries must not appear
+        assert len([k for k in forecast if k >= 0]) == 2
+
+    def test_parse_forecast_list_priority_over_hours_list(self, pv_installations, timezone):
+        """Test that 'forecast' list takes priority over 'hours_list' when both are present"""
+        provider = self._make_provider_wh(pv_installations, timezone)
+
+        attributes = {
+            "forecast": [
+                {"start": self._hour_str(timezone, 0), "end": self._hour_str(timezone, 1),
+                 "value": 111.0},
+            ],
+            "hours_list": [
+                {"time": "10:00", "kwh": 9.0},
+                {"time": "11:00", "kwh": 9.0},
+            ]
+        }
+
+        forecast = provider._parse_forecast_from_attributes(attributes)
+
+        # forecast list wins
+        assert forecast[0] == 111.0
+        assert len(forecast) == 1
+
+    def test_auto_detect_none_unit_defaults_to_wh(self, pv_installations, timezone):
+        """Test that auto-detecting a sensor with unit_of_measurement=None defaults to Wh"""
+        provider_state = {
+            "entity_id": "sensor.solar_forecast_ml_evcc_solar_prognose",
+            "state": "69 slots",
+            "attributes": {
+                "forecast": [],
+                "friendly_name": "Solar Forecast ML evcc Solar-Prognose"
+                # no unit_of_measurement key → evaluates to None
+            }
+        }
+
+        # Build a provider with explicit Wh unit, then directly test the async
+        # unit-check by calling _check_sensor_unit_async with a mocked WebSocket.
+        provider = ForecastSolarHomeAssistantML(
+            pvinstallations=pv_installations,
+            timezone=timezone,
+            base_url="http://homeassistant.local:8123",
+            api_token="test_token",
+            entity_id="sensor.solar_forecast_ml_evcc_solar_prognose",
+            sensor_unit="Wh"   # start with an explicit unit; we'll override below
+        )
+
+        # Patch _websocket_connect and the subsequent recv messages so that the
+        # async unit-check path returns an entity with no unit_of_measurement.
+        mock_ws = AsyncMock()
+        mock_ws.recv = AsyncMock(side_effect=[
+            json.dumps({"type": "auth_required", "ha_version": "2026.3.0"}),
+            json.dumps({"type": "auth_ok", "ha_version": "2026.3.0"}),
+            json.dumps({"type": "result", "id": 1, "success": True,
+                        "result": [provider_state]}),
+        ])
+        mock_ws.close = AsyncMock()
+
+        with patch(
+            'src.batcontrol.forecastsolar.forecast_homeassistant_ml.connect',
+            new_callable=AsyncMock,
+            return_value=mock_ws
+        ):
+            import asyncio
+            factor = asyncio.run(provider._check_sensor_unit_async())
+
+        # unit_of_measurement is None → should default to 1.0 (Wh) with a warning
+        assert factor == 1.0
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])