emhass 0.12.2__py3-none-any.whl → 0.12.4__py3-none-any.whl

emhass/command_line.py

@@ -11,7 +11,6 @@ import pickle
 import re
 import time
 from datetime import datetime, timezone
-from distutils.util import strtobool
 from importlib.metadata import version
 from typing import Optional, Tuple
 
@@ -646,9 +645,12 @@ def naive_mpc_optim(
     prediction_horizon = input_data_dict["params"]["passed_data"]["prediction_horizon"]
     soc_init = input_data_dict["params"]["passed_data"]["soc_init"]
     soc_final = input_data_dict["params"]["passed_data"]["soc_final"]
-    def_total_hours = input_data_dict["params"]["optim_conf"][
-        "operating_hours_of_each_deferrable_load"
-    ]
+    def_total_hours = input_data_dict["params"]["optim_conf"].get(
+        "operating_hours_of_each_deferrable_load", None
+    )
+    def_total_timestep = input_data_dict["params"]["optim_conf"].get(
+        "operating_timesteps_of_each_deferrable_load", None
+    )
     def_start_timestep = input_data_dict["params"]["optim_conf"][
         "start_timesteps_of_each_deferrable_load"
     ]
@@ -663,6 +665,7 @@ def naive_mpc_optim(
         soc_init,
         soc_final,
         def_total_hours,
+        def_total_timestep,
         def_start_timestep,
         def_end_timestep,
     )
@@ -1515,8 +1518,8 @@ def main():
     )
     parser.add_argument(
         "--log2file",
-        type=strtobool,
-        default="False",
+        type=bool,
+        default=False,
         help="Define if we should log to a file or not",
     )
     parser.add_argument(
@@ -1532,7 +1535,10 @@ def main():
         help="Pass runtime optimization parameters as dictionnary",
     )
     parser.add_argument(
-        "--debug", type=strtobool, default="False", help="Use True for testing purposes"
+        "--debug",
+        type=bool,
+        default=False,
+        help="Use True for testing purposes",
     )
     args = parser.parse_args()
 

emhass/data/emhass_inverters.csv

@@ -0,0 +1,8 @@
+Name,Vac,Pso,Paco,Pdco,Vdco,C0,C1,C2,C3,Pnt,Vdcmax,Idcmax,Mppt_low,Mppt_high,CEC_Date,CEC_hybrid,CEC_Type
+Units,V,W,W,W,V,1/W,1/V,1/V,1/V,W,V,A,V,V,,,
+[0],inv_snl_ac_voltage,inv_snl_pso,inv_snl_paco,inv_snl_pdco,inv_snl_vdco,inv_snl_c0,inv_snl_c1,inv_snl_c2,inv_snl_c3,inv_snl_pnt,inv_snl_vdcmax,inv_snl_idcmax,inv_snl_mppt_low,inv_snl_mppt_hi,inv_cec_date,inv_cec_hybrid,inv_cec_type
+Sungrow: SH25T,400,250,27500,26000,600,-0.0000828,-0.000759,-0.0001722,-0.0000414,25,1100,80,200,950,01/01/2025,Y,Hybrid
+Sungrow: SH20T,400,200,22000,21000,600,-0.00007584,-0.0007245,-0.0001587,-0.00003834,25,1100,80,200,950,01/01/2025,Y,Hybrid
+Sungrow: SH15T,400,150,16500,15700,600,-0.000069,-0.00069,-0.000138,-0.0000345,25,1100,80,200,950,01/01/2025,Y,Hybrid
+Sungrow: SH10RT,400,100,11000,10467,600,-0.00005892,-0.0006555,-0.0001173,-0.00002934,25,1100,80,200,950,01/01/2025,Y,Hybrid
+Sungrow: SH10RS,400,100,10000,9500,600,-0.000065,-0.00075,-0.00013,-0.000032,25,1000,25,250,850,01/01/2025,N,Grid-Tie

emhass/data/emhass_modules.csv

@@ -0,0 +1,6 @@
+Name,Manufacturer,Technology,Bifacial,STC,PTC,A_c,Length,Width,N_s,I_sc_ref,V_oc_ref,I_mp_ref,V_mp_ref,alpha_sc,beta_oc,T_NOCT,a_ref,I_L_ref,I_o_ref,R_s,R_sh_ref,Adjust,gamma_pmp,BIPV,Version,Date
+Units,,,,,,m2,m,m,,A,V,A,V,A/K,V/K,C,V,A,A,Ohm,Ohm,%,%/K,,,
+[0],lib_manufacturer,cec_material,lib_is_bifacial,,,cec_area,lib_length,lib_width,cec_n_s,cec_i_sc_ref,cec_v_oc_ref,cec_i_mp_ref,cec_v_mp_ref,cec_alpha_sc,cec_beta_oc,cec_t_noct,cec_a_ref,cec_i_l_ref,cec_i_o_ref,cec_r_s,cec_r_sh_ref,cec_adjust,cec_gamma_pmp,,,
+Jinko Solar JKM475N-60HL4-V,Jinko Solar,Mono-c-Si,0,475.0,432.0,2.16,1.903,1.134,120,14.23,42.54,13.49,35.21,0.046,-0.17,45.0,1.3,14.23,2e-7,0.2,300.0,1,-0.003,N,2021.08.01,01/03/2021
+Hanwha Q CELLS Q.PEAK L-G5 300W,Hanwha Q CELLS,Mono-c-Si,N,300.0,273.0,1.67,1.67,1.0,72,9.57,39.58,9.01,33.29,0.0006,-0.33,45.0,1.2,9.58,1e-10,0.5,1500,1,-0.38,N,2019.08.01,01/03/2019
+Risen RSM40-8-390M,Risen,Mono-c-Si,0,390.0,355.0,1.82,1.755,1.038,80,13.98,40.70,13.19,31.8,0.048,-0.15,45.0,1.25,13.98,1.9e-7,0.38,445.0,1,-0.35,N,2024.01.01,01/04/2024

emhass/forecast.py

@@ -9,6 +9,8 @@ import os
 import pickle
 import pickle as cPickle
 from datetime import datetime, timedelta
+import re
+from itertools import zip_longest
 from typing import Optional
 
 import numpy as np
@@ -319,86 +321,94 @@ class Forecast(object):
                     # If weather_forecast_cache, set request days as twice as long to avoid length issues (add a buffer)
                     if self.params["passed_data"].get("weather_forecast_cache", False):
                         days_solcast = min((days_solcast * 2), 336)
