emhass 0.4.12__py3-none-any.whl → 0.4.14__py3-none-any.whl

emhass/command_line.py

@@ -54,7 +54,7 @@ def set_input_data_dict(config_path: pathlib.Path, base_path: str, costfun: str,
     retrieve_hass_conf, optim_conf, plant_conf = utils.get_yaml_parse(
         config_path, use_secrets=not(get_data_from_file), params=params)
     # Treat runtimeparams
-    params, retrieve_hass_conf, optim_conf = utils.treat_runtimeparams(
+    params, retrieve_hass_conf, optim_conf, plant_conf = utils.treat_runtimeparams(
         runtimeparams, params, retrieve_hass_conf, 
         optim_conf, plant_conf, set_type, logger)
     # Define main objects
@@ -364,6 +364,7 @@ def forecast_model_predict(input_data_dict: dict, logger: logging.Logger,
     model_predict_entity_id = input_data_dict['params']['passed_data']['model_predict_entity_id']
     model_predict_unit_of_measurement = input_data_dict['params']['passed_data']['model_predict_unit_of_measurement']
     model_predict_friendly_name = input_data_dict['params']['passed_data']['model_predict_friendly_name']
+    publish_prefix = input_data_dict['params']['passed_data']['publish_prefix']
     if model_predict_publish:
         # Estimate the current index
         now_precise = datetime.now(input_data_dict['retrieve_hass_conf']['time_zone']).replace(second=0, microsecond=0)
@@ -380,7 +381,8 @@ def forecast_model_predict(input_data_dict: dict, logger: logging.Logger,
                                         model_predict_entity_id,
                                         model_predict_unit_of_measurement, 
                                         model_predict_friendly_name,
-                                        from_mlforecaster=True)
+                                        type_var = 'mlforecaster',
+                                        publish_prefix=publish_prefix)
     return predictions
 
 def forecast_model_tune(input_data_dict: dict, logger: logging.Logger,
@@ -462,19 +464,25 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
         idx_closest = opt_res_latest.index.get_indexer([now_precise], method='bfill')[0]
     if idx_closest == -1:
         idx_closest = opt_res_latest.index.get_indexer([now_precise], method='nearest')[0]
-    # Publish PV forecast
+    # Publish the data
     params = json.loads(input_data_dict['params'])
+    publish_prefix = params['passed_data']['publish_prefix']
+    # Publish PV forecast
     custom_pv_forecast_id = params['passed_data']['custom_pv_forecast_id']
     input_data_dict['rh'].post_data(opt_res_latest['P_PV'], idx_closest, 
                                     custom_pv_forecast_id["entity_id"], 
                                     custom_pv_forecast_id["unit_of_measurement"],
-                                    custom_pv_forecast_id["friendly_name"])
+                                    custom_pv_forecast_id["friendly_name"],
+                                    type_var = 'power',
+                                    publish_prefix=publish_prefix)
     # Publish Load forecast
     custom_load_forecast_id = params['passed_data']['custom_load_forecast_id']
     input_data_dict['rh'].post_data(opt_res_latest['P_Load'], idx_closest, 
                                     custom_load_forecast_id["entity_id"], 
                                     custom_load_forecast_id["unit_of_measurement"],
-                                    custom_load_forecast_id["friendly_name"])
+                                    custom_load_forecast_id["friendly_name"],
+                                    type_var = 'power',
+                                    publish_prefix=publish_prefix)
     cols_published = ['P_PV', 'P_Load']
     # Publish deferrable loads
     custom_deferrable_forecast_id = params['passed_data']['custom_deferrable_forecast_id']
@@ -485,7 +493,9 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
             input_data_dict['rh'].post_data(opt_res_latest["P_deferrable{}".format(k)], idx_closest, 
                                             custom_deferrable_forecast_id[k]["entity_id"], 
                                             custom_deferrable_forecast_id[k]["unit_of_measurement"],
-                                            custom_deferrable_forecast_id[k]["friendly_name"])
+                                            custom_deferrable_forecast_id[k]["friendly_name"],
+                                            type_var = 'deferrable',
+                                            publish_prefix=publish_prefix)
             cols_published = cols_published+["P_deferrable{}".format(k)]
     # Publish battery power
     if input_data_dict['opt'].optim_conf['set_use_battery']:
@@ -496,20 +506,26 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
             input_data_dict['rh'].post_data(opt_res_latest['P_batt'], idx_closest,
                                             custom_batt_forecast_id["entity_id"], 
                                             custom_batt_forecast_id["unit_of_measurement"],
-                                            custom_batt_forecast_id["friendly_name"])
+                                            custom_batt_forecast_id["friendly_name"],
+                                            type_var = 'batt',
+                                            publish_prefix=publish_prefix)
             cols_published = cols_published+["P_batt"]
             custom_batt_soc_forecast_id = params['passed_data']['custom_batt_soc_forecast_id']
             input_data_dict['rh'].post_data(opt_res_latest['SOC_opt']*100, idx_closest,
                                             custom_batt_soc_forecast_id["entity_id"], 
                                             custom_batt_soc_forecast_id["unit_of_measurement"],
-                                            custom_batt_soc_forecast_id["friendly_name"])
+                                            custom_batt_soc_forecast_id["friendly_name"],
+                                            type_var = 'SOC',
+                                            publish_prefix=publish_prefix)
             cols_published = cols_published+["SOC_opt"]
     # Publish grid power
     custom_grid_forecast_id = params['passed_data']['custom_grid_forecast_id']
     input_data_dict['rh'].post_data(opt_res_latest['P_grid'], idx_closest, 
                                     custom_grid_forecast_id["entity_id"], 
                                     custom_grid_forecast_id["unit_of_measurement"],
-                                    custom_grid_forecast_id["friendly_name"])
+                                    custom_grid_forecast_id["friendly_name"],
+                                    type_var = 'power',
+                                    publish_prefix=publish_prefix)
     cols_published = cols_published+["P_grid"]
     # Publish total value of cost function
     custom_cost_fun_id = params['passed_data']['custom_cost_fun_id']
@@ -517,20 +533,26 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
     input_data_dict['rh'].post_data(opt_res_latest[col_cost_fun], idx_closest, 
                                     custom_cost_fun_id["entity_id"], 
                                     custom_cost_fun_id["unit_of_measurement"],
-                                    custom_cost_fun_id["friendly_name"])
+                                    custom_cost_fun_id["friendly_name"],
+                                    type_var = 'cost_fun',
+                                    publish_prefix=publish_prefix)
     # Publish unit_load_cost
     custom_unit_load_cost_id = params['passed_data']['custom_unit_load_cost_id']
     input_data_dict['rh'].post_data(opt_res_latest['unit_load_cost'], idx_closest, 
                                     custom_unit_load_cost_id["entity_id"], 
                                     custom_unit_load_cost_id["unit_of_measurement"],
-                                    custom_unit_load_cost_id["friendly_name"])
+                                    custom_unit_load_cost_id["friendly_name"],
+                                    type_var = 'unit_load_cost',
+                                    publish_prefix=publish_prefix)
     cols_published = cols_published+["unit_load_cost"]
     # Publish unit_prod_price
     custom_unit_prod_price_id = params['passed_data']['custom_unit_prod_price_id']
     input_data_dict['rh'].post_data(opt_res_latest['unit_prod_price'], idx_closest, 
                                     custom_unit_prod_price_id["entity_id"], 
                                     custom_unit_prod_price_id["unit_of_measurement"],
-                                    custom_unit_prod_price_id["friendly_name"])
+                                    custom_unit_prod_price_id["friendly_name"],
+                                    type_var = 'unit_prod_price',
+                                    publish_prefix=publish_prefix)
     cols_published = cols_published+["unit_prod_price"]
     # Create a DF resuming what has been published
     opt_res = opt_res_latest[cols_published].loc[[opt_res_latest.index[idx_closest]]]

emhass/machine_learning_forecaster.py

@@ -200,6 +200,7 @@ class mlforecaster:
         if data_last_window is None:
             predictions = self.forecaster.predict(steps=self.num_lags, exog=self.data_test.drop(self.var_model, axis=1))
         else:
+            data_last_window = data_last_window.interpolate(method='linear', axis=0, limit=None)
             if self.is_tuned:
                 exog = mlforecaster.generate_exog(data_last_window, self.lags_opt, self.var_model)
                 predictions = self.forecaster.predict(steps=self.lags_opt, 

emhass/retrieve_hass.py

@@ -223,7 +223,7 @@ class retrieve_hass:
         list_df = copy.deepcopy(data_df).loc[data_df.index[idx]:].reset_index()
         list_df.columns = ['timestamps', entity_id]
         ts_list = [str(i) for i in list_df['timestamps'].tolist()]
-        vals_list = [str(np.round(i)) for i in list_df[entity_id].tolist()]
+        vals_list = [str(np.round(i,2)) for i in list_df[entity_id].tolist()]
         forecast_list = []
         for i, ts in enumerate(ts_list):
             datum = {}
@@ -231,7 +231,7 @@ class retrieve_hass:
             datum[entity_id.split('sensor.')[1]] = vals_list[i]
             forecast_list.append(datum)
         data = {
-            "state": str(state),
+            "state": "{:.2f}".format(state),
             "attributes": {
                 "unit_of_measurement": unit_of_measurement,
                 "friendly_name": friendly_name,
@@ -242,7 +242,9 @@ class retrieve_hass:
     
     def post_data(self, data_df: pd.DataFrame, idx: int, entity_id: str, 
                   unit_of_measurement: str, friendly_name: str,
-                  from_mlforecaster: Optional[bool]=False) -> None:
+                  type_var: str,
+                  from_mlforecaster: Optional[bool]=False,
+                  publish_prefix: Optional[str]="") -> None:
         r"""
         Post passed data to hass.
         
@@ -258,8 +260,15 @@ class retrieve_hass:
         :type unit_of_measurement: str
         :param friendly_name: The friendly name that will be used in the hass frontend.
         :type friendly_name: str
+        :param type_var: A variable to indicate the type of variable: power, SOC, etc.
+        :type type_var: str
+        :param publish_prefix: A common prefix for all published data entity_id.
+        :type publish_prefix: str, optional
 
         """
+        # Add a possible prefix to the entity ID
+        entity_id = entity_id.replace('sensor.', 'sensor.'+publish_prefix)
+        # Set the URL
         if self.hass_url == "http://supervisor/core/api": # If we are using the supervisor API
             url = self.hass_url+"/states/"+entity_id
         else: # Otherwise the Home Assistant Core API it is
@@ -269,34 +278,36 @@ class retrieve_hass:
             "content-type": "application/json",
         }
         # Preparing the data dict to be published
-        if 'cost_fun_' in entity_id:
+        if type_var == 'cost_fun':
             state = np.round(data_df.sum()[0],2)
+        elif type_var == 'unit_load_cost' or type_var == 'unit_prod_price':
+            state = np.round(data_df.loc[data_df.index[idx]],4)
         else:
             state = np.round(data_df.loc[data_df.index[idx]],2)
-        if 'p_pv' in entity_id or 'p_load' in entity_id or 'p_grid' in entity_id:
+        if type_var == 'power':
             data = retrieve_hass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement, 
                                                     friendly_name, "forecasts", state)
-        elif 'deferrable' in entity_id:
+        elif type_var == 'deferrable':
             data = retrieve_hass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement, 
                                                     friendly_name, "deferrables_schedule", state)
-        elif 'batt' in entity_id:
+        elif type_var == 'batt':
             data = retrieve_hass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement, 
                                                     friendly_name, "battery_scheduled_power", state)
-        elif 'SOC' in entity_id:
+        elif type_var == 'SOC':
             data = retrieve_hass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement, 
                                                     friendly_name, "battery_scheduled_soc", state)
-        elif 'unit_load_cost' in entity_id:
+        elif type_var == 'unit_load_cost':
             data = retrieve_hass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement, 
                                                     friendly_name, "unit_load_cost_forecasts", state)
-        elif 'unit_prod_price' in entity_id:
+        elif type_var == 'unit_prod_price':
             data = retrieve_hass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement, 
-                                                    friendly_name, "unit_load_cost_forecasts", state)
-        elif from_mlforecaster:
+                                                    friendly_name, "unit_prod_price_forecasts", state)
+        elif type_var == 'mlforecaster':
             data = retrieve_hass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement, 
                                                     friendly_name, "scheduled_forecast", state)
         else:
             data = {
-                "state": str(state),
+                "state": "{:.2f}".format(state),
                 "attributes": {
                     "unit_of_measurement": unit_of_measurement,
                     "friendly_name": friendly_name

emhass/utils.py

@@ -138,7 +138,8 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
                            'custom_cost_fun_id': {"entity_id": "sensor.total_cost_fun_value", "unit_of_measurement": "", "friendly_name": "Total cost function value"},
                            'custom_unit_load_cost_id': {"entity_id": "sensor.unit_load_cost", "unit_of_measurement": "€/kWh", "friendly_name": "Unit Load Cost"},
                            'custom_unit_prod_price_id': {"entity_id": "sensor.unit_prod_price", "unit_of_measurement": "€/kWh", "friendly_name": "Unit Prod Price"},
-                           'custom_deferrable_forecast_id': custom_deferrable_forecast_id}
+                           'custom_deferrable_forecast_id': custom_deferrable_forecast_id,
+                           'publish_prefix': ""}
     if 'passed_data' in params.keys():
         for key, value in default_passed_dict.items():
             params['passed_data'][key] = value
