emhass 0.11.1__tar.gz → 0.11.2__tar.gz

{emhass-0.11.1 → emhass-0.11.2}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.11.2 - 2024-10-31
+### Improvement
+- Added support to retrieve HA configuration. This will be used in the future to automatically retrieve some parameters as the currency
+### Fix
+- utils fix runtime parameter merge bugs 
+- configuration_script.js fix placeholder value bug 
+
 ## 0.11.1 - 2024-10-29
 ### Fix
 - Fix parameter saving and duplicate battery bugs 

{emhass-0.11.1 → emhass-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.11.1
+Version: 0.11.2
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ
@@ -47,9 +47,6 @@ Requires-Dist: plotly>=5.6.0
   </a>
   <a style="text-decoration:none" href="https://github.com/davidusb-geek/emhass/actions">
     <img alt="EMHASS GitHub Workflow Status" src="https://github.com/davidusb-geek/emhass/actions/workflows/publish_docker.yaml/badge.svg?event=release">
-  </a>
-   <a style="text-decoration:none" href="https://github.com/davidusb-geek/emhass-add-on/actions">
-    <img alt="EMHASS-Add-on GitHub Workflow Status" src="https://github.com/davidusb-geek/emhass-add-on/actions/workflows/publish_docker.yaml/badge.svg?event=release">
   </a>
   <a hstyle="text-decoration:none" ref="https://codecov.io/github/davidusb-geek/emhass" >
     <img src="https://codecov.io/github/davidusb-geek/emhass/branch/master/graph/badge.svg?token=BW7KSCHN90"/>

{emhass-0.11.1 → emhass-0.11.2}/README.md

@@ -12,9 +12,6 @@
   </a>
   <a style="text-decoration:none" href="https://github.com/davidusb-geek/emhass/actions">
     <img alt="EMHASS GitHub Workflow Status" src="https://github.com/davidusb-geek/emhass/actions/workflows/publish_docker.yaml/badge.svg?event=release">
-  </a>
-   <a style="text-decoration:none" href="https://github.com/davidusb-geek/emhass-add-on/actions">
-    <img alt="EMHASS-Add-on GitHub Workflow Status" src="https://github.com/davidusb-geek/emhass-add-on/actions/workflows/publish_docker.yaml/badge.svg?event=release">
   </a>
   <a hstyle="text-decoration:none" ref="https://codecov.io/github/davidusb-geek/emhass" >
     <img src="https://codecov.io/github/davidusb-geek/emhass/branch/master/graph/badge.svg?token=BW7KSCHN90"/>

{emhass-0.11.1 → emhass-0.11.2}/setup.py

@@ -19,7 +19,7 @@ long_description = (here / 'README.md').read_text(encoding='utf-8')
 
 setup(
     name='emhass',  # Required
-    version='0.11.1',  # Required
+    version='0.11.2',  # Required
     description='An Energy Management System for Home Assistant',  # Optional
     long_description=long_description,  # Optional
     long_description_content_type='text/markdown',  # Optional (see note above)

{emhass-0.11.1 → emhass-0.11.2}/src/emhass/data/config_defaults.json

@@ -19,8 +19,7 @@
   "sensor_power_photovoltaics": "sensor.power_photovoltaics",
   "sensor_power_load_no_var_loads": "sensor.power_load_no_var_loads",
   "sensor_replace_zero": [
-    "sensor.power_photovoltaics",
-    "sensor.power_load_no_var_loads"
+    "sensor.power_photovoltaics" 
   ],
   "sensor_linear_interp": [
     "sensor.power_photovoltaics",

{emhass-0.11.1 → emhass-0.11.2}/src/emhass/retrieve_hass.py

@@ -72,6 +72,19 @@ class RetrieveHass:
         self.logger = logger
         self.get_data_from_file = get_data_from_file
 
+    def get_ha_config(self):
+        """
+        Extract some configuration data from HA.
+        
+        """
+        headers = {
+            "Authorization": "Bearer " + self.long_lived_token,
+            "content-type": "application/json"
+            }
+        url = self.hass_url+"api/config"
+        response_config = get(url, headers=headers)
+        self.ha_config = response_config.json()
+    
     def get_data(self, days_list: pd.date_range, var_list: list, 
                  minimal_response: Optional[bool] = False, significant_changes_only: Optional[bool] = False,
                  test_url: Optional[str] = "empty") -> None:
@@ -98,15 +111,17 @@ class RetrieveHass:
             are experimental
         """
         self.logger.info("Retrieve hass get data method initiated...")
+        headers = {
+            "Authorization": "Bearer " + self.long_lived_token,
+            "content-type": "application/json"
+            }
+        # Looping on each day from days list
         self.df_final = pd.DataFrame()
         x = 0  # iterate based on days
-        # Looping on each day from days list
         for day in days_list:
             for i, var in enumerate(var_list):
                 if test_url == "empty":
-                    if (
-                        self.hass_url == "http://supervisor/core/api"
-                    ):  # If we are using the supervisor API
+                    if (self.hass_url == "http://supervisor/core/api"):  # If we are using the supervisor API
                         url = (
                             self.hass_url
                             + "/history/period/"
@@ -124,16 +139,10 @@ class RetrieveHass:
                         )
                     if minimal_response:  # A support for minimal response
                         url = url + "?minimal_response"
-                    if (
-                        significant_changes_only
-                    ):  # And for signicant changes only (check the HASS restful API for more info)
+                    if (significant_changes_only):  # And for signicant changes only (check the HASS restful API for more info)
                         url = url + "?significant_changes_only"
                 else:
                     url = test_url
-                headers = {
-                    "Authorization": "Bearer " + self.long_lived_token,
-                    "content-type": "application/json",
-                }
                 try:
                     response = get(url, headers=headers)
                 except Exception:

{emhass-0.11.1 → emhass-0.11.2}/src/emhass/static/configuration_script.js

@@ -407,7 +407,7 @@ function buildParamElement(
     else {
       return `
           ${type_specific_html}
-          <input class="param_input" type="${type}" value=${value} placeholder=${parameter_definition_object["default_value"]}>
+          <input class="param_input" type="${type}" placeholder=${parameter_definition_object["default_value"]} value=${value} >
           ${type_specific_html_end}
           `;
     }
@@ -418,9 +418,9 @@ function buildParamElement(
     if (typeof Object.values(value)[0] === "object") {
       for (param of Object.values(value)) {
         for (items of Object.values(param)) {
-          inputs += `<input class="param_input" type="${type}" value=${
+          inputs += `<input class="param_input" type="${type}" placeholder=${Object.values(items)[0]} value=${
             Object.values(items)[0]
-          } placeholder=${Object.values(items)[0]}>`;
+          }>`;
         }
         inputs += `</br>`;
       }
@@ -432,7 +432,7 @@ function buildParamElement(
       for (param of value) {
         inputs += `
           ${type_specific_html}
-          <input class="param_input" type="${type}" value=${param} placeholder=${parameter_definition_object["default_value"]}>
+          <input class="param_input" type="${type}" placeholder=${parameter_definition_object["default_value"]} value=${param}>
           ${type_specific_html_end}
           `;
       }

{emhass-0.11.1 → emhass-0.11.2}/src/emhass/utils.py

@@ -288,7 +288,7 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             else:
                 prediction_horizon = runtimeparams["prediction_horizon"]
             params["passed_data"]["prediction_horizon"] = prediction_horizon
-            if "soc_init" not in runtimeparams.keys():
+            if 'soc_init' not in runtimeparams.keys():
                 soc_init = plant_conf['battery_target_state_of_charge']
             else:
                 soc_init = runtimeparams["soc_init"]
@@ -298,23 +298,24 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             else:
                 soc_final = runtimeparams["soc_final"]
             params["passed_data"]["soc_final"] = soc_final
-            if 'operating_hours_of_each_deferrable_load' not in runtimeparams.keys():
-                def_total_hours = optim_conf['operating_hours_of_each_deferrable_load']
+            if 'operating_hours_of_each_deferrable_load' not in runtimeparams.keys() and  'def_total_hours'  not in runtimeparams.keys():
+                def_total_hours = optim_conf.get('operating_hours_of_each_deferrable_load') 
             else:
-                def_total_hours = runtimeparams['operating_hours_of_each_deferrable_load']
+                def_total_hours = runtimeparams.get(
+                'operating_hours_of_each_deferrable_load', runtimeparams.get('def_total_hours')) 
             params["passed_data"]['operating_hours_of_each_deferrable_load'] = def_total_hours
-            if 'start_timesteps_of_each_deferrable_load' in runtimeparams.keys():
-                def_start_timestep = runtimeparams['start_timesteps_of_each_deferrable_load']
-            else:
+            if 'start_timesteps_of_each_deferrable_load' not in runtimeparams.keys() and  'def_start_timestep' in runtimeparams.keys():
+                def_start_timestep = optim_conf.get('start_timesteps_of_each_deferrable_load') 
+            else:    
                 def_start_timestep = runtimeparams.get(
-                    'def_start_timestep', optim_conf['start_timesteps_of_each_deferrable_load'])
+                    'start_timesteps_of_each_deferrable_load', runtimeparams.get('def_start_timestep'))
             params["passed_data"]['start_timesteps_of_each_deferrable_load'] = def_start_timestep
-            if 'end_timesteps_of_each_deferrable_load' in runtimeparams.keys():
-                def_end_timestep = runtimeparams['end_timesteps_of_each_deferrable_load']
+            if 'end_timesteps_of_each_deferrable_load' not in  runtimeparams.keys() and 'def_end_timestep' not in  runtimeparams.keys():
+                def_end_timestep = optim_conf.get('end_timesteps_of_each_deferrable_load') 
             else:
                 def_end_timestep = runtimeparams.get(
-                    'def_end_timestep', optim_conf['end_timesteps_of_each_deferrable_load'])
-            params["passed_data"]["end_timesteps_of_each_deferrable_load"] = def_end_timestep
+                    'end_timesteps_of_each_deferrable_load', runtimeparams.get('def_end_timestep'))
+            params["passed_data"]['end_timesteps_of_each_deferrable_load'] = def_end_timestep
             forecast_dates = copy.deepcopy(forecast_dates)[0:prediction_horizon]
             # Load the default config
             if "def_load_config" in optim_conf:
@@ -364,11 +365,16 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
                 params['passed_data'][forecast_key] = None
        
         # Treat passed data for forecast model fit/predict/tune at runtime
-        if 'historic_days_to_retrieve' in runtimeparams.keys():
-            days_to_retrieve = runtimeparams['historic_days_to_retrieve']
+        if 'historic_days_to_retrieve' not in runtimeparams.keys() and 'days_to_retrieve' not in runtimeparams.keys():
+            historic_days_to_retrieve = retrieve_hass_conf.get('historic_days_to_retrieve') 
         else:
-            days_to_retrieve = runtimeparams.get('days_to_retrieve', 9)
-        params["passed_data"]['historic_days_to_retrieve'] = days_to_retrieve
+           historic_days_to_retrieve = runtimeparams.get(
+                    'historic_days_to_retrieve', runtimeparams.get('days_to_retrieve')) 
+        if historic_days_to_retrieve < 9:
+            logger.warning("warning `days_to_retrieve` is set to a value less than 9, this could cause an error with the fit")
+            logger.warning("setting`passed_data:days_to_retrieve` to 9 for fit/predict/tune")
+            historic_days_to_retrieve = 9
+        params["passed_data"]['historic_days_to_retrieve'] = historic_days_to_retrieve
         if "model_type" not in runtimeparams.keys():
             model_type = "load_forecast"
         else:
@@ -479,50 +485,35 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
         params["passed_data"]["publish_prefix"] = publish_prefix
 
         # Treat optimization (optim_conf) configuration parameters passed at runtime
-        if 'number_of_deferrable_loads' in runtimeparams.keys():
-            optim_conf['number_of_deferrable_loads'] = runtimeparams['number_of_deferrable_loads']
-        if 'num_def_loads' in runtimeparams.keys():
-            optim_conf['number_of_deferrable_loads'] = runtimeparams['num_def_loads']
-        if 'nominal_power_of_deferrable_loads' in runtimeparams.keys():
-            optim_conf['nominal_power_of_deferrable_loads'] = runtimeparams['nominal_power_of_deferrable_loads']
-        if 'P_deferrable_nom' in runtimeparams.keys():
-            optim_conf['nominal_power_of_deferrable_loads'] = runtimeparams['P_deferrable_nom']
-        if 'operating_hours_of_each_deferrable_load' in runtimeparams.keys():
-            optim_conf['operating_hours_of_each_deferrable_load'] = runtimeparams['operating_hours_of_each_deferrable_load']
-        if 'def_total_hours' in runtimeparams.keys():
-            optim_conf['operating_hours_of_each_deferrable_load'] = runtimeparams['def_total_hours']
-        if 'start_timesteps_of_each_deferrable_load' in runtimeparams.keys():
-            optim_conf['start_timesteps_of_each_deferrable_load'] = runtimeparams['start_timesteps_of_each_deferrable_load']
-        if 'end_timesteps_of_each_deferrable_load' in runtimeparams.keys():
-            optim_conf['end_timesteps_of_each_deferrable_load'] = runtimeparams['end_timesteps_of_each_deferrable_load']
+        if 'number_of_deferrable_loads' in runtimeparams.keys() or 'num_def_loads' in runtimeparams.keys():
+            optim_conf['number_of_deferrable_loads'] = runtimeparams.get(
+                    'number_of_deferrable_loads', runtimeparams.get('num_def_loads'))
+        if 'nominal_power_of_deferrable_loads' in runtimeparams.keys() or 'P_deferrable_nom' in runtimeparams.keys():
+            optim_conf['nominal_power_of_deferrable_loads'] = runtimeparams.get(
+                    'nominal_power_of_deferrable_loads', runtimeparams.get('P_deferrable_nom'))
+        if 'operating_hours_of_each_deferrable_load' in runtimeparams.keys() or 'def_total_hours' in runtimeparams.keys():
+            optim_conf['operating_hours_of_each_deferrable_load'] = runtimeparams.get(
+                'operating_hours_of_each_deferrable_load', runtimeparams.get('def_total_hours')) 
+        if 'start_timesteps_of_each_deferrable_load' in runtimeparams.keys() or 'def_start_timestep' in runtimeparams.keys():
+            optim_conf['start_timesteps_of_each_deferrable_load'] = runtimeparams.get(
+                    'start_timesteps_of_each_deferrable_load', runtimeparams.get('def_start_timestep'))
+        if 'end_timesteps_of_each_deferrable_load' in runtimeparams.keys() or 'def_end_timestep' in runtimeparams.keys():
+            optim_conf['end_timesteps_of_each_deferrable_load'] = runtimeparams.get(
+                    'end_timesteps_of_each_deferrable_load', runtimeparams.get('def_end_timestep'))  
         if "def_current_state" in runtimeparams.keys():
             optim_conf["def_current_state"] = [
                 bool(s) for s in runtimeparams["def_current_state"]]
-        if 'treat_deferrable_load_as_semi_cont' in runtimeparams.keys():
-            optim_conf['treat_deferrable_load_as_semi_cont'] = [
-                ast.literal_eval(str(k).capitalize())
-                for k in runtimeparams['treat_deferrable_load_as_semi_cont']
-            ]
-        if 'treat_def_as_semi_cont' in runtimeparams.keys():
+        if 'treat_deferrable_load_as_semi_cont' in runtimeparams.keys() or 'treat_def_as_semi_cont' in runtimeparams.keys():
             optim_conf['treat_deferrable_load_as_semi_cont'] = [
-                ast.literal_eval(str(k).capitalize())
-                for k in runtimeparams['treat_def_as_semi_cont']
-            ]
-        if 'set_deferrable_load_single_constant' in runtimeparams.keys():
+                ast.literal_eval(str(k).capitalize()) for k in runtimeparams.get('treat_deferrable_load_as_semi_cont',runtimeparams.get('treat_def_as_semi_cont'))
+            ]    
+        if 'set_deferrable_load_single_constant' in runtimeparams.keys() or 'set_def_constant' in runtimeparams.keys():
             optim_conf['set_deferrable_load_single_constant'] = [
-                ast.literal_eval(str(k).capitalize()) for k in runtimeparams['set_deferrable_load_single_constant']
+                ast.literal_eval(str(k).capitalize()) for k in runtimeparams.get('set_deferrable_load_single_constant',runtimeparams.get('set_def_constant'))
             ]
-        if 'set_def_constant' in runtimeparams.keys():
-            optim_conf['set_deferrable_load_single_constant'] = [
-                ast.literal_eval(str(k).capitalize()) for k in runtimeparams['set_def_constant']
-            ]
-        if 'set_deferrable_startup_penalty' in runtimeparams.keys():
-            optim_conf['set_deferrable_startup_penalty'] = [
-                ast.literal_eval(str(k).capitalize()) for k in runtimeparams['set_deferrable_startup_penalty']
-            ]
-        if 'def_start_penalty' in runtimeparams.keys():
+        if 'set_deferrable_startup_penalty' in runtimeparams.keys() or 'def_start_penalty' in runtimeparams.keys():
             optim_conf['set_deferrable_startup_penalty'] = [
-                ast.literal_eval(str(k).capitalize()) for k in runtimeparams['def_start_penalty']
+                ast.literal_eval(str(k).capitalize()) for k in runtimeparams.get('set_deferrable_startup_penalty',runtimeparams.get('def_start_penalty'))
             ]
         if 'def_load_config' in runtimeparams:
             optim_conf["def_load_config"] = runtimeparams['def_load_config']
@@ -534,9 +525,9 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             optim_conf['weight_battery_charge'] = runtimeparams['weight_battery_charge']
 
         # Treat retrieve data from Home Assistant (retrieve_hass_conf) configuration parameters passed at runtime
-        if 'optimization_time_step' in runtimeparams.keys():
-            retrieve_hass_conf['optimization_time_step'] = pd.to_timedelta(
-                runtimeparams['optimization_time_step'], "minutes")
+        if 'optimization_time_step' in runtimeparams.keys() or 'freq' in runtimeparams.keys():
+            retrieve_hass_conf['optimization_time_step'] = pd.to_timedelta(runtimeparams.get(
+                    'optimization_time_step', runtimeparams.get('freq')), "minutes")
         if 'continual_publish' in runtimeparams.keys():
             retrieve_hass_conf['continual_publish'] = bool(
                 runtimeparams['continual_publish'])
@@ -653,9 +644,7 @@ def get_yaml_parse(params: str, logger: logging.Logger) -> Tuple[dict, dict, dic
         return False, False, False
 
     optim_conf = input_conf.get("optim_conf", {})
-
     retrieve_hass_conf = input_conf.get("retrieve_hass_conf", {})
-
     plant_conf = input_conf.get("plant_conf", {})
 
     # Format time parameters
@@ -668,6 +657,70 @@ def get_yaml_parse(params: str, logger: logging.Logger) -> Tuple[dict, dict, dic
 
     return retrieve_hass_conf, optim_conf, plant_conf
 
+def get_legacy_yaml_parse(emhass_conf: dict, use_secrets: Optional[bool] = True,
+                          params: Optional[str] = None) -> Tuple[dict, dict, dict]:
+    """
+    Perform parsing of the config.yaml file.
+    
+    :param emhass_conf: Dictionary containing the needed emhass paths
+    :type emhass_conf: dict
+    :param use_secrets: Indicate if we should use a secrets file or not.
+        Set to False for unit tests.
+    :type use_secrets: bool, optional
+    :param params: Configuration parameters passed from data/options.json
+    :type params: str
+    :return: A tuple with the dictionaries containing the parsed data
+    :rtype: tuple(dict)
+
+    """
+    if params is None:
+        with open(emhass_conf["config_path"], 'r') as file:
+            input_conf = yaml.load(file, Loader=yaml.FullLoader)
+    else:
+        input_conf = json.loads(params)
+    if use_secrets:
+        if params is None:
+            with open(emhass_conf["config_path"].parent / 'secrets_emhass.yaml', 'r') as file: # Assume secrets and config file paths are the same 
+                input_secrets = yaml.load(file, Loader=yaml.FullLoader)
+        else:
+            input_secrets = input_conf.pop("params_secrets", None)
+
+    if type(input_conf["retrieve_hass_conf"]) == list:  # if using old config version
+        retrieve_hass_conf = dict(
+            {key: d[key] for d in input_conf["retrieve_hass_conf"] for key in d}
+        )
+    else:
+        retrieve_hass_conf = input_conf.get("retrieve_hass_conf", {})
+
+    if use_secrets:
+        retrieve_hass_conf.update(input_secrets)
+    else:
+        retrieve_hass_conf["hass_url"] = "http://supervisor/core/api"
+        retrieve_hass_conf["long_lived_token"] = "${SUPERVISOR_TOKEN}"
+        retrieve_hass_conf["time_zone"] = "Europe/Paris"
+        retrieve_hass_conf["lat"] = 45.83
+        retrieve_hass_conf["lon"] = 6.86
+        retrieve_hass_conf["alt"] = 4807.8
+    retrieve_hass_conf["freq"] = pd.to_timedelta(retrieve_hass_conf["freq"], "minutes")
+    retrieve_hass_conf["time_zone"] = pytz.timezone(retrieve_hass_conf["time_zone"])
+
+    if type(input_conf["optim_conf"]) == list:
+        optim_conf = dict({key: d[key] for d in input_conf["optim_conf"] for key in d})
+    else:
+        optim_conf = input_conf.get("optim_conf", {})
+
+    optim_conf["list_hp_periods"] = dict(
+        (key, d[key]) for d in optim_conf["list_hp_periods"] for key in d
+    )
+    optim_conf["delta_forecast"] = pd.Timedelta(days=optim_conf["delta_forecast"])
+
+    if type(input_conf["plant_conf"]) == list:
+        plant_conf = dict({key: d[key] for d in input_conf["plant_conf"] for key in d})
+    else:
+        plant_conf = input_conf.get("plant_conf", {})
+
+    return retrieve_hass_conf, optim_conf, plant_conf
+
 
 def get_injection_dict(df: pd.DataFrame, plot_size: Optional[int] = 1366) -> dict:
     """
@@ -867,7 +920,7 @@ def build_config(emhass_conf: dict, logger: logging.Logger, defaults_path: str,
 
 
 def build_legacy_config_params(emhass_conf: dict, legacy_config: dict,
-                 logger: logging.Logger) -> dict:
+                               logger: logging.Logger) -> dict:
     """
     Build a config dictionary with legacy config_emhass.yaml file. 
     Uses the associations file to convert parameter naming conventions (to config.json/config_defaults.json).
@@ -918,8 +971,7 @@ def build_legacy_config_params(emhass_conf: dict, legacy_config: dict,
     return config
     # params['associations_dict'] = associations_dict
 
-def param_to_config(param: dict,
-                 logger: logging.Logger) -> dict:
+def param_to_config(param: dict, logger: logging.Logger) -> dict:
     """
     A function that extracts the parameters from param back to the config.json format.
     Extracts parameters from config catagories.
@@ -949,7 +1001,7 @@ def param_to_config(param: dict,
     return return_config
 
 def build_secrets(emhass_conf: dict, logger: logging.Logger, argument: Optional[dict] = {}, options_path: Optional[str] = None, 
-                 secrets_path: Optional[str] = None, no_response: Optional[bool] = False) -> Tuple[dict, dict]:    
+                  secrets_path: Optional[str] = None, no_response: Optional[bool] = False) -> Tuple[dict, dict]:    
     """
     Retrieve and build parameters from secrets locations (ENV, ARG, Secrets file (secrets_emhass.yaml/options.json) and/or Home Assistant (via API))
     priority order (lwo to high) = Defaults (written in function), ENV, Options json file, Home Assistant API,  Secrets yaml file, Arguments

{emhass-0.11.1 → emhass-0.11.2}/src/emhass.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.11.1
+Version: 0.11.2
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ
@@ -47,9 +47,6 @@ Requires-Dist: plotly>=5.6.0
   </a>
   <a style="text-decoration:none" href="https://github.com/davidusb-geek/emhass/actions">
     <img alt="EMHASS GitHub Workflow Status" src="https://github.com/davidusb-geek/emhass/actions/workflows/publish_docker.yaml/badge.svg?event=release">
-  </a>
-   <a style="text-decoration:none" href="https://github.com/davidusb-geek/emhass-add-on/actions">
-    <img alt="EMHASS-Add-on GitHub Workflow Status" src="https://github.com/davidusb-geek/emhass-add-on/actions/workflows/publish_docker.yaml/badge.svg?event=release">
   </a>
   <a hstyle="text-decoration:none" ref="https://codecov.io/github/davidusb-geek/emhass" >
     <img src="https://codecov.io/github/davidusb-geek/emhass/branch/master/graph/badge.svg?token=BW7KSCHN90"/>

{emhass-0.11.1 → emhass-0.11.2}/tests/test_retrieve_hass.py

@@ -34,10 +34,16 @@ class TestRetrieveHass(unittest.TestCase):
         save_data_to_file = False
 
         # Build params with default secrets (no config)
-        if emhass_conf['defaults_path'].exists():   
-            _,secrets = utils.build_secrets(emhass_conf,logger,no_response=True)
-            params =  utils.build_params(emhass_conf,secrets,{},logger)
-            retrieve_hass_conf, _, _ = get_yaml_parse(params,logger)
+        if emhass_conf['defaults_path'].exists():
+            if get_data_from_file:
+                _,secrets = utils.build_secrets(emhass_conf,logger,no_response=True)
+                params =  utils.build_params(emhass_conf,secrets,{},logger)
+                retrieve_hass_conf, _, _ = get_yaml_parse(params,logger)
+            else:
+                emhass_conf['secrets_path'] = root / 'secrets_emhass.yaml'
+                emhass_conf['config_path'] = pathlib.Path(root) / 'config_emhass.yaml'
+                retrieve_hass_conf, _, _ = utils.get_legacy_yaml_parse(emhass_conf)
+                params = None
         else:
             raise Exception("config_defaults. does not exist in path: "+str(emhass_conf['defaults_path'] ))
 
@@ -60,8 +66,8 @@ class TestRetrieveHass(unittest.TestCase):
                 self.rh.df_final, self.days_list, self.var_list = pickle.load(inp)
         # Else obtain sensor values from HA
         else:
-            self.days_list = get_days_list(self.retrieve_hass_conf['historic_days_to_retrieve'])
-            self.var_list = [self.retrieve_hass_conf['sensor_power_load_no_var_loads'], self.retrieve_hass_conf['sensor_power_photovoltaics']]
+            self.days_list = get_days_list(self.retrieve_hass_conf['days_to_retrieve'])
+            self.var_list = [self.retrieve_hass_conf['var_PV'], self.retrieve_hass_conf['var_load']]
             self.rh.get_data(self.days_list, self.var_list,
                              minimal_response=False, significant_changes_only=False)
             # Check to save updated data to file 

{emhass-0.11.1 → emhass-0.11.2}/tests/test_utils.py

@@ -67,7 +67,7 @@ class TestCommandLineUtils(unittest.TestCase):
         self.assertTrue(params['optim_conf']['lp_solver'] == "default")
         self.assertTrue(params['optim_conf']['lp_solver_path'] == "empty")
         self.assertTrue(config['load_peak_hour_periods'] == {'period_hp_1': [{'start': '02:54'}, {'end': '15:24'}], 'period_hp_2': [{'start': '17:24'}, {'end': '20:24'}]})
-        self.assertTrue(params['retrieve_hass_conf']['sensor_replace_zero'] == ['sensor.power_photovoltaics','sensor.power_load_no_var_loads'])
+        self.assertTrue(params['retrieve_hass_conf']['sensor_replace_zero'] == ['sensor.power_photovoltaics'])
         # Test with config.json 
         config = utils.build_config(emhass_conf,logger,emhass_conf['defaults_path'],emhass_conf['config_path'])
         params = utils.build_params(emhass_conf,{},config,logger)