emhass 0.11.4__tar.gz → 0.12.0__tar.gz

{emhass-0.11.4 → emhass-0.12.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.12.0 - 2024-12-29
+### BREAKING CHANGE
+- The solar PV system is now optional. If you have a PV system then use the switch on the webui or set the `set_use_pv` parameter to `True`.
+### Improvement
+- A new load power forecast method based on statistic and typical household load power consumption. This and the optional PV, will make it easier for new users to on-board EMHASS because this new default behavior does not require any data retrieval from Home Assistant or any other external source.
+- Updated documentation.
+
 ## 0.11.4 - 2024-12-24
 ### Fix
 - Fix bug when treating runtime params, fix optimization_time_step timedelta 

{emhass-0.11.4 → emhass-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.11.4
+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.11.4 → emhass-0.12.0}/README.md

@@ -88,11 +88,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. 
@@ -100,10 +105,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.11.4 → emhass-0.12.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "emhass"
-version = "0.11.4"
+version = "0.12.0"
 description = "An Energy Management System for Home Assistant"
 readme = "README.md"
 requires-python = ">=3.10, <3.12"

{emhass-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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-0.11.4 → emhass-0.12.0}/src/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,

{emhass-0.11.4 → emhass-0.12.0}/src/emhass.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.11.4
+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.11.4 → emhass-0.12.0}/tests/test_command_line_utils.py

@@ -149,6 +149,7 @@ class TestCommandLineUtils(unittest.TestCase):
             "load_power_forecast": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
             "load_cost_forecast": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
             "prod_price_forecast": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+            "prediction_horizon": 10,
         }
         runtimeparams_json = json.dumps(runtimeparams)
         params = copy.deepcopy(json.loads(self.params_json))

{emhass-0.11.4 → emhass-0.12.0}/tests/test_forecast.py

@@ -76,7 +76,7 @@ class TestForecast(unittest.TestCase):
         # Obtain sensor values from saved file
         if self.get_data_from_file:
             with open(emhass_conf["data_path"] / "test_df_final.pkl", "rb") as inp:
-                self.rh.df_final, self.days_list, self.var_list = pickle.load(inp)
+                self.rh.df_final, self.days_list, self.var_list, self.rh.ha_config = pickle.load(inp)
             self.retrieve_hass_conf["sensor_power_load_no_var_loads"] = str(
                 self.var_list[0]
             )
@@ -429,8 +429,8 @@ class TestForecast(unittest.TestCase):
         )
         # Obtain sensor values from saved file
         if self.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)