-                    url = (
-                        "https://api.solcast.com.au/rooftop_sites/"
-                        + self.retrieve_hass_conf["solcast_rooftop_id"]
-                        + "/forecasts?hours="
-                        + str(days_solcast)
-                    )
-                    response = get(url, headers=headers)
-                    """import bz2 # Uncomment to save a serialized data for tests
-                    import _pickle as cPickle
-                    with bz2.BZ2File("data/test_response_solcast_get_method.pbz2", "w") as f: 
-                        cPickle.dump(response, f)"""
-                    # Verify the request passed
-                    if int(response.status_code) == 200:
-                        data = response.json()
-                    elif (
-                        int(response.status_code) == 402
-                        or int(response.status_code) == 429
-                    ):
-                        self.logger.error(
-                            "Solcast error: May have exceeded your subscription limit."
-                        )
-                        return False
-                    elif (
-                        int(response.status_code) >= 400
-                        or int(response.status_code) >= 202
+                    # Split `roof_id` into a list (support comma or space as separator)
+                    roof_ids = re.split(r"[,\s]+", self.retrieve_hass_conf["solcast_rooftop_id"].strip())
+                    # Summary list of data
+                    total_data_list = [0] * len(self.forecast_dates)
+                    # Iteration over individual `roof_id`
+                    for roof_id in roof_ids:
+                        url = (
+                            f"https://api.solcast.com.au/rooftop_sites/{roof_id}/forecasts?hours={days_solcast}"
+                        )                  
+                        response = get(url, headers=headers)
+                        """import bz2 # Uncomment to save a serialized data for tests
+                        import _pickle as cPickle
+                        with bz2.BZ2File("data/test_response_solcast_get_method.pbz2", "w") as f: 
+                            cPickle.dump(response, f)"""
+                        # Verify the request passed
+                        if int(response.status_code) == 200:
+                            data = response.json()
+                        elif (
+                            int(response.status_code) == 402
+                            or int(response.status_code) == 429
+                        ):
+                            self.logger.error(
+                                "Solcast error: May have exceeded your subscription limit."
+                            )
+                            return False
+                        elif (
+                            int(response.status_code) >= 400
+                            or (int(response.status_code) >= 202 and int(response.status_code) <= 299)
+                        ):
+                            self.logger.error(
+                                "Solcast error: There was a issue with the solcast request, check solcast API key and rooftop ID."
+                            )
+                            self.logger.error(
+                                "Solcast error: Check that your subscription is valid and your network can connect to Solcast."
+                            )
+                            return False
+                        # Data processing for the current `roof_id`
+                        data_list = []
+                        for elm in data["forecasts"]:
+                            data_list.append(
+                                elm["pv_estimate"] * 1000
+                            )  # Converting kW to W
+                        # Check if the retrieved data has the correct length
+                        if len(data_list) < len(self.forecast_dates):
+                            self.logger.error(
+                                "Not enough data retrieved from Solcast service, try increasing the time step or use MPC."
+                            )
+                            return False
+                        # Adding the data of the current `roof_id` to the total
+                        total_data_list = [
+                            total + current for total, current in zip_longest(total_data_list, data_list, fillvalue=0)
+                        ]
+                    # If runtime weather_forecast_cache is true save forecast result to file as cache
+                    if self.params["passed_data"].get(
+                        "weather_forecast_cache", False
                     ):
-                        self.logger.error(
-                            "Solcast error: There was a issue with the solcast request, check solcast API key and rooftop ID."
-                        )
-                        self.logger.error(
-                            "Solcast error: Check that your subscription is valid and your network can connect to Solcast."
-                        )
-                        return False
-                    data_list = []
-                    for elm in data["forecasts"]:
-                        data_list.append(
-                            elm["pv_estimate"] * 1000
-                        )  # Converting kW to W
-                    # Check if the retrieved data has the correct length
-                    if len(data_list) < len(self.forecast_dates):
-                        self.logger.error(
-                            "Not enough data retried from Solcast service, try increasing the time step or use MPC."
+                        # Add x2 forecast periods for cached results. This adds a extra delta_forecast amount of days for a buffer
+                        cached_forecast_dates = self.forecast_dates.union(
+                            pd.date_range(
+                                self.forecast_dates[-1],
+                                periods=(len(self.forecast_dates) + 1),
+                                freq=self.freq,
+                            )[1:]
                         )
-                    else:
-                        # If runtime weather_forecast_cache is true save forecast result to file as cache
-                        if self.params["passed_data"].get(
-                            "weather_forecast_cache", False
-                        ):
-                            # Add x2 forecast periods for cached results. This adds a extra delta_forecast amount of days for a buffer
-                            cached_forecast_dates = self.forecast_dates.union(
-                                pd.date_range(
-                                    self.forecast_dates[-1],
-                                    periods=(len(self.forecast_dates) + 1),
-                                    freq=self.freq,
-                                )[1:]
+                        cache_data_list = total_data_list[0 : len(cached_forecast_dates)]
+                        cache_data_dict = {
+                            "ts": cached_forecast_dates,
+                            "yhat": cache_data_list,
+                        }
+                        data_cache = pd.DataFrame.from_dict(cache_data_dict)
+                        data_cache.set_index("ts", inplace=True)
+                        with open(w_forecast_cache_path, "wb") as file:
+                            cPickle.dump(data_cache, file)
+                        if not os.path.isfile(w_forecast_cache_path):
+                            self.logger.warning(
+                                "Solcast forecast data could not be saved to file."
                             )
-                            cache_data_list = data_list[0 : len(cached_forecast_dates)]
-                            cache_data_dict = {
-                                "ts": cached_forecast_dates,
-                                "yhat": cache_data_list,
-                            }
-                            data_cache = pd.DataFrame.from_dict(cache_data_dict)
-                            data_cache.set_index("ts", inplace=True)
-                            with open(w_forecast_cache_path, "wb") as file:
-                                cPickle.dump(data_cache, file)
-                            if not os.path.isfile(w_forecast_cache_path):
-                                self.logger.warning(
-                                    "Solcast forecast data could not be saved to file."
-                                )
-                            else:
-                                self.logger.info(
-                                    "Saved the Solcast results to cache, for later reference."
-                                )
-                        # Trim request results to forecast_dates
-                        data_list = data_list[0 : len(self.forecast_dates)]
-                        data_dict = {"ts": self.forecast_dates, "yhat": data_list}
-                        # Define DataFrame
-                        data = pd.DataFrame.from_dict(data_dict)
-                        # Define index
-                        data.set_index("ts", inplace=True)
+                        else:
+                            self.logger.info(
+                                "Saved the Solcast results to cache, for later reference."
+                            )
+                    # Trim request results to forecast_dates
+                    total_data_list = total_data_list[0 : len(self.forecast_dates)]
+                    data_dict = {"ts": self.forecast_dates, "yhat": total_data_list}
+                    # Define DataFrame
+                    data = pd.DataFrame.from_dict(data_dict)
+                    # Define index
+                    data.set_index("ts", inplace=True)
                 # Else, notify user to update cache
                 else:
                     self.logger.error("Unable to obtain Solcast cache file.")
@@ -906,33 +916,35 @@ class Forecast(object):
             # Upsampling
             # Use 'asfreq' to create empty slots, then interpolate
             resampled_data = data.resample(freq).asfreq()
-            resampled_data = resampled_data.interpolate(method='time')
+            resampled_data = resampled_data.interpolate(method="time")
         else:
             # No resampling needed
             resampled_data = data.copy()
         return resampled_data
-    
+
     @staticmethod
     def get_typical_load_forecast(data, forecast_date):
         r"""
         Forecast the load profile for the next day based on historic data.
 
-        :param data: A DataFrame with a DateTimeIndex containing the historic load data. 
+        :param data: A DataFrame with a DateTimeIndex containing the historic load data.
                     Must include a 'load' column.
         :type data: pd.DataFrame
         :param forecast_date: The date for which the forecast will be generated.
         :type forecast_date: pd.Timestamp
-        :return: A Series with the forecasted load profile for the next day and a list of days used 
+        :return: A Series with the forecasted load profile for the next day and a list of days used
                 to calculate the forecast.
         :rtype: tuple (pd.Series, list)
         """
         # Ensure the 'load' column exists
-        if 'load' not in data.columns:
+        if "load" not in data.columns:
             raise ValueError("Data must have a 'load' column.")
         # Filter historic data for the same month and day of the week
         month = forecast_date.month
         day_of_week = forecast_date.dayofweek
-        historic_data = data[(data.index.month == month) & (data.index.dayofweek == day_of_week)]
+        historic_data = data[
+            (data.index.month == month) & (data.index.dayofweek == day_of_week)
+        ]
         used_days = np.unique(historic_data.index.date)
         # Align all historic data to the forecast day
         aligned_data = []
@@ -940,7 +952,11 @@ class Forecast(object):
             daily_data = data[data.index.date == pd.Timestamp(day).date()]
             aligned_daily_data = daily_data.copy()
             aligned_daily_data.index = aligned_daily_data.index.map(
-                lambda x: x.replace(year=forecast_date.year, month=forecast_date.month, day=forecast_date.day)
+                lambda x: x.replace(
+                    year=forecast_date.year,
+                    month=forecast_date.month,
+                    day=forecast_date.day,
+                )
             )
             aligned_data.append(aligned_daily_data)
         # Combine all aligned historic data into a single DataFrame
@@ -948,7 +964,7 @@ class Forecast(object):
         # Compute the mean load for each timestamp
         forecast = combined_data.groupby(combined_data.index).mean()
         return forecast, used_days
-    
+
     def get_load_forecast(
         self,
         days_min_load_forecast: Optional[int] = 3,
@@ -1041,14 +1057,18 @@ class Forecast(object):
             ):
                 return False
             df = rh.df_final.copy()[[self.var_load_new]]
-        if method == "typical":  # using typical statistical data from a household power consumption
+        if (
+            method == "typical"
+        ):  # using typical statistical data from a household power consumption
             # Loading data from history file
             model_type = "load_clustering"
-            data_path = self.emhass_conf["data_path"] / str("data_train_" + model_type + ".pkl")
+            data_path = self.emhass_conf["data_path"] / str(
+                "data_train_" + model_type + ".pkl"
+            )
             with open(data_path, "rb") as fid:
                 data, _ = pickle.load(fid)
             # Resample the data if needed
-            current_freq = pd.Timedelta('30min')
+            current_freq = pd.Timedelta("30min")
             if self.freq != current_freq:
                 data = Forecast.resample_data(data, self.freq, current_freq)
             # Generate forecast
@@ -1057,20 +1077,28 @@ class Forecast(object):
             forecast = pd.DataFrame()
             for date in dates_list:
                 forecast_date = pd.Timestamp(date)
-                data.columns = ['load']
-                forecast_tmp, used_days = Forecast.get_typical_load_forecast(data, forecast_date)
-                self.logger.debug(f"Using {len(used_days)} days of data to generate the forecast.")
+                data.columns = ["load"]
+                forecast_tmp, used_days = Forecast.get_typical_load_forecast(
+                    data, forecast_date
+                )
+                self.logger.debug(
+                    f"Using {len(used_days)} days of data to generate the forecast."
+                )
                 # Normalize the forecast
-                forecast_tmp = forecast_tmp*self.plant_conf['maximum_power_from_grid']/9000
+                forecast_tmp = (
+                    forecast_tmp * self.plant_conf["maximum_power_from_grid"] / 9000
+                )
                 data_list.extend(forecast_tmp.values.ravel().tolist())
                 if len(forecast) == 0:
                     forecast = forecast_tmp
                 else:
                     forecast = pd.concat([forecast, forecast_tmp], axis=0)
             forecast.index = forecast.index.tz_convert(self.time_zone)
-            forecast_out = forecast.loc[forecast.index.intersection(self.forecast_dates)]
-            forecast_out.index.name = 'ts'
-            forecast_out = forecast_out.rename(columns={'load': 'yhat'})
+            forecast_out = forecast.loc[
+                forecast.index.intersection(self.forecast_dates)
+            ]
+            forecast_out.index.name = "ts"
+            forecast_out = forecast_out.rename(columns={"load": "yhat"})
         elif method == "naive":  # using a naive approach
             mask_forecast_out = (
                 df.index > days_list[-1] - self.optim_conf["delta_forecast_daily"]

emhass/machine_learning_forecaster.py

@@ -1,22 +1,22 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-import logging
 import copy
+import logging
 import time
+import warnings
 from typing import Optional, Tuple
-import pandas as pd
-import numpy as np
 
-from sklearn.linear_model import LinearRegression
-from sklearn.linear_model import ElasticNet
-from sklearn.neighbors import KNeighborsRegressor
+import numpy as np
+import pandas as pd
+from skforecast.ForecasterAutoreg import ForecasterAutoreg
+from skforecast.model_selection import (
+    backtesting_forecaster,
+    bayesian_search_forecaster,
+)
+from sklearn.linear_model import ElasticNet, LinearRegression
 from sklearn.metrics import r2_score
-
-from skforecast.recursive import ForecasterRecursive
-from skforecast.model_selection import bayesian_search_forecaster, backtesting_forecaster, TimeSeriesFold
-
-import warnings
+from sklearn.neighbors import KNeighborsRegressor
 
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
@@ -169,10 +169,7 @@ class MLForecaster:
             )
             base_model = KNeighborsRegressor()
         # Define the forecaster object
-        self.forecaster = ForecasterRecursive(
-            regressor = base_model,
-            lags      = self.num_lags
-            )
+        self.forecaster = ForecasterAutoreg(regressor=base_model, lags=self.num_lags)
         # Fit and time it
         self.logger.info("Training a " + self.sklearn_model + " model")
         start_time = time.time()
@@ -201,22 +198,18 @@ class MLForecaster:
             # Using backtesting tool to evaluate the model
             self.logger.info("Performing simple backtesting of fitted model")
             start_time = time.time()
-            cv = TimeSeriesFold(
-                steps                 = self.num_lags,
-                initial_train_size    = None,
-                fixed_train_size      = False,
-                gap                   = 0,
-                allow_incomplete_fold = True,
-                refit                 = False
-            )
             metric, predictions_backtest = backtesting_forecaster(
-                forecaster         = self.forecaster,
-                y                  = self.data_train[self.var_model],
-                exog               = self.data_train.drop(self.var_model, axis=1),
-                cv                 = cv,
-                metric             = MLForecaster.neg_r2_score,
-                verbose            = False,
-                show_progress      = True
+                forecaster=self.forecaster,
+                y=self.data_train[self.var_model],
+                exog=self.data_train.drop(self.var_model, axis=1),
+                steps=self.num_lags,
+                initial_train_size=None,
+                allow_incomplete_fold=True,
+                gap=0,
+                metric=MLForecaster.neg_r2_score,
+                verbose=False,
+                refit=False,
+                show_progress=True,
             )
             self.logger.info(f"Elapsed backtesting time: {time.time() - start_time}")
             self.logger.info(f"Backtest R2 score: {-metric}")
@@ -356,25 +349,24 @@ class MLForecaster:
         # The optimization routine call
         self.logger.info("Bayesian hyperparameter optimization with backtesting")
         start_time = time.time()
-        cv = TimeSeriesFold(
-            steps                 = num_lags,
-            initial_train_size    = len(self.data_exo.loc[:self.date_train]),
-            fixed_train_size      = True,
-            gap                   = 0,
-            skip_folds            = None,
-            allow_incomplete_fold = True,
-            refit                 = refit
-        )
-        self.optimize_results, self.optimize_results_object = bayesian_search_forecaster(
-            forecaster         = self.forecaster,
-            y                  = self.data_train[self.var_model],
-            exog               = self.data_train.drop(self.var_model, axis=1),
-            cv                 = cv,
-            search_space       = search_space,
-            metric             = MLForecaster.neg_r2_score,
-            n_trials           = 10,
-            random_state       = 123,
-            return_best        = True
+        self.optimize_results, self.optimize_results_object = (
+            bayesian_search_forecaster(
+                forecaster=self.forecaster,
+                y=self.data_train[self.var_model],
+                exog=self.data_train.drop(self.var_model, axis=1),
+                search_space=search_space,
+                metric=MLForecaster.neg_r2_score,
+                n_trials=10,
+                random_state=123,
+                steps=num_lags,
+                initial_train_size=len(self.data_exo.loc[: self.date_train]),
+                return_best=True,
+                fixed_train_size=True,
+                gap=0,
+                allow_incomplete_fold=True,
+                skip_folds=None,
+                refit=refit,
+            )
         )
         self.logger.info(f"Elapsed time: {time.time() - start_time}")
         self.is_tuned = True

emhass/optimization.py

@@ -4,7 +4,6 @@
 import bz2
 import copy
 import logging
-import pathlib
 import pickle as cPickle
 from math import ceil
 from typing import Optional, Tuple
@@ -85,7 +84,7 @@ class Optimization:
         self.var_load = self.retrieve_hass_conf["sensor_power_load_no_var_loads"]
         self.var_load_new = self.var_load + "_positive"
         self.costfun = costfun
-        # self.emhass_conf = emhass_conf
+        self.emhass_conf = emhass_conf
         self.logger = logger
         self.var_load_cost = var_load_cost
         self.var_prod_price = var_prod_price
@@ -120,6 +119,7 @@ class Optimization:
         soc_init: Optional[float] = None,
         soc_final: Optional[float] = None,
         def_total_hours: Optional[list] = None,
+        def_total_timestep: Optional[list] = None,
         def_start_timestep: Optional[list] = None,
         def_end_timestep: Optional[list] = None,
         debug: Optional[bool] = False,
@@ -152,6 +152,9 @@ class Optimization:
         :param def_total_hours: The functioning hours for this iteration for each deferrable load. \
             (For continuous deferrable loads: functioning hours at nominal power)
         :type def_total_hours: list
+        :param def_total_timestep: The functioning timesteps for this iteration for each deferrable load. \
+            (For continuous deferrable loads: functioning timesteps at nominal power)
+        :type def_total_timestep: list
         :param def_start_timestep: The timestep as from which each deferrable load is allowed to operate.
         :type def_start_timestep: list
         :param def_end_timestep: The timestep before which each deferrable load should operate.
@@ -173,8 +176,13 @@ class Optimization:
                     soc_final = soc_init
                 else:
                     soc_final = self.plant_conf["battery_target_state_of_charge"]
-        if def_total_hours is None:
+
+        # If def_total_timestep os set, bypass def_total_hours
+        if def_total_timestep is not None:
+            def_total_hours = [0 if x != 0 else x for x in def_total_hours]
+        elif def_total_hours is None:
             def_total_hours = self.optim_conf["operating_hours_of_each_deferrable_load"]
+
         if def_start_timestep is None:
             def_start_timestep = self.optim_conf[
                 "start_timesteps_of_each_deferrable_load"
@@ -381,7 +389,7 @@ class Optimization:
                 * self.timeStep
                 * (
                     self.optim_conf["weight_battery_discharge"] * P_sto_pos[i]
-                    + self.optim_conf["weight_battery_charge"] * P_sto_neg[i]
+                    - self.optim_conf["weight_battery_charge"] * P_sto_neg[i]
                 )
                 for i in set_I
             )
@@ -462,7 +470,8 @@ class Optimization:
             for i in range(len(self.plant_conf["pv_inverter_model"])):
                 if type(self.plant_conf["pv_inverter_model"][i]) == str:
                     cec_inverters = bz2.BZ2File(
-                        pathlib.Path(__file__).parent / "data/cec_inverters.pbz2", "rb"
+                        self.emhass_conf["root_path"] / "data" / "cec_inverters.pbz2",
+                        "rb",
                     )
                     cec_inverters = cPickle.load(cec_inverters)
                     inverter = cec_inverters[self.plant_conf["pv_inverter_model"][i]]
@@ -472,7 +481,7 @@ class Optimization:
         else:
             if type(self.plant_conf["pv_inverter_model"][i]) == str:
                 cec_inverters = bz2.BZ2File(
-                    pathlib.Path(__file__).parent / "data/cec_inverters.pbz2", "rb"
+                    self.emhass_conf["root_path"] / "data" / "cec_inverters.pbz2", "rb"
                 )
                 cec_inverters = cPickle.load(cec_inverters)
                 inverter = cec_inverters[self.plant_conf["pv_inverter_model"]]
@@ -699,8 +708,7 @@ class Optimization:
                         predicted_temps[k] = predicted_temp
 
             else:
-                if def_total_hours[k] > 0:
-                    # Total time of deferrable load
+                if def_total_timestep and def_total_timestep[k] > 0:
                     constraints.update(
                         {
                             "constraint_defload{}_energy".format(k): plp.LpConstraint(
@@ -708,13 +716,33 @@ class Optimization:
                                     P_deferrable[k][i] * self.timeStep for i in set_I
                                 ),
                                 sense=plp.LpConstraintEQ,
-                                rhs=def_total_hours[k]
+                                rhs=(self.timeStep * def_total_timestep[k])
                                 * self.optim_conf["nominal_power_of_deferrable_loads"][
                                     k
                                 ],
                             )
                         }
                     )
+                else:
+                    if def_total_hours[k] > 0:
+                        # Total time of deferrable load
+                        constraints.update(
+                            {
+                                "constraint_defload{}_energy".format(
+                                    k
+                                ): plp.LpConstraint(
+                                    e=plp.lpSum(
+                                        P_deferrable[k][i] * self.timeStep
+                                        for i in set_I
+                                    ),
+                                    sense=plp.LpConstraintEQ,
+                                    rhs=def_total_hours[k]
+                                    * self.optim_conf[
+                                        "nominal_power_of_deferrable_loads"
+                                    ][k],
+                                )
+                            }
+                        )
 
             # Ensure deferrable loads consume energy between def_start_timestep & def_end_timestep
             self.logger.debug(
@@ -722,12 +750,23 @@ class Optimization:
                     k, def_start_timestep[k], def_end_timestep[k]
                 )
             )
-            def_start, def_end, warning = Optimization.validate_def_timewindow(
-                def_start_timestep[k],
-                def_end_timestep[k],
-                ceil(def_total_hours[k] / self.timeStep),
-                n,
-            )
+            if def_total_timestep and def_total_timestep[k] > 0:
+                def_start, def_end, warning = Optimization.validate_def_timewindow(
+                    def_start_timestep[k],
+                    def_end_timestep[k],
+                    ceil(
+                        (60 / ((self.freq.seconds / 60) * def_total_timestep[k]))
+                        / self.timeStep
+                    ),
+                    n,
+                )
+            else:
+                def_start, def_end, warning = Optimization.validate_def_timewindow(
+                    def_start_timestep[k],
+                    def_end_timestep[k],
+                    ceil(def_total_hours[k] / self.timeStep),
+                    n,
+                )
             if warning is not None:
                 self.logger.warning("Deferrable load {} : {}".format(k, warning))
             self.logger.debug(
@@ -837,15 +876,35 @@ class Optimization:
                     }
                 )
                 # P_def_bin2 must be 1 for exactly the correct number of timesteps.
-                constraints.update(
-                    {
-                        "constraint_pdef{}_start5".format(k): plp.LpConstraint(
-                            e=plp.lpSum(P_def_bin2[k][i] for i in set_I),
-                            sense=plp.LpConstraintEQ,
-                            rhs=def_total_hours[k] / self.timeStep,
-                        )
-                    }
-                )
+                if def_total_timestep and def_total_timestep[k] > 0:
+                    constraints.update(
+                        {
+                            "constraint_pdef{}_start5".format(k): plp.LpConstraint(
+                                e=plp.lpSum(P_def_bin2[k][i] for i in set_I),
+                                sense=plp.LpConstraintEQ,
+                                rhs=(
+                                    (
+                                        60
+                                        / (
+                                            (self.freq.seconds / 60)
+                                            * def_total_timestep[k]
+                                        )
+                                    )
+                                    / self.timeStep
+                                ),
+                            )
+                        }
+                    )
+                else:
+                    constraints.update(
+                        {
+                            "constraint_pdef{}_start5".format(k): plp.LpConstraint(
+                                e=plp.lpSum(P_def_bin2[k][i] for i in set_I),
+                                sense=plp.LpConstraintEQ,
+                                rhs=def_total_hours[k] / self.timeStep,
+                            )
+                        }
+                    )
 
             # Treat deferrable load as a semi-continuous variable
             if self.optim_conf["treat_deferrable_load_as_semi_cont"][k]:
@@ -1336,6 +1395,7 @@ class Optimization:
         soc_init: Optional[float] = None,
         soc_final: Optional[float] = None,
         def_total_hours: Optional[list] = None,
+        def_total_timestep: Optional[list] = None,
         def_start_timestep: Optional[list] = None,
         def_end_timestep: Optional[list] = None,
     ) -> pd.DataFrame:
@@ -1362,6 +1422,9 @@ class Optimization:
         :param soc_final: The final battery SOC for the optimization. This parameter \
             is optional, if not given soc_init = soc_final = soc_target from the configuration file.
         :type soc_final: 
+        :param def_total_timestep: The functioning timesteps for this iteration for each deferrable load. \
+            (For continuous deferrable loads: functioning timesteps at nominal power)
+        :type def_total_timestep: list
         :param def_total_hours: The functioning hours for this iteration for each deferrable load. \
             (For continuous deferrable loads: functioning hours at nominal power)
         :type def_total_hours: list
@@ -1395,6 +1458,7 @@ class Optimization:
             soc_init=soc_init,
             soc_final=soc_final,
             def_total_hours=def_total_hours,
+            def_total_timestep=def_total_timestep,
             def_start_timestep=def_start_timestep,
             def_end_timestep=def_end_timestep,
         )

emhass/retrieve_hass.py

@@ -80,6 +80,7 @@ class RetrieveHass:
         self.emhass_conf = emhass_conf
         self.logger = logger
         self.get_data_from_file = get_data_from_file
+        self.var_list = []
 
     def get_ha_config(self):
         """
@@ -286,6 +287,7 @@ class RetrieveHass:
                 + str(self.freq)
             )
             return False
+        self.var_list = var_list
         return True
 
     def prepare_data(
@@ -336,7 +338,21 @@ class RetrieveHass:
                 "sensor.power_photovoltaics and sensor.power_load_no_var_loads should not be the same"
             )
             return False
-        if set_zero_min:  # Apply minimum values
+        # Confirm var_replace_zero & var_interp contain only sensors contained in var_list
+        if isinstance(var_replace_zero, list) and all(
+            item in var_replace_zero for item in self.var_list
+        ):
+            pass
+        else:
+            var_replace_zero = []
+        if isinstance(var_interp, list) and all(
+            item in var_interp for item in self.var_list
+        ):
+            pass
+        else:
+            var_interp = []
+        # Apply minimum values
+        if set_zero_min:
             self.df_final.clip(lower=0.0, inplace=True, axis=1)
             self.df_final.replace(to_replace=0.0, value=np.nan, inplace=True)
         new_var_replace_zero = []
@@ -347,6 +363,12 @@ class RetrieveHass:
                 new_string = string.replace(var_load, var_load + "_positive")
                 new_var_replace_zero.append(new_string)
         else:
+            self.logger.warning(
+                "Unable to find all the sensors in sensor_replace_zero parameter"
+            )
+            self.logger.warning(
+                "Confirm sure all sensors in sensor_replace_zero are sensor_power_photovoltaics and/or ensor_power_load_no_var_loads "
+            )
             new_var_replace_zero = None
         if var_interp is not None:
             for string in var_interp:
@@ -354,6 +376,12 @@ class RetrieveHass:
                 new_var_interp.append(new_string)
         else:
             new_var_interp = None
+            self.logger.warning(
+                "Unable to find all the sensors in sensor_linear_interp parameter"
+            )
+            self.logger.warning(
+                "Confirm all sensors in sensor_linear_interp are sensor_power_photovoltaics and/or ensor_power_load_no_var_loads "
+            )
         # Treating NaN replacement: either by zeros or by linear interpolation
         if new_var_replace_zero is not None:
             self.df_final[new_var_replace_zero] = self.df_final[

emhass/utils.py

@@ -161,33 +161,52 @@ def update_params_with_ha_config(
     params = json.loads(params)
     # Update params
     currency_to_symbol = {
-        'EUR': '€',
-        'USD': '$',
-        'GBP': '£',
-        'YEN': '¥',
-        'JPY': '¥',
-        'AUD': 'A$',
-        'CAD': 'C$',
-        'CHF': 'CHF',  # Swiss Franc has no special symbol
-        'CNY': '¥',
-        'INR': '₹',
-        'CZK': 'Kč',
+        "EUR": "€",
+        "USD": "$",
+        "GBP": "£",
+        "YEN": "¥",
+        "JPY": "¥",
+        "AUD": "A$",
+        "CAD": "C$",
+        "CHF": "CHF",  # Swiss Franc has no special symbol
+        "CNY": "¥",
+        "INR": "₹",
+        "CZK": "Kč",
+        "BGN": "лв",
+        "DKK": "kr",
+        "HUF": "Ft",
+        "PLN": "zł",
+        "RON": "Leu",
+        "SEK": "kr",
+        "TRY": "Lira",
+        "VEF": "Bolivar",
+        "VND": "Dong",
+        "THB": "Baht",
+        "SGD": "S$",
+        "IDR": "Roepia",
+        "ZAR": "Rand",
         # Add more as needed
     }
-    if 'currency' in ha_config.keys():
-        ha_config['currency'] = currency_to_symbol.get(ha_config['currency'], 'Unknown')
+    if "currency" in ha_config.keys():
+        ha_config["currency"] = currency_to_symbol.get(ha_config["currency"], "Unknown")
     else:
-        ha_config['currency'] = '€'
-    if 'unit_system' not in ha_config.keys():
-        ha_config['unit_system'] = {'temperature': '°C'}
-    
-    for k in range(params["optim_conf"]["number_of_deferrable_loads"]):
-        params['passed_data']['custom_predicted_temperature_id'][k].update(
-            {"unit_of_measurement": ha_config['unit_system']['temperature']}
+        ha_config["currency"] = "€"
+    if "unit_system" not in ha_config.keys():
+        ha_config["unit_system"] = {"temperature": "°C"}
+
+    number_of_deferrable_loads = params["optim_conf"]["number_of_deferrable_loads"]
+    if "num_def_loads" in params["passed_data"].keys():
+        number_of_deferrable_loads = params["passed_data"]["num_def_loads"]
+    if "number_of_deferrable_loads" in params["passed_data"].keys():
+        number_of_deferrable_loads = params["passed_data"]["number_of_deferrable_loads"]
+
+    for k in range(number_of_deferrable_loads):
+        params["passed_data"]["custom_predicted_temperature_id"][k].update(
+            {"unit_of_measurement": ha_config["unit_system"]["temperature"]}
         )
     updated_passed_dict = {
         "custom_cost_fun_id": {
-            "unit_of_measurement": ha_config['currency'],
+            "unit_of_measurement": ha_config["currency"],
         },
         "custom_unit_load_cost_id": {
             "unit_of_measurement": f"{ha_config['currency']}/kWh",
@@ -249,9 +268,9 @@ def treat_runtimeparams(
     params["plant_conf"].update(plant_conf)
 
     # Check defaults on HA retrieved config
-    default_currency_unit = '€'
-    default_temperature_unit = '°C'
-    
+    default_currency_unit = "€"
+    default_temperature_unit = "°C"
+
     # Some default data needed
     custom_deferrable_forecast_id = []
     custom_predicted_temperature_id = []
@@ -462,10 +481,17 @@ def treat_runtimeparams(
             else:
                 soc_final = runtimeparams["soc_final"]
             params["passed_data"]["soc_final"] = soc_final
-
-            params["passed_data"]["operating_hours_of_each_deferrable_load"] = params[
-                "optim_conf"
-            ].get("operating_hours_of_each_deferrable_load", None)
+            if "operating_timesteps_of_each_deferrable_load" in runtimeparams.keys():
+                params["passed_data"]["operating_timesteps_of_each_deferrable_load"] = (
+                    runtimeparams["operating_timesteps_of_each_deferrable_load"]
+                )
+                params["optim_conf"]["operating_timesteps_of_each_deferrable_load"] = (
+                    runtimeparams["operating_timesteps_of_each_deferrable_load"]
+                )
+            if "operating_hours_of_each_deferrable_load" in params["optim_conf"].keys():
+                params["passed_data"]["operating_hours_of_each_deferrable_load"] = (
+                    params["optim_conf"]["operating_hours_of_each_deferrable_load"]
+                )
             params["passed_data"]["start_timesteps_of_each_deferrable_load"] = params[
                 "optim_conf"
             ].get("start_timesteps_of_each_deferrable_load", None)

emhass/web_server.py

@@ -8,9 +8,9 @@ import os
 import pickle
 import re
 import threading
-from distutils.util import strtobool
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
+from typing import Optional
 
 import yaml
 from flask import Flask, make_response, request
@@ -45,7 +45,26 @@ from emhass.utils import (
 
 # Define the Flask instance
 app = Flask(__name__)
+
 emhass_conf = {}
+entity_path = Path
+params_secrets = {}
+continual_publish_thread = []
+injection_dict = {}
+
+
+def create_app(settings_override=None):
+    """
+    Create a Flask application.
+    :param settings_override: Override settings
+    :return: Flask app
+    """
+    global app
+    gunicorn_logger = logging.getLogger("gunicorn.error")
+    app.logger.handlers = gunicorn_logger.handlers
+    app.logger.setLevel(logging.INFO)
+    main()
+    return app
 
 
 def checkFileLog(refString=None) -> bool:
@@ -153,6 +172,10 @@ def configuration():
 
     """
     app.logger.info("serving configuration.html...")
