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

emhass/retrieve_hass.py

@@ -3,6 +3,8 @@
 
 import json
 import copy
+import os
+import pathlib
 import datetime
 import logging
 from typing import Optional
@@ -61,18 +63,13 @@ class RetrieveHass:
         self.freq = freq
         self.time_zone = time_zone
         self.params = params
-        # self.emhass_conf = emhass_conf
+        self.emhass_conf = emhass_conf
         self.logger = logger
         self.get_data_from_file = get_data_from_file
 
-    def get_data(
-        self,
-        days_list: pd.date_range,
-        var_list: list,
-        minimal_response: Optional[bool] = False,
-        significant_changes_only: Optional[bool] = False,
-        test_url: Optional[str] = "empty",
-    ) -> None:
+    def get_data(self, days_list: pd.date_range, var_list: list, 
+                 minimal_response: Optional[bool] = False, significant_changes_only: Optional[bool] = False,
+                 test_url: Optional[str] = "empty") -> None:
         r"""
         Retrieve the actual data from hass.
         
@@ -100,9 +97,7 @@ class RetrieveHass:
         x = 0  # iterate based on days
         # Looping on each day from days list
         for day in days_list:
-
             for i, var in enumerate(var_list):
-
                 if test_url == "empty":
                     if (
                         self.hass_url == "http://supervisor/core/api"
@@ -289,15 +284,8 @@ class RetrieveHass:
         return True
 
     @staticmethod
-    def get_attr_data_dict(
-        data_df: pd.DataFrame,
-        idx: int,
-        entity_id: str,
-        unit_of_measurement: str,
-        friendly_name: str,
-        list_name: str,
-        state: float,
-    ) -> dict:
+    def get_attr_data_dict(data_df: pd.DataFrame, idx: int, entity_id: str, unit_of_measurement: str,
+                           friendly_name: str, list_name: str, state: float) -> dict:
         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()]
@@ -318,17 +306,11 @@ class RetrieveHass:
         }
         return data
 
-    def post_data(
-        self,
-        data_df: pd.DataFrame,
-        idx: int,
-        entity_id: str,
-        unit_of_measurement: str,
-        friendly_name: str,
-        type_var: str,
-        from_mlforecaster: Optional[bool] = False,
-        publish_prefix: Optional[str] = "",
-    ) -> None:
+
+    def post_data(self, data_df: pd.DataFrame, idx: int, entity_id: str, unit_of_measurement: str,
+                  friendly_name: str, type_var: str, from_mlforecaster: Optional[bool] = False,
+                  publish_prefix: Optional[str] = "", save_entities: Optional[bool] = False, 
+                  logger_levels: Optional[str] = "info", dont_post: Optional[bool] = False) -> None:
         r"""
         Post passed data to hass.
         
@@ -348,6 +330,12 @@ class RetrieveHass:
         :type type_var: str
         :param publish_prefix: A common prefix for all published data entity_id.
         :type publish_prefix: str, optional
