emhass 0.11.3__py3-none-any.whl → 0.12.0__py3-none-any.whl

emhass/command_line.py

@@ -69,7 +69,7 @@ def set_input_data_dict(
     retrieve_hass_conf, optim_conf, plant_conf = utils.get_yaml_parse(params, logger)
     if type(retrieve_hass_conf) is bool:
         return False
-
+    
     # Treat runtimeparams
     params, retrieve_hass_conf, optim_conf, plant_conf = utils.treat_runtimeparams(
         runtimeparams,
@@ -81,7 +81,8 @@ def set_input_data_dict(
         logger,
         emhass_conf,
     )
-    # Define main objects
+    
+    # Define the data retrieve object
     rh = RetrieveHass(
         retrieve_hass_conf["hass_url"],
         retrieve_hass_conf["long_lived_token"],
@@ -92,6 +93,21 @@ def set_input_data_dict(
         logger,
         get_data_from_file=get_data_from_file,
     )
+    
+    # Retrieve basic configuration data from hass
+    if get_data_from_file:
+        with open(emhass_conf["data_path"] / "test_df_final.pkl", "rb") as inp:
+            _, _, _, rh.ha_config = pickle.load(inp)
+    else:
+        rh.get_ha_config()
+    
+    # Update the params dict using data from the HA configuration
+    params = utils.update_params_with_ha_config(
+        params,
+        rh.ha_config,
+    )
+    
+    # Define the forecast and optimization objects
     fcst = Forecast(
         retrieve_hass_conf,
         optim_conf,
@@ -111,12 +127,13 @@ def set_input_data_dict(
         emhass_conf,
         logger,
     )
+
     # Perform setup based on type of action
     if set_type == "perfect-optim":
         # Retrieve data from hass
         if get_data_from_file:
             with open(emhass_conf["data_path"] / "test_df_final.pkl", "rb") as inp:
-                rh.df_final, days_list, var_list = pickle.load(inp)
+                rh.df_final, days_list, var_list, rh.ha_config = pickle.load(inp)
             retrieve_hass_conf["sensor_power_load_no_var_loads"] = str(var_list[0])
             retrieve_hass_conf["sensor_power_photovoltaics"] = str(var_list[1])
             retrieve_hass_conf["sensor_linear_interp"] = [
@@ -154,12 +171,18 @@ def set_input_data_dict(
         P_PV_forecast, P_load_forecast, df_input_data_dayahead = None, None, None
     elif set_type == "dayahead-optim":
         # Get PV and load forecasts
-        df_weather = fcst.get_weather_forecast(
-            method=optim_conf["weather_forecast_method"]
-        )
-        if isinstance(df_weather, bool) and not df_weather:
-            return False
-        P_PV_forecast = fcst.get_power_from_weather(df_weather)
+        if (
+            optim_conf["set_use_pv"]
+            or optim_conf.get("weather_forecast_method", None) == "list"
+        ):
+            df_weather = fcst.get_weather_forecast(
+                method=optim_conf["weather_forecast_method"]
+            )
+            if isinstance(df_weather, bool) and not df_weather:
+                return False
+            P_PV_forecast = fcst.get_power_from_weather(df_weather)
+        else:
+            P_PV_forecast = pd.Series(0, index=fcst.forecast_dates)
         P_load_forecast = fcst.get_load_forecast(
             method=optim_conf["load_forecast_method"]
         )
@@ -208,7 +231,7 @@ def set_input_data_dict(
         # Retrieve data from hass
         if get_data_from_file:
             with open(emhass_conf["data_path"] / "test_df_final.pkl", "rb") as inp:
-                rh.df_final, days_list, var_list = pickle.load(inp)
+                rh.df_final, days_list, var_list, rh.ha_config = pickle.load(inp)
             retrieve_hass_conf["sensor_power_load_no_var_loads"] = str(var_list[0])
             retrieve_hass_conf["sensor_power_photovoltaics"] = str(var_list[1])
             retrieve_hass_conf["sensor_linear_interp"] = [
@@ -241,14 +264,20 @@ def set_input_data_dict(
             return False
         df_input_data = rh.df_final.copy()
         # Get PV and load forecasts
-        df_weather = fcst.get_weather_forecast(
-            method=optim_conf["weather_forecast_method"]
-        )
-        if isinstance(df_weather, bool) and not df_weather:
-            return False
-        P_PV_forecast = fcst.get_power_from_weather(
-            df_weather, set_mix_forecast=True, df_now=df_input_data
-        )
+        if (
+            optim_conf["set_use_pv"]
+            or optim_conf.get("weather_forecast_method", None) == "list"
+        ):
+            df_weather = fcst.get_weather_forecast(
+                method=optim_conf["weather_forecast_method"]
+            )
+            if isinstance(df_weather, bool) and not df_weather:
+                return False
+            P_PV_forecast = fcst.get_power_from_weather(
+                df_weather, set_mix_forecast=True, df_now=df_input_data
+            )
+        else:
+            P_PV_forecast = pd.Series(0, index=fcst.forecast_dates)
         P_load_forecast = fcst.get_load_forecast(
             method=optim_conf["load_forecast_method"],
             set_mix_forecast=True,
@@ -403,10 +432,8 @@ def weather_forecast_cache(
     :rtype: bool
 
     """
-
     # Parsing yaml
     retrieve_hass_conf, optim_conf, plant_conf = utils.get_yaml_parse(params, logger)
-
     # Treat runtimeparams
     params, retrieve_hass_conf, optim_conf, plant_conf = utils.treat_runtimeparams(
         runtimeparams,
@@ -417,8 +444,8 @@ def weather_forecast_cache(
         "forecast",
         logger,
         emhass_conf,
+        {},
     )
-
     # Make sure weather_forecast_cache is true
     if (params != None) and (params != "null"):
         params = json.loads(params)
@@ -426,12 +453,10 @@ def weather_forecast_cache(
         params = {}
     params["passed_data"]["weather_forecast_cache"] = True
     params = json.dumps(params)
-
     # Create Forecast object
     fcst = Forecast(
         retrieve_hass_conf, optim_conf, plant_conf, params, emhass_conf, logger
     )
-
     result = fcst.get_weather_forecast(optim_conf["weather_forecast_method"])
     if isinstance(result, bool) and not result:
         return False

emhass/data/associations.csv

@@ -15,6 +15,7 @@ params_secrets,lon,Longitude
 params_secrets,alt,Altitude
 optim_conf,costfun,costfun
 optim_conf,logging_level,logging_level
+optim_conf,set_use_pv,set_use_pv
 optim_conf,set_use_battery,set_use_battery
 optim_conf,num_def_loads,number_of_deferrable_loads
 optim_conf,P_deferrable_nom,nominal_power_of_deferrable_loads,list_nominal_power_of_deferrable_loads

emhass/data/config_defaults.json

@@ -84,6 +84,7 @@
   "photovoltaic_production_sell_price": 0.1419,
   "maximum_power_from_grid": 9000,
   "maximum_power_to_grid": 9000,
+  "set_use_pv": false,
   "pv_module_model": [
     "CSUN_Eurasia_Energy_Systems_Industry_and_Trade_CSUN295_60M"
   ],

emhass/forecast.py

@@ -886,10 +886,73 @@ class Forecast(object):
                 forecast_out = pd.concat([forecast_out, forecast_tp], axis=0)
         return forecast_out
 
+    @staticmethod
+    def resample_data(data, freq, current_freq):
+        r"""
+        Resample a DataFrame with a custom frequency.
+
+        :param data: Original time series data with a DateTimeIndex.
+        :type data: pd.DataFrame
+        :param freq: Desired frequency for resampling (e.g., pd.Timedelta("10min")).
+        :type freq: pd.Timedelta
+        :return: Resampled data at the specified frequency.
+        :rtype: pd.DataFrame
+        """
+        if freq > current_freq:
+            # Downsampling
+            # Use 'mean' to aggregate or choose other options ('sum', 'max', etc.)
+            resampled_data = data.resample(freq).mean()
+        elif freq < current_freq:
+            # Upsampling
+            # Use 'asfreq' to create empty slots, then interpolate
+            resampled_data = data.resample(freq).asfreq()
+            resampled_data = resampled_data.interpolate(method='time')
+        else:
+            # No resampling needed
+            resampled_data = data.copy()
+        return resampled_data
+    
+    @staticmethod
+    def get_typical_load_forecast(data, forecast_date):
+        r"""
+        Forecast the load profile for the next day based on historic data.
+
+        :param data: A DataFrame with a DateTimeIndex containing the historic load data. 
+                    Must include a 'load' column.
+        :type data: pd.DataFrame
+        :param forecast_date: The date for which the forecast will be generated.
+        :type forecast_date: pd.Timestamp
+        :return: A Series with the forecasted load profile for the next day and a list of days used 
+                to calculate the forecast.
+        :rtype: tuple (pd.Series, list)
+        """
+        # Ensure the 'load' column exists
+        if 'load' not in data.columns:
+            raise ValueError("Data must have a 'load' column.")
+        # Filter historic data for the same month and day of the week
+        month = forecast_date.month
+        day_of_week = forecast_date.dayofweek
+        historic_data = data[(data.index.month == month) & (data.index.dayofweek == day_of_week)]
+        used_days = np.unique(historic_data.index.date)
+        # Align all historic data to the forecast day
+        aligned_data = []
+        for day in used_days:
+            daily_data = data[data.index.date == pd.Timestamp(day).date()]
+            aligned_daily_data = daily_data.copy()
+            aligned_daily_data.index = aligned_daily_data.index.map(
+                lambda x: x.replace(year=forecast_date.year, month=forecast_date.month, day=forecast_date.day)
+            )
+            aligned_data.append(aligned_daily_data)
+        # Combine all aligned historic data into a single DataFrame
+        combined_data = pd.concat(aligned_data)
+        # Compute the mean load for each timestamp
+        forecast = combined_data.groupby(combined_data.index).mean()
+        return forecast, used_days
+    
     def get_load_forecast(
         self,
         days_min_load_forecast: Optional[int] = 3,
-        method: Optional[str] = "naive",
+        method: Optional[str] = "typical",
         csv_path: Optional[str] = "data_load_forecast.csv",
         set_mix_forecast: Optional[bool] = False,
         df_now: Optional[pd.DataFrame] = pd.DataFrame(),
@@ -904,10 +967,11 @@ class Forecast(object):
             will be used to generate a naive forecast, defaults to 3
         :type days_min_load_forecast: int, optional
         :param method: The method to be used to generate load forecast, the options \
+            are 'typical' for a typical household load consumption curve, \
             are 'naive' for a persistance model, 'mlforecaster' for using a custom \
             previously fitted machine learning model, 'csv' to read the forecast from \
             a CSV file and 'list' to use data directly passed at runtime as a list of \
-            values. Defaults to 'naive'.
+            values. Defaults to 'typical'.
         :type method: str, optional
         :param csv_path: The path to the CSV file used when method = 'csv', \
             defaults to "/data/data_load_forecast.csv"
@@ -956,7 +1020,7 @@ class Forecast(object):
             if self.get_data_from_file:
                 filename_path = self.emhass_conf["data_path"] / "test_df_final.pkl"
                 with open(filename_path, "rb") as inp:
-                    rh.df_final, days_list, var_list = pickle.load(inp)
+                    rh.df_final, days_list, var_list, rh.ha_config = pickle.load(inp)
                     self.var_load = var_list[0]
                     self.retrieve_hass_conf["sensor_power_load_no_var_loads"] = (
                         self.var_load
@@ -977,7 +1041,37 @@ class Forecast(object):
             ):
                 return False
             df = rh.df_final.copy()[[self.var_load_new]]
-        if method == "naive":  # using a naive approach
+        if method == "typical":  # using typical statistical data from a household power consumption
+            # Loading data from history file
+            model_type = "load_clustering"
+            data_path = self.emhass_conf["data_path"] / str("data_train_" + model_type + ".pkl")
+            with open(data_path, "rb") as fid:
+                data, _ = pickle.load(fid)
+            # Resample the data if needed
+            current_freq = pd.Timedelta('30min')
+            if self.freq != current_freq:
+                data = Forecast.resample_data(data, self.freq, current_freq)
+            # Generate forecast
+            data_list = []
+            dates_list = np.unique(self.forecast_dates.date).tolist()
+            forecast = pd.DataFrame()
+            for date in dates_list:
+                forecast_date = pd.Timestamp(date)
+                data.columns = ['load']
+                forecast_tmp, used_days = Forecast.get_typical_load_forecast(data, forecast_date)
+                self.logger.debug(f"Using {len(used_days)} days of data to generate the forecast.")
+                # Normalize the forecast
+                forecast_tmp = forecast_tmp*self.plant_conf['maximum_power_from_grid']/9000
+                data_list.extend(forecast_tmp.values.ravel().tolist())
+                if len(forecast) == 0:
+                    forecast = forecast_tmp
+                else:
+                    forecast = pd.concat([forecast, forecast_tmp], axis=0)
+            forecast.index = forecast.index.tz_convert(self.time_zone)
+            forecast_out = forecast.loc[forecast.index.intersection(self.forecast_dates)]
+            forecast_out.index.name = 'ts'
+            forecast_out = forecast_out.rename(columns={'load': 'yhat'})
+        elif method == "naive":  # using a naive approach
             mask_forecast_out = (
                 df.index > days_list[-1] - self.optim_conf["delta_forecast_daily"]
             )

emhass/optimization.py

@@ -661,7 +661,7 @@ class Optimization:
                                     cooling_constant
                                     * (
                                         predicted_temp[I - 1]
-                                        - outdoor_temperature_forecast[I - 1]
+                                        - outdoor_temperature_forecast.iloc[I - 1]
                                     )
                                 )
                             )

emhass/static/configuration_list.html

@@ -29,6 +29,10 @@
 <div id="Solar System (PV)" class="section-card">
   <div class="section-card-header">
     <h4>Solar System (PV)</h4>
+    <label class="switch"> <!-- switch connected to set_use_pv  -->
+      <input id="set_use_pv" type="checkbox">
+      <span class="slider"></span>
+    </label>
   </div>
   <div class="section-body"> </div> <!--  parameters will get generated here -->
 </div>

emhass/static/configuration_script.js

@@ -121,7 +121,7 @@ function loadConfigurationListView(param_definitions, config, list_html) {
   }
 
   //list parameters used in the section headers
-  header_input_list = ["set_use_battery", "number_of_deferrable_loads"];
+  header_input_list = ["set_use_battery", "set_use_pv", "number_of_deferrable_loads"];
 
   //get the main container and append list template html
   document.getElementById("configuration-container").innerHTML = list_html;
@@ -265,7 +265,7 @@ function buildParamContainers(
   });
 
   //check initial checkbox state, check "value" of input and match to "checked" value
-  let checkbox = document.querySelectorAll("input[type='checkbox']");
+  let checkbox = SectionContainer.querySelectorAll("input[type='checkbox']");
   checkbox.forEach(function (answer) {
     let value = answer.value === "true";
     answer.checked = value;
@@ -559,6 +559,19 @@ function headerElement(element, param_definitions, config) {
       }
       break;
 
+    //if set_use_pv, add or remove PV section (inc. related params)
+    case "set_use_pv":
+      if (element.checked) {
+        param_container.innerHTML = "";
+        buildParamContainers("Solar System (PV)", param_definitions["Solar System (PV)"], config, [
+          "set_use_pv",
+        ]);
+        element.checked = true;
+      } else {
+        param_container.innerHTML = "";
+      }
+      break;
+
     //if number_of_deferrable_loads, the number of inputs in the "Deferrable Loads" section should add up to number_of_deferrable_loads value in header
     case "number_of_deferrable_loads":
       //get a list of param in section

emhass/static/data/param_definitions.json

@@ -101,11 +101,12 @@
       "Description": "The load forecast method that will be used. The options are ‘csv’ to load a CSV file or ‘naive’ for a simple 1-day persistence model.",
       "input": "select",
       "select_options": [
+        "typical",
         "naive",
         "mlforecaster",
         "csv"
       ],
-      "default_value": "naive"
+      "default_value": "typical"
     },
     "set_total_pv_sell": {
       "friendly_name": "PV straight to grid",
@@ -229,6 +230,12 @@
     }
   },
   "Solar System (PV)": {
+    "set_use_pv": {
+      "friendly_name": "Enable PV system",
+      "Description": "Set to True if we should consider an solar PV system. Defaults to False",
+      "input": "boolean",
+      "default_value": false
+    },
     "pv_module_model": {
       "friendly_name": "PV module model name",
       "Description": "The PV module model. This parameter can be a list of items to enable the simulation of mixed orientation systems.",

emhass/templates/configuration.html

@@ -66,7 +66,7 @@
     </div>
   </div>
   <footer class="footer">
-    <p style="margin-top:10px; text-align:center;">&copy; MIT License | Copyright (c) 2021-2023 David
+    <p style="margin-top:10px; text-align:center;">&copy; MIT License | Copyright (c) 2021-2025 David
       HERNANDEZ</p>
   </footer>
   </div>

emhass/templates/index.html

@@ -69,7 +69,7 @@
         <div>
 
             <footer class="footer">
-                <p style="margin-top:10px; text-align:center;">&copy; MIT License | Copyright (c) 2021-2023 David
+                <p style="margin-top:10px; text-align:center;">&copy; MIT License | Copyright (c) 2021-2025 David
                     HERNANDEZ</p>
             </footer>
 </body>

emhass/utils.py

@@ -138,6 +138,70 @@ def get_forecast_dates(
     return forecast_dates
 
 
+def update_params_with_ha_config(
+    params: str,
+    ha_config: dict,
+) -> dict:
+    """
+    Update the params with the Home Assistant configuration.
+
+    Parameters
+    ----------
+    params : str
+        The serialized params.
+    ha_config : dict
+        The Home Assistant configuration.
+
+    Returns
+    -------
+    dict
+        The updated params.
+    """
+    # Load serialized params
+    params = json.loads(params)
+    # Update params
+    currency_to_symbol = {
+        'EUR': '€',
+        'USD': '$',
+        'GBP': '£',
+        'YEN': '¥',
+        'JPY': '¥',
+        'AUD': 'A$',
+        'CAD': 'C$',
+        'CHF': 'CHF',  # Swiss Franc has no special symbol
+        'CNY': '¥',
+        'INR': '₹',
+        # Add more as needed
+    }
+    if 'currency' in ha_config.keys():
+        ha_config['currency'] = currency_to_symbol.get(ha_config['currency'], 'Unknown')
+    else:
+        ha_config['currency'] = '€'
+    if 'unit_system' not in ha_config.keys():
+        ha_config['unit_system'] = {'temperature': '°C'}
+    
+    for k in range(params["optim_conf"]["number_of_deferrable_loads"]):
+        params['passed_data']['custom_predicted_temperature_id'][k].update(
+            {"unit_of_measurement": ha_config['unit_system']['temperature']}
+        )
+    updated_passed_dict = {
+        "custom_cost_fun_id": {
+            "unit_of_measurement": ha_config['currency'],
+        },
+        "custom_unit_load_cost_id": {
+            "unit_of_measurement": f"{ha_config['currency']}/kWh",
+        },
+        "custom_unit_prod_price_id": {
+            "unit_of_measurement": f"{ha_config['currency']}/kWh",
+        },
+    }
+    for key, value in updated_passed_dict.items():
+        params["passed_data"][key]["unit_of_measurement"] = value["unit_of_measurement"]
+    # Serialize the final params
+    params = json.dumps(params, default=str)
+    return params
+
+
 def treat_runtimeparams(
     runtimeparams: str,
     params: str,
@@ -183,6 +247,10 @@ def treat_runtimeparams(
     params["optim_conf"].update(optim_conf)
     params["plant_conf"].update(plant_conf)
 
+    # Check defaults on HA retrieved config
+    default_currency_unit = '€'
+    default_temperature_unit = '°C'
+    
     # Some default data needed
     custom_deferrable_forecast_id = []
     custom_predicted_temperature_id = []
@@ -197,7 +265,7 @@ def treat_runtimeparams(
         custom_predicted_temperature_id.append(
             {
                 "entity_id": "sensor.temp_predicted{}".format(k),
-                "unit_of_measurement": "°C",
+                "unit_of_measurement": default_temperature_unit,
                 "friendly_name": "Predicted temperature {}".format(k),
             }
         )
@@ -239,7 +307,7 @@ def treat_runtimeparams(
         },
         "custom_cost_fun_id": {
             "entity_id": "sensor.total_cost_fun_value",
-            "unit_of_measurement": "",
+            "unit_of_measurement": default_currency_unit,
             "friendly_name": "Total cost function value",
         },
         "custom_optim_status_id": {
@@ -249,12 +317,12 @@ def treat_runtimeparams(
         },
         "custom_unit_load_cost_id": {
             "entity_id": "sensor.unit_load_cost",
-            "unit_of_measurement": "€/kWh",
+            "unit_of_measurement": f"{default_currency_unit}/kWh",
             "friendly_name": "Unit Load Cost",
         },
         "custom_unit_prod_price_id": {
             "entity_id": "sensor.unit_prod_price",
-            "unit_of_measurement": "€/kWh",
+            "unit_of_measurement": f"{default_currency_unit}/kWh",
             "friendly_name": "Unit Prod Price",
         },
         "custom_deferrable_forecast_id": custom_deferrable_forecast_id,
@@ -308,7 +376,7 @@ def treat_runtimeparams(
                 runtimeparams.get("optimization_time_step", runtimeparams.get("freq"))
             )
             params["retrieve_hass_conf"]["optimization_time_step"] = pd.to_timedelta(
-                optimization_time_step
+                optimization_time_step, "minutes"
             )
         else:
             optimization_time_step = int(
@@ -338,59 +406,6 @@ def treat_runtimeparams(
             optimization_time_step, delta_forecast, time_zone
         )
 
-        # Treat passed forecast data lists
-        list_forecast_key = [
-            "pv_power_forecast",
-            "load_power_forecast",
-            "load_cost_forecast",
-            "prod_price_forecast",
-            "outdoor_temperature_forecast",
-        ]
-        forecast_methods = [
-            "weather_forecast_method",
-            "load_forecast_method",
-            "load_cost_forecast_method",
-            "production_price_forecast_method",
-            "outdoor_temperature_forecast_method",
-        ]
-
-        # Loop forecasts, check if value is a list and greater than or equal to forecast_dates
-        for method, forecast_key in enumerate(list_forecast_key):
-            if forecast_key in runtimeparams.keys():
-                if isinstance(runtimeparams[forecast_key], list) and len(
-                    runtimeparams[forecast_key]
-                ) >= len(forecast_dates):
-                    params["passed_data"][forecast_key] = runtimeparams[forecast_key]
-                    params["optim_conf"][forecast_methods[method]] = "list"
-                else:
-                    logger.error(
-                        f"ERROR: The passed data is either not a list or the length is not correct, length should be {str(len(forecast_dates))}"
-                    )
-                    logger.error(
-                        f"Passed type is {str(type(runtimeparams[forecast_key]))} and length is {str(len(runtimeparams[forecast_key]))}"
-                    )
-                # Check if string contains list, if so extract
-                if isinstance(runtimeparams[forecast_key], str):
-                    if isinstance(ast.literal_eval(runtimeparams[forecast_key]), list):
-                        runtimeparams[forecast_key] = ast.literal_eval(
-                            runtimeparams[forecast_key]
-                        )
-                list_non_digits = [
-                    x
-                    for x in runtimeparams[forecast_key]
-                    if not (isinstance(x, int) or isinstance(x, float))
-                ]
-                if len(list_non_digits) > 0:
-                    logger.warning(
-                        f"There are non numeric values on the passed data for {forecast_key}, check for missing values (nans, null, etc)"
-                    )
-                    for x in list_non_digits:
-                        logger.warning(
-                            f"This value in {forecast_key} was detected as non digits: {str(x)}"
-                        )
-            else:
-                params["passed_data"][forecast_key] = None
-
         # Add runtime exclusive (not in config) parameters to params
         # regressor-model-fit
         if set_type == "regressor-model-fit":
@@ -447,6 +462,16 @@ def treat_runtimeparams(
                 soc_final = runtimeparams["soc_final"]
             params["passed_data"]["soc_final"] = soc_final
 
+            params["passed_data"]["operating_hours_of_each_deferrable_load"] = params[
+                "optim_conf"
+            ].get("operating_hours_of_each_deferrable_load", None)
+            params["passed_data"]["start_timesteps_of_each_deferrable_load"] = params[
+                "optim_conf"
+            ].get("start_timesteps_of_each_deferrable_load", None)
+            params["passed_data"]["end_timesteps_of_each_deferrable_load"] = params[
+                "optim_conf"
+            ].get("end_timesteps_of_each_deferrable_load", None)
+
             forecast_dates = copy.deepcopy(forecast_dates)[0:prediction_horizon]
 
             # Load the default config
@@ -480,6 +505,59 @@ def treat_runtimeparams(
             params["passed_data"]["soc_init"] = None
             params["passed_data"]["soc_final"] = None
 
+        # Treat passed forecast data lists
+        list_forecast_key = [
+            "pv_power_forecast",
+            "load_power_forecast",
+            "load_cost_forecast",
+            "prod_price_forecast",
+            "outdoor_temperature_forecast",
+        ]
+        forecast_methods = [
+            "weather_forecast_method",
+            "load_forecast_method",
+            "load_cost_forecast_method",
+            "production_price_forecast_method",
+            "outdoor_temperature_forecast_method",
+        ]
+
+        # Loop forecasts, check if value is a list and greater than or equal to forecast_dates
+        for method, forecast_key in enumerate(list_forecast_key):
+            if forecast_key in runtimeparams.keys():
+                if isinstance(runtimeparams[forecast_key], list) and len(
+                    runtimeparams[forecast_key]
+                ) >= len(forecast_dates):
+                    params["passed_data"][forecast_key] = runtimeparams[forecast_key]
+                    params["optim_conf"][forecast_methods[method]] = "list"
+                else:
+                    logger.error(
+                        f"ERROR: The passed data is either not a list or the length is not correct, length should be {str(len(forecast_dates))}"
+                    )
+                    logger.error(
+                        f"Passed type is {str(type(runtimeparams[forecast_key]))} and length is {str(len(runtimeparams[forecast_key]))}"
+                    )
+                # Check if string contains list, if so extract
+                if isinstance(runtimeparams[forecast_key], str):
+                    if isinstance(ast.literal_eval(runtimeparams[forecast_key]), list):
+                        runtimeparams[forecast_key] = ast.literal_eval(
+                            runtimeparams[forecast_key]
+                        )
+                list_non_digits = [
+                    x
+                    for x in runtimeparams[forecast_key]
+                    if not (isinstance(x, int) or isinstance(x, float))
+                ]
+                if len(list_non_digits) > 0:
+                    logger.warning(
+                        f"There are non numeric values on the passed data for {forecast_key}, check for missing values (nans, null, etc)"
+                    )
+                    for x in list_non_digits:
+                        logger.warning(
+                            f"This value in {forecast_key} was detected as non digits: {str(x)}"
+                        )
+            else:
+                params["passed_data"][forecast_key] = None
+
         # Treat passed data for forecast model fit/predict/tune at runtime
         if (
             params["passed_data"].get("historic_days_to_retrieve", None) is not None
@@ -1091,7 +1169,7 @@ def build_secrets(
     :type logger: logging.Logger
     :param argument: dictionary of secrets arguments passed (url,key)
     :type argument: dict
-    :param options_path: path to the options file (options.json) (usually provided bt EMHASS-Add-on)
+    :param options_path: path to the options file (options.json) (usually provided by EMHASS-Add-on)
     :type options_path: str
     :param secrets_path: path to secrets file (secrets_emhass.yaml)
     :type secrets_path: str

emhass/web_server.py

@@ -14,6 +14,7 @@ from pathlib import Path
 
 import yaml
 from flask import Flask, make_response, request
+from flask import logging as log
 from jinja2 import Environment, PackageLoader
 from waitress import serve
 
@@ -384,7 +385,6 @@ def action_call(action_name):
 
     ActionStr = " >> Setting input data dict"
     app.logger.info(ActionStr)
-    app.logger.warning(costfun)
     input_data_dict = set_input_data_dict(
         emhass_conf, costfun, params, runtimeparams, action_name, app.logger
     )
@@ -652,37 +652,30 @@ if __name__ == "__main__":
         raise Exception("missing: " + str(emhass_conf["data_path"]))
 
     # Define loggers
-    ch = logging.StreamHandler()
     formatter = logging.Formatter(
         "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
     )
-    ch.setFormatter(formatter)
+    log.default_handler.setFormatter(formatter)
     # Action file logger
     fileLogger = logging.FileHandler(str(emhass_conf["data_path"] / "actionLogs.txt"))
     formatter = logging.Formatter("%(levelname)s - %(name)s - %(message)s")
     fileLogger.setFormatter(formatter)  # add format to Handler
     if logging_level == "DEBUG":
         app.logger.setLevel(logging.DEBUG)
-        ch.setLevel(logging.DEBUG)
         fileLogger.setLevel(logging.DEBUG)
     elif logging_level == "INFO":
         app.logger.setLevel(logging.INFO)
-        ch.setLevel(logging.INFO)
         fileLogger.setLevel(logging.INFO)
     elif logging_level == "WARNING":
         app.logger.setLevel(logging.WARNING)
-        ch.setLevel(logging.WARNING)
         fileLogger.setLevel(logging.WARNING)
     elif logging_level == "ERROR":
         app.logger.setLevel(logging.ERROR)
-        ch.setLevel(logging.ERROR)
         fileLogger.setLevel(logging.ERROR)
     else:
         app.logger.setLevel(logging.DEBUG)
-        ch.setLevel(logging.DEBUG)
         fileLogger.setLevel(logging.DEBUG)
     app.logger.propagate = False
-    app.logger.addHandler(ch)
     app.logger.addHandler(fileLogger)
     # Clear Action File logger file, ready for new instance
     clearFileLog()

{emhass-0.11.3.dist-info → emhass-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.11.3
+Version: 0.12.0
 Summary: An Energy Management System for Home Assistant
 Author-email: David HERNANDEZ <davidusb@gmail.com>
 License: MIT
@@ -132,11 +132,16 @@ Installation instructions and example Home Assistant automation configurations a
 You must follow these steps to make EMHASS work properly:
 
 1) Install and run EMHASS.
-    - There are multiple methods of installing and Running EMHASS. See [Installation Method](##Installation-Methods) below to pick a method that best suits your use case.
+    - There are multiple methods of installing and Running EMHASS. See [Installation Method](#Installation-Methods) below to pick a method that best suits your use case.
 
-2) Define all the parameters in the configuration file *(`config.json`)* or configuration page *(`YOURIP:5000/configuration`)*. 
+2) Define all the parameters in the configuration file *(`config.json`)* or configuration page *(`YOURIP:5000/configuration`)*.
+```{note} 
+
+New in EMHASS v0.12.0: the default configuration does not need to retrieve any data from Home Assistant! After installing and running the add-on, EMHASS should start and it will be ready to launch an optimization.
+```
     - See the description for each parameter in the [configuration](https://emhass.readthedocs.io/en/latest/config.html) docs. 
-        - You will most notably need to define the main data entering EMHASS. This will be the Home Assistant sensor/variable `sensor.power_photovoltaics` for the name of your Home Assistant variable containing the PV produced power, and the sensor/variable `sensor.power_load_no_var_loads`, for the load power of your household excluding the power of the deferrable loads that you want to optimize.
+    - EMHASS has a default configuration with 2 deferrable loads, no solar PV, no batteries and a basic load power forecasting method.
+      - If you want to consider solar PV and more advanced load power forecast methods, you will need to define the main data entering EMHASS. This will be the Home Assistant sensor/variable `sensor.power_load_no_var_loads`, for the load power of your household excluding the power of the deferrable loads that you want to optimize, and the sensor/variable `sensor.power_photovoltaics` for the name of your Home Assistant variable containing the PV produced power (if solar PV is activated).
       - If you have a PV installation then this dedicated web app can be useful for finding your inverter and solar panel models: [https://emhass-pvlib-database.streamlit.app/](https://emhass-pvlib-database.streamlit.app/)
 
 4) Launch the optimization and check the results. 
@@ -144,10 +149,10 @@ You must follow these steps to make EMHASS work properly:
     - Or with a `curl` command like this: `curl -i -H 'Content-Type:application/json' -X POST -d '{}' http://localhost:5000/action/dayahead-optim`.
 
 5) If you’re satisfied with the optimization results then you can set the optimization and data publish task commands in an automation. 
-    - You can read more about this in the [usage](##usage) section below.
+    - You can read more about this in the [usage](#usage) section below.
 
 6) The final step is to link the deferrable loads variables to real switches on your installation. 
-    - An example code for this using automations and the shell command integration is presented below in the [usage](##usage) section.
+    - An example code for this using automations and the shell command integration is presented below in the [usage](#usage) section.
 
 A more detailed workflow is given below:
 

emhass-0.12.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+emhass/command_line.py,sha256=xXu0A87fgiv38YbEJZiK3xQZ63wEMp081YqUCNsAWcM,70688
+emhass/forecast.py,sha256=_Gc8k6_8Nz87WHXKyUH6iXK956Z2TGzhL8L6t-tO_sk,63496
+emhass/machine_learning_forecaster.py,sha256=JErz50i_D59J5wXdbf_EUPb_FG45qRflv51iBA7ARXU,17417
+emhass/machine_learning_regressor.py,sha256=yFwMvVEmlgDJUsHhBT-HpNE3j2TC24e8Gmbcn9MPfeU,10690
+emhass/optimization.py,sha256=izMgRJFEP_9LHvZeX6FM1lxWyDWX3Tq2hFvu8ZP9FN4,61457
+emhass/retrieve_hass.py,sha256=LLZBoP5Rkyg0_uSvJSG5m-6apVoWZ6MWuXPPA-j-JsI,25617
+emhass/utils.py,sha256=esxcCoA38VhhugOHRvu69hJ8_V_zJkAqu0jUHW26rck,68969
+emhass/web_server.py,sha256=QsqT51AdlAgNCG3NV1zbm4YkBSq_0BaC3cIEzPeZvl8,28023
+emhass/data/associations.csv,sha256=IpEZIIWYdFjkRoC5xa1pRHjwnVs_VH8G8ogbGFxLfGI,3679
+emhass/data/cec_inverters.pbz2,sha256=tK8FvAUDW0uYez8EPttdCJwHhpPofclYV6GhhNZL0Pk,168272
+emhass/data/cec_modules.pbz2,sha256=8vEaysgYffXg3KUl8XSF36Mdywzi3LpEtUN_qenjO9s,1655747
+emhass/data/config_defaults.json,sha256=-mQHahDv6Z5wYgClOs4VVr5KVCP51olb3f2mEj3Beic,2777
+emhass/static/advanced.html,sha256=gAhsd14elDwh1Ts4lf9wn_ZkczzzObq5qOimi_la3Ic,2067
+emhass/static/basic.html,sha256=ro2WwWgJyoUhqx_nJFzKCEG8FA8863vSHLmrjGYcEgs,677
+emhass/static/configuration_list.html,sha256=i4v83RVduWjdjkjPhA74e-j8NSUpFzqMGU3ixOaJLfI,1740
+emhass/static/configuration_script.js,sha256=CU6CuvnFrAWhnCns8K_AyX8fAdOJMrtR7wX7pXzpnK4,31525
+emhass/static/script.js,sha256=q3qTqc_pTLTK-0NPKurxFXcJ2vZLz4TctPfUgz09ygo,16291
+emhass/static/style.css,sha256=a_8YlGubn1zoF5RTLJ_Qkrb8tAjUY9p7oAKxhCvJY2s,19288
+emhass/static/data/param_definitions.json,sha256=W-vq1Hj5_-YDpfl00cYF7kuLAQpfpsamjKGh7eU20LY,19485
+emhass/static/img/emhass_icon.png,sha256=Kyx6hXQ1huJLHAq2CaBfjYXR25H9j99PSWHI0lShkaQ,19030
+emhass/static/img/emhass_logo_short.svg,sha256=yzMcqtBRCV8rH84-MwnigZh45_f9Eoqwho9P8nCodJA,66736
+emhass/static/img/feather-sprite.svg,sha256=VHjMJQg88wXa9CaeYrKGhNtyK0xdd47zCqwSIa-hxo8,60319
+emhass/templates/configuration.html,sha256=M-_L__juYzcdGDaryGrz6LG2mguW2f1Sx6k01YfG7Dc,2885
+emhass/templates/index.html,sha256=1V44c0yyliu_z8inl0K-zmmmkhQumH3Bqk8Jj1YJPzY,3076
+emhass/templates/template.html,sha256=TkGgMecQEbFUZA4ymPwMUzNjKHsENvCgroUWbPt7G4Y,158
+emhass-0.12.0.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
+emhass-0.12.0.dist-info/METADATA,sha256=7e1QOm_rd__64snbbStegC7hFW8q62JHdC2sHlCFhSw,49398
+emhass-0.12.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+emhass-0.12.0.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
+emhass-0.12.0.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
+emhass-0.12.0.dist-info/RECORD,,

emhass-0.11.3.dist-info/RECORD

@@ -1,32 +0,0 @@
-emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-emhass/command_line.py,sha256=3fN0gUrTImxCUbmESgU8j_dXUwvkaCDMSdwcHWY0SQI,69671
-emhass/forecast.py,sha256=Jr1DAobtFoTfCS9RvtPQvYRTYrvyp1Ubq-X1noqh7jA,58763
-emhass/machine_learning_forecaster.py,sha256=JErz50i_D59J5wXdbf_EUPb_FG45qRflv51iBA7ARXU,17417
-emhass/machine_learning_regressor.py,sha256=yFwMvVEmlgDJUsHhBT-HpNE3j2TC24e8Gmbcn9MPfeU,10690
-emhass/optimization.py,sha256=-s3gWblpc85v-q0Ad9M8lXlG8ZZW0iL_s_I_9EUhzwA,61452
-emhass/retrieve_hass.py,sha256=LLZBoP5Rkyg0_uSvJSG5m-6apVoWZ6MWuXPPA-j-JsI,25617
-emhass/utils.py,sha256=U0fH_CbYQJd-izWqjBfJc-ih1y14S5IISIFtBHe1wM0,66330
-emhass/web_server.py,sha256=BdCefS_ipseUOa3sq-HFl1hWrA9NZbfxe3mt0ZqcgIU,28244
-emhass/data/associations.csv,sha256=Wv2845irZDMYm8svg__Ev0c2BgkVX88yAXoqpy1C4RM,3646
-emhass/data/cec_inverters.pbz2,sha256=tK8FvAUDW0uYez8EPttdCJwHhpPofclYV6GhhNZL0Pk,168272
-emhass/data/cec_modules.pbz2,sha256=8vEaysgYffXg3KUl8XSF36Mdywzi3LpEtUN_qenjO9s,1655747
-emhass/data/config_defaults.json,sha256=0jyYfF1ob3QMbjP8h2rd0jlbfe2uYm68NYW0GKM5qfk,2754
-emhass/static/advanced.html,sha256=gAhsd14elDwh1Ts4lf9wn_ZkczzzObq5qOimi_la3Ic,2067
-emhass/static/basic.html,sha256=ro2WwWgJyoUhqx_nJFzKCEG8FA8863vSHLmrjGYcEgs,677
-emhass/static/configuration_list.html,sha256=4ZAL-4YXdofnx17np-v39Yt3qW2TWbSzNBkj86bpvIg,1578
-emhass/static/configuration_script.js,sha256=N95GzyQdLzzOuSNw4L78BdArdqLPYJKhU3baGEsOhZE,31098
-emhass/static/script.js,sha256=q3qTqc_pTLTK-0NPKurxFXcJ2vZLz4TctPfUgz09ygo,16291
-emhass/static/style.css,sha256=a_8YlGubn1zoF5RTLJ_Qkrb8tAjUY9p7oAKxhCvJY2s,19288
-emhass/static/data/param_definitions.json,sha256=2z_nb94wrj-fVORy0F_hoOCHHv7CbemIoKpScCmRcPI,19243
-emhass/static/img/emhass_icon.png,sha256=Kyx6hXQ1huJLHAq2CaBfjYXR25H9j99PSWHI0lShkaQ,19030
-emhass/static/img/emhass_logo_short.svg,sha256=yzMcqtBRCV8rH84-MwnigZh45_f9Eoqwho9P8nCodJA,66736
-emhass/static/img/feather-sprite.svg,sha256=VHjMJQg88wXa9CaeYrKGhNtyK0xdd47zCqwSIa-hxo8,60319
-emhass/templates/configuration.html,sha256=yS9p730GHf99ZYK0NiZjkuaxPjH1ZFo8R6xL5c1ZZ9s,2885
-emhass/templates/index.html,sha256=Ehn-hUdraIwX_5Usb5Liz1ip24NfztmCxsi0J4Tf3-A,3076
-emhass/templates/template.html,sha256=TkGgMecQEbFUZA4ymPwMUzNjKHsENvCgroUWbPt7G4Y,158
-emhass-0.11.3.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
-emhass-0.11.3.dist-info/METADATA,sha256=hkZYpwr5bjDhC9hGaQdAY2braRkT10_LD5pHCFuxQ3A,48945
-emhass-0.11.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-emhass-0.11.3.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
-emhass-0.11.3.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
-emhass-0.11.3.dist-info/RECORD,,