emhass 0.13.3__py3-none-any.whl → 0.13.5__py3-none-any.whl

emhass/command_line.py

@@ -72,7 +72,9 @@ def retrieve_home_assistant_data(
         if optim_conf.get("set_use_pv", True):
             var_list.append(retrieve_hass_conf["sensor_power_photovoltaics"])
             if optim_conf.get("set_use_adjusted_pv", True):
-                var_list.append(retrieve_hass_conf["sensor_power_photovoltaics_forecast"])
+                var_list.append(
+                    retrieve_hass_conf["sensor_power_photovoltaics_forecast"]
+                )
         if not rh.get_data(
             days_list, var_list, minimal_response=False, significant_changes_only=False
         ):
@@ -302,7 +304,8 @@ def set_input_data_dict(
         else:
             P_PV_forecast = pd.Series(0, index=fcst.forecast_dates)
         P_load_forecast = fcst.get_load_forecast(
-            method=optim_conf["load_forecast_method"]
+            days_min_load_forecast=optim_conf["delta_forecast_daily"].days,
+            method=optim_conf["load_forecast_method"],
         )
         if isinstance(P_load_forecast, bool) and not P_load_forecast:
             logger.error(
@@ -400,6 +403,7 @@ def set_input_data_dict(
         else:
             P_PV_forecast = pd.Series(0, index=fcst.forecast_dates)
         P_load_forecast = fcst.get_load_forecast(
+            days_min_load_forecast=optim_conf["delta_forecast_daily"].days,
             method=optim_conf["load_forecast_method"],
             set_mix_forecast=set_mix_forecast,
             df_now=df_input_data,

emhass/data/associations.csv

@@ -61,6 +61,10 @@ plant_conf,surface_azimuth,surface_azimuth,list_surface_azimuth
 plant_conf,modules_per_string,modules_per_string,list_modules_per_string
 plant_conf,strings_per_inverter,strings_per_inverter,list_strings_per_inverter
 plant_conf,inverter_is_hybrid,inverter_is_hybrid
+plant_conf,inverter_ac_output_max,inverter_ac_output_max
+plant_conf,inverter_ac_input_max,inverter_ac_input_max
+plant_conf,inverter_efficiency_dc_ac,inverter_efficiency_dc_ac
+plant_conf,inverter_efficiency_ac_dc,inverter_efficiency_ac_dc
 plant_conf,compute_curtailment,compute_curtailment
 plant_conf,Pd_max,battery_discharge_power_max
 plant_conf,Pc_max,battery_charge_power_max

emhass/data/config_defaults.json

@@ -116,6 +116,10 @@
     1
   ],
   "inverter_is_hybrid": false,
+  "inverter_ac_output_max": 1000,
+  "inverter_ac_input_max": 1000,
+  "inverter_efficiency_dc_ac": 1.0,
+  "inverter_efficiency_ac_dc": 1.0,
   "compute_curtailment": false,
   "set_use_battery": false,
   "battery_discharge_power_max": 1000,

emhass/forecast.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 import bz2
 import copy
 import json
@@ -216,8 +214,7 @@ class Forecast:
                     ]
 
     def get_cached_open_meteo_forecast_json(
-        self,
-        max_age: int | None = 30,
+        self, max_age: int | None = 30, forecast_days: int = 3
     ) -> dict:
         r"""
         Get weather forecast json from Open-Meteo and cache it for re-use.
@@ -235,10 +232,30 @@ class Forecast:
             before it is discarded and a new version fetched from Open-Meteo.
             Defaults to 30 minutes.
         :type max_age: int, optional
+        :param forecast_days: The number of days of forecast data required from Open-Meteo.
+            One additional day is always fetched from Open-Meteo so there is an extra data in the cache.
+            Defaults to 2 days (3 days fetched) to match the prior default.
+        :type forecast_days: int, optional
         :return: The json containing the Open-Meteo forecast data
         :rtype: dict
 
         """
+
+        # Ensure at least 3 weather forecast days (and 1 more than requested)
+        if forecast_days is None:
+            self.logger.warning(
+                "Open-Meteo forecast_days is missing so defaulting to 3 days"
+            )
+            forecast_days = 3
+        elif forecast_days < 3:
+            self.logger.warning(
+                "Open-Meteo forecast_days is too low (%s) so defaulting to 3 days",
+                forecast_days,
+            )
+            forecast_days = 3
+        else:
+            forecast_days = forecast_days + 1
+
         json_path = os.path.abspath(
             self.emhass_conf["data_path"] / "cached-open-meteo-forecast.json"
         )
@@ -287,10 +304,13 @@ class Forecast:
                 + "shortwave_radiation_instant,"
                 + "diffuse_radiation_instant,"
                 + "direct_normal_irradiance_instant"
+                + "&forecast_days="
+                + str(forecast_days)
                 + "&timezone="
                 + quote(str(self.time_zone), safe="")
             )
             try:
+                self.logger.debug("Fetching data from Open-Meteo using URL: %s", url)
                 response = get(url, headers=headers)
                 self.logger.debug("Returned HTTP status code: %s", response.status_code)
                 response.raise_for_status()
@@ -349,7 +369,8 @@ class Forecast:
         ):  # The scrapper option is being left here for backward compatibility
             if not os.path.isfile(w_forecast_cache_path):
                 data_raw = self.get_cached_open_meteo_forecast_json(
-                    self.optim_conf["open_meteo_cache_max_age"]
+                    self.optim_conf["open_meteo_cache_max_age"],
+                    self.optim_conf["delta_forecast_daily"].days,
                 )
                 data_15min = pd.DataFrame.from_dict(data_raw["minutely_15"])
                 data_15min["time"] = pd.to_datetime(data_15min["time"])
@@ -671,6 +692,7 @@ class Forecast:
         alpha: float,
         beta: float,
         col: str,
+        ignore_pv_feedback: bool = False,
     ) -> pd.DataFrame:
         """A simple correction method for forecasted data using the current real values of a variable.
 
@@ -684,9 +706,15 @@ class Forecast:
         :type beta: float
         :param col: The column variable name
         :type col: str
+        :param ignore_pv_feedback: If True, bypass mixing and return original forecast (used during curtailment)
+        :type ignore_pv_feedback: bool
         :return: The output DataFrame with the corrected values
         :rtype: pd.DataFrame
         """
+        # If ignoring PV feedback (e.g., during curtailment), return original forecast
+        if ignore_pv_feedback:
+            return df_forecast
+
         first_fcst = alpha * df_forecast.iloc[0] + beta * df_now[col].iloc[-1]
         df_forecast.iloc[0] = int(round(first_fcst))
         return df_forecast
@@ -787,12 +815,14 @@ class Forecast:
                     # Extracting results for AC power
                     P_PV_forecast = mc.results.ac
         if set_mix_forecast:
+            ignore_pv_feedback = self.params["passed_data"].get("ignore_pv_feedback_during_curtailment", False)
             P_PV_forecast = Forecast.get_mix_forecast(
                 df_now,
                 P_PV_forecast,
                 self.params["passed_data"]["alpha"],
                 self.params["passed_data"]["beta"],
                 self.var_PV,
+                ignore_pv_feedback,
             )
         P_PV_forecast[P_PV_forecast < 0] = 0  # replace any negative PV values with zero
         self.logger.debug("get_power_from_weather returning:\n%s", P_PV_forecast)