@@ -322,6 +323,9 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
         if 'solar_forecast_kwp' in runtimeparams.keys():
             retrieve_hass_conf['solar_forecast_kwp'] = runtimeparams['solar_forecast_kwp']
             optim_conf['weather_forecast_method'] = 'solar.forecast'
+        # Treat plant configuration parameters passed at runtime
+        if 'SOCtarget' in runtimeparams.keys():
+            plant_conf['SOCtarget'] = runtimeparams['SOCtarget']
         # Treat custom entities id's and friendly names for variables
         if 'custom_pv_forecast_id' in runtimeparams.keys():
             params['passed_data']['custom_pv_forecast_id'] = runtimeparams['custom_pv_forecast_id']
@@ -341,9 +345,15 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             params['passed_data']['custom_unit_prod_price_id'] = runtimeparams['custom_unit_prod_price_id']
         if 'custom_deferrable_forecast_id' in runtimeparams.keys():
             params['passed_data']['custom_deferrable_forecast_id'] = runtimeparams['custom_deferrable_forecast_id']
+        # A condition to put a prefix on all published data
+        if 'publish_prefix' not in runtimeparams.keys():
+            publish_prefix = ""
+        else:
+            publish_prefix = runtimeparams['publish_prefix']
+        params['passed_data']['publish_prefix'] = publish_prefix
     # Serialize the final params
     params = json.dumps(params)
-    return params, retrieve_hass_conf, optim_conf
+    return params, retrieve_hass_conf, optim_conf, plant_conf
 
 def get_yaml_parse(config_path: str, use_secrets: Optional[bool] = True,
                    params: Optional[str] = None) -> Tuple[dict, dict, dict]:

{emhass-0.4.12.dist-info → emhass-0.4.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.4.12
+Version: 0.4.14
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ
@@ -8,13 +8,13 @@ Author-email: davidusb@gmail.com
 License: UNKNOWN
 Keywords: energy,management,optimization,hass
 Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
+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.8
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8, <3.10
+Requires-Python: >=3.8, <=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: wheel
 Requires-Dist: numpy (==1.22.2)
@@ -30,7 +30,7 @@ Requires-Dist: pulp (>=2.4)
 Requires-Dist: pyyaml (>=5.4.1)
 Requires-Dist: netcdf4 (>=1.5.3)
 Requires-Dist: tables (==3.7.0)
-Requires-Dist: skforecast (==0.8.1)
+Requires-Dist: skforecast (==0.9.1)
 
 <div align="center">
   <br>
@@ -62,6 +62,15 @@ Requires-Dist: skforecast (==0.8.1)
     <img alt="Read the Docs" src="https://img.shields.io/readthedocs/emhass">
   </a>
 </p>
+<br>
+<p align="center">
+If you like this work please consider buying a coffee ;-) 
+</p>
+<p align="center">
+  <a href="https://www.buymeacoffee.com/davidusbgeek" target="_blank">
+    <img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" >
+  </a>
+</p>
 
 EHMASS is a Python module designed to optimize your home energy interfacing with Home Assistant.
 
@@ -306,7 +315,7 @@ shell_command:
   publish_data: "curl -i -H \"Content-Type:application/json\" -X POST -d '{\"custom_load_forecast_id\": {\"entity_id\": \"sensor.p_load_forecast\", \"unit_of_measurement\": \"W\", \"friendly_name\": \"Load Power Forecast\"}}' http://localhost:5000/action/publish-data"
 ```
 
-These keys are available to modify: `custom_pv_forecast_id`, `custom_load_forecast_id`, `custom_batt_forecast_id`, `custom_batt_soc_forecast_id`,  `custom_grid_forecast_id`, `custom_cost_fun_id`, `custom_deferrable_forecast_id`.
+These keys are available to modify: `custom_pv_forecast_id`, `custom_load_forecast_id`, `custom_batt_forecast_id`, `custom_batt_soc_forecast_id`,  `custom_grid_forecast_id`, `custom_cost_fun_id`, `custom_deferrable_forecast_id`, `custom_unit_load_cost_id` and `custom_unit_prod_price_id`.
 
 If you provide the `custom_deferrable_forecast_id` then the passed data should be a list of dictionaries, like this:
 ```