+            with open(emhass_conf["data_path"] / "test_df_final.pkl", "rb") as inp:
+                rh.df_final, days_list, var_list, rh.ha_config = pickle.load(inp)
             retrieve_hass_conf["sensor_power_load_no_var_loads"] = str(self.var_list[0])
             retrieve_hass_conf["sensor_power_photovoltaics"] = str(self.var_list[1])
             retrieve_hass_conf["sensor_linear_interp"] = [
@@ -667,7 +667,7 @@ class TestForecast(unittest.TestCase):
         # Obtain sensor values from saved file
         if self.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(self.var_list[0])
             retrieve_hass_conf["sensor_power_photovoltaics"] = str(self.var_list[1])
             retrieve_hass_conf["sensor_linear_interp"] = [
@@ -901,6 +901,19 @@ class TestForecast(unittest.TestCase):
         self.assertTrue((P_load_forecast.index == self.fcst.forecast_dates).all())
         self.assertEqual(len(self.P_PV_forecast), len(P_load_forecast))
 
+    # Test load forecast with typical statistics method
+    def test_get_load_forecast_typical(self):
+        P_load_forecast = self.fcst.get_load_forecast(method='typical')
+        self.assertIsInstance(P_load_forecast, pd.core.series.Series)
+        self.assertIsInstance(
+            P_load_forecast.index, pd.core.indexes.datetimes.DatetimeIndex
+        )
+        self.assertIsInstance(
+            P_load_forecast.index.dtype, pd.core.dtypes.dtypes.DatetimeTZDtype
+        )
+        self.assertEqual(P_load_forecast.index.tz, self.fcst.time_zone)
+        self.assertEqual(len(self.P_PV_forecast), len(P_load_forecast))
+
     # Test load cost forecast dataframe output using saved csv referece file
     def test_get_load_cost_forecast(self):
         df_input_data = self.fcst.get_load_cost_forecast(self.df_input_data)

{emhass-0.11.4 → emhass-0.12.0}/tests/test_machine_learning_forecaster.py

@@ -100,7 +100,7 @@ class TestMLForecaster(unittest.TestCase):
         )
         # Open and extract saved sensor data to test against
         with open(emhass_conf["data_path"] / "test_df_final.pkl", "rb") as inp:
-            self.rh.df_final, self.days_list, self.var_list = pickle.load(inp)
+            self.rh.df_final, self.days_list, self.var_list, self.rh.ha_config = pickle.load(inp)
 
     def test_fit(self):
         df_pred, df_pred_backtest = self.mlf.fit()

{emhass-0.11.4 → emhass-0.12.0}/tests/test_optimization.py

@@ -73,7 +73,7 @@ class TestOptimization(unittest.TestCase):
         # Obtain sensor values from saved file
         if get_data_from_file:
             with open(emhass_conf["data_path"] / "test_df_final.pkl", "rb") as inp:
-                self.rh.df_final, self.days_list, self.var_list = pickle.load(inp)
+                self.rh.df_final, self.days_list, self.var_list, self.rh.ha_config = pickle.load(inp)
             self.retrieve_hass_conf["sensor_power_load_no_var_loads"] = str(
                 self.var_list[0]
             )

{emhass-0.11.4 → emhass-0.12.0}/tests/test_retrieve_hass.py

@@ -92,7 +92,7 @@ class TestRetrieveHass(unittest.TestCase):
         # Obtain sensor values from saved file
         if self.get_data_from_file:
             with open(emhass_conf["data_path"] / "test_df_final.pkl", "rb") as inp:
-                self.rh.df_final, self.days_list, self.var_list = pickle.load(inp)
+                self.rh.df_final, self.days_list, self.var_list, self.rh.ha_config = pickle.load(inp)
         # Else obtain sensor values from HA
         else:
             self.days_list = get_days_list(
@@ -108,11 +108,30 @@ class TestRetrieveHass(unittest.TestCase):
                 minimal_response=False,
                 significant_changes_only=False,
             )
+            # Mocking retrieve of ha_config using: self.rh.get_ha_config()
+            self.rh.ha_config = {
+                'country': 'FR',
+                'currency': 'EUR',
+                'elevation': 4807,
+                'latitude': 48.83,
+                'longitude': 6.86,
+                'time_zone': 'Europe/Paris',
+                'unit_system': {
+                    'length': 'km',
+                    'accumulated_precipitation': 'mm',
+                    'area': 'm²',
+                    'mass': 'g',
+                    'pressure': 'Pa',
+                    'temperature': '°C',
+                    'volume': 'L',
+                    'wind_speed': 'm/s'
+                }
+            }
             # Check to save updated data to file
             if save_data_to_file:
                 with open(emhass_conf["data_path"] / "test_df_final.pkl", "wb") as outp:
                     pickle.dump(
-                        (self.rh.df_final, self.days_list, self.var_list),
+                        (self.rh.df_final, self.days_list, self.var_list, self.rh.ha_config),
                         outp,
                         pickle.HIGHEST_PROTOCOL,
                     )

{emhass-0.11.4 → emhass-0.12.0}/tests/test_utils.py

@@ -439,6 +439,37 @@ class TestCommandLineUtils(unittest.TestCase):
         self.assertIsInstance(runtimeparams["load_cost_forecast"], str)
         self.assertIsInstance(runtimeparams["prod_price_forecast"], str)
 
+    def test_update_params_with_ha_config(self):
+        # Test dayahead runtime params
+        retrieve_hass_conf, optim_conf, plant_conf = utils.get_yaml_parse(
+            self.params_json, logger
+        )
+        set_type = "dayahead-optim"
+        params, retrieve_hass_conf, optim_conf, plant_conf = utils.treat_runtimeparams(
+            self.runtimeparams_json,
+            self.params_json,
+            retrieve_hass_conf,
+            optim_conf,
+            plant_conf,
+            set_type,
+            logger,
+            emhass_conf,
+        )
+        ha_config = {
+            'currency': 'USD',
+            'unit_system': {'temperature': '°F'}
+        }
+        params_json = utils.update_params_with_ha_config(
+            params,
+            ha_config,
+        )
+        params = json.loads(params_json)
+        self.assertTrue(params["passed_data"]["custom_predicted_temperature_id"][0]["unit_of_measurement"] == "°F")
+        self.assertTrue(params["passed_data"]["custom_predicted_temperature_id"][1]["unit_of_measurement"] == "°F")
+        self.assertTrue(params["passed_data"]["custom_cost_fun_id"]["unit_of_measurement"] == '$')
+        self.assertTrue(params["passed_data"]["custom_unit_load_cost_id"]["unit_of_measurement"] == '$/kWh')
+        self.assertTrue(params["passed_data"]["custom_unit_prod_price_id"]["unit_of_measurement"] == '$/kWh')
+
     def test_build_secrets(self):
         # Test the build_secrets defaults from get_test_params()
         params = TestCommandLineUtils.get_test_params()