@@ -1410,14 +1440,22 @@ class Forecast:
             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"]
+            # Old code logic (shifted timestamp problem)
+            # mask_forecast_out = (
+            #     df.index > days_list[-1] - self.optim_conf["delta_forecast_daily"]
+            # )
+            # forecast_out = df.copy().loc[mask_forecast_out]
+            # forecast_out = forecast_out.rename(columns={self.var_load_new: "yhat"})
+            # forecast_out = forecast_out.iloc[0 : len(self.forecast_dates)]
+            # forecast_out.index = self.forecast_dates
+            # New code logic
+            forecast_horizon = len(self.forecast_dates)
+            historical_values = df.iloc[-forecast_horizon:]
+            forecast_out = pd.DataFrame(
+                historical_values.values,
+                index=self.forecast_dates,
+                columns=["yhat"]
             )
-            forecast_out = df.copy().loc[mask_forecast_out]
-            forecast_out = forecast_out.rename(columns={self.var_load_new: "yhat"})
-            # Force forecast_out length to avoid mismatches
-            forecast_out = forecast_out.iloc[0 : len(self.forecast_dates)]
-            forecast_out.index = self.forecast_dates
         elif (
             method == "mlforecaster"
         ):  # using a custom forecast model with machine learning
@@ -1506,12 +1544,14 @@ class Forecast:
             return False
         P_Load_forecast = copy.deepcopy(forecast_out["yhat"])
         if set_mix_forecast:
+            # Load forecasts don't need curtailment protection - always use feedback
             P_Load_forecast = Forecast.get_mix_forecast(
                 df_now,
                 P_Load_forecast,
                 self.params["passed_data"]["alpha"],
                 self.params["passed_data"]["beta"],
                 self.var_load_new,
+                False,  # Never ignore feedback for load forecasts
             )
         self.logger.debug("get_load_forecast returning:\n%s", P_Load_forecast)
         return P_Load_forecast

emhass/machine_learning_forecaster.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 import logging
 import time
 import warnings

emhass/optimization.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 import bz2
 import copy
 import logging
@@ -114,10 +112,14 @@ class Optimization:
                 "lp_solver=COIN_CMD but lp_solver_path=empty, attempting to use lp_solver_path=/usr/bin/cbc"
             )
             self.lp_solver_path = "/usr/bin/cbc"
-        self.logger.debug(f"Initialized Optimization with retrieve_hass_conf: {retrieve_hass_conf}")
+        self.logger.debug(
+            f"Initialized Optimization with retrieve_hass_conf: {retrieve_hass_conf}"
+        )
         self.logger.debug(f"Optimization configuration: {optim_conf}")
         self.logger.debug(f"Plant configuration: {plant_conf}")
-        self.logger.debug(f"Solver configuration: lp_solver={self.lp_solver}, lp_solver_path={self.lp_solver_path}")
+        self.logger.debug(
+            f"Solver configuration: lp_solver={self.lp_solver}, lp_solver_path={self.lp_solver_path}"
+        )
         self.logger.debug(f"Number of threads: {self.num_threads}")
 
     def perform_optimization(
@@ -187,10 +189,14 @@ class Optimization:
                     soc_final = soc_init
                 else:
                     soc_final = self.plant_conf["battery_target_state_of_charge"]
-            self.logger.debug(f"Battery usage enabled. Initial SOC: {soc_init}, Final SOC: {soc_final}")
+            self.logger.debug(
+                f"Battery usage enabled. Initial SOC: {soc_init}, Final SOC: {soc_final}"
+            )
 
         # If def_total_timestep os set, bypass def_total_hours
         if def_total_timestep is not None:
+            if def_total_hours is None:
+                def_total_hours = self.optim_conf["operating_hours_of_each_deferrable_load"]
             def_total_hours = [0 if x != 0 else x for x in def_total_hours]
         elif def_total_hours is None:
             def_total_hours = self.optim_conf["operating_hours_of_each_deferrable_load"]
@@ -205,9 +211,21 @@ class Optimization:
 
         num_deferrable_loads = self.optim_conf["number_of_deferrable_loads"]
 
-        def_total_hours = def_total_hours + [0] * (num_deferrable_loads - len(def_total_hours))
-        def_start_timestep = def_start_timestep + [0] * (num_deferrable_loads - len(def_start_timestep))
-        def_end_timestep = def_end_timestep + [0] * (num_deferrable_loads - len(def_end_timestep))
+        # Retrieve the minimum power for each deferrable load, defaulting to 0 if not provided
+        min_power_of_deferrable_loads = self.optim_conf.get("minimum_power_of_deferrable_loads", [0] * num_deferrable_loads)
+        min_power_of_deferrable_loads = min_power_of_deferrable_loads + [0] * (
+            num_deferrable_loads - len(min_power_of_deferrable_loads)
+        )
+
+        def_total_hours = def_total_hours + [0] * (
+            num_deferrable_loads - len(def_total_hours)
+        )
+        def_start_timestep = def_start_timestep + [0] * (
+            num_deferrable_loads - len(def_start_timestep)
+        )
+        def_end_timestep = def_end_timestep + [0] * (
+            num_deferrable_loads - len(def_end_timestep)
+        )
 
         #### The LP problem using Pulp ####
         opt_model = plp.LpProblem("LP_Model", plp.LpMaximize)
@@ -473,71 +491,145 @@ class Optimization:
                     for i in set_I
                 }
 
-        # Constraint for hybrid inverter and curtailment cases
-        if isinstance(self.plant_conf["pv_module_model"], list):
-            P_nom_inverter = 0.0
-            for i in range(len(self.plant_conf["pv_inverter_model"])):
-                if isinstance(self.plant_conf["pv_inverter_model"][i], str):
-                    cec_inverters = bz2.BZ2File(
-                        self.emhass_conf["root_path"] / "data" / "cec_inverters.pbz2",
-                        "rb",
-                    )
-                    cec_inverters = cPickle.load(cec_inverters)
-                    inverter = cec_inverters[self.plant_conf["pv_inverter_model"][i]]
-                    P_nom_inverter += inverter.Paco
-                else:
-                    P_nom_inverter += self.plant_conf["pv_inverter_model"][i]
-        else:
-            if isinstance(self.plant_conf["pv_inverter_model"][i], str):
-                cec_inverters = bz2.BZ2File(
-                    self.emhass_conf["root_path"] / "data" / "cec_inverters.pbz2", "rb"
-                )
-                cec_inverters = cPickle.load(cec_inverters)
-                inverter = cec_inverters[self.plant_conf["pv_inverter_model"]]
-                P_nom_inverter = inverter.Paco
-            else:
-                P_nom_inverter = self.plant_conf["pv_inverter_model"]
         if self.plant_conf["inverter_is_hybrid"]:
