emhass 0.11.1__py3-none-any.whl → 0.11.2__py3-none-any.whl

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/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/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/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.dist-info → emhass-0.11.2.dist-info}/METADATA

@@ -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.dist-info → emhass-0.11.2.dist-info}/RECORD

@@ -4,17 +4,17 @@ emhass/forecast.py,sha256=EZuQnhVmXcHOxteaw1o44BVMVS956Y2UaTRELNT7RaI,53644
 emhass/machine_learning_forecaster.py,sha256=UP9YR3NSt-b_5i2b8wMAfXRWeMnJjSkBXnXvHepzHpM,16109
 emhass/machine_learning_regressor.py,sha256=QMAokLgEjvQ8Xy5gYZBQGQTzh2zgg6d6iydoPmy0QeI,10546
 emhass/optimization.py,sha256=IagqVYN2k8KFtQ0ZUZWab6egmDvpkYSQG8qyBmoWvyM,50877
-emhass/retrieve_hass.py,sha256=jLh8nSpsdeZJCaI7qKxAcZYpH8OKouMHz1OiezqLuqc,23430
-emhass/utils.py,sha256=_wCO_88Ycn0Gd5EcGHMBcyI9NQ-saWunGzvZVqufn-o,65336
+emhass/retrieve_hass.py,sha256=TzvowZLRNnNVKTv5peAbfmM05k_4JqMfZ-SymU3g7iw,23711
+emhass/utils.py,sha256=jtTnVa4X9w4Qgey2-XbWPUC_lg4LIFoedmh3yreeAes,68507
 emhass/web_server.py,sha256=QALTX0We82qToxiCnX2SocgkjlUsHLubqJ5WrCWO3P0,27229
 emhass/data/associations.csv,sha256=GFE_4ptHT6qno0lJt_rEeOXBqkLd759GNqXEVp4x2Po,3654
 emhass/data/cec_inverters.pbz2,sha256=tK8FvAUDW0uYez8EPttdCJwHhpPofclYV6GhhNZL0Pk,168272
 emhass/data/cec_modules.pbz2,sha256=8vEaysgYffXg3KUl8XSF36Mdywzi3LpEtUN_qenjO9s,1655747
-emhass/data/config_defaults.json,sha256=GKw2p3jObwMY1wAR_D_x8T8eNzQgu3awNQnIBuBwhJE,2791
+emhass/data/config_defaults.json,sha256=0jyYfF1ob3QMbjP8h2rd0jlbfe2uYm68NYW0GKM5qfk,2754
 emhass/static/advanced.html,sha256=gAhsd14elDwh1Ts4lf9wn_ZkczzzObq5qOimi_la3Ic,2067
 emhass/static/basic.html,sha256=ro2WwWgJyoUhqx_nJFzKCEG8FA8863vSHLmrjGYcEgs,677
 emhass/static/configuration_list.html,sha256=4ZAL-4YXdofnx17np-v39Yt3qW2TWbSzNBkj86bpvIg,1578
-emhass/static/configuration_script.js,sha256=PQYZHWMb0dohrw3hI7HeIXNEae6PamIvvs84IePLThw,31097
+emhass/static/configuration_script.js,sha256=N95GzyQdLzzOuSNw4L78BdArdqLPYJKhU3baGEsOhZE,31098
 emhass/static/script.js,sha256=q3qTqc_pTLTK-0NPKurxFXcJ2vZLz4TctPfUgz09ygo,16291
 emhass/static/style.css,sha256=a_8YlGubn1zoF5RTLJ_Qkrb8tAjUY9p7oAKxhCvJY2s,19288
 emhass/static/data/param_definitions.json,sha256=Nq4dnSmug0mWU8JooqVayKa67NQ2b6k30Z-ac2BJcys,19158
@@ -24,9 +24,9 @@ emhass/static/img/feather-sprite.svg,sha256=VHjMJQg88wXa9CaeYrKGhNtyK0xdd47zCqwS
 emhass/templates/configuration.html,sha256=yS9p730GHf99ZYK0NiZjkuaxPjH1ZFo8R6xL5c1ZZ9s,2885
 emhass/templates/index.html,sha256=Ehn-hUdraIwX_5Usb5Liz1ip24NfztmCxsi0J4Tf3-A,3076
 emhass/templates/template.html,sha256=TkGgMecQEbFUZA4ymPwMUzNjKHsENvCgroUWbPt7G4Y,158
-emhass-0.11.1.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
-emhass-0.11.1.dist-info/METADATA,sha256=x9mxnfO20GSc2HsZn375WlEKWMOreP9cNvOWpOQz3WI,48843
-emhass-0.11.1.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-emhass-0.11.1.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
-emhass-0.11.1.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
-emhass-0.11.1.dist-info/RECORD,,
+emhass-0.11.2.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
+emhass-0.11.2.dist-info/METADATA,sha256=fBUrr3jdNsmfINxtemxhL1ISYeDTCESHThh6xKpFd9I,48570
+emhass-0.11.2.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+emhass-0.11.2.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
+emhass-0.11.2.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
+emhass-0.11.2.dist-info/RECORD,,

{emhass-0.11.1.dist-info → emhass-0.11.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any