+        :param save_entities: if entity data should be saved in data_path/entities
+        :type save_entities: bool, optional
+        :param logger_levels: set logger level, info or debug, to output  
+        :type logger_levels: str, optional
+        :param dont_post: dont post to HA
+        :type dont_post: bool, optional
 
         """
         # Add a possible prefix to the entity ID
@@ -362,10 +350,12 @@ class RetrieveHass:
         headers = {
             "Authorization": "Bearer " + self.long_lived_token,
             "content-type": "application/json",
-        }
+        }  
         # Preparing the data dict to be published
         if type_var == "cost_fun":
-            state = np.round(data_df.sum()[0], 2)
+            if isinstance(data_df.iloc[0],pd.Series): #if Series extract
+                data_df = data_df.iloc[:, 0]
+            state = np.round(data_df.sum(), 2)
         elif type_var == "unit_load_cost" or type_var == "unit_prod_price":
             state = np.round(data_df.loc[data_df.index[idx]], 4)
         elif type_var == "optim_status":
@@ -375,75 +365,26 @@ class RetrieveHass:
         else:
             state = np.round(data_df.loc[data_df.index[idx]], 2)
         if type_var == "power":
-            data = RetrieveHass.get_attr_data_dict(
-                data_df,
-                idx,
-                entity_id,
-                unit_of_measurement,
-                friendly_name,
-                "forecasts",
-                state,
-            )
+            data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement,
+                                                   friendly_name, "forecasts", state)
         elif type_var == "deferrable":
-            data = RetrieveHass.get_attr_data_dict(
-                data_df,
-                idx,
-                entity_id,
-                unit_of_measurement,
-                friendly_name,
-                "deferrables_schedule",
-                state,
-            )
+            data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement,
+                                                   friendly_name, "deferrables_schedule", state)
         elif type_var == "batt":
-            data = RetrieveHass.get_attr_data_dict(
-                data_df,
-                idx,
-                entity_id,
-                unit_of_measurement,
-                friendly_name,
-                "battery_scheduled_power",
-                state,
-            )
+            data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement,
+                                                   friendly_name, "battery_scheduled_power", state)
         elif type_var == "SOC":
-            data = RetrieveHass.get_attr_data_dict(
-                data_df,
-                idx,
-                entity_id,
-                unit_of_measurement,
-                friendly_name,
-                "battery_scheduled_soc",
-                state,
-            )
+            data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement,
+                                                   friendly_name, "battery_scheduled_soc", state)
         elif type_var == "unit_load_cost":
-            data = RetrieveHass.get_attr_data_dict(
-                data_df,
-                idx,
-                entity_id,
-                unit_of_measurement,
-                friendly_name,
-                "unit_load_cost_forecasts",
-                state,
-            )
+            data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement, 
+                                                   friendly_name, "unit_load_cost_forecasts", state)
         elif type_var == "unit_prod_price":
-            data = RetrieveHass.get_attr_data_dict(
-                data_df,
-                idx,
-                entity_id,
-                unit_of_measurement,
-                friendly_name,
-                "unit_prod_price_forecasts",
-                state,
-            )
+            data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement,
+                                                   friendly_name, "unit_prod_price_forecasts", state)
         elif type_var == "mlforecaster":
-            data = RetrieveHass.get_attr_data_dict(
-                data_df,
-                idx,
-                entity_id,
-                unit_of_measurement,
-                friendly_name,
-                "scheduled_forecast",
-                state,
-            )
+            data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement,
+                                                   friendly_name, "scheduled_forecast", state)
         elif type_var == "optim_status":
             data = {
                 "state": state,
@@ -469,20 +410,54 @@ class RetrieveHass:
                 },
             }
         # Actually post the data
-        if self.get_data_from_file:
-
+        if self.get_data_from_file or dont_post:
             class response:
                 pass
-
             response.status_code = 200
             response.ok = True
         else:
             response = post(url, headers=headers, data=json.dumps(data))
+
         # Treating the response status and posting them on the logger
         if response.ok:
-            self.logger.info("Successfully posted to " + entity_id + " = " + str(state))
+
+            if logger_levels == "DEBUG":
+                self.logger.debug("Successfully posted to " + entity_id + " = " + str(state))
+            else:
+                self.logger.info("Successfully posted to " + entity_id + " = " + str(state))
+
+            # If save entities is set, save entity data to /data_path/entities
+            if (save_entities):
+                entities_path = self.emhass_conf['data_path'] / "entities"
+                
+                # Clarify folder exists
+                pathlib.Path(entities_path).mkdir(parents=True, exist_ok=True)
+                
+                # Save entity data to json file
+                result = data_df.to_json(index="timestamp", orient='index', date_unit='s', date_format='iso')
+                parsed = json.loads(result)
+                with open(entities_path / (entity_id + ".json"), "w") as file:                       
+                    json.dump(parsed, file, indent=4)
+                 
+                # Save the required metadata to json file
+                if os.path.isfile(entities_path / "metadata.json"):
+                    with open(entities_path / "metadata.json", "r") as file:
+                        metadata = json.load(file) 
+                else:
+                    metadata = {}
+                with open(entities_path / "metadata.json", "w") as file:                       
+                    # Save entity metadata, key = entity_id 
+                    metadata[entity_id] = {'name': data_df.name, 'unit_of_measurement': unit_of_measurement,'friendly_name': friendly_name,'type_var': type_var, 'freq': int(self.freq.seconds / 60)}
+                    
+                    # Find lowest frequency to set for continual loop freq
+                    if metadata.get("lowest_freq",None) == None or metadata["lowest_freq"] > int(self.freq.seconds / 60):
+                        metadata["lowest_freq"] = int(self.freq.seconds / 60)
+                    json.dump(metadata,file, indent=4)
+
+                    self.logger.debug("Saved " + entity_id + " to json file")   
+ 
         else:
-            self.logger.info(
+            self.logger.warning(
                 "The status code for received curl command response is: "
                 + str(response.status_code)
             )

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"
@@ -41,6 +40,7 @@ def get_root(file: str, num_parent: Optional[int] = 3) -> str:
         raise ValueError("num_parent value not valid, must be between 1 and 3")
     return root
 
+
 def get_logger(fun_name: str, emhass_conf: dict, save_to_file: Optional[bool] = True,
                logging_level: Optional[str] = "DEBUG") -> Tuple[logging.Logger, logging.StreamHandler]:
     """