+            P_nom_inverter_output = self.plant_conf.get("inverter_ac_output_max", None)
+            P_nom_inverter_input = self.plant_conf.get("inverter_ac_input_max", None)
+
+            # Fallback to legacy pv_inverter_model for output power if new setting is not provided
+            if P_nom_inverter_output is None:
+                if "pv_inverter_model" in self.plant_conf:
+                    if isinstance(self.plant_conf["pv_inverter_model"], list):
+                        P_nom_inverter_output = 0.0
+                        for i in range(len(self.plant_conf["pv_inverter_model"])):
+                            if isinstance(self.plant_conf["pv_inverter_model"][i], str):
+                                cec_inverters = bz2.BZ2File(
+                                    self.emhass_conf["root_path"]
+                                    / "data"
+                                    / "cec_inverters.pbz2",
+                                    "rb",
+                                )
+                                cec_inverters = cPickle.load(cec_inverters)
+                                inverter = cec_inverters[
+                                    self.plant_conf["pv_inverter_model"][i]
+                                ]
+                                P_nom_inverter_output += inverter.Paco
+                            else:
+                                P_nom_inverter_output += self.plant_conf[
+                                    "pv_inverter_model"
+                                ][i]
+                    else:
+                        if isinstance(self.plant_conf["pv_inverter_model"], str):
+                            cec_inverters = bz2.BZ2File(
+                                self.emhass_conf["root_path"]
+                                / "data"
+                                / "cec_inverters.pbz2",
+                                "rb",
+                            )
+                            cec_inverters = cPickle.load(cec_inverters)
+                            inverter = cec_inverters[
+                                self.plant_conf["pv_inverter_model"]
+                            ]
+                            P_nom_inverter_output = inverter.Paco
+                        else:
+                            P_nom_inverter_output = self.plant_conf["pv_inverter_model"]
+
+            if P_nom_inverter_input is None:
+                P_nom_inverter_input = P_nom_inverter_output
+
+            # Get efficiency parameters, defaulting to 100%
+            eff_dc_ac = self.plant_conf.get("inverter_efficiency_dc_ac", 1.0)
+            eff_ac_dc = self.plant_conf.get("inverter_efficiency_ac_dc", 1.0)
+
+            # Calculate the maximum allowed DC power flows based on AC limits and efficiency.
+            P_dc_ac_max = P_nom_inverter_output / eff_dc_ac
+            P_ac_dc_max = P_nom_inverter_input * eff_ac_dc
+
+            # Define unidirectional DC power flow variables with the tight, calculated bounds.
+            P_dc_ac = {
+                (i): plp.LpVariable(
+                    cat="Continuous",
+                    lowBound=0,
+                    upBound=P_dc_ac_max,
+                    name=f"P_dc_ac_{i}",
+                )
+                for i in set_I
+            }
+            P_ac_dc = {
+                (i): plp.LpVariable(
+                    cat="Continuous",
+                    lowBound=0,
+                    upBound=P_ac_dc_max,
+                    name=f"P_ac_dc_{i}",
+                )
+                for i in set_I
+            }
+            # Binary variable to enforce unidirectional flow
+            is_dc_sourcing = {
+                (i): plp.LpVariable(cat="Binary", name=f"is_dc_sourcing_{i}")
+                for i in set_I
+            }
+
+            # Define the core energy balance equations for each timestep
+            for i in set_I:
+                # The net DC power from PV and battery must equal the net DC flow of the inverter
+                constraints.update(
+                    {
+                        f"constraint_dc_bus_balance_{i}": plp.LpConstraint(
+                            e=(
+                                P_PV[i]
+                                - P_PV_curtailment[i]
+                                + P_sto_pos[i]
+                                + P_sto_neg[i]
+                            )
+                            - (P_dc_ac[i] - P_ac_dc[i]),
+                            sense=plp.LpConstraintEQ,
+                            rhs=0,
+                        )
+                    }
+                )
+
+                # The AC power is defined by the efficiency-adjusted DC flows
+                constraints.update(
+                    {
+                        f"constraint_ac_bus_balance_{i}": plp.LpConstraint(
+                            e=P_hybrid_inverter[i]
+                            - ((P_dc_ac[i] * eff_dc_ac) - (P_ac_dc[i] / eff_ac_dc)),
+                            sense=plp.LpConstraintEQ,
+                            rhs=0,
+                        )
+                    }
+                )
+
+                # Use the binary variable to ensure only one direction is active at a time
+                constraints.update(
+                    {
+                        # If is_dc_sourcing = 1 (DC->AC is active), then P_ac_dc must be 0.
+                        f"constraint_enforce_ac_dc_zero_{i}": plp.LpConstraint(
+                            e=P_ac_dc[i] - (1 - is_dc_sourcing[i]) * P_ac_dc_max,
+                            sense=plp.LpConstraintLE,
+                            rhs=0,
+                        ),
+                        # If is_dc_sourcing = 0 (AC->DC is active), then P_dc_ac must be 0.
+                        f"constraint_enforce_dc_ac_zero_{i}": plp.LpConstraint(
+                            e=P_dc_ac[i] - is_dc_sourcing[i] * P_dc_ac_max,
+                            sense=plp.LpConstraintLE,
+                            rhs=0,
+                        ),
+                    }
+                )
+
+        # Apply curtailment constraint if enabled, regardless of inverter type
+        if self.plant_conf["compute_curtailment"]:
             constraints.update(
                 {
-                    f"constraint_hybrid_inverter1_{i}": plp.LpConstraint(
-                        e=P_PV[i]
-                        - P_PV_curtailment[i]
-                        + P_sto_pos[i]
-                        + P_sto_neg[i]
-                        - P_nom_inverter,
+                    f"constraint_curtailment_{i}": plp.LpConstraint(
+                        e=P_PV_curtailment[i] - max(P_PV[i], 0),
                         sense=plp.LpConstraintLE,
                         rhs=0,
                     )
                     for i in set_I
                 }
             )
-            constraints.update(
-                {
-                    f"constraint_hybrid_inverter2_{i}": plp.LpConstraint(
-                        e=P_PV[i]
-                        - P_PV_curtailment[i]
-                        + P_sto_pos[i]
-                        + P_sto_neg[i]
-                        - P_hybrid_inverter[i],
-                        sense=plp.LpConstraintEQ,
-                        rhs=0,
-                    )
-                    for i in set_I
-                }
-            )
-        else:
-            if self.plant_conf["compute_curtailment"]:
-                constraints.update(
-                    {
-                        f"constraint_curtailment_{i}": plp.LpConstraint(
-                            e=P_PV_curtailment[i] - max(P_PV[i], 0),
-                            sense=plp.LpConstraintLE,
-                            rhs=0,
-                        )
-                        for i in set_I
-                    }
-                )
 
         # Two special constraints just for a self-consumption cost function
         if self.costfun == "self-consumption":
@@ -591,7 +683,9 @@ class Optimization:
             if isinstance(
                 self.optim_conf["nominal_power_of_deferrable_loads"][k], list
             ):
-                self.logger.debug(f"Load {k} is sequence-based. Sequence: {self.optim_conf['nominal_power_of_deferrable_loads'][k]}")
+                self.logger.debug(
+                    f"Load {k} is sequence-based. Sequence: {self.optim_conf['nominal_power_of_deferrable_loads'][k]}"
+                )
                 # Constraint for sequence of deferrable
                 # WARNING: This is experimental, formulation seems correct but feasibility problems.
                 # Probably uncomptabile with other constraints
@@ -609,7 +703,9 @@ class Optimization:
                 y = plp.LpVariable.dicts(
                     f"y{k}", (i for i in range(len(matrix))), cat="Binary"
                 )
-                self.logger.debug(f"Load {k}: Created binary variables for sequence placement: y = {list(y.keys())}")
+                self.logger.debug(
+                    f"Load {k}: Created binary variables for sequence placement: y = {list(y.keys())}"
+                )
                 constraints.update(
                     {
                         f"single_value_constraint_{k}": plp.LpConstraint(
@@ -664,12 +760,16 @@ class Optimization:
                     cooling_constant = hc["cooling_constant"]
                     heating_rate = hc["heating_rate"]
                     overshoot_temperature = hc["overshoot_temperature"]
-                    outdoor_temperature_forecast = data_opt["outdoor_temperature_forecast"]
+                    outdoor_temperature_forecast = data_opt[
+                        "outdoor_temperature_forecast"
+                    ]
                     desired_temperatures = hc["desired_temperatures"]
                     sense = hc.get("sense", "heat")
                     sense_coeff = 1 if sense == "heat" else -1
 
-                    self.logger.debug(f"Load {k}: Thermal parameters: start_temperature={start_temperature}, cooling_constant={cooling_constant}, heating_rate={heating_rate}, overshoot_temperature={overshoot_temperature}")
+                    self.logger.debug(
+                        f"Load {k}: Thermal parameters: start_temperature={start_temperature}, cooling_constant={cooling_constant}, heating_rate={heating_rate}, overshoot_temperature={overshoot_temperature}"
+                    )
 
                     predicted_temp = [start_temperature]
                     for Id in set_I:
@@ -682,7 +782,9 @@ class Optimization:
                                 * (
                                     heating_rate
                                     * self.timeStep
-                                    / self.optim_conf["nominal_power_of_deferrable_loads"][k]
+                                    / self.optim_conf[
+                                        "nominal_power_of_deferrable_loads"
+                                    ][k]
                                 )
                             )
                             - (
@@ -694,9 +796,7 @@ class Optimization:
                             )
                         )
 
-                        is_overshoot = plp.LpVariable(
-                            f"defload_{k}_overshoot_{Id}"
-                        )
+                        is_overshoot = plp.LpVariable(f"defload_{k}_overshoot_{Id}")
                         constraints.update(
                             {
                                 f"constraint_defload{k}_overshoot_{Id}_1": plp.LpConstraint(
@@ -732,9 +832,10 @@ class Optimization:
                                     "penalty_factor must be positive, otherwise the problem will become unsolvable"
                                 )
                             penalty_value = (
-                                predicted_temp[Id]
-                                - desired_temperatures[Id]
-                            ) * penalty_factor * sense_coeff
+                                (predicted_temp[Id] - desired_temperatures[Id])
+                                * penalty_factor
+                                * sense_coeff
+                            )
                             penalty_var = plp.LpVariable(
                                 f"defload_{k}_thermal_penalty_{Id}",
                                 cat="Continuous",
@@ -755,13 +856,14 @@ class Optimization:
                     self.logger.debug(f"Load {k}: Thermal constraints set.")
 
             # --- Standard/non-thermal deferrable load logic comes after thermal ---
-            elif (
-                (def_total_timestep and def_total_timestep[k] > 0)
-                or (len(def_total_hours) > k and def_total_hours[k] > 0)):
-
+            elif (def_total_timestep and def_total_timestep[k] > 0) or (
+                len(def_total_hours) > k and def_total_hours[k] > 0
+            ):
                 self.logger.debug(f"Load {k} is standard/non-thermal.")
                 if def_total_timestep and def_total_timestep[k] > 0:
-                    self.logger.debug(f"Load {k}: Using total timesteps constraint: {def_total_timestep[k]}")
+                    self.logger.debug(
+                        f"Load {k}: Using total timesteps constraint: {def_total_timestep[k]}"
+                    )
                     constraints.update(
                         {
                             f"constraint_defload{k}_energy": plp.LpConstraint(
@@ -770,12 +872,16 @@ class Optimization:
                                 ),
                                 sense=plp.LpConstraintEQ,
                                 rhs=(self.timeStep * def_total_timestep[k])
-                                * self.optim_conf["nominal_power_of_deferrable_loads"][k],
+                                * self.optim_conf["nominal_power_of_deferrable_loads"][
+                                    k
+                                ],
                             )
                         }
                     )
                 else:
-                    self.logger.debug(f"Load {k}: Using total hours constraint: {def_total_hours[k]}")
+                    self.logger.debug(
+                        f"Load {k}: Using total hours constraint: {def_total_hours[k]}"
+                    )
                     constraints.update(
                         {
                             f"constraint_defload{k}_energy": plp.LpConstraint(
@@ -784,13 +890,14 @@ class Optimization:
                                 ),
                                 sense=plp.LpConstraintEQ,
                                 rhs=def_total_hours[k]
-                                * self.optim_conf["nominal_power_of_deferrable_loads"][k],
+                                * self.optim_conf["nominal_power_of_deferrable_loads"][
+                                    k
+                                ],
                             )
                         }
                     )
                 self.logger.debug(f"Load {k}: Standard load constraints set.")
 
-
             # Ensure deferrable loads consume energy between def_start_timestep & def_end_timestep
             self.logger.debug(
                 f"Deferrable load {k}: Proposed optimization window: {def_start_timestep[k]} --> {def_end_timestep[k]}"
@@ -799,10 +906,7 @@ class Optimization:
                 def_start, def_end, warning = Optimization.validate_def_timewindow(
                     def_start_timestep[k],
                     def_end_timestep[k],
-                    ceil(
-                        (60 / ((self.freq.seconds / 60) * def_total_timestep[k]))
-                        / self.timeStep
-                    ),
+                    ceil(def_total_timestep[k]),
                     n,
                 )
             else:
@@ -844,6 +948,20 @@ class Optimization:
                     }
                 )
 
+            # Constraint for the minimum power of deferrable loads using the big-M method.
+            # This enforces: P_deferrable = 0 OR P_deferrable >= min_power.
+            if min_power_of_deferrable_loads[k] > 0:
+                self.logger.debug(f"Applying minimum power constraint for deferrable load {k}: {min_power_of_deferrable_loads[k]} W")
+                constraints.update(
+                    {
+                        f"constraint_pdef{k}_min_power_{i}": plp.LpConstraint(
+                            e=P_deferrable[k][i] - (min_power_of_deferrable_loads[k] * P_def_bin2[k][i]),
+                            sense=plp.LpConstraintGE,
+                            rhs=0
+                        ) for i in set_I
+                    }
+                )
+
             # Treat the number of starts for a deferrable load (new method considering current state)
             current_state = 0
             if (
@@ -923,16 +1041,7 @@ class Optimization:
                             f"constraint_pdef{k}_start5": plp.LpConstraint(
                                 e=plp.lpSum(P_def_bin2[k][i] for i in set_I),
                                 sense=plp.LpConstraintEQ,
-                                rhs=(
-                                    (
-                                        60
-                                        / (
-                                            (self.freq.seconds / 60)
-                                            * def_total_timestep[k]
-                                        )
-                                    )
-                                    / self.timeStep
-                                ),
+                                rhs=def_total_timestep[k],
                             )
                         }
                     )
