emhass 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

emhass/command_line.py

@@ -59,8 +59,8 @@ def set_input_data_dict(config_path: pathlib.Path, base_path: str, costfun: str,
         optim_conf, plant_conf, set_type, logger)
     # Define main objects
     rh = RetrieveHass(retrieve_hass_conf['hass_url'], retrieve_hass_conf['long_lived_token'], 
-                       retrieve_hass_conf['freq'], retrieve_hass_conf['time_zone'], 
-                       params, base_path, logger, get_data_from_file=get_data_from_file)
+                      retrieve_hass_conf['freq'], retrieve_hass_conf['time_zone'], 
+                      params, base_path, logger, get_data_from_file=get_data_from_file)
     fcst = Forecast(retrieve_hass_conf, optim_conf, plant_conf,
                     params, base_path, logger, get_data_from_file=get_data_from_file)
     opt = Optimization(retrieve_hass_conf, optim_conf, plant_conf, 
@@ -76,12 +76,12 @@ def set_input_data_dict(config_path: pathlib.Path, base_path: str, costfun: str,
             days_list = utils.get_days_list(retrieve_hass_conf['days_to_retrieve'])
             var_list = [retrieve_hass_conf['var_load'], retrieve_hass_conf['var_PV']]
             if not rh.get_data(days_list, var_list,
-                        minimal_response=False, significant_changes_only=False):
+                               minimal_response=False, significant_changes_only=False):
                 return False 
         if not rh.prepare_data(retrieve_hass_conf['var_load'], load_negative = retrieve_hass_conf['load_negative'],
-                        set_zero_min = retrieve_hass_conf['set_zero_min'], 
-                        var_replace_zero = retrieve_hass_conf['var_replace_zero'], 
-                        var_interp = retrieve_hass_conf['var_interp']):
+                               set_zero_min = retrieve_hass_conf['set_zero_min'], 
+                               var_replace_zero = retrieve_hass_conf['var_replace_zero'], 
+                               var_interp = retrieve_hass_conf['var_interp']):
             return False
         df_input_data = rh.df_final.copy()
         # What we don't need for this type of action
@@ -113,12 +113,12 @@ def set_input_data_dict(config_path: pathlib.Path, base_path: str, costfun: str,
             days_list = utils.get_days_list(1)
             var_list = [retrieve_hass_conf['var_load'], retrieve_hass_conf['var_PV']]
             if not rh.get_data(days_list, var_list,
-                        minimal_response=False, significant_changes_only=False):
+                               minimal_response=False, significant_changes_only=False):
                 return False
         if not rh.prepare_data(retrieve_hass_conf['var_load'], load_negative = retrieve_hass_conf['load_negative'],
-                        set_zero_min = retrieve_hass_conf['set_zero_min'], 
-                        var_replace_zero = retrieve_hass_conf['var_replace_zero'], 
-                        var_interp = retrieve_hass_conf['var_interp']):
+                               set_zero_min = retrieve_hass_conf['set_zero_min'], 
+                               var_replace_zero = retrieve_hass_conf['var_replace_zero'], 
+                               var_interp = retrieve_hass_conf['var_interp']):
             return False
         df_input_data = rh.df_final.copy()
         # Get PV and load forecasts
@@ -201,9 +201,11 @@ def perfect_forecast_optim(input_data_dict: dict, logger: logging.Logger,
     # Load cost and prod price forecast
     df_input_data = input_data_dict['fcst'].get_load_cost_forecast(
         input_data_dict['df_input_data'], 
-        method=input_data_dict['fcst'].optim_conf['load_cost_forecast_method'])
+        method=input_data_dict['fcst'].optim_conf['load_cost_forecast_method'],
+        list_and_perfect=True)
     df_input_data = input_data_dict['fcst'].get_prod_price_forecast(
-        df_input_data, method=input_data_dict['fcst'].optim_conf['prod_price_forecast_method'])
+        df_input_data, method=input_data_dict['fcst'].optim_conf['prod_price_forecast_method'],
+        list_and_perfect=True)
     opt_res = input_data_dict['opt'].perform_perfect_forecast_optim(df_input_data, input_data_dict['days_list'])
     # Save CSV file for analysis
     if save_data_to_file:

emhass/forecast.py

@@ -7,6 +7,8 @@ import copy
 import logging
 import json
 from typing import Optional
+import bz2
+import pickle as cPickle
 import pandas as pd
 import numpy as np
 from datetime import datetime, timedelta
@@ -21,7 +23,7 @@ from pvlib.irradiance import disc
 
 from emhass.retrieve_hass import RetrieveHass
 from emhass.machine_learning_forecaster import MLForecaster
-from emhass.utils import get_days_list
+from emhass.utils import get_days_list, get_root, set_df_index_freq
 
 
 class Forecast(object):
@@ -133,7 +135,7 @@ class Forecast(object):
         self.time_zone = self.retrieve_hass_conf['time_zone']
         self.method_ts_round = self.retrieve_hass_conf['method_ts_round']
         self.timeStep = self.freq.seconds/3600 # in hours
-        self.time_delta = pd.to_timedelta(opt_time_delta, "hours") # The period of optimization
+        self.time_delta = pd.to_timedelta(opt_time_delta, "hours")
         self.var_PV = self.retrieve_hass_conf['var_PV']
         self.var_load = self.retrieve_hass_conf['var_load']
         self.var_load_new = self.var_load+'_positive'
@@ -159,7 +161,7 @@ class Forecast(object):
         self.end_forecast = (self.start_forecast + self.optim_conf['delta_forecast']).replace(microsecond=0)
         self.forecast_dates = pd.date_range(start=self.start_forecast, 
                                             end=self.end_forecast-self.freq, 
-                                            freq=self.freq).round(self.freq, ambiguous='infer', nonexistent=self.freq)
+                                            freq=self.freq).round(self.freq, ambiguous='infer', nonexistent='shift_forward')
         if params is not None:
             if 'prediction_horizon' in list(self.params['passed_data'].keys()):
                 if self.params['passed_data']['prediction_horizon'] is not None:
@@ -184,7 +186,7 @@ class Forecast(object):
             freq_scrap = pd.to_timedelta(60, "minutes") # The scrapping time step is 60min
             forecast_dates_scrap = pd.date_range(start=self.start_forecast,
                                                  end=self.end_forecast-freq_scrap, 
-                                                 freq=freq_scrap).round(freq_scrap, ambiguous='infer', nonexistent=freq_scrap)
+                                                 freq=freq_scrap).round(freq_scrap, ambiguous='infer', nonexistent='shift_forward')
             # Using the clearoutside webpage
             response = get("https://clearoutside.com/forecast/"+str(round(self.lat, 2))+"/"+str(round(self.lon, 2))+"?desktop=true")
             '''import bz2 # Uncomment to save a serialized data for tests
@@ -412,8 +414,10 @@ class Forecast(object):
                 # Setting the main parameters of the PV plant
                 location = Location(latitude=self.lat, longitude=self.lon)
                 temp_params = TEMPERATURE_MODEL_PARAMETERS['sapm']['close_mount_glass_glass']
-                cec_modules = pvlib.pvsystem.retrieve_sam('CECMod')
-                cec_inverters = pvlib.pvsystem.retrieve_sam('cecinverter')
+                cec_modules = bz2.BZ2File(get_root(__file__, num_parent=2) / 'emhass/data/cec_modules.pbz2', "rb")
+                cec_modules = cPickle.load(cec_modules)
+                cec_inverters = bz2.BZ2File(get_root(__file__, num_parent=2) / 'emhass/data/cec_inverters.pbz2', "rb")
+                cec_inverters = cPickle.load(cec_inverters)
                 if type(self.plant_conf['module_model']) == list:
                     P_PV_forecast = pd.Series(0, index=df_weather.index)
                     for i in range(len(self.plant_conf['module_model'])):
@@ -476,15 +480,16 @@ class Forecast(object):
         end_forecast_csv = (start_forecast_csv + self.optim_conf['delta_forecast']).replace(microsecond=0)
         forecast_dates_csv = pd.date_range(start=start_forecast_csv, 
                                            end=end_forecast_csv+timedelta(days=timedelta_days)-self.freq, 
-                                           freq=self.freq).round(self.freq, ambiguous='infer', nonexistent=self.freq)
+                                           freq=self.freq).round(self.freq, ambiguous='infer', nonexistent='shift_forward')
         if self.params is not None:
             if 'prediction_horizon' in list(self.params['passed_data'].keys()):
                 if self.params['passed_data']['prediction_horizon'] is not None:
                     forecast_dates_csv = forecast_dates_csv[0:self.params['passed_data']['prediction_horizon']]
         return forecast_dates_csv
     
-    def get_forecast_out_from_csv(self, df_final: pd.DataFrame, forecast_dates_csv: pd.date_range,
-                                  csv_path: str, data_list: Optional[list] = None) -> pd.DataFrame:
+    def get_forecast_out_from_csv_or_list(self, df_final: pd.DataFrame, forecast_dates_csv: pd.date_range,
+                                          csv_path: str, data_list: Optional[list] = None, 
+                                          list_and_perfect: Optional[bool] = False) -> pd.DataFrame:
         r"""
         Get the forecast data as a DataFrame from a CSV file. 
         
@@ -502,34 +507,67 @@ class Forecast(object):
         :rtype: pd.DataFrame
 
         """
-        days_list = df_final.index.day.unique().tolist()
         if csv_path is None:
             data_dict = {'ts':forecast_dates_csv, 'yhat':data_list}
             df_csv = pd.DataFrame.from_dict(data_dict)
             df_csv.index = forecast_dates_csv
             df_csv.drop(['ts'], axis=1, inplace=True)
+            df_csv = set_df_index_freq(df_csv)
+            if list_and_perfect:
+                days_list = df_final.index.day.unique().tolist()
+            else:
+                days_list = df_csv.index.day.unique().tolist()
         else:
             load_csv_file_path = self.root + csv_path
             df_csv = pd.read_csv(load_csv_file_path, header=None, names=['ts', 'yhat'])
             df_csv.index = forecast_dates_csv
             df_csv.drop(['ts'], axis=1, inplace=True)
+            df_csv = set_df_index_freq(df_csv)
+            days_list = df_final.index.day.unique().tolist()
         forecast_out = pd.DataFrame()
         for day in days_list:
-            first_elm_index = [i for i, x in enumerate(df_final.index.day == day) if x][0]
-            last_elm_index = [i for i, x in enumerate(df_final.index.day == day) if x][-1]
-            fcst_index = pd.date_range(start=df_final.index[first_elm_index],
-                                       end=df_final.index[last_elm_index], 
-                                       freq=df_final.index.freq)
-            first_hour = str(df_final.index[first_elm_index].hour)+":"+str(df_final.index[first_elm_index].minute)
-            last_hour = str(df_final.index[last_elm_index].hour)+":"+str(df_final.index[last_elm_index].minute)
+            if csv_path is None:
+                if list_and_perfect:
+                    df_tmp = copy.deepcopy(df_final)
+                else:
+                    df_tmp = copy.deepcopy(df_csv)
+            else:
+                df_tmp = copy.deepcopy(df_final)
+            first_elm_index = [i for i, x in enumerate(df_tmp.index.day == day) if x][0]
+            last_elm_index = [i for i, x in enumerate(df_tmp.index.day == day) if x][-1]
+            fcst_index = pd.date_range(start=df_tmp.index[first_elm_index],
+                                    end=df_tmp.index[last_elm_index], 
+                                    freq=df_tmp.index.freq)
+            first_hour = str(df_tmp.index[first_elm_index].hour)+":"+str(df_tmp.index[first_elm_index].minute)
+            last_hour = str(df_tmp.index[last_elm_index].hour)+":"+str(df_tmp.index[last_elm_index].minute)
             if len(forecast_out) == 0:
-                forecast_out = pd.DataFrame(
-                    df_csv.between_time(first_hour, last_hour).values,
-                    index=fcst_index)
+                if csv_path is None:
+                    if list_and_perfect:
+                        forecast_out = pd.DataFrame(
+                            df_csv.between_time(first_hour, last_hour).values,
+                            index=fcst_index)
+                    else:
+                        forecast_out = pd.DataFrame(
+                            df_csv.loc[fcst_index,:].between_time(first_hour, last_hour).values,
+                            index=fcst_index)
+                else:
+                    forecast_out = pd.DataFrame(
+                        df_csv.between_time(first_hour, last_hour).values,
+                        index=fcst_index)
             else:
-                forecast_tp = pd.DataFrame(
-                    df_csv.between_time(first_hour, last_hour).values,
-                    index=fcst_index)
+                if csv_path is None:
+                    if list_and_perfect:
+                        forecast_tp = pd.DataFrame(
+                            df_csv.between_time(first_hour, last_hour).values,
+                            index=fcst_index)
+                    else:
+                        forecast_tp = pd.DataFrame(
+                            df_csv.loc[fcst_index,:].between_time(first_hour, last_hour).values,
+                            index=fcst_index)
+                else:
+                    forecast_tp = pd.DataFrame(
+                        df_csv.between_time(first_hour, last_hour).values,
+                        index=fcst_index)
                 forecast_out = pd.concat([forecast_out, forecast_tp], axis=0)
         return forecast_out
     
@@ -664,7 +702,8 @@ class Forecast(object):
         return P_Load_forecast
     
     def get_load_cost_forecast(self, df_final: pd.DataFrame, method: Optional[str] = 'hp_hc_periods',
-                               csv_path: Optional[str] = "data_load_cost_forecast.csv") -> pd.DataFrame:
+                               csv_path: Optional[str] = "data_load_cost_forecast.csv",
+                               list_and_perfect: Optional[bool] = False) -> pd.DataFrame:
         r"""
         Get the unit cost for the load consumption based on multiple tariff \
         periods. This is the cost of the energy from the utility in a vector \
@@ -694,7 +733,7 @@ class Forecast(object):
                 df_final.loc[df_hp.index, self.var_load_cost] = self.optim_conf['load_cost_hp']
         elif method == 'csv':
             forecast_dates_csv = self.get_forecast_days_csv(timedelta_days=0)
-            forecast_out = self.get_forecast_out_from_csv(
+            forecast_out = self.get_forecast_out_from_csv_or_list(
                 df_final, forecast_dates_csv, csv_path)
             df_final[self.var_load_cost] = forecast_out
         elif method == 'list': # reading a list of values
@@ -708,8 +747,8 @@ class Forecast(object):
                 data_list = data_list[0:len(self.forecast_dates)]
                 # Define the correct dates
                 forecast_dates_csv = self.get_forecast_days_csv(timedelta_days=0)
-                forecast_out = self.get_forecast_out_from_csv(
-                    df_final, forecast_dates_csv, None, data_list=data_list)
+                forecast_out = self.get_forecast_out_from_csv_or_list(
+                    df_final, forecast_dates_csv, None, data_list=data_list, list_and_perfect=list_and_perfect)
                 # Fill the final DF
                 df_final[self.var_load_cost] = forecast_out
         else:
@@ -718,7 +757,8 @@ class Forecast(object):
         return df_final
     
     def get_prod_price_forecast(self, df_final: pd.DataFrame, method: Optional[str] = 'constant',
-                               csv_path: Optional[str] = "/data/data_prod_price_forecast.csv") -> pd.DataFrame:
+                                csv_path: Optional[str] = "/data/data_prod_price_forecast.csv",
+                                list_and_perfect: Optional[bool] = False) -> pd.DataFrame:
         r"""
         Get the unit power production price for the energy injected to the grid.\
         This is the price of the energy injected to the utility in a vector \
@@ -743,7 +783,7 @@ class Forecast(object):
             df_final[self.var_prod_price] = self.optim_conf['prod_sell_price']
         elif method == 'csv':
             forecast_dates_csv = self.get_forecast_days_csv(timedelta_days=0)
-            forecast_out = self.get_forecast_out_from_csv(df_final,
+            forecast_out = self.get_forecast_out_from_csv_or_list(df_final,
                                                           forecast_dates_csv,
                                                           csv_path)
             df_final[self.var_prod_price] = forecast_out
@@ -758,8 +798,8 @@ class Forecast(object):
                 data_list = data_list[0:len(self.forecast_dates)]
                 # Define the correct dates
                 forecast_dates_csv = self.get_forecast_days_csv(timedelta_days=0)
-                forecast_out = self.get_forecast_out_from_csv(
-                    df_final, forecast_dates_csv, None, data_list=data_list)
+                forecast_out = self.get_forecast_out_from_csv_or_list(
+                    df_final, forecast_dates_csv, None, data_list=data_list, list_and_perfect=list_and_perfect)
                 # Fill the final DF
                 df_final[self.var_prod_price] = forecast_out
         else:

emhass/optimization.py

@@ -162,10 +162,10 @@ class Optimization:
         
         ## Add decision variables
         P_grid_neg  = {(i):plp.LpVariable(cat='Continuous',
-                                          lowBound=-self.plant_conf['P_grid_max'], upBound=0,
+                                          lowBound=-self.plant_conf['P_to_grid_max'], upBound=0,
                                           name="P_grid_neg{}".format(i)) for i in set_I}
         P_grid_pos  = {(i):plp.LpVariable(cat='Continuous',
-                                          lowBound=0, upBound=self.plant_conf['P_grid_max'],
+                                          lowBound=0, upBound=self.plant_conf['P_from_grid_max'],
                                           name="P_grid_pos{}".format(i)) for i in set_I}
         P_deferrable = []
         P_def_bin1 = []
@@ -267,13 +267,13 @@ class Optimization:
         # Avoid injecting and consuming from grid at the same time
         constraints.update({"constraint_pgridpos_{}".format(i) : 
             plp.LpConstraint(
-                e = P_grid_pos[i] - self.plant_conf['P_grid_max']*D[i],
+                e = P_grid_pos[i] - self.plant_conf['P_from_grid_max']*D[i],
                 sense = plp.LpConstraintLE,
                 rhs = 0)
             for i in set_I})
         constraints.update({"constraint_pgridneg_{}".format(i) : 
             plp.LpConstraint(
-                e = -P_grid_neg[i] - self.plant_conf['P_grid_max']*(1-D[i]),
+                e = -P_grid_neg[i] - self.plant_conf['P_to_grid_max']*(1-D[i]),
                 sense = plp.LpConstraintLE,
                 rhs = 0)
             for i in set_I})

emhass/retrieve_hass.py

@@ -133,14 +133,14 @@ class RetrieveHass:
                 try: # Sometimes when there are connection problems we need to catch empty retrieved json
                     data = response.json()[0]
                 except IndexError:
-                    if x is 0:
+                    if x == 0:
                         self.logger.error("The retrieved JSON is empty, A sensor:" + var + " may have 0 days of history or passed sensor may not be correct")
                     else:
                         self.logger.error("The retrieved JSON is empty for day:"+ str(day) +", days_to_retrieve may be larger than the recorded history of sensor:" + var + " (check your recorder settings)")
                     return False
                 df_raw = pd.DataFrame.from_dict(data)
                 if len(df_raw) == 0:
-                    if x is 0:
+                    if x == 0:
                         self.logger.error("The retrieved Dataframe is empty, A sensor:" + var + " may have 0 days of history or passed sensor may not be correct")
                     else:
                         self.logger.error("Retrieved empty Dataframe for day:"+ str(day) +", days_to_retrieve may be larger than the recorded history of sensor:" + var + " (check your recorder settings)")
@@ -149,7 +149,7 @@ class RetrieveHass:
                     from_date = pd.to_datetime(df_raw['last_changed'], format="ISO8601").min()
                     to_date = pd.to_datetime(df_raw['last_changed'], format="ISO8601").max()
                     ts = pd.to_datetime(pd.date_range(start=from_date, end=to_date, freq=self.freq), 
-                                        format='%Y-%d-%m %H:%M').round(self.freq, ambiguous='infer', nonexistent=self.freq)
+                                        format='%Y-%d-%m %H:%M').round(self.freq, ambiguous='infer', nonexistent='shift_forward')
                     df_day = pd.DataFrame(index = ts)
                 # Caution with undefined string data: unknown, unavailable, etc.
                 df_tp = df_raw.copy()[['state']].replace(

emhass/static/script.js

@@ -1,8 +1,3 @@
-//before page load check for stylesheet
-document.onreadystatechange = async function() {
-    checkStyleSheets()
-}
-
 //on page reload get saved data
 window.onload = async function () {
 
@@ -12,23 +7,6 @@ window.onload = async function () {
     document.getElementById("basicOrAdvanced").addEventListener("click", () => SwitchBasicOrAdvanced());
 };
 
-//check style sheet is loaded 
-async function checkStyleSheets() {
-    var styleHREF = getHTMLURL() + `static/style.css`
-    var styles = document.styleSheets;
-    for (var i = 0; i < styles.length; i++) {
-        if (styles[i].href.match("style")["input"] == styleHREF) {
-            return true
-        }
-    }
-    //if could not find file
-    var style = document.createElement("link");
-    style.rel = "stylesheet";
-    style.href = styleHREF;
-    style.type = "text/css";
-    document.getElementsByTagName("head")[0].appendChild(style);
-}
-
 //add listeners to buttons (based on page)
 function loadButtons(page) {
     switch (page) {
@@ -120,19 +98,10 @@ function SwitchBasicOrAdvanced() {
     }
 }
 
-//set current url
-function getHTMLURL() {
-    var currentUrl
-    if (window.location) {
-        currentUrl = window.location.href; //get current url to append
-    }
-    else { currentUrl = "" }
-    return currentUrl
-}
 
 //get html data from basic.html or advanced.html
 async function getHTMLData(htmlFile) {
-    const response = await fetch(getHTMLURL() + `static/` + htmlFile);
+    const response = await fetch(`static/` + htmlFile);
     blob = await response.blob(); //get data blob
     htmlTemplateData = await new Response(blob).text(); //obtain html from blob
     return await htmlTemplateData;
@@ -148,7 +117,7 @@ async function formAction(action, page) {
 
     if (data !== 0) { //don't run if there is an error in the input (box/list) Json data
         showChangeStatus("loading", {}); // show loading div for status
-        const response = await fetch(getHTMLURL() + `action/${action}`, {
+        const response = await fetch(`action/` + action, {
             //fetch data from webserver.py
             method: "POST",
             headers: {
@@ -206,7 +175,7 @@ async function showChangeStatus(status, logJson) {
 async function getTemplate() {
     //fetch data from webserver.py
     let htmlTemplateData = "";
-    response = await fetch(getHTMLURL() + `template/table-template`, {
+    response = await fetch(`template/table-template`, {
         method: "GET",
     });
     blob = await response.blob(); //get data blob

emhass/static/style.css

@@ -550,16 +550,16 @@ https://github.com/feathericons/feather */
   stroke-linecap: round !important;
   stroke-linejoin: round !important;
   fill: none !important;
-  filter: drop-shadow( #282928 .2px .2px) !important;
+  filter: drop-shadow(#282928 .2px .2px) !important;
   -webkit-text-size-adjust: none !important;
   -ms-text-size-adjust: none !important;
 
 }
 
-/* feather icons no background color */ 
+/* feather icons no background color */
 #top-links a {
   background: none !important;
-} 
+}
 
 /* -------------- */
 
@@ -586,7 +586,8 @@ select {
 }
 
 
-.alert, .info {
+.alert,
+.info {
   max-width: 50%;
 }
 
@@ -600,7 +601,7 @@ h2 {
   margin-bottom: .3em;
 }
 
-.table_div h4{
+.table_div h4 {
   margin-top: .5em;
 }
 
@@ -683,17 +684,49 @@ button {
 
 th {
   padding: 5px 7.77px;
+  text-align: center;
 }
 
-.mystyle tr:nth-child(even) {
+.mystyle tr:nth-child(even) td,
+th {
   background: #e1e1e1;
 }
 
-.mystyle tr:hover {
-  background: silver;
+.mystyle tr:nth-child(odd) td {
+  background: white;
+}
+
+.mystyle tr:hover td {
+  background-color: silver;
   cursor: pointer;
 }
 
+th:last-child {
+  border-top-right-radius: 7px;
+}
+
+th:first-child {
+  border-top-left-radius: 7px;
+}
+
+tr:last-child td:first-child {
+  border-bottom-left-radius: 7px;
+}
+
+tr:last-child td:last-child {
+  border-bottom-right-radius: 7px;
+}
+
+tr:hover td:first-child {
+  border-top-left-radius: 7px;
+  border-bottom-left-radius: 7px;
+}
+
+tr:hover td:last-child {
+  border-top-right-radius: 7px;
+  border-bottom-right-radius: 7px;
+}
+
 #top-links {
   display: flex;
   position: absolute;
@@ -795,14 +828,20 @@ th {
 }
 
 /* Basic and Advanced fade transitions */
-.TabSelection, #advance, #basic, button, select, .info {
+.TabSelection,
+#advance,
+#basic,
+button,
+select,
+.info {
   animation-name: fadeInOpacity;
   animation-iteration-count: 1;
   animation-timing-function: ease-in-out;
   animation-duration: .3s;
 }
 
-.input-list, .input-box {
+.input-list,
+.input-box {
   animation-name: fadeInOpacity;
   animation-iteration-count: 1;
   animation-timing-function: ease-in-out;
@@ -944,7 +983,8 @@ th {
     display: none !important;
   }
 
-  .info, .alert {
+  .info,
+  .alert {
     max-width: 100%;
   }
 }
@@ -957,15 +997,17 @@ th {
   }
 
   img,
-  figure, svg.main-svg{
+  figure,
+  svg.main-svg {
     -webkit-filter: invert(.82);
     filter: invert(.82);
   }
-  
-  figure, svg.main-svg{
-  border-color: #181818;
-  border-style: solid;
-  border-width: 1px;
+
+  figure,
+  svg.main-svg {
+    border-color: #181818;
+    border-style: solid;
+    border-width: 1px;
   }
 
   button,
@@ -1008,10 +1050,12 @@ th {
   .modebar-btn svg path {
     fill: #111 !important;
   }
+
   .modebar-btn svg {
-    filter:invert(100%) sepia(64%) saturate(2%) hue-rotate(294deg) brightness(85%) contrast(93%) !important
+    filter: invert(100%) sepia(64%) saturate(2%) hue-rotate(294deg) brightness(85%) contrast(93%) !important
   }
-  .modebar-btn--logo svg{
+
+  .modebar-btn--logo svg {
     filter: None !important;
     /* filter: invert(100%) saturate(100%) brightness(87%) contrast(100%) !important */
   }
@@ -1024,37 +1068,28 @@ th {
     color: #e1e1e1;
   }
 
-  tr td:nth-child(even),
-  .mystyle tr td:nth-child(even) {
-    background-color: #3d3d3d;
+  .mystyle tr {
+    background: none;
   }
 
-  tr:nth-child(odd),
-  .mystyle tr:nth-child(odd) {
-    background-color: #111111;
+  .mystyle tr:nth-child(even) td,
+  th {
+    background: #282928;
   }
 
-  tr:nth-child(even),
-  .mystyle tr:nth-child(even) {
-    background-color: #181818;
+  .mystyle tr:nth-child(odd) td {
+    background: #111111;
   }
 
-  tr:hover td,
-  th {
+  .mystyle tr:hover td {
     background-color: #3f3f3f;
   }
 
-  tr:hover td,
-  th:last-child, th:first-child, td:first-child, td:last-child
-  {
-    border-radius: 7px
-  }
-
-  .modebar-group{
+  .modebar-group {
     background-color: #0000 !important;
   }
 
-  .modebar-btn{
+  .modebar-btn {
     background: #3f3f3f;
   }
 
@@ -1076,4 +1111,4 @@ th {
   }
 
 
-}
+}

emhass/templates/index.html

@@ -4,9 +4,9 @@
 <head>
     <title>EMHASS: Energy Management Optimization for Home Assistant</title>
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <link rel="stylesheet" type="text/css" href="{{ basename }}/static/style.css">
-    <link rel="icon" type="image/x-icon" href="{{ basename }}/static/img/emhass_logo_short.svg">
-    <script src="{{ basename }}/static/script.js"></script>
+    <link rel="stylesheet" type="text/css" href="static/style.css?version=1"> <!-- change version on stylesheet changes  -->
+    <link rel="icon" type="image/x-icon" href="static/img/emhass_logo_short.svg">
+    <script src="static/script.js"></script>
 </head>
 
 <body style="margin: auto; align-items:center; text-align:center;">
@@ -17,22 +17,22 @@
             <!-- advanced or basic page switch -->
             <a id="basicOrAdvanced" style="margin-right: 24px; cursor: pointer; z-index: 1">
                 <svg class="feather">
-                    <use class="feather" href="{{ basename }}/static/img/feather-sprite.svg#tool" />
+                    <use class="feather" href="static/img/feather-sprite.svg#tool" />
                 </svg>
             </a>
             <a href="https://emhass.readthedocs.io/en/latest/">
                 <svg class="feather" style="margin-right: 12px;";>
-                    <use class="feather" href="{{ basename }}/static/img/feather-sprite.svg#book" />
+                    <use class="feather" href="static/img/feather-sprite.svg#book" />
                 </svg>
             </a>
             <a href="https://github.com/davidusb-geek/emhass" target="_blank" rel="noopener noreferrer">
                 <svg class="feather" style="margin-right: 0px;" >
-                    <use class="feather" href="{{ basename }}/static/img/feather-sprite.svg#git-branch" />
+                    <use class="feather" href="static/img/feather-sprite.svg#git-branch" />
                 </svg>
             </a>
         </div>
         <!-- Title -->
-        <img src="{{ basename }}/static/img/emhass_icon.png" alt="">
+        <img src="static/img/emhass_icon.png" alt="">
         <h2>EMHASS: Energy Management Optimization for Home Assistant</h2>
     </div>
 

emhass/utils.py

@@ -96,7 +96,7 @@ def get_forecast_dates(freq: int, delta_forecast: int,
     end_forecast = (start_forecast + pd.Timedelta(days=delta_forecast)).replace(microsecond=0)
     forecast_dates = pd.date_range(start=start_forecast, 
         end=end_forecast+timedelta(days=timedelta_days)-freq, 
-        freq=freq).round(freq, ambiguous='infer', nonexistent=freq)
+        freq=freq).round(freq, ambiguous='infer', nonexistent='shift_forward')
     return forecast_dates
 
 def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dict, optim_conf: dict, plant_conf: dict,
@@ -208,62 +208,23 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             params['passed_data']['alpha'] = None
             params['passed_data']['beta'] = None
         # Treat passed forecast data lists
-        if 'pv_power_forecast' in runtimeparams.keys():
-            if type(runtimeparams['pv_power_forecast']) == list and len(runtimeparams['pv_power_forecast']) >= len(forecast_dates):
-                params['passed_data']['pv_power_forecast'] = runtimeparams['pv_power_forecast']
-                optim_conf['weather_forecast_method'] = 'list'
+        list_forecast_key = ['pv_power_forecast', 'load_power_forecast', 'load_cost_forecast', 'prod_price_forecast']
+        forecast_methods = ['weather_forecast_method', 'load_forecast_method', 'load_cost_forecast_method', 'prod_price_forecast_method']
+        for method, forecast_key in enumerate(list_forecast_key):
+            if forecast_key in runtimeparams.keys():
+                if type(runtimeparams[forecast_key]) == list and len(runtimeparams[forecast_key]) >= len(forecast_dates):
+                    params['passed_data'][forecast_key] = runtimeparams[forecast_key]
+                    optim_conf[forecast_methods[method]] = 'list'
+                else:
+                    logger.error(f"ERROR: The passed data is either not a list or the length is not correct, length should be {str(len(forecast_dates))}")
+                    logger.error(f"Passed type is {str(type(runtimeparams[forecast_key]))} and length is {str(len(runtimeparams[forecast_key]))}")
+                list_non_digits = [x for x in runtimeparams[forecast_key] if not (isinstance(x, int) or isinstance(x, float))]
+                if len(list_non_digits) > 0:
+                    logger.warning(f"There are non numeric values on the passed data for {forecast_key}, check for missing values (nans, null, etc)")
+                    for x in list_non_digits:
+                        logger.warning(f"This value in {forecast_key} was detected as non digits: {str(x)}")
             else:
-                logger.error("ERROR: The passed data is either not a list or the length is not correct, length should be "+str(len(forecast_dates)))
-                logger.error("Passed type is "+str(type(runtimeparams['pv_power_forecast']))+" and length is "+str(len(runtimeparams['pv_power_forecast'])))
-            list_non_digits = [x for x in runtimeparams['pv_power_forecast'] if not (isinstance(x, int) or isinstance(x, float))]
-            if len(list_non_digits) > 0:
-                logger.warning("There are non numeric values on the passed data for pv_power_forecast, check for missing values (nans, null, etc)")
-                for x in list_non_digits:
-                    logger.warning("This value in pv_power_forecast was detected as non digits: "+str(x))
-        else:
-            params['passed_data']['pv_power_forecast'] = None
-        if 'load_power_forecast' in runtimeparams.keys():
-            if type(runtimeparams['load_power_forecast']) == list and len(runtimeparams['load_power_forecast']) >= len(forecast_dates):
-                params['passed_data']['load_power_forecast'] = runtimeparams['load_power_forecast']
-                optim_conf['load_forecast_method'] = 'list'
-            else:
-                logger.error("ERROR: The passed data is either not a list or the length is not correct, length should be "+str(len(forecast_dates)))
-                logger.error("Passed type is "+str(type(runtimeparams['load_power_forecast']))+" and length is "+str(len(runtimeparams['load_power_forecast'])))
-            list_non_digits = [x for x in runtimeparams['load_power_forecast'] if not (isinstance(x, int) or isinstance(x, float))]
-            if len(list_non_digits) > 0:
-                logger.warning("There are non numeric values on the passed data for load_power_forecast, check for missing values (nans, null, etc)")
-                for x in list_non_digits:
-                    logger.warning("This value in load_power_forecast was detected as non digits: "+str(x))
-        else:
-            params['passed_data']['load_power_forecast'] = None
-        if 'load_cost_forecast' in runtimeparams.keys():
-            if type(runtimeparams['load_cost_forecast']) == list and len(runtimeparams['load_cost_forecast']) >= len(forecast_dates):
-                params['passed_data']['load_cost_forecast'] = runtimeparams['load_cost_forecast']
-                optim_conf['load_cost_forecast_method'] = 'list'
-            else:
-                logger.error("ERROR: The passed data is either not a list or the length is not correct, length should be "+str(len(forecast_dates)))
-                logger.error("Passed type is "+str(type(runtimeparams['load_cost_forecast']))+" and length is "+str(len(runtimeparams['load_cost_forecast'])))
-            list_non_digits = [x for x in runtimeparams['load_cost_forecast'] if not (isinstance(x, int) or isinstance(x, float))]
-            if len(list_non_digits) > 0:
-                logger.warning("There are non numeric values on the passed data or load_cost_forecast, check for missing values (nans, null, etc)")
-                for x in list_non_digits:
-                    logger.warning("This value in load_cost_forecast was detected as non digits: "+str(x))
-        else:
-            params['passed_data']['load_cost_forecast'] = None
-        if 'prod_price_forecast' in runtimeparams.keys():
-            if type(runtimeparams['prod_price_forecast']) == list and len(runtimeparams['prod_price_forecast']) >= len(forecast_dates):
-                params['passed_data']['prod_price_forecast'] = runtimeparams['prod_price_forecast']
-                optim_conf['prod_price_forecast_method'] = 'list'
-            else:
-                logger.error("ERROR: The passed data is either not a list or the length is not correct, length should be "+str(len(forecast_dates)))
-                logger.error("Passed type is "+str(type(runtimeparams['prod_price_forecast']))+" and length is "+str(len(runtimeparams['prod_price_forecast'])))
-            list_non_digits = [x for x in runtimeparams['prod_price_forecast'] if not (isinstance(x, int) or isinstance(x, float))]
-            if len(list_non_digits) > 0:
-                logger.warning("There are non numeric values on the passed data for prod_price_forecast, check for missing values (nans, null, etc)")
-                for x in list_non_digits:
-                    logger.warning("This value in prod_price_forecast was detected as non digits: "+str(x))
-        else:
-            params['passed_data']['prod_price_forecast'] = None
+                params['passed_data'][forecast_key] = None
         # Treat passed data for forecast model fit/predict/tune at runtime
         if 'days_to_retrieve' not in runtimeparams.keys():
             days_to_retrieve = 9
@@ -634,8 +595,9 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
             params['optim_conf']['def_start_timestep'] = [i['start_timesteps_of_each_deferrable_load'] for i in options.get('list_start_timesteps_of_each_deferrable_load')]
         if options.get('list_end_timesteps_of_each_deferrable_load',None) != None: 
             params['optim_conf']['def_end_timestep'] = [i['end_timesteps_of_each_deferrable_load'] for i in options.get('list_end_timesteps_of_each_deferrable_load')]
-        # Updating variables in plant_con
-            params['plant_conf']['P_grid_max'] = options.get('maximum_power_from_grid',params['plant_conf']['P_grid_max'])
+        # Updating variables in plant_conf
+        params['plant_conf']['P_from_grid_max'] = options.get('maximum_power_from_grid',params['plant_conf']['P_from_grid_max'])
+        params['plant_conf']['P_to_grid_max'] = options.get('maximum_power_to_grid',params['plant_conf']['P_to_grid_max'])
         if options.get('list_pv_module_model',None) != None:         
             params['plant_conf']['module_model'] = [i['pv_module_model'] for i in options.get('list_pv_module_model')]
         if options.get('list_pv_inverter_model',None) != None:        
@@ -656,8 +618,7 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
         params['plant_conf']['SOCmin'] = options.get('battery_minimum_state_of_charge',params['plant_conf']['SOCmin']) 
         params['plant_conf']['SOCmax'] = options.get('battery_maximum_state_of_charge',params['plant_conf']['SOCmax']) 
         params['plant_conf']['SOCtarget'] = options.get('battery_target_state_of_charge',params['plant_conf']['SOCtarget'])
-
-                # Check parameter lists have the same amounts as deferrable loads
+        # Check parameter lists have the same amounts as deferrable loads
         # If not, set defaults it fill in gaps
         if params['optim_conf']['num_def_loads'] is not len(params['optim_conf']['def_start_timestep']):
             logger.warning("def_start_timestep / list_start_timesteps_of_each_deferrable_load does not match number in num_def_loads, adding default values to parameter")
@@ -683,10 +644,6 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
             logger.warning("P_deferrable_nom / list_nominal_power_of_deferrable_loads does not match number in num_def_loads, adding default values to parameter")
             for x in range(len(params['optim_conf']['P_deferrable_nom']), params['optim_conf']['num_def_loads']):
                 params['optim_conf']['P_deferrable_nom'].append(0)   
-        if params['optim_conf']['num_def_loads'] is not len(params['optim_conf']['list_hp_periods']):
-            logger.warning("list_hp_periods / list_peak_hours_periods_(start&end)_hours does not match number in num_def_loads, adding default values to parameter")
-            for x in range(len(params['optim_conf']['list_hp_periods']), params['optim_conf']['num_def_loads']):
-                params['optim_conf']['list_hp_periods'].append({'period_hp_'+str(x+1):[{'start':'02:54'},{'end':'20:24'}]})
         # days_to_retrieve should be no less then 2
         if params['retrieve_hass_conf']['days_to_retrieve'] < 2:
             params['retrieve_hass_conf']['days_to_retrieve'] = 2

emhass/web_server.py

@@ -69,8 +69,13 @@ def index():
     else:
         app.logger.warning("The data container dictionary is empty... Please launch an optimization task")
         injection_dict={}
-    basename = request.headers.get("X-Ingress-Path", "")
-    return make_response(template.render(injection_dict=injection_dict, basename=basename))
+
+    # replace {{basename}} in html template html with path root  
+    # basename = request.headers.get("X-Ingress-Path", "")
+    # return make_response(template.render(injection_dict=injection_dict, basename=basename))
+    
+    return make_response(template.render(injection_dict=injection_dict))
+
 
 #get actions 
 @app.route('/template/<action_name>', methods=['GET'])
@@ -86,8 +91,7 @@ def template_action(action_name):
         else:
             app.logger.warning("The data container dictionary is empty... Please launch an optimization task")
             injection_dict={}        
-        basename = request.headers.get("X-Ingress-Path", "")    
-        return make_response(template.render(injection_dict=injection_dict, basename=basename))
+        return make_response(template.render(injection_dict=injection_dict))
 
 #post actions 
 @app.route('/action/<action_name>', methods=['POST'])

{emhass-0.8.4.dist-info → emhass-0.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.8.4
+Version: 0.8.6
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ
@@ -12,7 +12,7 @@ Classifier: Topic :: Software Development :: Build Tools
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9, <3.12
+Requires-Python: >=3.10, <3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: wheel
@@ -466,8 +466,6 @@ curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0,
 curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93], "prediction_horizon":10, "soc_init":0.5,"soc_final":0.6,"def_total_hours":[1,3],"def_start_timestep":[0,3],"def_end_timestep":[0,6]}' http://localhost:5000/action/naive-mpc-optim
 ```
 
-
-
 ## A machine learning forecaster
 
 Starting in v0.4.0 a new machine learning forecaster class was introduced.

emhass-0.8.6.dist-info/RECORD

@@ -0,0 +1,25 @@
+emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+emhass/command_line.py,sha256=TrNJnP1V94NoGanR7-Ik1ZVWlE6fsbDjWUIuH0l-0bs,37580
+emhass/forecast.py,sha256=38WF2XkopDOwvSZJU3_m01BXyiENVypEVOeXcHP-5Fo,45704
+emhass/machine_learning_forecaster.py,sha256=8Rm0-pltsjIYqLv01zCeO_Ij_n2HKC62dv_kCno7UsU,15640
+emhass/optimization.py,sha256=WcUJSDSBK7wgx0jaX25mhco7ZfqG1g066Ebh6ACyruQ,37197
+emhass/retrieve_hass.py,sha256=COf8LD6B0arFI-P71PXyLT7snB7_Wg5c3bMhRdVMdI4,18406
+emhass/utils.py,sha256=zj1rzpzsRpifgDcmeqRZUcM6WL6GGCcUAdStmGoXlJE,42394
+emhass/web_server.py,sha256=FFdIZio-QGFH3t-p-Le2Q1o6_cqjfBSdoEXdExJ21nY,21541
+emhass/data/cec_inverters.pbz2,sha256=tK8FvAUDW0uYez8EPttdCJwHhpPofclYV6GhhNZL0Pk,168272
+emhass/data/cec_modules.pbz2,sha256=8vEaysgYffXg3KUl8XSF36Mdywzi3LpEtUN_qenjO9s,1655747
+emhass/static/advanced.html,sha256=AsT3lMD0AjvAqzAYvUPmslyOYk2C3LA-VfoSB2PwnYA,1747
+emhass/static/basic.html,sha256=hJ4EgCXVNHL5nMQWkIHWjsTm_bJb0N_ZN4zFUjhxEzU,608
+emhass/static/script.js,sha256=bj3Pksm97sM4lUTpp3IkStx8fMwee39GnDWhrWjvV_A,17250
+emhass/static/style.css,sha256=xSihd06G-AeMKtFGPCJAnTaGVQXKuPM7kvVvDuQDuxU,15557
+emhass/static/img/emhass_icon.png,sha256=Kyx6hXQ1huJLHAq2CaBfjYXR25H9j99PSWHI0lShkaQ,19030
+emhass/static/img/emhass_logo_short.svg,sha256=yzMcqtBRCV8rH84-MwnigZh45_f9Eoqwho9P8nCodJA,66736
+emhass/static/img/feather-sprite.svg,sha256=VHjMJQg88wXa9CaeYrKGhNtyK0xdd47zCqwSIa-hxo8,60319
+emhass/templates/index.html,sha256=_BsvUJ981uSQkx5H9tq_3es__x4WdPiOy7FjNoNYU9w,2744
+emhass/templates/template.html,sha256=TkGgMecQEbFUZA4ymPwMUzNjKHsENvCgroUWbPt7G4Y,158
+emhass-0.8.6.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
+emhass-0.8.6.dist-info/METADATA,sha256=KR8yrRLmiYFe6ljkjXrQO-De3j-26I1d3WO3pZXMSvs,34758
+emhass-0.8.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+emhass-0.8.6.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
+emhass-0.8.6.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
+emhass-0.8.6.dist-info/RECORD,,

emhass-0.8.4.dist-info/RECORD

@@ -1,23 +0,0 @@
-emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-emhass/command_line.py,sha256=Os1W93kSIIiJ_IU48qfkEw691_ywaI0WknRBUDWleYc,37464
-emhass/forecast.py,sha256=2_Dm03_XyEVPYnKnJzA5TABYgt3tCe9_zRDGOOfFtEM,43555
-emhass/machine_learning_forecaster.py,sha256=8Rm0-pltsjIYqLv01zCeO_Ij_n2HKC62dv_kCno7UsU,15640
-emhass/optimization.py,sha256=M9BlbJ4f38APoIsHKLY_pfKszVWA61cPv_QnmtazkRA,37181
-emhass/retrieve_hass.py,sha256=buVvu-PJcphN9rlIhW1lI7oYk5r0fHh3h450eqznIAU,18400
-emhass/utils.py,sha256=tH6a7ofXpa18Gnll08wCHUdLMzHqqM3aEC-9-nyXKd4,46151
-emhass/web_server.py,sha256=U8aqg0udqxChBMxr83b0bE84HZLnuLQyb6SQaJmKtzM,21475
-emhass/static/advanced.html,sha256=AsT3lMD0AjvAqzAYvUPmslyOYk2C3LA-VfoSB2PwnYA,1747
-emhass/static/basic.html,sha256=hJ4EgCXVNHL5nMQWkIHWjsTm_bJb0N_ZN4zFUjhxEzU,608
-emhass/static/script.js,sha256=m6Bxqx1aHWcboXSiAqeEv8XscVC7W9sw8-Z_gPQzp5c,18173
-emhass/static/style.css,sha256=HSMn-URvvTvOXs_uVK3Ln7GM2xAvAlJjXdoNVWAdFk0,15222
-emhass/static/img/emhass_icon.png,sha256=Kyx6hXQ1huJLHAq2CaBfjYXR25H9j99PSWHI0lShkaQ,19030
-emhass/static/img/emhass_logo_short.svg,sha256=yzMcqtBRCV8rH84-MwnigZh45_f9Eoqwho9P8nCodJA,66736
-emhass/static/img/feather-sprite.svg,sha256=VHjMJQg88wXa9CaeYrKGhNtyK0xdd47zCqwSIa-hxo8,60319
-emhass/templates/index.html,sha256=pZCThgtHXEB6p2JlrMFJrbC3o35PcBmdome3OnNH_SE,2792
-emhass/templates/template.html,sha256=TkGgMecQEbFUZA4ymPwMUzNjKHsENvCgroUWbPt7G4Y,158
-emhass-0.8.4.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
-emhass-0.8.4.dist-info/METADATA,sha256=90908Yq-TiZHviiU1JMCErLMOqTJpuA9xzvx1cxCn7M,34759
-emhass-0.8.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-emhass-0.8.4.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
-emhass-0.8.4.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
-emhass-0.8.4.dist-info/RECORD,,