@@ -88,9 +88,8 @@ def get_logger(fun_name: str, emhass_conf: dict, save_to_file: Optional[bool] =
     return logger, ch
 
 
-def get_forecast_dates(
-    freq: int, delta_forecast: int, timedelta_days: Optional[int] = 0
-) -> pd.core.indexes.datetimes.DatetimeIndex:
+def get_forecast_dates(freq: int, delta_forecast: int, timedelta_days: Optional[int] = 0
+                       ) -> pd.core.indexes.datetimes.DatetimeIndex:
     """
     Get the date_range list of the needed future dates using the delta_forecast parameter.
 
@@ -113,15 +112,9 @@ def get_forecast_dates(
     return forecast_dates
 
 
-def treat_runtimeparams(
-    runtimeparams: str,
-    params: str,
-    retrieve_hass_conf: dict,
-    optim_conf: dict,
-    plant_conf: dict,
-    set_type: str,
-    logger: logging.Logger,
-) -> Tuple[str, dict]:
+def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dict, optim_conf: dict,
+                        plant_conf: dict, set_type: str, logger: logging.Logger
+                        ) -> Tuple[str, dict]:
     """
     Treat the passed optimization runtime parameters.
 
@@ -419,6 +412,8 @@ def treat_runtimeparams(
             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())
@@ -449,6 +444,8 @@ def treat_runtimeparams(
             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"]
@@ -493,16 +490,23 @@ def treat_runtimeparams(
             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
 
+
 def get_yaml_parse(emhass_conf: dict, use_secrets: Optional[bool] = True,
                    params: Optional[str] = None) -> Tuple[dict, dict, dict]:
     """
@@ -526,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)
@@ -655,9 +659,7 @@ def get_injection_dict(df: pd.DataFrame, plot_size: Optional[int] = 1366) -> dic
     return injection_dict
 
 
-def get_injection_dict_forecast_model_fit(
-    df_fit_pred: pd.DataFrame, mlf: MLForecaster
-) -> dict:
+def get_injection_dict_forecast_model_fit(df_fit_pred: pd.DataFrame, mlf: MLForecaster) -> dict:
     """
     Build a dictionary with graphs and tables for the webui for special MLF fit case.
 
@@ -686,9 +688,7 @@ def get_injection_dict_forecast_model_fit(
     return injection_dict
 
 
-def get_injection_dict_forecast_model_tune(
-    df_pred_optim: pd.DataFrame, mlf: MLForecaster
-) -> dict:
+def get_injection_dict_forecast_model_tune(df_pred_optim: pd.DataFrame, mlf: MLForecaster) -> dict:
     """
     Build a dictionary with graphs and tables for the webui for special MLF tune case.
 
@@ -719,13 +719,8 @@ def get_injection_dict_forecast_model_tune(
     return injection_dict
 
 
-def build_params(
-    params: dict,
-    params_secrets: dict,
-    options: dict,
-    addon: int,
-    logger: logging.Logger,
-) -> dict:
+def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
+                 logger: logging.Logger) -> dict:
     """
     Build the main params dictionary from the loaded options.json when using the add-on.
 
@@ -744,60 +739,30 @@ def build_params(
     """
     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"]
@@ -813,43 +778,22 @@ def build_params(
                 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"]
@@ -861,27 +805,27 @@ def build_params(
             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:        
@@ -894,14 +838,15 @@ def build_params(
             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']):
@@ -931,9 +876,7 @@ def build_params(
         # 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
@@ -967,7 +910,6 @@ def get_days_list(days_to_retrieve: int) -> pd.date_range:
     today = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0)
     d = (today - timedelta(days=days_to_retrieve)).isoformat()
     days_list = pd.date_range(start=d, end=today.isoformat(), freq="D")
-
     return days_list