@@ -1142,18 +1251,27 @@ class Optimization:
         timeout = self.optim_conf["lp_solver_timeout"]
         # solving with default solver CBC
         if self.lp_solver == "PULP_CBC_CMD":
-            opt_model.solve(PULP_CBC_CMD(msg=0, timeLimit=timeout, threads=self.num_threads))
+            opt_model.solve(
+                PULP_CBC_CMD(msg=0, timeLimit=timeout, threads=self.num_threads)
+            )
         elif self.lp_solver == "GLPK_CMD":
             opt_model.solve(GLPK_CMD(msg=0, timeLimit=timeout))
         elif self.lp_solver == "HiGHS":
             opt_model.solve(HiGHS(msg=0, timeLimit=timeout))
         elif self.lp_solver == "COIN_CMD":
             opt_model.solve(
-                COIN_CMD(msg=0, path=self.lp_solver_path, timeLimit=timeout, threads=self.num_threads)
+                COIN_CMD(
+                    msg=0,
+                    path=self.lp_solver_path,
+                    timeLimit=timeout,
+                    threads=self.num_threads,
+                )
             )
         else:
             self.logger.warning("Solver %s unknown, using default", self.lp_solver)
-            opt_model.solve(PULP_CBC_CMD(msg=0, timeLimit=timeout, threads=self.num_threads))
+            opt_model.solve(
+                PULP_CBC_CMD(msg=0, timeLimit=timeout, threads=self.num_threads)
+            )
 
         # The status of the solution is printed to the screen
         self.optim_status = plp.LpStatus[opt_model.status]