+    # get params
+    if (emhass_conf["data_path"] / "params.pkl").exists():
+        with open(str(emhass_conf["data_path"] / "params.pkl"), "rb") as fid:
+            emhass_conf["config_path"], params = pickle.load(fid)
     # Load HTML template
     file_loader = PackageLoader("emhass", "templates")
     env = Environment(loader=file_loader)
@@ -328,7 +351,7 @@ def parameter_set():
         with open(str(emhass_conf["data_path"] / "params.pkl"), "wb") as fid:
             pickle.dump(
                 (
-                    config_path,
+                    emhass_conf["config_path"],
                     build_params(emhass_conf, params_secrets, config, app.logger),
                 ),
                 fid,
@@ -349,6 +372,9 @@ def action_call(action_name):
     :type action_name: String
 
     """
+    global continual_publish_thread
+    global injection_dict
+
     # Setting up parameters
     # Params
     ActionStr = " >> Obtaining params: "
@@ -524,31 +550,18 @@ def action_call(action_name):
         return make_response(msg, 400)
 
 
-if __name__ == "__main__":
-    # Parsing arguments
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--url",
-        type=str,
-        help="The URL to your Home Assistant instance, ex the external_url in your hass configuration",
-    )
-    parser.add_argument(
-        "--key",
-        type=str,
-        help="Your access key. If using EMHASS in standalone this should be a Long-Lived Access Token",
-    )
-    parser.add_argument(
-        "--no_response",
-        type=strtobool,
-        default="False",
-        help="This is set if json response errors occur",
-    )
-    args = parser.parse_args()
-
+def main(
+    args: Optional[dict] = None,
+):
+    global continual_publish_thread
+    global emhass_conf
+    global entity_path
+    global injection_dict
+    global app
     # Pre formatted config parameters
     config = {}
     # Secrets
-    params_secrets = {}
+    global params_secrets
     # Built parameters (formatted config + secrets)
     params = None
 
@@ -601,11 +614,16 @@ if __name__ == "__main__":
         app.logger.setLevel(logging.DEBUG)
 
     ## Secrets
+    # Argument
     argument = {}
-    if args.url:
-        argument["url"] = args.url
-    if args.key:
-        argument["key"] = args.key
+    no_response = False
+    if args is not None:
+        if args.get("url", None):
+            argument["url"] = args["url"]
+        if args.get("key", None):
+            argument["key"] = args["key"]
+        if args.get("no_response", None):
+            no_response = args["no_response"]
     # Combine secrets from ENV, Arguments/ARG, Secrets file (secrets_emhass.yaml), options (options.json from addon configuration file) and/or Home Assistant Standalone API (if exist)
     emhass_conf, secrets = build_secrets(
         emhass_conf,
@@ -613,7 +631,7 @@ if __name__ == "__main__":
         argument,
         options_path,
         os.getenv("SECRETS_PATH", default="/app/secrets_emhass.yaml"),
-        bool(args.no_response),
+        bool(no_response),
     )
     params_secrets.update(secrets)
 
@@ -706,4 +724,33 @@ if __name__ == "__main__":
         app.logger.info("Using core emhass version: " + version("emhass"))
     except PackageNotFoundError:
         app.logger.info("Using development emhass version")
+
+    return server_ip, port
+
+
+if __name__ == "__main__":
+    # Parsing arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--url",
+        type=str,
+        help="The URL to your Home Assistant instance, ex the external_url in your hass configuration",
+    )
+    parser.add_argument(
+        "--key",
+        type=str,
+        help="Your access key. If using EMHASS in standalone this should be a Long-Lived Access Token",
+    )
+    parser.add_argument(
+        "--no_response",
+        type=bool,
+        default=False,
+        help="This is set if json response errors occur",
+    )
+    args = parser.parse_args()
+
+    server_ip, port = main(vars(args))
+    os.environ["IP"] = str(server_ip)
+    os.environ["PORT"] = str(port)
+
     serve(app, host=server_ip, port=port, threads=8)

{emhass-0.12.2.dist-info → emhass-0.12.4.dist-info}/METADATA

@@ -1,46 +1,48 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: emhass
-Version: 0.12.2
+Version: 0.12.4
 Summary: An Energy Management System for Home Assistant
+Project-URL: Homepage, https://github.com/davidusb-geek/emhass
 Author-email: David HERNANDEZ <davidusb@gmail.com>
 License: MIT
-Project-URL: Homepage, https://github.com/davidusb-geek/emhass
-Keywords: energy,management,optimization,hass
+License-File: LICENSE
+Keywords: energy,hass,management,optimization
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Build Tools
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: <3.12,>=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy==1.26.4
-Requires-Dist: scipy==1.12.0
-Requires-Dist: pandas<=2.0.3
-Requires-Dist: pvlib>=0.10.2
-Requires-Dist: protobuf>=3.0.0
-Requires-Dist: pytz>=2021.1
+Requires-Dist: beautifulsoup4>=4.12.3
+Requires-Dist: flask>=3.1.0
+Requires-Dist: gunicorn>=23.0.0
+Requires-Dist: h5py>=3.12.1
+Requires-Dist: numpy<2.3.0,>=2.0.0
+Requires-Dist: pandas>=2.1.1
+Requires-Dist: plotly>=6.0.0rc0
+Requires-Dist: protobuf>=5.29.1
+Requires-Dist: pulp>=2.8.0
+Requires-Dist: pvlib>=0.10.3
+Requires-Dist: pytz>=2023.4
+Requires-Dist: pyyaml>=6.0.1
 Requires-Dist: requests>=2.25.1
-Requires-Dist: beautifulsoup4>=4.9.3
-Requires-Dist: h5py==3.12.1
-Requires-Dist: pulp>=2.4
-Requires-Dist: pyyaml>=5.4.1
-Requires-Dist: tables<=3.9.1
-Requires-Dist: skforecast==0.14.0
-Requires-Dist: flask>=2.0.3
-Requires-Dist: waitress>=2.1.1
-Requires-Dist: plotly>=5.6.0
+Requires-Dist: scipy>=1.14.0
+Requires-Dist: skforecast>=0.9.0
+Requires-Dist: tables>=3.9.1
+Requires-Dist: waitress>=3.0.2
 Provides-Extra: docs
-Requires-Dist: sphinx; extra == "docs"
-Requires-Dist: sphinx-rtd-theme; extra == "docs"
-Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: myst-parser; extra == 'docs'
+Requires-Dist: sphinx; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme; extra == 'docs'
 Provides-Extra: test
-Requires-Dist: requests_mock; extra == "test"
-Requires-Dist: pytest; extra == "test"
-Requires-Dist: coverage; extra == "test"
-Requires-Dist: snakeviz; extra == "test"
-Requires-Dist: ruff; extra == "test"
+Requires-Dist: coverage; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: requests-mock; extra == 'test'
+Requires-Dist: ruff; extra == 'test'
+Requires-Dist: snakeviz; extra == 'test'
+Requires-Dist: tabulate; extra == 'test'
+Description-Content-Type: text/markdown
 
 <div align="center">
   <br>
@@ -572,6 +574,7 @@ Here is the list of the other additional dictionary keys that can be passed at r
 - `nominal_power_of_deferrable_loads` for the nominal power for each deferrable load in Watts.
 
 - `operating_hours_of_each_deferrable_load` for the total number of hours that each deferrable load should operate.
+  - Alteratively, you can pass `operating_timesteps_of_each_deferrable_load` to set the total number of timesteps for each deferrable load. *(better parameter to use for setting under 1 hr)* 
 
 - `start_timesteps_of_each_deferrable_load` for the timestep from which each deferrable load is allowed to operate (if you don't want the deferrable load to use the whole optimization timewindow).
 

{emhass-0.12.2.dist-info → emhass-0.12.4.dist-info}/RECORD

@@ -1,16 +1,19 @@
 emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-emhass/command_line.py,sha256=4sAFhE6pBfB0SeYlhxKg_LwAOQJi_atMRurtNxYWIWA,70727
-emhass/forecast.py,sha256=_Gc8k6_8Nz87WHXKyUH6iXK956Z2TGzhL8L6t-tO_sk,63496
-emhass/machine_learning_forecaster.py,sha256=JErz50i_D59J5wXdbf_EUPb_FG45qRflv51iBA7ARXU,17417
+emhass/command_line.py,sha256=n9mQB-aQvxoyRWMj3zgafiITp-VJ8Owdj0q9jiAgKL4,70875
+emhass/forecast.py,sha256=62jwTz2RMDWQXT959w23KW7jGEtwyW7Idkdy3of8c7o,64574
+emhass/machine_learning_forecaster.py,sha256=4DVROJ8Y60hgSXCOJ5cIKvYRbxHoZYNu0hfuBtEsyx0,16898
 emhass/machine_learning_regressor.py,sha256=yFwMvVEmlgDJUsHhBT-HpNE3j2TC24e8Gmbcn9MPfeU,10690
-emhass/optimization.py,sha256=izMgRJFEP_9LHvZeX6FM1lxWyDWX3Tq2hFvu8ZP9FN4,61457
-emhass/retrieve_hass.py,sha256=RIzRiGzo09TO6zfDKqIClnLzQ5n2YkV97pinXPPXWsQ,26135
-emhass/utils.py,sha256=fkdsncHcTW70vlwp9-JjDzJqVpa7imW07QY7rEXEpHY,68991
-emhass/web_server.py,sha256=QsqT51AdlAgNCG3NV1zbm4YkBSq_0BaC3cIEzPeZvl8,28023
+emhass/optimization.py,sha256=DVUEtYrXFYNUIGpOPFX87TvpM1yqlmxjpERzZ7TNUIc,64680
+emhass/retrieve_hass.py,sha256=t51D1D_HjpV6h4IA0xitV5wQ39Wr3Lh2A-bJPEWdZJc,27282
+emhass/utils.py,sha256=7kuQfEQrYFh78Q5M2bQB0_x_4F-MvZ69v1c8JNFO1eU,70181
+emhass/web_server.py,sha256=qVFzU6ei_T4NhnPyhQ3BJyB_cWJz7VkpooPafZlqE98,29253
 emhass/data/associations.csv,sha256=IpEZIIWYdFjkRoC5xa1pRHjwnVs_VH8G8ogbGFxLfGI,3679
-emhass/data/cec_inverters.pbz2,sha256=tK8FvAUDW0uYez8EPttdCJwHhpPofclYV6GhhNZL0Pk,168272
-emhass/data/cec_modules.pbz2,sha256=8vEaysgYffXg3KUl8XSF36Mdywzi3LpEtUN_qenjO9s,1655747
+emhass/data/cec_inverters.pbz2,sha256=P1JkVuAF1VKD8HmA9Y-Pvb45dv7E-bIwAVkGXDftZLQ,189425
+emhass/data/cec_modules.pbz2,sha256=h14aS6aC1x1NKsCeTctsVZdFgAl5WiBZFAdnFZR_vE4,1885712
 emhass/data/config_defaults.json,sha256=-mQHahDv6Z5wYgClOs4VVr5KVCP51olb3f2mEj3Beic,2777
+emhass/data/emhass_inverters.csv,sha256=V5yN2B6TQpgT7ob4vQDvFW-Lzt8g3l5MODSDdlMOl9I,991
+emhass/data/emhass_modules.csv,sha256=IX2QfcyL8X5rpu9GYBBxBeeflZFckHAP8_L2bb602Yk,1056
+emhass/img/emhass_icon.png,sha256=Kyx6hXQ1huJLHAq2CaBfjYXR25H9j99PSWHI0lShkaQ,19030
 emhass/static/advanced.html,sha256=gAhsd14elDwh1Ts4lf9wn_ZkczzzObq5qOimi_la3Ic,2067
 emhass/static/basic.html,sha256=ro2WwWgJyoUhqx_nJFzKCEG8FA8863vSHLmrjGYcEgs,677
 emhass/static/configuration_list.html,sha256=i4v83RVduWjdjkjPhA74e-j8NSUpFzqMGU3ixOaJLfI,1740
@@ -24,9 +27,8 @@ emhass/static/img/feather-sprite.svg,sha256=VHjMJQg88wXa9CaeYrKGhNtyK0xdd47zCqwS
 emhass/templates/configuration.html,sha256=M-_L__juYzcdGDaryGrz6LG2mguW2f1Sx6k01YfG7Dc,2885
 emhass/templates/index.html,sha256=1V44c0yyliu_z8inl0K-zmmmkhQumH3Bqk8Jj1YJPzY,3076
 emhass/templates/template.html,sha256=TkGgMecQEbFUZA4ymPwMUzNjKHsENvCgroUWbPt7G4Y,158
-emhass-0.12.2.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
-emhass-0.12.2.dist-info/METADATA,sha256=ITyAlhDMWqjrmvS6aPd8EOh7MQP08sVviUiDDmjJtYQ,49387
-emhass-0.12.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-emhass-0.12.2.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
-emhass-0.12.2.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
-emhass-0.12.2.dist-info/RECORD,,
+emhass-0.12.4.dist-info/METADATA,sha256=QSe1zRBt_wjb-wp5ZRrlDmtyJtTBesZco0ARGslI-sk,49664
+emhass-0.12.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emhass-0.12.4.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
+emhass-0.12.4.dist-info/licenses/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
+emhass-0.12.4.dist-info/RECORD,,

{emhass-0.12.2.dist-info → emhass-0.12.4.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

emhass-0.12.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-emhass