@@ -9,6 +9,7 @@
 # pylint: disable=attribute-defined-outside-init
 
 
+from solcast import SolarAPI
 from gecloud import GECloudDirect, GECloudData
 from ohme import OhmeAPI
 from octopus import OctopusAPI
@@ -61,6 +62,25 @@
             "mcp_port": {"required": False, "config": "mcp_port", "default": 8199},
         },
     },
+    "solar": {
+        "class": SolarAPI,
+        "name": "Solar API",
+        "args": {
+            "prefix": {"required": True, "config": "prefix"},
+            "solcast_host": {"required": False, "config": "solcast_host"},
+            "solcast_api_key": {"required": False, "config": "solcast_api_key"},
+            "solcast_sites": {"required": False, "config": "solcast_sites"},
+            "solcast_poll_hours": {"required": False, "config": "solcast_poll_hours", "default": 8},
+            "forecast_solar": {"required": False, "config": "forecast_solar", "default": False},
+            "forecast_solar_max_age": {"required": False, "config": "forecast_solar_max_age", "default": 8},
+            "pv_forecast_today": {"required": False, "config": "pv_forecast_today"},
+            "pv_forecast_tomorrow": {"required": False, "config": "pv_forecast_tomorrow"},
+            "pv_forecast_d3": {"required": False, "config": "pv_forecast_d3"},
+            "pv_forecast_d4": {"required": False, "config": "pv_forecast_d4"},
+            "pv_scaling": {"required": False, "config": "pv_scaling", "default": 1.0},
+        },
+        "required_or": ["solcast_host", "forecast_solar", "pv_forecast_today"],
+    },
     "gecloud": {
         "class": GECloudDirect,
         "name": "GivEnergy Cloud Direct",
@@ -217,6 +237,11 @@ def initialize(self, only=None):
                     have_all_args = False
                 else:
                     arg_dict[arg] = self.base.get_arg(arg_info["config"], default, indirect=indirect)
+            required_or = component_info.get("required_or", [])
+            # If required_or is set we must have at least one of the listed args
+            if required_or:
+                if not any(arg_dict.get(arg, None) for arg in required_or):
+                    have_all_args = False
             if have_all_args:
                 self.log(f"Initializing {component_info['name']} interface")
                 self.components[component_name] = component_info["class"](*arg_dict.values(), self.base)
 
@@ -11,7 +11,7 @@
 
 from datetime import datetime, timedelta
 from utils import minutes_to_time, str2time, dp0, dp1, dp2, dp3, dp4, time_string_to_stamp, minute_data
-from config import MINUTE_WATT, PREDICT_STEP, TIME_FORMAT, TIME_FORMAT_SECONDS, PREDBAT_MODE_OPTIONS, PREDBAT_MODE_CONTROL_SOC, PREDBAT_MODE_CONTROL_CHARGEDISCHARGE, PREDBAT_MODE_CONTROL_CHARGE, PREDBAT_MODE_MONITOR, TIME_FORMAT_DAILY
+from config import MINUTE_WATT, PREDICT_STEP, TIME_FORMAT, PREDBAT_MODE_OPTIONS, PREDBAT_MODE_CONTROL_SOC, PREDBAT_MODE_CONTROL_CHARGEDISCHARGE, PREDBAT_MODE_CONTROL_CHARGE, PREDBAT_MODE_MONITOR
 from futurerate import FutureRate
 
 
@@ -430,109 +430,6 @@ def minute_data_load(self, now_utc, entity_name, max_days_previous, load_scaling
             age_days = 0
         return load_minutes, age_days
 
-    def prune_today(self, data, prune=True, group=15, prune_future=False, intermediate=False):
-        """
-        Remove data from before today
-        """
-        results = {}
-        last_time = None
-        prev_value = None
-        for key in data:
-            # Convert key in format '2024-09-07T15:40:09.799567+00:00' into a datetime
-            if "." in key:
-                timekey = datetime.strptime(key, TIME_FORMAT_SECONDS)
-            else:
-                timekey = datetime.strptime(key, TIME_FORMAT)
-            if last_time and (timekey - last_time).seconds < group * 60:
-                continue
-            if intermediate and last_time and ((timekey - last_time).seconds > group * 60):
-                # Large gap, introduce intermediate data point
-                seconds_gap = int((timekey - last_time).total_seconds())
-                for i in range(1, seconds_gap // int(group * 60)):
-                    new_time = last_time + timedelta(seconds=i * group * 60)
-                    results[new_time.strftime(TIME_FORMAT)] = prev_value
-            if not prune or (timekey > self.midnight_utc):
-                if prune_future and (timekey > self.now_utc):
-                    continue
-                results[key] = data[key]
-                last_time = timekey
-                prev_value = data[key]
-        return results
-
-    def history_attribute(self, history, state_key="state", last_updated_key="last_updated", scale=1.0, attributes=False, daily=False, offset_days=0, first=True, pounds=False):
-        results = {}
-        last_updated_time = None
-        last_day_stamp = None
-
-        if not isinstance(history, list):
-            return results
-
-        if history and len(history) >= 1:
-            history = history[0]
-
-        if not isinstance(history, list):
-            self.log("Warn: history_attribute expects a list of history items, got {}".format(type(history)))
-            return results
-
-        # Process history
-        for item in history:
-            if last_updated_key not in item:
-                continue
-
-            if attributes:
-                if state_key not in item["attributes"]:
-                    continue
-                state = item["attributes"][state_key]
-            else:
-                # Ignore data without correct keys
-                if state_key not in item:
-                    continue
-
-                # Unavailable or bad values
-                if item[state_key] == "unavailable" or item[state_key] == "unknown":
-                    continue
-
-                state = item[state_key]
-
-            # Get the numerical key and the timestamp and ignore if in error
-            try:
-                state = float(state) * scale
-                if pounds:
-                    state = dp2(state / 100)
-            except (ValueError, TypeError):
-                if isinstance(state, str):
-                    if state.lower() in ["on", "true", "yes"]:
-                        state = 1
-                    elif state.lower() in ["off", "false", "no"]:
-                        state = 0
-                    else:
-                        continue
-                else:
-                    continue
-
-            try:
-                last_updated_time = item[last_updated_key]
-                last_updated_stamp = str2time(last_updated_time)
-            except (ValueError, TypeError):
-                continue
-
-            day_stamp = last_updated_stamp.astimezone().replace(hour=0, minute=0, second=0, microsecond=0)
-            if offset_days:
-                day_stamp += timedelta(days=offset_days)
-
-            if first and daily and day_stamp == last_day_stamp:
-                continue
-            last_day_stamp = day_stamp
-
-            # Add the state to the result
-            if daily:
-                # Convert day stamp from UTC into localtime
-                results[day_stamp.strftime(TIME_FORMAT_DAILY)] = state
-            else:
-                results[last_updated_time] = state
-
-        return results
-
     def fetch_sensor_data(self):
         """
         Fetch all the data, e.g. energy rates, load, PV predictions, car plan etc.
@@ -944,6 +841,50 @@ def fetch_sensor_data(self):
         else:
             self.load_inday_adjustment = 1.0
 
+    def fetch_pv_forecast(self):
+        """
+        Fetch PV forecast data from one or more sensors
+        """
+        pv_forecast_minute = {}
+        pv_forecast_minute10 = {}
+
+        # Get data from forecast sensor
+        entity_id = "sensor." + self.prefix + "_pv_forecast_raw"
+        pv_forecast_packed_ld = self.get_state_wrapper(entity_id=entity_id, attribute="forecast")
+        pv_forecast10_packed_ld = self.get_state_wrapper(entity_id=entity_id, attribute="forecast10")
+
+        # Convert keys to integers and values to floats
+        pv_forecast_packed = {}
+        pv_forecast10_packed = {}
+
+        if pv_forecast_packed_ld:
+            for key, value in pv_forecast_packed_ld.items():
+                try:
+                    minute = int(key)
+                    pv_forecast_packed[minute] = float(value)
+                except (ValueError, TypeError):
+                    pass
+
+        if pv_forecast10_packed_ld:
+            for key, value in pv_forecast10_packed_ld.items():
+                try:
+                    minute = int(key)
+                    pv_forecast10_packed[minute] = float(value)
+                except (ValueError, TypeError):
+                    pass
+
+        # Unpack the forecast data
+        max_minute = max(pv_forecast_packed.keys()) if pv_forecast_packed else 0
+        last_value = 0
+        last_value10 = 0
+        for minute in range(0, max_minute + 1):
+            last_value = pv_forecast_packed.get(minute, last_value)
+            last_value10 = pv_forecast10_packed.get(minute, last_value10)
+            pv_forecast_minute[minute] = last_value
+            pv_forecast_minute10[minute] = last_value10
+
+        return pv_forecast_minute, pv_forecast_minute10
+
     def predict_battery_temperature(self, battery_temperature_history, step):
         """
         Given historical battery temperature data, predict the future temperature
 
@@ -62,7 +62,6 @@
 from predheat import PredHeat
 from octopus import Octopus
 from energydataservice import Energidataservice
-from solcast import Solcast
 from components import Components
 from execute import Execute
 from plan import Plan
@@ -73,7 +72,7 @@
 from plugin_system import PluginSystem
 
 
-class PredBat(hass.Hass, Octopus, Energidataservice, Solcast, Fetch, Plan, Execute, Output, UserInterface):
+class PredBat(hass.Hass, Octopus, Energidataservice, Fetch, Plan, Execute, Output, UserInterface):
     """
     The battery prediction class itself
     """