@@ -1317,7 +1435,9 @@ class Optimization:
 
         # Battery initialization logging
         if self.optim_conf["set_use_battery"]:
-            self.logger.debug(f"Battery usage enabled. Initial SOC: {soc_init}, Final SOC: {soc_final}")
+            self.logger.debug(
+                f"Battery usage enabled. Initial SOC: {soc_init}, Final SOC: {soc_final}"
+            )
 
         # Deferrable load initialization logging
         self.logger.debug(f"Deferrable load operating hours: {def_total_hours}")

emhass/retrieve_hass.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 import copy
 import datetime
 import json
@@ -109,7 +107,9 @@ class RetrieveHass:
         try:
             self.ha_config = response_config.json()
         except Exception:
-            self.logger.error("EMHASS was unable to obtain configuration data from Home Assistant")
+            self.logger.error(
+                "EMHASS was unable to obtain configuration data from Home Assistant"
+            )
             return False
 
     def get_data(
@@ -204,7 +204,9 @@ class RetrieveHass:
                         )
                         return False
                     if response.status_code > 299:
-                        self.logger.error(f"Home assistant request GET error: {response.status_code} for var {var}")
+                        self.logger.error(
+                            f"Home assistant request GET error: {response.status_code} for var {var}"
+                        )
                         return False
                 """import bz2 # Uncomment to save a serialized data for tests
                 import _pickle as cPickle
@@ -268,7 +270,7 @@ class RetrieveHass:
                     ).max()
                     ts = pd.to_datetime(
                         pd.date_range(start=from_date, end=to_date, freq=self.freq),
-                        format="%Y-%d-%m %H:%M"
+                        format="%Y-%d-%m %H:%M",
                     ).round(self.freq, ambiguous="infer", nonexistent="shift_forward")
                     df_day = pd.DataFrame(index=ts)
                 # Caution with undefined string data: unknown, unavailable, etc.

emhass/static/data/param_definitions.json

@@ -187,6 +187,30 @@
       "input": "boolean",
       "default_value": false
     },
+    "inverter_ac_output_max": {
+      "friendly_name": "Max hybrid inverter AC output power",
+      "Description": "Maximum hybrid inverter output power from combined PV and battery discharge.",
+      "input": "int",
+      "default_value": 0
+    },
+    "inverter_ac_input_max": {
+      "friendly_name": "Max hybrid inverter AC input power",
+      "Description": "Maximum hybrid inverter input power from grid to charge battery.",
+      "input": "int",
+      "default_value": 0
+    },
+    "inverter_efficiency_dc_ac": {
+      "friendly_name": "Hybrid inverter efficency DC to AC",
+      "Description": "Hybrid inverter efficiency from the DC bus to AC output. (percentage/100)",
+      "input": "float",
+      "default_value": 1.0
+    },
+    "inverter_efficiency_ac_dc": {
+      "friendly_name": "Hybrid inverter efficency AC to DC",
+      "Description": "Hybrid inverter efficiency when charging from the AC input to DC bus. (percentage/100)",
+      "input": "float",
+      "default_value": 1.0
+    },
     "compute_curtailment": {
       "friendly_name": "Set compute curtailment (grid export limit)",
       "Description": "Set to True to compute a special PV curtailment variable (Default False)",
@@ -484,6 +508,12 @@
       "Description": "The desired battery state of charge at the end of each optimization cycle. (percentage/100)",
       "input": "float",
       "default_value": 0.6
+    },
+    "ignore_pv_feedback_during_curtailment": {
+      "friendly_name": "Ignore PV feedback during curtailment",
+      "Description": "When set to true, prevents PV forecast from being updated with real PV data, avoiding flip-flop behavior during curtailment operations",
+      "input": "bool",
+      "default_value": false
     }
   }
 }

emhass/utils.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 from __future__ import annotations
 
 import ast
@@ -120,12 +119,12 @@ def get_forecast_dates(
 
     """
     freq = pd.to_timedelta(freq, "minutes")
-    start_forecast = pd.Timestamp(datetime.now()).replace(
-        hour=0, minute=0, second=0, microsecond=0
-    )
-    end_forecast = (start_forecast + pd.Timedelta(days=delta_forecast)).replace(
-        microsecond=0
+    start_forecast = (
+        pd.Timestamp(datetime.now(), tz=time_zone)
+        .replace(microsecond=0)
+        .floor(freq=freq)
     )
+    end_forecast = start_forecast + pd.Timedelta(days=delta_forecast)
     forecast_dates = (
         pd.date_range(
             start=start_forecast,
@@ -409,11 +408,29 @@ def treat_runtimeparams(
             runtimeparams.get("delta_forecast_daily", None) is not None
             or runtimeparams.get("delta_forecast", None) is not None
         ):
-            delta_forecast = int(
-                runtimeparams.get(
-                    "delta_forecast_daily", runtimeparams["delta_forecast"]
+            # Use old param name delta_forecast (if provided) for backwards compatibility
+            delta_forecast = runtimeparams.get("delta_forecast", None)
+            # Prefer new param name delta_forecast_daily
+            delta_forecast = runtimeparams.get("delta_forecast_daily", delta_forecast)
+            # Ensure delta_forecast is numeric and at least 1 day
+            if delta_forecast is None:
+                logger.warning("delta_forecast_daily is missing so defaulting to 1 day")
+                delta_forecast = 1
+            else:
+                try:
+                    delta_forecast = int(delta_forecast)
+                except ValueError:
+                    logger.warning(
+                        "Invalid delta_forecast_daily value (%s) so defaulting to 1 day",
+                        delta_forecast,
+                    )
+                    delta_forecast = 1
+            if delta_forecast <= 0:
+                logger.warning(
+                    "delta_forecast_daily is too low (%s) so defaulting to 1 day",
+                    delta_forecast,
                 )
-            )
+                delta_forecast = 1
             params["optim_conf"]["delta_forecast_daily"] = pd.Timedelta(
                 days=delta_forecast
             )
@@ -574,27 +591,49 @@ def treat_runtimeparams(
         # 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]
+                forecast_input = runtimeparams[forecast_key]
+                if isinstance(forecast_input, dict):
+                    forecast_data_df = pd.DataFrame.from_dict(
+                        forecast_input, orient="index"
+                    ).reset_index()
+                    forecast_data_df.columns = ["time", "value"]
+                    forecast_data_df["time"] = pd.to_datetime(
+                        forecast_data_df["time"], format="ISO8601", utc=True
+                    ).dt.tz_convert(time_zone)
+
+                    # align index with forecast_dates
+                    forecast_data_df = (
+                        forecast_data_df.resample(
+                            pd.to_timedelta(optimization_time_step, "minutes"),
+                            on="time",
+                        )
+                        .aggregate({"value": "mean"})
+                        .reindex(forecast_dates, method="nearest")
+                    )
+                    forecast_data_df["value"] = (
+                        forecast_data_df["value"].ffill().bfill()
+                    )
+                    forecast_input = forecast_data_df["value"].tolist()
+                if isinstance(forecast_input, list) and len(forecast_input) >= len(
+                    forecast_dates
+                ):
+                    params["passed_data"][forecast_key] = forecast_input
                     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))}"
+                        f"ERROR: The passed data is either the wrong type 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]
-                        )
+                if isinstance(forecast_input, str):
+                    if isinstance(ast.literal_eval(forecast_input), list):
+                        forecast_input = ast.literal_eval(forecast_input)
+                        runtimeparams[forecast_key] = forecast_input
                 list_non_digits = [
                     x
-                    for x in runtimeparams[forecast_key]
+                    for x in forecast_input
                     if not (isinstance(x, int) or isinstance(x, float))
                 ]
                 if len(list_non_digits) > 0:
@@ -923,6 +962,7 @@ def get_injection_dict(df: pd.DataFrame, plot_size: int | None = 1366) -> dict:
         template="presentation",
         line_shape="hv",
         color_discrete_sequence=colors,
+        render_mode="svg",
     )
     fig_0.update_layout(xaxis_title="Timestamp", yaxis_title="System powers (W)")
     if "SOC_opt" in df.columns.to_list():
