emhass 0.9.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

emhass/utils.py

@@ -12,7 +12,6 @@ import pandas as pd
 import yaml
 import pytz
 
-
 import plotly.express as px
 
 pd.options.plotting.backend = "plotly"
@@ -413,6 +412,8 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             optim_conf["def_start_timestep"] = runtimeparams["def_start_timestep"]
         if "def_end_timestep" in runtimeparams.keys():
             optim_conf["def_end_timestep"] = runtimeparams["def_end_timestep"]
+        if "def_current_state" in runtimeparams.keys():
+            optim_conf["def_current_state"] = [bool(s) for s in runtimeparams["def_current_state"]]
         if "treat_def_as_semi_cont" in runtimeparams.keys():
             optim_conf["treat_def_as_semi_cont"] = [
                 eval(str(k).capitalize())
@@ -443,6 +444,8 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             optim_conf["weight_battery_charge"] = runtimeparams["weight_battery_charge"]
         if 'freq' in runtimeparams.keys():
             retrieve_hass_conf['freq'] = pd.to_timedelta(runtimeparams['freq'], "minutes")
+        if 'continual_publish' in runtimeparams.keys():
+            retrieve_hass_conf['continual_publish'] = bool(runtimeparams['continual_publish'])  
         # Treat plant configuration parameters passed at runtime
         if "SOCtarget" in runtimeparams.keys():
             plant_conf["SOCtarget"] = runtimeparams["SOCtarget"]
@@ -487,12 +490,18 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             params["passed_data"]["custom_deferrable_forecast_id"] = runtimeparams[
                 "custom_deferrable_forecast_id"
             ]
-        # A condition to put a prefix on all published data
+        # A condition to put a prefix on all published data, or check for saved data under prefix name
         if "publish_prefix" not in runtimeparams.keys():
             publish_prefix = ""
         else:
             publish_prefix = runtimeparams["publish_prefix"]
         params["passed_data"]["publish_prefix"] = publish_prefix
+        # A condition to manually save entity data under data_path/entities after optimization
+        if "entity_save" not in runtimeparams.keys():
+            entity_save = ""
+        else:
+            entity_save = runtimeparams["entity_save"]
+        params["passed_data"]["entity_save"] = entity_save
     # Serialize the final params
     params = json.dumps(params)
     return params, retrieve_hass_conf, optim_conf, plant_conf
@@ -521,7 +530,7 @@ def get_yaml_parse(emhass_conf: dict, use_secrets: Optional[bool] = True,
         input_conf = json.loads(params)
     if use_secrets:
         if params is None:
-            with open(emhass_conf["root_path"] / 'secrets_emhass.yaml', 'r') as file: #assume secrets file is in root path 
+            with open(emhass_conf["config_path"].parent / 'secrets_emhass.yaml', 'r') as file: # Assume secrets and config file paths are the same 
                 input_secrets = yaml.load(file, Loader=yaml.FullLoader)
         else:
             input_secrets = input_conf.pop("params_secrets", None)
@@ -730,60 +739,30 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
     """
     if addon == 1:
         # Updating variables in retrieve_hass_conf
-        params["retrieve_hass_conf"]["freq"] = options.get(
-            "optimization_time_step", params["retrieve_hass_conf"]["freq"]
-        )
-        params["retrieve_hass_conf"]["days_to_retrieve"] = options.get(
-            "historic_days_to_retrieve",
-            params["retrieve_hass_conf"]["days_to_retrieve"],
-        )
-        params["retrieve_hass_conf"]["var_PV"] = options.get(
-            "sensor_power_photovoltaics", params["retrieve_hass_conf"]["var_PV"]
-        )
-        params["retrieve_hass_conf"]["var_load"] = options.get(
-            "sensor_power_load_no_var_loads", params["retrieve_hass_conf"]["var_load"]
-        )
-        params["retrieve_hass_conf"]["load_negative"] = options.get(
-            "load_negative", params["retrieve_hass_conf"]["load_negative"]
-        )
-        params["retrieve_hass_conf"]["set_zero_min"] = options.get(
-            "set_zero_min", params["retrieve_hass_conf"]["set_zero_min"]
-        )
+        params["retrieve_hass_conf"]["freq"] = options.get("optimization_time_step", params["retrieve_hass_conf"]["freq"])
+        params["retrieve_hass_conf"]["days_to_retrieve"] = options.get("historic_days_to_retrieve", params["retrieve_hass_conf"]["days_to_retrieve"])
+        params["retrieve_hass_conf"]["var_PV"] = options.get("sensor_power_photovoltaics", params["retrieve_hass_conf"]["var_PV"])
+        params["retrieve_hass_conf"]["var_load"] = options.get("sensor_power_load_no_var_loads", params["retrieve_hass_conf"]["var_load"])
+        params["retrieve_hass_conf"]["load_negative"] = options.get("load_negative", params["retrieve_hass_conf"]["load_negative"])
+        params["retrieve_hass_conf"]["set_zero_min"] = options.get("set_zero_min", params["retrieve_hass_conf"]["set_zero_min"])
         params["retrieve_hass_conf"]["var_replace_zero"] = [
-            options.get(
-                "sensor_power_photovoltaics",
-                params["retrieve_hass_conf"]["var_replace_zero"],
-            )
+            options.get("sensor_power_photovoltaics", params["retrieve_hass_conf"]["var_replace_zero"])
         ]
         params["retrieve_hass_conf"]["var_interp"] = [
-            options.get(
-                "sensor_power_photovoltaics", params["retrieve_hass_conf"]["var_PV"]
-            ),
-            options.get(
-                "sensor_power_load_no_var_loads",
-                params["retrieve_hass_conf"]["var_load"],
-            ),
+            options.get("sensor_power_photovoltaics", params["retrieve_hass_conf"]["var_PV"]),
+            options.get("sensor_power_load_no_var_loads", params["retrieve_hass_conf"]["var_load"])
         ]
-        params["retrieve_hass_conf"]["method_ts_round"] = options.get(
-            "method_ts_round", params["retrieve_hass_conf"]["method_ts_round"]
-        )
+        params["retrieve_hass_conf"]["method_ts_round"] = options.get("method_ts_round", params["retrieve_hass_conf"]["method_ts_round"])
+        params["retrieve_hass_conf"]["continual_publish"] = options.get("continual_publish", params["retrieve_hass_conf"]["continual_publish"])
         # Update params Secrets if specified
         params["params_secrets"] = params_secrets
-        params["params_secrets"]["time_zone"] = options.get(
-            "time_zone", params_secrets["time_zone"]
-        )
+        params["params_secrets"]["time_zone"] = options.get("time_zone", params_secrets["time_zone"])
         params["params_secrets"]["lat"] = options.get("Latitude", params_secrets["lat"])
-        params["params_secrets"]["lon"] = options.get(
-            "Longitude", params_secrets["lon"]
-        )
+        params["params_secrets"]["lon"] = options.get("Longitude", params_secrets["lon"])
         params["params_secrets"]["alt"] = options.get("Altitude", params_secrets["alt"])
         # Updating variables in optim_conf
-        params["optim_conf"]["set_use_battery"] = options.get(
-            "set_use_battery", params["optim_conf"]["set_use_battery"]
-        )
-        params["optim_conf"]["num_def_loads"] = options.get(
-            "number_of_deferrable_loads", params["optim_conf"]["num_def_loads"]
-        )
+        params["optim_conf"]["set_use_battery"] = options.get("set_use_battery", params["optim_conf"]["set_use_battery"])
+        params["optim_conf"]["num_def_loads"] = options.get("number_of_deferrable_loads", params["optim_conf"]["num_def_loads"])
         if options.get("list_nominal_power_of_deferrable_loads", None) != None:
             params["optim_conf"]["P_deferrable_nom"] = [
                 i["nominal_power_of_deferrable_loads"]
@@ -799,43 +778,22 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
                 i["treat_deferrable_load_as_semi_cont"]
                 for i in options.get("list_treat_deferrable_load_as_semi_cont")
             ]
-        params["optim_conf"]["weather_forecast_method"] = options.get(
-            "weather_forecast_method", params["optim_conf"]["weather_forecast_method"]
-        )
+        params["optim_conf"]["weather_forecast_method"] = options.get("weather_forecast_method", params["optim_conf"]["weather_forecast_method"])
         # Update optional param secrets
         if params["optim_conf"]["weather_forecast_method"] == "solcast":
-            params["params_secrets"]["solcast_api_key"] = options.get(
-                "optional_solcast_api_key",
-                params_secrets.get("solcast_api_key", "123456"),
-            )
-            params["params_secrets"]["solcast_rooftop_id"] = options.get(
-                "optional_solcast_rooftop_id",
-                params_secrets.get("solcast_rooftop_id", "123456"),
-            )
+            params["params_secrets"]["solcast_api_key"] = options.get("optional_solcast_api_key", params_secrets.get("solcast_api_key", "123456"))
+            params["params_secrets"]["solcast_rooftop_id"] = options.get("optional_solcast_rooftop_id", params_secrets.get("solcast_rooftop_id", "123456"))
         elif params["optim_conf"]["weather_forecast_method"] == "solar.forecast":
-            params["params_secrets"]["solar_forecast_kwp"] = options.get(
-                "optional_solar_forecast_kwp",
-                params_secrets.get("solar_forecast_kwp", 5),
-            )
-        params["optim_conf"]["load_forecast_method"] = options.get(
-            "load_forecast_method", params["optim_conf"]["load_forecast_method"]
-        )
-        params["optim_conf"]["delta_forecast"] = options.get(
-            "delta_forecast_daily", params["optim_conf"]["delta_forecast"]
-        )
-        params["optim_conf"]["load_cost_forecast_method"] = options.get(
-            "load_cost_forecast_method",
-            params["optim_conf"]["load_cost_forecast_method"],
-        )
+            params["params_secrets"]["solar_forecast_kwp"] = options.get("optional_solar_forecast_kwp", params_secrets.get("solar_forecast_kwp", 5))
+        params["optim_conf"]["load_forecast_method"] = options.get("load_forecast_method", params["optim_conf"]["load_forecast_method"])
+        params["optim_conf"]["delta_forecast"] = options.get("delta_forecast_daily", params["optim_conf"]["delta_forecast"])
+        params["optim_conf"]["load_cost_forecast_method"] = options.get("load_cost_forecast_method", params["optim_conf"]["load_cost_forecast_method"])
         if options.get("list_set_deferrable_load_single_constant", None) != None:
             params["optim_conf"]["set_def_constant"] = [
                 i["set_deferrable_load_single_constant"]
                 for i in options.get("list_set_deferrable_load_single_constant")
             ]
-        if (
-            options.get("list_peak_hours_periods_start_hours", None) != None
-            and options.get("list_peak_hours_periods_end_hours", None) != None
-        ):
+        if (options.get("list_peak_hours_periods_start_hours", None) != None and options.get("list_peak_hours_periods_end_hours", None) != None):
             start_hours_list = [
                 i["peak_hours_periods_start_hours"]
                 for i in options["list_peak_hours_periods_start_hours"]
@@ -847,27 +805,27 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
             num_peak_hours = len(start_hours_list)
             list_hp_periods_list = [{'period_hp_'+str(i+1):[{'start':start_hours_list[i]},{'end':end_hours_list[i]}]} for i in range(num_peak_hours)]
             params['optim_conf']['list_hp_periods'] = list_hp_periods_list
-        params['optim_conf']['load_cost_hp'] = options.get('load_peak_hours_cost',params['optim_conf']['load_cost_hp'])
+        params['optim_conf']['load_cost_hp'] = options.get('load_peak_hours_cost', params['optim_conf']['load_cost_hp'])
         params['optim_conf']['load_cost_hc'] = options.get('load_offpeak_hours_cost', params['optim_conf']['load_cost_hc'])
         params['optim_conf']['prod_price_forecast_method'] = options.get('production_price_forecast_method', params['optim_conf']['prod_price_forecast_method'])
-        params['optim_conf']['prod_sell_price'] = options.get('photovoltaic_production_sell_price',params['optim_conf']['prod_sell_price'])
-        params['optim_conf']['set_total_pv_sell'] = options.get('set_total_pv_sell',params['optim_conf']['set_total_pv_sell'])
-        params['optim_conf']['lp_solver'] = options.get('lp_solver',params['optim_conf']['lp_solver'])
-        params['optim_conf']['lp_solver_path'] = options.get('lp_solver_path',params['optim_conf']['lp_solver_path'])
-        params['optim_conf']['set_nocharge_from_grid'] = options.get('set_nocharge_from_grid',params['optim_conf']['set_nocharge_from_grid'])
-        params['optim_conf']['set_nodischarge_to_grid'] = options.get('set_nodischarge_to_grid',params['optim_conf']['set_nodischarge_to_grid'])
-        params['optim_conf']['set_battery_dynamic'] = options.get('set_battery_dynamic',params['optim_conf']['set_battery_dynamic'])
-        params['optim_conf']['battery_dynamic_max'] = options.get('battery_dynamic_max',params['optim_conf']['battery_dynamic_max'])
-        params['optim_conf']['battery_dynamic_min'] = options.get('battery_dynamic_min',params['optim_conf']['battery_dynamic_min'])
-        params['optim_conf']['weight_battery_discharge'] = options.get('weight_battery_discharge',params['optim_conf']['weight_battery_discharge'])
-        params['optim_conf']['weight_battery_charge'] = options.get('weight_battery_charge',params['optim_conf']['weight_battery_charge'])
+        params['optim_conf']['prod_sell_price'] = options.get('photovoltaic_production_sell_price', params['optim_conf']['prod_sell_price'])
+        params['optim_conf']['set_total_pv_sell'] = options.get('set_total_pv_sell', params['optim_conf']['set_total_pv_sell'])
+        params['optim_conf']['lp_solver'] = options.get('lp_solver', params['optim_conf']['lp_solver'])
+        params['optim_conf']['lp_solver_path'] = options.get('lp_solver_path', params['optim_conf']['lp_solver_path'])
+        params['optim_conf']['set_nocharge_from_grid'] = options.get('set_nocharge_from_grid', params['optim_conf']['set_nocharge_from_grid'])
+        params['optim_conf']['set_nodischarge_to_grid'] = options.get('set_nodischarge_to_grid', params['optim_conf']['set_nodischarge_to_grid'])
+        params['optim_conf']['set_battery_dynamic'] = options.get('set_battery_dynamic', params['optim_conf']['set_battery_dynamic'])
+        params['optim_conf']['battery_dynamic_max'] = options.get('battery_dynamic_max', params['optim_conf']['battery_dynamic_max'])
+        params['optim_conf']['battery_dynamic_min'] = options.get('battery_dynamic_min', params['optim_conf']['battery_dynamic_min'])
+        params['optim_conf']['weight_battery_discharge'] = options.get('weight_battery_discharge', params['optim_conf']['weight_battery_discharge'])
+        params['optim_conf']['weight_battery_charge'] = options.get('weight_battery_charge', params['optim_conf']['weight_battery_charge'])
         if options.get('list_start_timesteps_of_each_deferrable_load',None) != None: 
             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_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'])
+        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:        
@@ -880,14 +838,15 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
             params['plant_conf']['modules_per_string'] = [i['modules_per_string'] for i in options.get('list_modules_per_string')]
         if options.get('list_strings_per_inverter',None) != None: 
             params['plant_conf']['strings_per_inverter'] = [i['strings_per_inverter'] for i in options.get('list_strings_per_inverter')]
-        params['plant_conf']['Pd_max'] = options.get('battery_discharge_power_max',params['plant_conf']['Pd_max']) 
-        params['plant_conf']['Pc_max'] = options.get('battery_charge_power_max',params['plant_conf']['Pc_max'])
-        params['plant_conf']['eta_disch'] = options.get('battery_discharge_efficiency',params['plant_conf']['eta_disch'])
-        params['plant_conf']['eta_ch'] = options.get('battery_charge_efficiency',params['plant_conf']['eta_ch'])
-        params['plant_conf']['Enom'] = options.get('battery_nominal_energy_capacity',params['plant_conf']['Enom'])
-        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'])
+        params["plant_conf"]["inverter_is_hybrid"] = options.get("inverter_is_hybrid", params["plant_conf"]["inverter_is_hybrid"])
+        params['plant_conf']['Pd_max'] = options.get('battery_discharge_power_max', params['plant_conf']['Pd_max']) 
+        params['plant_conf']['Pc_max'] = options.get('battery_charge_power_max', params['plant_conf']['Pc_max'])
+        params['plant_conf']['eta_disch'] = options.get('battery_discharge_efficiency', params['plant_conf']['eta_disch'])
+        params['plant_conf']['eta_ch'] = options.get('battery_charge_efficiency', params['plant_conf']['eta_ch'])
+        params['plant_conf']['Enom'] = options.get('battery_nominal_energy_capacity', params['plant_conf']['Enom'])
+        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
         # If not, set defaults it fill in gaps
         if params['optim_conf']['num_def_loads'] is not len(params['optim_conf']['def_start_timestep']):
@@ -917,9 +876,7 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
         # 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
-            logger.warning(
-                "days_to_retrieve should not be lower then 2, setting days_to_retrieve to 2. Make sure your sensors also have at least 2 days of history"
-            )
+            logger.warning("days_to_retrieve should not be lower then 2, setting days_to_retrieve to 2. Make sure your sensors also have at least 2 days of history")
     else:
         params["params_secrets"] = params_secrets
     # The params dict

emhass/web_server.py

@@ -7,21 +7,21 @@ from requests import get
 from waitress import serve
 from importlib.metadata import version, PackageNotFoundError
 from pathlib import Path
-import os, json, argparse, pickle, yaml, logging,  re
+import os, json, argparse, pickle, yaml, logging,  re, threading
 from distutils.util import strtobool
 
 from emhass.command_line import set_input_data_dict
 from emhass.command_line import perfect_forecast_optim, dayahead_forecast_optim, naive_mpc_optim
 from emhass.command_line import forecast_model_fit, forecast_model_predict, forecast_model_tune
 from emhass.command_line import regressor_model_fit, regressor_model_predict
-from emhass.command_line import publish_data
+from emhass.command_line import publish_data, continual_publish
 from emhass.utils import get_injection_dict, get_injection_dict_forecast_model_fit, \
     get_injection_dict_forecast_model_tune, build_params
 
 # Define the Flask instance
 app = Flask(__name__)
 
-#check logfile for error, anything after string match if provided 
+# Check logfile for error, anything after string match if provided 
 def checkFileLog(refString=None):
     if (refString is not None): 
        logArray = grabLog(refString) #grab reduced log array
@@ -34,7 +34,7 @@ def checkFileLog(refString=None):
                 return True     
     return False
 
-#find string in logs, append all lines after to return
+# Find string in logs, append all lines after to return
 def grabLog(refString): 
     isFound = []
     output = []
@@ -49,13 +49,14 @@ def grabLog(refString):
                     output.append(logArray[x])
     return output
 
-#clear the log file
+# Clear the log file
 def clearFileLog(): 
     if ((emhass_conf['data_path'] / 'actionLogs.txt')).exists():
         with open(str(emhass_conf['data_path'] / 'actionLogs.txt'), "w") as fp:
             fp.truncate()    
 
-#initial index page render
+
+# Initial index page render
 @app.route('/')
 def index():
     app.logger.info("EMHASS server online, serving index.html...")
@@ -97,6 +98,7 @@ def template_action(action_name):
 #post actions 
 @app.route('/action/<action_name>', methods=['POST'])
 def action_call(action_name):
+    # Setting up parameters
     with open(str(emhass_conf['data_path'] / 'params.pkl'), "rb") as fid:
         emhass_conf['config_path'], params = pickle.load(fid)
     runtimeparams = request.get_json(force=True)
@@ -110,6 +112,15 @@ def action_call(action_name):
         params, runtimeparams, action_name, app.logger)
     if not input_data_dict:
         return make_response(grabLog(ActionStr), 400)
+    
+    # If continual_publish is True, start thread with loop function
+    if len(continual_publish_thread) == 0 and input_data_dict['retrieve_hass_conf'].get("continual_publish",False):
+        # Start Thread
+        continualLoop = threading.Thread(name="continual_publish",target=continual_publish,args=[input_data_dict,entity_path,app.logger])
+        continualLoop.start()
+        continual_publish_thread.append(continualLoop)      
+        
+    # run action based on POST request
     if action_name == 'publish-data':
         ActionStr = " >> Publishing data..."
         app.logger.info(ActionStr)
@@ -238,6 +249,7 @@ if __name__ == "__main__":
     CONFIG_PATH = os.getenv("CONFIG_PATH", default="/app/config_emhass.yaml")
     OPTIONS_PATH = os.getenv('OPTIONS_PATH', default="/app/options.json")
     DATA_PATH = os.getenv("DATA_PATH", default="/app/data/")
+    ROOT_PATH = os.getenv("ROOT_PATH", default=str(Path(__file__).parent))
     
     #options None by default
     options = None 
@@ -273,10 +285,11 @@ if __name__ == "__main__":
     #save paths to dictionary
     config_path = Path(CONFIG_PATH)
     data_path = Path(DATA_PATH)
+    root_path = Path(ROOT_PATH)
     emhass_conf = {}
     emhass_conf['config_path'] = config_path
     emhass_conf['data_path'] = data_path
-    emhass_conf['root_path'] = Path(config_path).parent #assume root is parent of config_path
+    emhass_conf['root_path'] = root_path 
     
     # Read the example default config file
     if config_path.exists():
@@ -446,6 +459,18 @@ if __name__ == "__main__":
     app.logger.addHandler(fileLogger)   
     clearFileLog() #Clear Action File logger file, ready for new instance
 
+
+    #If entity_path exists, remove any entity/metadata files 
+    entity_path = emhass_conf['data_path'] / "entities"
+    if os.path.exists(entity_path): 
+        entity_pathContents = os.listdir(entity_path)
+        if len(entity_pathContents) > 0:
+            for entity in entity_pathContents:
+                os.remove(entity_path / entity)
+
+    # Initialise continual publish thread list
+    continual_publish_thread = []
+    
     # Launch server
     port = int(os.environ.get('PORT', 5000))
     app.logger.info("Launching the emhass webserver at: http://"+web_ui_url+":"+str(port))

{emhass-0.9.1.dist-info → emhass-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.9.1
+Version: 0.10.0
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ
@@ -285,6 +285,8 @@ sudo chmod +x /home/user/emhass/scripts/publish_data.sh
 ```
 ### Common for any installation method
 
+#### Options 1, Home Assistant automate publish
+
 In `automations.yaml`:
 ```yaml
 - alias: EMHASS day-ahead optimization
@@ -300,9 +302,36 @@ In `automations.yaml`:
   action:
   - service: shell_command.publish_data
 ```
-In these automations the day-ahead optimization is performed everyday at 5:30am and the data is published every 5 minutes.
+In these automation's the day-ahead optimization is performed once a day, everyday at 5:30am, and the data *(output of automation)* is published every 5 minutes.
+
+#### Option 2, EMHASS automate publish 
 
-The final action will be to link a sensor value in Home Assistant to control the switch of a desired controllable load. For example imagine that I want to control my water heater and that the `publish-data` action is publishing the optimized value of a deferrable load that I want to be linked to my water heater desired behavior. In this case we could use an automation like this one below to control the desired real switch:
+In `automations.yaml`:
+```yaml
+- alias: EMHASS day-ahead optimization
+  trigger:
+    platform: time
+    at: '05:30:00'
+  action:
+  - service: shell_command.dayahead_optim
+  - service: shell_command.publish_data
+```
+in configuration page/`config_emhass.yaml` 
+```json
+"method_ts_round": "first"
+"continual_publish": true
+```
+In this automation the day-ahead optimization is performed once a day, everyday at 5:30am. 
+If the `freq` parameter is set to `30` *(default)* in the configuration, the results of the day-ahead optimization will generate 48 values *(for each entity)*, a value for each 30 minutes in a day *(i.e. 24 hrs x 2)*.
+
+Setting the parameter `continual_publish` to `true` in the configuration page, will allow EMHASS to store the optimization results as entities/sensors into seperate json files. `continual_publish` will periodically (every `freq` amount of minutes) run a publish, and publish the optimization results of each generated entities/sensors to Home Assistant. The current state of the sensor/entity being updated every time publish runs, selecting one of the 48 stored values, by comparing the stored values timestamps, the current timestamp and [`"method_ts_round": "first"`](#the-publish-data-specificities) to select the optimal stored value for the current state.
+
+option 1 and 2 are very similar, however option 2 (`continual_publish`) will require a cpu thread to constantly be run inside of EMHASS, lowering efficiency. The reason why you may pick one over the other is explained in more detail bellow in [continual_publish](#continual_publish-emhass-automation).
+
+Lastly, we can link a EMHASS published entities/sensor's current state to a Home Assistant entity on/off switch, controlling a desired controllable load. 
+For example, imagine that I want to control my water heater. I can use a published `deferrable` EMHASS entity to control my water heaters desired behavior. In this case, we could use an automation like below, to control the desired water heater on and off:
+  
+on:
 ```yaml
 automation:
 - alias: Water Heater Optimized ON
@@ -317,7 +346,7 @@ automation:
     - service: homeassistant.turn_on
       entity_id: switch.water_heater_switch
 ```
-A second automation should be used to turn off the switch:
+off:
 ```yaml
 automation:
 - alias: Water Heater Optimized OFF
@@ -332,14 +361,15 @@ automation:
     - service: homeassistant.turn_off
       entity_id: switch.water_heater_switch
 ```
+The result of these automation's will turn on and off the Home Assistant entity `switch.water_heater_switch` using the current state from the EMHASS entity `sensor.p_deferrable0`. `sensor.p_deferrable0`  being the entity generated from the EMHASS day-ahead optimization and published by examples above. The `sensor.p_deferrable0` entity current state being updated every 30 minutes (or `freq` minutes) via a automated publish option 1 or 2. *(selecting one of the 48 stored data values)*
 
 ## The publish-data specificities
 
-The `publish-data` command will push to Home Assistant the optimization results for each deferrable load defined in the configuration. For example if you have defined two deferrable loads, then the command will publish `sensor.p_deferrable0` and `sensor.p_deferrable1` to Home Assistant. When the `dayahead-optim` is launched, after the optimization, a csv file will be saved on disk. The `publish-data` command will load the latest csv file and look for the closest timestamp that match the current time using the `datetime.now()` method in Python. This means that if EMHASS is configured for 30min time step optimizations, the csv will be saved with timestamps 00:00, 00:30, 01:00, 01:30, ... and so on. If the current time is 00:05, then the closest timestamp of the optimization results that will be published is 00:00. If the current time is 00:25, then the closest timestamp of the optimization results that will be published is 00:30.
+`publish-data` (which is either run manually, or automatically via `continual_publish` or Home Assistant automation), will push the optimization results to Home Assistant for each deferrable load defined in the configuration. For example if you have defined two deferrable loads, then the command will publish `sensor.p_deferrable0` and `sensor.p_deferrable1` to Home Assistant. When the `dayahead-optim` is launched, after the optimization, either entity json files or a csv file will be saved on disk. The `publish-data` command will load the latest csv/json files to look for the closest timestamp that match the current time using the `datetime.now()` method in Python. This means that if EMHASS is configured for 30min time step optimizations, the csv/json will be saved with timestamps 00:00, 00:30, 01:00, 01:30, ... and so on. If the current time is 00:05, and parameter `method_ts_round` is set to `nearest` in the configuration, then the closest timestamp of the optimization results that will be published is 00:00. If the current time is 00:25, then the closest timestamp of the optimization results that will be published is 00:30.
 
 The `publish-data` command will also publish PV and load forecast data on sensors `p_pv_forecast` and `p_load_forecast`. If using a battery, then the battery optimized power and the SOC will be published on sensors `p_batt_forecast` and `soc_batt_forecast`. On these sensors the future values are passed as nested attributes.
 
-It is possible to provide custm sensor names for all the data exported by the `publish-data` command. For this, when using the `publish-data` endpoint just add some runtime parameters as dictionaries like this:
+If you run publish manually *(or via a Home Assistant Automation)*, it is possible to provide custom sensor names for all the data exported by the `publish-data` command. For this, when using the `publish-data` endpoint we can just add some runtime parameters as dictionaries like this:
 ```yaml
 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"
@@ -387,12 +417,85 @@ In EMHASS we have basically 4 forecasts to deal with:
 
 - PV production selling price forecast: at what price are you selling your excess PV production on the next 24h. This is given in EUR/kWh.
 
-The sensor containing the load data should be specified in parameter `var_load` in the configuration file. As we want to optimize the household energies, when need to forecast the load power conumption. The default method for this is a naive approach using 1-day persistence. The load data variable should not contain the data from the deferrable loads themselves. For example, lets say that you set your deferrable load to be the washing machine. The variable that you should enter in EMHASS will be: `var_load: 'sensor.power_load_no_var_loads'` and `sensor.power_load_no_var_loads = sensor.power_load - sensor.power_washing_machine`. This is supposing that the overall load of your house is contained in variable: `sensor.power_load`. The sensor `sensor.power_load_no_var_loads` can be easily created with a new template sensor in Home Assistant.
+The sensor containing the load data should be specified in parameter `var_load` in the configuration file. As we want to optimize the household energies, when need to forecast the load power consumption. The default method for this is a naive approach using 1-day persistence. The load data variable should not contain the data from the deferrable loads themselves. For example, lets say that you set your deferrable load to be the washing machine. The variable that you should enter in EMHASS will be: `var_load: 'sensor.power_load_no_var_loads'` and `sensor.power_load_no_var_loads = sensor.power_load - sensor.power_washing_machine`. This is supposing that the overall load of your house is contained in variable: `sensor.power_load`. The sensor `sensor.power_load_no_var_loads` can be easily created with a new template sensor in Home Assistant.
 
 If you are implementing a MPC controller, then you should also need to provide some data at the optimization runtime using the key `runtimeparams`.
 
 The valid values to pass for both forecast data and MPC related data are explained below.
 
+### Alternative publish methods
+Due to the flexibility of EMHASS, multiple different approaches to publishing the optimization results have been created. Select a option that best meets your use case:
+
+#### publish last optimization *(manual)*
+By default, running an optimization in EMHASS will output the results into the csv file: `data_path/opt_res_latest.csv`  *(overriding the existing data on that file)*. We run the publish command to publish the last optimization saved in the `opt_res_latest.csv`:
+```bash
+# RUN dayahead
+curl -i -H 'Content-Type:application/json' -X POST -d {} http://localhost:5000/action/dayahead-optim
+# Then publish teh results of dayahead
+curl -i -H 'Content-Type:application/json' -X POST -d {} http://localhost:5000/action/publish-data
+```
+*Note, the published entities from the publish-data action will not automatically update the entities current state (current state being used to check when to turn on and off appliances via Home Assistant automatons). To update the EMHASS entities state, another publish would have to be re-run later when the current time matches the next values timestamp (E.g every 30 minutes). See examples bellow for methods to automate the publish-action.*
+
+#### continual_publish *(EMHASS Automation)*
+As discussed in [Common for any installation method - option 2](#option-2-emhass-automate-publish), setting `continual_publish` to `true` in the configuration saves the output of the optimization into the `data_path/entities` folder *(a .json file for each sensor/entity)*. A constant loop (in `freq` minutes) will run, observe the .json files in that folder, and publish the saved files periodically (updating the current state of the entity by comparing date.now with the saved data value timestamps). 
+
+For users that wish to run multiple different optimizations, you can set the runtime parameter: `publish_prefix` to something like: `"mpc_"` or `"dh_"`. This will generate unique entity_id names per optimization and save these unique entities as separate files in the folder. All the entity files will then be updated when the next loop iteration runs. If a different `freq` integer was passed as a runtime parameter in an optimization, the `continual_publish` loop will be based on the lowest `freq` saved. An example:
+
+```bash
+# RUN dayahead, with freq=30 (default), prefix=dh_ 
+curl -i -H 'Content-Type:application/json' -X POST -d '{"publish_prefix":"dh_"}' http://localhost:5000/action/dayahead-optim
+# RUN MPC, with freq=5, prefix=mpc_
+curl -i -H 'Content-Type:application/json' -X POST -d '{"freq":5,"publish_prefix":"mpc_"}' http://localhost:5000/action/naive-mpc-optim
+```
+This will tell continual_publish to loop every 5 minutes based on the freq passed in MPC. All entities from the output of dayahead "dh_" and MPC "mpc_" will be published every 5 minutes.
+
+</br>
+
+*It is recommended to use the 2 other options bellow once you have a more advance understanding of EMHASS and/or Home Assistant.*
+
+#### Mixture of continual_publish and manual *(Home Assistant Automation for Publish)*
+
+You can choose to save one optimization for continual_publish and bypass another optimization by setting `"continual_publish":false` runtime parameter:
+```bash
+# RUN dayahead, with freq=30 (default), prefix=dh_, included into continual_publish
+curl -i -H 'Content-Type:application/json' -X POST -d '{"publish_prefix":"dh_"}' http://localhost:5000/action/dayahead-optim
+
+# RUN MPC, with freq=5, prefix=mpc_, Manually publish, excluded from continual_publish loop
+curl -i -H 'Content-Type:application/json' -X POST -d '{"continual_publish":false,"freq":5,"publish_prefix":"mpc_"}' http://localhost:5000/action/naive-mpc-optim
+# Publish MPC output
+curl -i -H 'Content-Type:application/json' -X POST -d {} http://localhost:5000/action/publish-data
+```
+This example saves the dayahead optimization into `data_path/entities` as .json files, being included in the `continutal_publish` loop (publishing every 30 minutes). The MPC optimization will not be saved in `data_path/entities`, and therefore only into `data_path/opt_res_latest.csv`. Requiring a publish-data action to be run manually (or via a Home Assistant) Automation for the MPC results. 
+
+#### Manual *(Home Assistant Automation for Publish)*
+
+For users who wish to have full control of exactly when they will like to run a publish and have the ability to save multiple different optimizations. The `entity_save` runtime parameter has been created to save the optimization output entities to .json files whilst  `continual_publish` is set to `false` in the configuration. Allowing the user to reference the saved .json files manually via a publish:
+
+in configuration page/`config_emhass.yaml` :
+```json
+"continual_publish": false
+```
+POST action :
+```bash
+# RUN dayahead, with freq=30 (default), prefix=dh_, save entity
+curl -i -H 'Content-Type:application/json' -X POST -d '{"entity_save": true, "publish_prefix":"dh_"}' http://localhost:5000/action/dayahead-optim
+# RUN MPC, with freq=5, prefix=mpc_, save entity
+curl -i -H 'Content-Type:application/json' -X POST -d '{"entity_save": true", "freq":5,"publish_prefix":"mpc_"}' http://localhost:5000/action/naive-mpc-optim
+```
+You can then reference these .json saved entities via their `publish_prefix`. Include the same `publish_prefix` in the `publish_data` action:
+```bash
+#Publish the MPC optimization ran above 
+curl -i -H 'Content-Type:application/json' -X POST -d '{"publish_prefix":"mpc_"}'  http://localhost:5000/action/publish-data
+```
+This will publish all entities from the MPC (_mpc) optimization above.
+</br>
+Alternatively, you can choose to publish all the saved files .json files with `publish_prefix` = all:
+```bash
+#Publish all saved entities
+curl -i -H 'Content-Type:application/json' -X POST -d '{"publish_prefix":"all"}'  http://localhost:5000/action/publish-data
+```
+This action will publish the dayahead (_dh) and MPC (_mpc) optimization results from the optimizations above.
+
 ### Forecast data
 
 It is possible to provide EMHASS with your own forecast data. For this just add the data as list of values to a data dictionary during the call to `emhass` using the `runtimeparams` option. 
@@ -491,7 +594,7 @@ Check the dedicated section in the documentation here: [https://emhass.readthedo
 
 ## Development
 
-Pull request are very much accepted on this project. For development you can find some instructions here [Development](https://emhass.readthedocs.io/en/latest/develop.html)
+Pull request are very much accepted on this project. For development you can find some instructions here [Development](https://emhass.readthedocs.io/en/latest/develop.html).
 
 ## Troubleshooting
 

{emhass-0.9.1.dist-info → emhass-0.10.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-emhass/command_line.py,sha256=mxMvxqN5rp30AZ_QR4uWWxWu5NxLMNesgf44pJ-sVWk,47908
-emhass/forecast.py,sha256=lZZ7B8CUj-r9aXk1YDVr3bF7vgH-KUM1MoA99F0IBmA,47076
+emhass/command_line.py,sha256=RPMFS86McukgzoGmeq-DEMwyCZrpFx6Ko27Ndj_A0Fc,57211
+emhass/forecast.py,sha256=VdB8O6V4LYXdfIg7fHNRIVdvj2Y8Ow8Z7r1Ck3hvvh8,47631
 emhass/machine_learning_forecaster.py,sha256=az8cYRCckmR-WEdXyigbe8udtbj82yfahPmow4gue4s,15655
 emhass/machine_learning_regressor.py,sha256=WmR9ODWkY64RAniqLowwf5tZWzPTVp5ftCTKNtzcd6I,10407
-emhass/optimization.py,sha256=ijiSBKdU0fS6TBpeoBo-CoPz6lBMU4nnsi6aiZi1J0I,37252
-emhass/retrieve_hass.py,sha256=Xz3dYfQri-6irltbPr4QDDI7GGLJPwW3WEzRyHeC62Q,20391
-emhass/utils.py,sha256=4sm8QMp2rU1DZVM7XYT4FK5O7z_GEZTXbZcfn8nyBgc,47820
-emhass/web_server.py,sha256=UfPUBA-ct1Su8cQFyufnW0Bb4BBlpGHF3yXN47sXkig,23055
+emhass/optimization.py,sha256=bNn3txHurUNrnW-FFmY9MRokn1X1V50pjK9TNH3z-Es,47305
+emhass/retrieve_hass.py,sha256=k-BPZMqW-uQ95Q7Gzz93nPkLHStDCkI7-047GVYBGC0,22983
+emhass/utils.py,sha256=uc2yrcvA-GwJPsGOQIc_tEf3MxtGu_tMNf1PyyEx3Aw,48112
+emhass/web_server.py,sha256=8hzVjDTCSMdPwpgzstGiH11IArIYiaYGSYkAiMq4S78,24095
 emhass/data/cec_inverters.pbz2,sha256=tK8FvAUDW0uYez8EPttdCJwHhpPofclYV6GhhNZL0Pk,168272
 emhass/data/cec_modules.pbz2,sha256=8vEaysgYffXg3KUl8XSF36Mdywzi3LpEtUN_qenjO9s,1655747
 emhass/static/advanced.html,sha256=15tYNw9ck_ds1zxQk0XXj7wmS9px_0x0GDx57cFx3vA,1970
@@ -18,9 +18,9 @@ emhass/static/img/emhass_logo_short.svg,sha256=yzMcqtBRCV8rH84-MwnigZh45_f9Eoqwh
 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.9.1.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
-emhass-0.9.1.dist-info/METADATA,sha256=jc55aJnUsaxY7_yKqCux0BSmVdySw2ftms7fqnJfMCc,35940
-emhass-0.9.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-emhass-0.9.1.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
-emhass-0.9.1.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
-emhass-0.9.1.dist-info/RECORD,,
+emhass-0.10.0.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
+emhass-0.10.0.dist-info/METADATA,sha256=602w53NAKX6TNa7sQcTVpyZlUrlgcJn1yxX2oz9Hn_M,44352
+emhass-0.10.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+emhass-0.10.0.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
+emhass-0.10.0.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
+emhass-0.10.0.dist-info/RECORD,,