@@ -378,6 +387,10 @@ Here is the list of the other additional dictionnary keys that can be passed at
 
 - `solar_forecast_kwp` for the PV peak installed power in kW used for the solar.forecast API call. 
 
+- `SOCtarget` for the desired target value of initial and final SOC.
+
+- `publish_prefix` use this key to pass a common prefix to all published data. This will add a prefix to the sensor name but also to the forecasts attributes keys within the sensor.
+
 ## A naive Model Predictive Controller
 
 A MPC controller was introduced in v0.3.0. This is an informal/naive representation of a MPC controller. 

emhass-0.4.14.dist-info/RECORD

@@ -0,0 +1,15 @@
+emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+emhass/command_line.py,sha256=ROab6kyZfUh7L-kVl4YbZJeOr-slPTYL5YOqPF9Y0TM,36018
+emhass/forecast.py,sha256=3zqFIKwfu5cjGGLDGUZ-j1eMu8sWlSAc679oGmIwPeo,43060
+emhass/machine_learning_forecaster.py,sha256=Zhs8zcTn9E5yBNjdyYDPXjd2x6iQuqtL-QgaE74ODco,15633
+emhass/optimization.py,sha256=xJGtIRU3TjEtfQSDoxf-eR2OX8c74HzFz1aTDcSdlWU,31220
+emhass/retrieve_hass.py,sha256=TRECIc_ZohY1MOVC5t7UjB0t9Ke3gNIn6x8ZrnBMGUo,16969
+emhass/utils.py,sha256=OFb4VA7tooaUkTlqo7SPvBQPShsS5_wFE4KymJUH6KA,23644
+emhass/web_server.py,sha256=zGN-xt7bh7wErbRPDQZcGEL8NWIhLlzJDKVBCdsbOP8,19684
+emhass/static/style.css,sha256=5qGJl0MZGSaSvr0HUcGQ9UgMtDKP2CiyE-1H-jbsLuU,6760
+emhass/templates/index.html,sha256=gdiq_mJQgiRBMEVfFyxpeqlndJJm1YprGb8R6SjS40k,6614
+emhass-0.4.14.dist-info/METADATA,sha256=goup4y0hGPWtD9qeYz8w72xEgJhynGRz4OHcTY0m4xk,28137
+emhass-0.4.14.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+emhass-0.4.14.dist-info/entry_points.txt,sha256=tJULCm7mHGYb_IxyzPN_4KFYvhxv209_jq68jPiByy0,53
+emhass-0.4.14.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
+emhass-0.4.14.dist-info/RECORD,,

emhass-0.4.12.dist-info/RECORD

@@ -1,15 +0,0 @@
-emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-emhass/command_line.py,sha256=w8_IIxfBiB3SMgO2J-vXdlToEFMcxrmW0f7chGUemy8,34589
-emhass/forecast.py,sha256=3zqFIKwfu5cjGGLDGUZ-j1eMu8sWlSAc679oGmIwPeo,43060
-emhass/machine_learning_forecaster.py,sha256=sZeo94Ss7XvewQ7BXX53i9daWl_Sc4Z-oU1K45OQEU4,15536
-emhass/optimization.py,sha256=xJGtIRU3TjEtfQSDoxf-eR2OX8c74HzFz1aTDcSdlWU,31220
-emhass/retrieve_hass.py,sha256=v5J1JpRX6lK5YyYNdoTe9LPphjYZTelPy88a0ygRoJo,16379
-emhass/utils.py,sha256=M1-E0o-X0D1uOrKARRTnvhzosd3pYCkPjbEvumc34Ic,23116
-emhass/web_server.py,sha256=zGN-xt7bh7wErbRPDQZcGEL8NWIhLlzJDKVBCdsbOP8,19684
-emhass/static/style.css,sha256=5qGJl0MZGSaSvr0HUcGQ9UgMtDKP2CiyE-1H-jbsLuU,6760
-emhass/templates/index.html,sha256=gdiq_mJQgiRBMEVfFyxpeqlndJJm1YprGb8R6SjS40k,6614
-emhass-0.4.12.dist-info/METADATA,sha256=XnL-du1EsCUmXXSKAE1nORXvoYaWDf0ez2QBKoJQe_o,27318
-emhass-0.4.12.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-emhass-0.4.12.dist-info/entry_points.txt,sha256=tJULCm7mHGYb_IxyzPN_4KFYvhxv209_jq68jPiByy0,53
-emhass-0.4.12.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
-emhass-0.4.12.dist-info/RECORD,,