@@ -932,6 +972,7 @@ def get_injection_dict(df: pd.DataFrame, plot_size: int | None = 1366) -> dict:
             template="presentation",
             line_shape="hv",
             color_discrete_sequence=colors,
+            render_mode="svg",
         )
         fig_1.update_layout(xaxis_title="Timestamp", yaxis_title="Battery SOC (%)")
     cols_cost = [i for i in df.columns.to_list() if "cost_" in i or "unit_" in i]
@@ -945,6 +986,7 @@ def get_injection_dict(df: pd.DataFrame, plot_size: int | None = 1366) -> dict:
         template="presentation",
         line_shape="hv",
         color_discrete_sequence=colors,
+        render_mode="svg",
     )
     fig_2.update_layout(xaxis_title="Timestamp", yaxis_title="System costs (currency)")
     # Get full path to image
@@ -1638,6 +1680,7 @@ def build_params(
         "end_timesteps_of_each_deferrable_load": None,
         "alpha": None,
         "beta": None,
+        "ignore_pv_feedback_during_curtailment": None,
     }
 
     return params

emhass/web_server.py

@@ -10,10 +10,10 @@ import threading
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 
+import jinja2
 import yaml
 from flask import Flask, make_response, request
 from flask import logging as log
-from jinja2 import Environment, PackageLoader
 from waitress import serve
 
 from emhass.command_line import (
@@ -50,6 +50,10 @@ params_secrets = {}
 continual_publish_thread = []
 injection_dict = {}
 
+templates = jinja2.Environment(
+    loader=jinja2.PackageLoader("emhass", "templates"),
+)
+
 
 def create_app(settings_override=None):
     """
@@ -137,14 +141,6 @@ def index():
 
     """
     app.logger.info("EMHASS server online, serving index.html...")
-    # Load HTML template
-    file_loader = PackageLoader("emhass", "templates")
-    env = Environment(loader=file_loader)
-    # check if index.html exists
-    if "index.html" not in env.list_templates():
-        app.logger.error("Unable to find index.html in emhass module")
-        return make_response(["ERROR: unable to find index.html in emhass module"], 404)
-    template = env.get_template("index.html")
     # Load cached dict (if exists), to present generated plot tables
     if (emhass_conf["data_path"] / "injection_dict.pkl").exists():
         with open(str(emhass_conf["data_path"] / "injection_dict.pkl"), "rb") as fid:
@@ -159,6 +155,7 @@ def index():
     # basename = request.headers.get("X-Ingress-Path", "")
     # return make_response(template.render(injection_dict=injection_dict, basename=basename))
 
+    template = templates.get_template("index.html")
     return make_response(template.render(injection_dict=injection_dict))
 
 
@@ -174,16 +171,8 @@ def configuration():
     if (emhass_conf["data_path"] / "params.pkl").exists():
         with open(str(emhass_conf["data_path"] / "params.pkl"), "rb") as fid:
             emhass_conf["config_path"], params = pickle.load(fid)
-    # Load HTML template
-    file_loader = PackageLoader("emhass", "templates")
-    env = Environment(loader=file_loader)
-    # check if configuration.html exists
-    if "configuration.html" not in env.list_templates():
-        app.logger.error("Unable to find configuration.html in emhass module")
-        return make_response(
-            ["ERROR: unable to find configuration.html in emhass module"], 404
-        )
-    template = env.get_template("configuration.html")
+
+    template = templates.get_template("configuration.html")
     return make_response(template.render(config=params))
 
 
@@ -195,15 +184,6 @@ def template_action():
 
     """
     app.logger.info(" >> Sending rendered template table data")
-    file_loader = PackageLoader("emhass", "templates")
-    env = Environment(loader=file_loader)
-    # Check if template.html exists
-    if "template.html" not in env.list_templates():
-        app.logger.error("Unable to find template.html in emhass module")
-        return make_response(
-            ["WARNING: unable to find template.html in emhass module"], 404
-        )
-    template = env.get_template("template.html")
     if (emhass_conf["data_path"] / "injection_dict.pkl").exists():
         with open(str(emhass_conf["data_path"] / "injection_dict.pkl"), "rb") as fid:
             injection_dict = pickle.load(fid)
@@ -211,6 +191,8 @@ def template_action():
         app.logger.warning("Unable to obtain plot data from injection_dict.pkl")
         app.logger.warning("Try running an launch an optimization task")
         injection_dict = {}
+
+    template = templates.get_template("template.html")
     return make_response(template.render(injection_dict=injection_dict))
 
 

{emhass-0.13.3.dist-info → emhass-0.13.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emhass
-Version: 0.13.3
+Version: 0.13.5
 Summary: An Energy Management System for Home Assistant
 Project-URL: Homepage, https://github.com/davidusb-geek/emhass
 Project-URL: Source, https://github.com/davidusb-geek/emhass
@@ -118,17 +118,10 @@ Description-Content-Type: text/markdown
 </div>
 
 <br>
-<p align="center">
-If you like this work please consider buying a coffee ;-) 
-</p>
-<p align="center">
-  <a href="https://www.buymeacoffee.com/davidusbgeek" target="_blank">
-    <img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" >
-  </a>
+<p align="left">
+EMHASS is a Python module designed to optimize your home energy interfacing with Home Assistant.
 </p>
 
-EHMASS is a Python module designed to optimize your home energy interfacing with Home Assistant.
-
 ## Introduction
 
 EMHASS (Energy Management for Home Assistant) is an optimization tool designed for residential households. The package uses a Linear Programming approach to optimize energy usage while considering factors such as electricity prices, power generation from solar panels, and energy storage from batteries. EMHASS provides a high degree of configurability, making it easy to integrate with Home Assistant and other smart home systems. Whether you have solar panels, energy storage, or just a controllable load, EMHASS can provide an optimized daily schedule for your devices, allowing you to save money and minimize your environmental impact.
@@ -197,12 +190,13 @@ _Note: Both EMHASS via Docker and EMHASS-Add-on contain the same Docker image. T
 
 ### Method 2) Running EMHASS in Docker
 
-You can also install EMHASS using Docker as a container. This can be in the same machine as Home Assistant (if your running Home Assistant as a Docker container) or in a different distant machine. To install first pull the latest image:
+You can also install EMHASS using Docker as a container. This can be in the same machine as Home Assistant (if your running Home Assistant as a Docker container) or in a different distant machine. The "share" folder is where EMHASS stores the config.json file. In the examples below adjust the "-v" volume mappings to reflect where your path to the local host directory needs to be mapped to.
+To install first pull the latest image:
 ```bash
 # pull Docker image
 docker pull ghcr.io/davidusb-geek/emhass:latest
-# run Docker image, mounting config.json and secrets_emhass.yaml from host
-docker run --rm -it --restart always  -p 5000:5000 --name emhass-container -v ./config.json:/share/config.json -v ./secrets_emhass.yaml:/app/secrets_emhass.yaml ghcr.io/davidusb-geek/emhass:latest
+# run Docker image, mounting the dir storing config.json and secrets_emhass.yaml from host
+docker run --rm -it --restart always  -p 5000:5000 --name emhass-container -v /emhass/share:/share/ -v /emhass/secrets_emhass.yaml:/app/secrets_emhass.yaml ghcr.io/davidusb-geek/emhass:latest
 ```
 *Note it is not recommended to install the latest EMHASS image with `:latest` *(as you would likely want to control when you update EMHASS version)*. Instead, find the [latest version tag](https://github.com/davidusb-geek/emhass/pkgs/container/emhass) (E.g: `v0.2.1`) and replace `latest`*
 
@@ -216,7 +210,7 @@ cd emhass
 # may need to set architecture tag (docker build --build-arg TARGETARCH=amd64 -t emhass-local .)
 docker build -t emhass-local . 
 # run built Docker image, mounting config.json and secrets_emhass.yaml from host
-docker run --rm -it -p 5000:5000 --name emhass-container -v ./config.json:/share/config.json -v ./secrets_emhass.yaml:/app/secrets_emhass.yaml emhass-local
+docker run --rm -it -p 5000:5000 --name emhass-container -v /emhass/share:/share -v /emhass/secrets_emhass.yaml:/app/secrets_emhass.yaml emhass-local
 ```
 
 Before running the docker container, make sure you have a designated folder for emhass on your host device and a `secrets_emhass.yaml` file. You can get a example of the secrets file from [`secrets_emhass(example).yaml`](https://github.com/davidusb-geek/emhass/blob/master/secrets_emhass(example).yaml) file on this repository.
@@ -232,23 +226,23 @@ Latitude: 45.83
 Longitude: 6.86
 Altitude: 4807.8
 EOT
-docker run --rm -it --restart always  -p 5000:5000 --name emhass-container -v ./config.json:/share/config.json -v ./secrets_emhass.yaml:/app/secrets_emhass.yaml ghcr.io/davidusb-geek/emhass:latest
+docker run --rm -it --restart always  -p 5000:5000 --name emhass-container -v /emhass/share:/share -v /emhass/secrets_emhass.yaml:/app/secrets_emhass.yaml ghcr.io/davidusb-geek/emhass:latest
 ```
 
 #### Docker, things to note 
 
-- You can create a `config.json` file prior to running emhass. *(obtain a example from: [config_defaults.json](https://github.com/davidusb-geek/emhass/blob/enhass-standalone-addon-merge/src/emhass/data/config_defaults.json)* Alteratively, you can insert your parameters into the configuration page on the EMHASS web server. (for EMHASS to auto create a config.json) With either option, the volume mount `-v ./config.json:/share/config.json` should be applied to make sure your config is stored on the host device. (to be not deleted when the EMHASS container gets removed/image updated)*
+- You can create a `config.json` file prior to running emhass. *(obtain a example from: [config_defaults.json](https://github.com/davidusb-geek/emhass/blob/enhass-standalone-addon-merge/src/emhass/data/config_defaults.json)* Alteratively, you can insert your parameters into the configuration page on the EMHASS web server. (for EMHASS to auto create a config.json) With either option, the volume mount `-v /emhass/share:/share` should be applied to make sure your config is stored on the host device. (to be not deleted when the EMHASS container gets removed/image updated)*
 
 - If you wish to keep a local, semi-persistent copy of the EMHASS-generated data, create a local folder on your device, then mount said folder inside the container.  
   ```bash
   #create data folder 
   mkdir -p ~/emhass/data 
-  docker run -it --restart always -p 5000:5000 -e LOCAL_COSTFUN="profit" -v ~/emhass/config.json:/app/config.json -v ~/emhass/data:/data  -v ~/emhass/secrets_emhass.yaml:/app/secrets_emhass.yaml --name DockerEMHASS <REPOSITORY:TAG>
+  docker run -it --restart always -p 5000:5000 -e LOCAL_COSTFUN="profit" -v /emhass/share:/share -v /emhass/data:/data  -v /emhass/secrets_emhass.yaml:/app/secrets_emhass.yaml --name DockerEMHASS <REPOSITORY:TAG>
   ```
     
 - If you wish to set the web_server's homepage optimization diagrams to a timezone other than UTC, set `TZ` environment variable on docker run:
   ```bash
-  docker run -it --restart always -p 5000:5000  -e TZ="Europe/Paris" -v ~/emhass/config.json:/app/config.json -v ~/emhass/secrets_emhass.yaml:/app/secrets_emhass.yaml --name DockerEMHASS <REPOSITORY:TAG>
+  docker run -it --restart always -p 5000:5000  -e TZ="Europe/Paris" -v /emhass/share:/share -v /emhass/secrets_emhass.yaml:/app/secrets_emhass.yaml --name DockerEMHASS <REPOSITORY:TAG>
   ```  
 ### Method 3) Legacy method using a Python virtual environment *(Legacy CLI)*
 If you wish to run EMHASS optimizations with cli commands. *(no persistent web server session)* you can run EMHASS via the python package alone *(not wrapped in a Docker container)*.
@@ -320,12 +314,22 @@ Additional optimization strategies were developed later, that can be used in com
 
 ### Dayahead Optimization - Method 1) Add-on and docker standalone
 
-In `configuration.yaml`:
+We can use the `shell_command` integration in `configuration.yaml`:
 ```yaml
 shell_command:
   dayahead_optim: "curl -i -H \"Content-Type:application/json\" -X POST -d '{}' http://localhost:5000/action/dayahead-optim"
   publish_data: "curl -i -H \"Content-Type:application/json\" -X POST -d '{}' http://localhost:5000/action/publish-data"
 ```
+An alternative that will be useful when passing data at runtime (see dedicated section), we can use the the `rest_command` instead:
+```yaml
+rest_command:
+  url: http://127.0.0.1:5000/action/dayahead-optim
+  method: POST
+  headers:
+    content-type: application/json
+  payload: >-
+    {}
+```
 ### Dayahead Optimization - Method 2) Legacy method using a Python virtual environment
 
 In `configuration.yaml`:
@@ -388,8 +392,8 @@ In `automations.yaml`:
 ```
 in configuration page/`config.json` 
 ```json
-'method_ts_round': "first"
-'continual_publish': true
+"method_ts_round": "first"
+"continual_publish": true
 ```
 In this automation, the day-ahead optimization is performed once a day, every day at 5:30am. 
 If the `optimization_time_step` parameter is set to `30` *(default)* in the configuration, the results of the day-ahead optimization will generate 48 values *(for each entity)*, a value for every 30 minutes in a day *(i.e. 24 hrs x 2)*.
@@ -543,7 +547,7 @@ For users who wish to have full control of exactly when they would like to run a
 
 in configuration page/`config.json` :
 ```json
-'continual_publish': false
+"continual_publish": false
 ```
 POST action :
 ```bash
@@ -667,6 +671,25 @@ curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0,
 curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93], "prediction_horizon":10, "soc_init":0.5,"soc_final":0.6,"operating_hours_of_each_deferrable_load":[1,3],"start_timesteps_of_each_deferrable_load":[0,3],"end_timesteps_of_each_deferrable_load":[0,6]}' http://localhost:5000/action/naive-mpc-optim
 ```
 
+For a more readable option we can use the `rest_command` integration:
+```yaml
+rest_command:
+  url: http://127.0.0.1:5000/action/dayahead-optim
+  method: POST
+  headers:
+    content-type: application/json
+  payload: >-
+    {
+      "pv_power_forecast": [0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93],
+      "prediction_horizon":10,
+      "soc_init":0.5,
+      "soc_final":0.6,
+      "operating_hours_of_each_deferrable_load":[1,3],
+      "start_timesteps_of_each_deferrable_load":[0,3],
+      "end_timesteps_of_each_deferrable_load":[0,6]
+    }
+```
+
 ## A machine learning forecaster
 
 Starting in v0.4.0 a new machine learning forecaster class was introduced.

{emhass-0.13.3.dist-info → emhass-0.13.5.dist-info}/RECORD

@@ -1,16 +1,16 @@
 emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-emhass/command_line.py,sha256=sJIpI11BAJi1Ao7ck4B_zbr6dD1V7VY3S6UmxqRFRcE,75857
-emhass/forecast.py,sha256=lEBKnzJSxpbAYQ-OiW_qnKTTj8cl95yk4Ggkyk_rpyo,83892
-emhass/machine_learning_forecaster.py,sha256=zr5BczdsvoUCKpxV3XL4Ts-IWcS6zuhXYdeQwBD5gE8,16282
+emhass/command_line.py,sha256=XrD4uOONtaCDUQ3TMjJwDDIuOjyO_K8BZH3r_TBN1Eg,76048
+emhass/forecast.py,sha256=hLau1KjvwHM6jRQtWyhFLMf3fehdHIQlWG7A_inToKI,85951
+emhass/machine_learning_forecaster.py,sha256=tRC9P94-gMAPJsxWilT_jeful1Xmcev4PfMmuGFdzIk,16258
 emhass/machine_learning_regressor.py,sha256=Ih1q-vUWHWbGFxv9F12omwgyMRp-iaMU_m-yploVbyU,9532
-emhass/optimization.py,sha256=5Fb9Wn3nIi_IqnKV8XX-fxpG7eRxsiunaW-ZvXYmQ5M,68260
-emhass/retrieve_hass.py,sha256=JQqNurTHtu6VdTTBnh0Sx1N3KMOLLuAn6jMQLokgpcw,29532
-emhass/utils.py,sha256=UysLZJ-TzsWvkNyihXkPwcf_qGUpxN_HfnAVcb0KWkY,73889
-emhass/web_server.py,sha256=xOgM3lVwXAN6Ctoi5in21ImeSvx6-wDNtgYZqLQN01I,29153
-emhass/data/associations.csv,sha256=J2HTMK5UjdU6k8ehxkPAsnXzl7-gATKGWXed_0oO2To,4180
+emhass/optimization.py,sha256=kZNqC3InaIUD9Oc7kyxUwThpJLWSpSvBATaRmRJL_3k,73417
+emhass/retrieve_hass.py,sha256=FPWK43NOD8Hq-oLbrJ_M1Sh8h5rOLwfkL1zpRWVBLoE,29593
+emhass/utils.py,sha256=nHY8HStgff-kMhTNoo6Gp4p1gbom2qYltfH1pDFsnow,76025
+emhass/web_server.py,sha256=fwdGHPPu3_wJ3bqrQVctK357iW4Gz57-mVSfIluRs88,28075
+emhass/data/associations.csv,sha256=BIQNjKpr-QC3cMJIRzJ7F2eMGNVubDe0544dYWMIJw4,4418
 emhass/data/cec_inverters.pbz2,sha256=ca-dO6sv38_FI2w_6fkAIzcrEqzFBkG8MHKNGbCZPow,189400
 emhass/data/cec_modules.pbz2,sha256=Y639TNqhaIxh2Ec7AUPxy8k4lQugY5rURVVVexj0fMU,1885444
-emhass/data/config_defaults.json,sha256=Bz-qXLCWmKzvr6q_N4yVbgHua_K6OhL_Y--GFXjIx0c,3148
+emhass/data/config_defaults.json,sha256=9GUT1zjEIMxijbLXRjO4_VAoi_x0tsq2pczAQoHuwoI,3287
 emhass/img/emhass_icon.png,sha256=Kyx6hXQ1huJLHAq2CaBfjYXR25H9j99PSWHI0lShkaQ,19030
 emhass/static/advanced.html,sha256=gAhsd14elDwh1Ts4lf9wn_ZkczzzObq5qOimi_la3Ic,2067
 emhass/static/basic.html,sha256=ro2WwWgJyoUhqx_nJFzKCEG8FA8863vSHLmrjGYcEgs,677
@@ -18,15 +18,15 @@ emhass/static/configuration_list.html,sha256=i4v83RVduWjdjkjPhA74e-j8NSUpFzqMGU3
 emhass/static/configuration_script.js,sha256=Ek0Ry1Ae6ZGMl28mYxno6bPTwY4rK7AHcL58C6T6qUo,31727
 emhass/static/script.js,sha256=-JYS8fHjchrMi1hYYKMd9p7vZvPcnYiY8NNuRC99fJM,16323
 emhass/static/style.css,sha256=a_8YlGubn1zoF5RTLJ_Qkrb8tAjUY9p7oAKxhCvJY2s,19288
-emhass/static/data/param_definitions.json,sha256=vsmc1Ykeng2fjRy5PhxOvWCBtgKLr17sCOsGpMkpkLQ,22000
+emhass/static/data/param_definitions.json,sha256=aKqXH4Cd3cucAIG2gs2AADNDsTxipDHY0SZ9lxRAqHQ,23330
 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.13.3.dist-info/METADATA,sha256=ZzGJGH85Ru7-TpPuqzXcJcTPXu7h2R7qhxEf-8BIDBk,51534
-emhass-0.13.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emhass-0.13.3.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
-emhass-0.13.3.dist-info/licenses/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
-emhass-0.13.3.dist-info/RECORD,,
+emhass-0.13.5.dist-info/METADATA,sha256=hiTlDKqSEsdgc_JapuWUhJurOs-GGrt6ZJAsz9__pM0,52124
+emhass-0.13.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emhass-0.13.5.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
+emhass-0.13.5.dist-info/licenses/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
+emhass-0.13.5.dist-info/RECORD,,