emhass 0.8.0__tar.gz → 0.8.2__tar.gz

{emhass-0.8.0 → emhass-0.8.2}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.8.2] - 2024-03-10
+### Improvement
+- Proposed a new solution to survive DST using special option of Pandas `round` method
+- Added option to `web_server` to init `data_path` as an options param
+- Styling docs and html files on webui
+- Advanced and basic pages improvements on webui
+### Fix
+- Fixed support for ARM achitectures
+
+## [0.8.1] - 2024-02-28
+### Improvement
+- Improved documentation
+### Fix
+- Persistent data storage fix
+- Docker Standalone Publish Workspace Fix
+
 ## [0.8.0] - 2024-02-25
 ### Improvement
 - Thanks to the great work from @GeoDerp we now have a unified/centralized Dockerfile that allows for testing different installation configuration methods in one place. This greatly helps testing, notably emulating the add-on environment. This will improve overall testing for both teh core code and the add-on. Again many thanks!
@@ -580,6 +596,9 @@ Thanks to @GeoDerp for this great work!
 [0.7.6]: https://github.com/davidusb-geek/emhass/releases/tag/v0.7.6
 [0.7.7]: https://github.com/davidusb-geek/emhass/releases/tag/v0.7.7
 [0.7.8]: https://github.com/davidusb-geek/emhass/releases/tag/v0.7.8
+[0.8.0]: https://github.com/davidusb-geek/emhass/releases/tag/v0.8.0
+[0.8.1]: https://github.com/davidusb-geek/emhass/releases/tag/v0.8.1
+[0.8.2]: https://github.com/davidusb-geek/emhass/releases/tag/v0.8.2
 
 # Notes
 All notable changes to this project will be documented in this file.

{emhass-0.8.0 → emhass-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.8.0
+Version: 0.8.2
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ
@@ -16,8 +16,8 @@ Requires-Python: >=3.9, <3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: wheel
-Requires-Dist: numpy<=1.26
-Requires-Dist: scipy<=1.11.3
+Requires-Dist: numpy==1.26.4
+Requires-Dist: scipy==1.12.0
 Requires-Dist: pandas<=2.0.3
 Requires-Dist: pvlib>=0.10.2
 Requires-Dist: protobuf>=3.0.0
@@ -132,38 +132,44 @@ These architectures are supported: `amd64`, `armv7`, `armhf` and `aarch64`.
 ### Method 2) Using Docker in standalone mode
 
 You can also install EMHASS using docker. This can be in the same machine as Home Assistant (if using the supervised install method) or in a different distant machine. To install first pull the latest image from docker hub:
-```
+```bash
 docker pull davidusb/emhass-docker-standalone
 ```
 
 You can also build your image locally. For this clone this repository, setup your `config_emhass.yaml` file and use the provided make file with this command:
-```
+```bash
 make -f deploy_docker.mk clean_deploy
 ```
 Then load the image in the .tar file:
-```
+```bash
 docker load -i <TarFileName>.tar
 ```
 Finally check your image tag with `docker images` and launch the docker itself:
-```
+```bash
 docker run -it --restart always -p 5000:5000 -e "LOCAL_COSTFUN=profit" -v $(pwd)/config_emhass.yaml:/app/config_emhass.yaml -v $(pwd)/secrets_emhass.yaml:/app/secrets_emhass.yaml --name DockerEMHASS <REPOSITORY:TAG>
 ```
+  - If you wish to keep a local, persistent copy of the EMHASS generated data, create a local folder on your device, then mount said folder inside the container.  
+    ```bash
+    mkdir -p $(pwd)/data #linux: create data folder on local device
+
+    docker run -it --restart always -p 5000:5000 -e "LOCAL_COSTFUN=profit" -v $(pwd)/config_emhass.yaml:/app/config_emhass.yaml -v $(pwd)/data:/app/data  -v $(pwd)/secrets_emhass.yaml:/app/secrets_emhass.yaml --name DockerEMHASS <REPOSITORY:TAG>
+    ```
 
 ### Method 3) Legacy method using a Python virtual environment
 
 With this method it is recommended to install on a virtual environment.
 For this you will need `virtualenv`, install it using:
-```
+```bash
 sudo apt install python3-virtualenv
 ```
 Then create and activate the virtual environment:
-```
+```bash
 virtualenv -p /usr/bin/python3 emhassenv
 cd emhassenv
 source bin/activate
 ```
 Install using the distribution files:
-```
+```bash
 python3 -m pip install emhass
 ```
 Clone this repository to obtain the example configuration files.
@@ -174,7 +180,7 @@ We will suppose that this repository is cloned to:
 This will be the root path containing the yaml configuration files (`config_emhass.yaml` and `secrets_emhass.yaml`) and the different needed folders (a `data` folder to store the optimizations results and a `scripts` folder containing the bash scripts described further below).
 
 To upgrade the installation in the future just use:
-```
+```bash
 python3 -m pip install --upgrade emhass
 ```
 
@@ -210,7 +216,7 @@ The available arguments are:
 - `--version`: Show the current version of EMHASS.
 
 For example, the following line command can be used to perform a day-ahead optimization task:
-```
+```bash
 emhass --action 'dayahead-optim' --config '/home/user/emhass/config_emhass.yaml' --costfun 'profit'
 ```
 Before running any valuable command you need to modify the `config_emhass.yaml` and `secrets_emhass.yaml` files. These files should contain the information adapted to your own system. To do this take a look at the special section for this in the [documentation](https://emhass.readthedocs.io/en/latest/config.html).
@@ -224,7 +230,7 @@ Then additional optimization strategies were developed, that can be used in comb
 ### Dayahead Optimization - Method 1) Add-on and docker standalone
 
 In `configuration.yaml`:
-```
+```yaml
 shell_command:
   dayahead_optim: "curl -i -H \"Content-Type:application/json\" -X POST -d '{}' http://localhost:5000/action/dayahead-optim"
   publish_data: "curl -i -H \"Content-Type:application/json\" -X POST -d '{}' http://localhost:5000/action/publish-data"
@@ -232,25 +238,25 @@ shell_command:
 ### Dayahead Optimization - Method 2) Legacy method using a Python virtual environment
 
 In `configuration.yaml`:
-```
+```yaml
 shell_command:
   dayahead_optim: /home/user/emhass/scripts/dayahead_optim.sh
   publish_data: /home/user/emhass/scripts/publish_data.sh
 ```
 Create the file `dayahead_optim.sh` with the following content:
-```
+```bash
 #!/bin/bash
 . /home/user/emhassenv/bin/activate
 emhass --action 'dayahead-optim' --config '/home/user/emhass/config_emhass.yaml'
 ```
 And the file `publish_data.sh` with the following content:
-```
+```bash
 #!/bin/bash
 . /home/user/emhassenv/bin/activate
 emhass --action 'publish-data' --config '/home/user/emhass/config_emhass.yaml'
 ```
 Then specify user rights and make the files executables:
-```
+```bash
 sudo chmod -R 755 /home/user/emhass/scripts/dayahead_optim.sh
 sudo chmod -R 755 /home/user/emhass/scripts/publish_data.sh
 sudo chmod +x /home/user/emhass/scripts/dayahead_optim.sh
@@ -259,7 +265,7 @@ sudo chmod +x /home/user/emhass/scripts/publish_data.sh
 ### Common for any installation method
 
 In `automations.yaml`:
-```
+```yaml
 - alias: EMHASS day-ahead optimization
   trigger:
     platform: time
@@ -276,7 +282,7 @@ In `automations.yaml`:
 In these automations the day-ahead optimization is performed everyday at 5:30am and the data is published every 5 minutes.
 
 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:
-```
+```yaml
 automation:
 - alias: Water Heater Optimized ON
   trigger:
@@ -291,7 +297,7 @@ automation:
       entity_id: switch.water_heater_switch
 ```
 A second automation should be used to turn off the switch:
-```
+```yaml
 automation:
 - alias: Water Heater Optimized OFF
   trigger:
@@ -313,7 +319,7 @@ The `publish-data` command will push to Home Assistant the optimization results
 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:
-```
+```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"
 ```
@@ -321,7 +327,7 @@ shell_command:
 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:
-```
+```yaml
 shell_command:
   publish_data: "curl -i -H \"Content-Type:application/json\" -X POST -d '{\"custom_deferrable_forecast_id\": [{\"entity_id\": \"sensor.p_deferrable0\",\"unit_of_measurement\": \"W\", \"friendly_name\": \"Deferrable Load 0\"},{\"entity_id\": \"sensor.p_deferrable1\",\"unit_of_measurement\": \"W\", \"friendly_name\": \"Deferrable Load 1\"}]}' http://localhost:5000/action/publish-data"
 ```
@@ -371,11 +377,11 @@ The valid values to pass for both forecast data and MPC related data are explain
 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. 
 
 For example if using the add-on or the standalone docker installation you can pass this data as list of values to the data dictionary during the `curl` POST:
-```
+```bash
 curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93, 1164.33, 1046.68, 1559.1, 2091.26, 1556.76, 1166.73, 1516.63, 1391.13, 1720.13, 820.75, 804.41, 251.63, 79.25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}' http://localhost:5000/action/dayahead-optim
 ```
 Or if using the legacy method using a Python virtual environment:
-```
+```bash
 emhass --action 'dayahead-optim' --config '/home/user/emhass/config_emhass.yaml' --runtimeparams '{"pv_power_forecast":[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93, 1164.33, 1046.68, 1559.1, 2091.26, 1556.76, 1166.73, 1516.63, 1391.13, 1720.13, 820.75, 804.41, 251.63, 79.25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}'
 ```
 
@@ -448,10 +454,16 @@ When applying this controller, the following `runtimeparams` should be defined:
 
 A correct call for a MPC optimization should look like:
 
+```bash
+curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93], "prediction_horizon":10, "soc_init":0.5,"soc_final":0.6}' http://192.168.3.159:5000/action/naive-mpc-optim
 ```
-curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93], "prediction_horizon":10, "soc_init":0.5,"soc_final":0.6,"def_total_hours":[1,3],"def_start_timestep":[0,3],"def_end_timestep":[0,6],}' http://localhost:5000/action/naive-mpc-optim
+*Example with :`def_total_hours`, `def_start_timestep`, `def_end_timestep`.*
+```bash
+curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93], "prediction_horizon":10, "soc_init":0.5,"soc_final":0.6,"def_total_hours":[1,3],"def_start_timestep":[0,3],"def_end_timestep":[0,6]}' http://localhost:5000/action/naive-mpc-optim
 ```
 
+
+
 ## A machine learning forecaster
 
 Starting in v0.4.0 a new machine learning forecaster class was introduced.

{emhass-0.8.0 → emhass-0.8.2}/README.md

@@ -97,38 +97,44 @@ These architectures are supported: `amd64`, `armv7`, `armhf` and `aarch64`.
 ### Method 2) Using Docker in standalone mode
 
 You can also install EMHASS using docker. This can be in the same machine as Home Assistant (if using the supervised install method) or in a different distant machine. To install first pull the latest image from docker hub:
-```
+```bash
 docker pull davidusb/emhass-docker-standalone
 ```
 
 You can also build your image locally. For this clone this repository, setup your `config_emhass.yaml` file and use the provided make file with this command:
-```
+```bash
 make -f deploy_docker.mk clean_deploy
 ```
 Then load the image in the .tar file:
-```
+```bash
 docker load -i <TarFileName>.tar
 ```
 Finally check your image tag with `docker images` and launch the docker itself:
-```
+```bash
 docker run -it --restart always -p 5000:5000 -e "LOCAL_COSTFUN=profit" -v $(pwd)/config_emhass.yaml:/app/config_emhass.yaml -v $(pwd)/secrets_emhass.yaml:/app/secrets_emhass.yaml --name DockerEMHASS <REPOSITORY:TAG>
 ```
+  - If you wish to keep a local, persistent copy of the EMHASS generated data, create a local folder on your device, then mount said folder inside the container.  
+    ```bash
+    mkdir -p $(pwd)/data #linux: create data folder on local device
+
+    docker run -it --restart always -p 5000:5000 -e "LOCAL_COSTFUN=profit" -v $(pwd)/config_emhass.yaml:/app/config_emhass.yaml -v $(pwd)/data:/app/data  -v $(pwd)/secrets_emhass.yaml:/app/secrets_emhass.yaml --name DockerEMHASS <REPOSITORY:TAG>
+    ```
 
 ### Method 3) Legacy method using a Python virtual environment
 
 With this method it is recommended to install on a virtual environment.
 For this you will need `virtualenv`, install it using:
-```
+```bash
 sudo apt install python3-virtualenv
 ```
 Then create and activate the virtual environment:
-```
+```bash
 virtualenv -p /usr/bin/python3 emhassenv
 cd emhassenv
 source bin/activate
 ```
 Install using the distribution files:
-```
+```bash
 python3 -m pip install emhass
 ```
 Clone this repository to obtain the example configuration files.
@@ -139,7 +145,7 @@ We will suppose that this repository is cloned to:
 This will be the root path containing the yaml configuration files (`config_emhass.yaml` and `secrets_emhass.yaml`) and the different needed folders (a `data` folder to store the optimizations results and a `scripts` folder containing the bash scripts described further below).
 
 To upgrade the installation in the future just use:
-```
+```bash
 python3 -m pip install --upgrade emhass
 ```
 
@@ -175,7 +181,7 @@ The available arguments are:
 - `--version`: Show the current version of EMHASS.
 
 For example, the following line command can be used to perform a day-ahead optimization task:
-```
+```bash
 emhass --action 'dayahead-optim' --config '/home/user/emhass/config_emhass.yaml' --costfun 'profit'
 ```
 Before running any valuable command you need to modify the `config_emhass.yaml` and `secrets_emhass.yaml` files. These files should contain the information adapted to your own system. To do this take a look at the special section for this in the [documentation](https://emhass.readthedocs.io/en/latest/config.html).
@@ -189,7 +195,7 @@ Then additional optimization strategies were developed, that can be used in comb
 ### Dayahead Optimization - Method 1) Add-on and docker standalone
 
 In `configuration.yaml`:
-```
+```yaml
 shell_command:
   dayahead_optim: "curl -i -H \"Content-Type:application/json\" -X POST -d '{}' http://localhost:5000/action/dayahead-optim"
   publish_data: "curl -i -H \"Content-Type:application/json\" -X POST -d '{}' http://localhost:5000/action/publish-data"
@@ -197,25 +203,25 @@ shell_command:
 ### Dayahead Optimization - Method 2) Legacy method using a Python virtual environment
 
 In `configuration.yaml`:
-```
+```yaml
 shell_command:
   dayahead_optim: /home/user/emhass/scripts/dayahead_optim.sh
   publish_data: /home/user/emhass/scripts/publish_data.sh
 ```
 Create the file `dayahead_optim.sh` with the following content:
-```
+```bash
 #!/bin/bash
 . /home/user/emhassenv/bin/activate
 emhass --action 'dayahead-optim' --config '/home/user/emhass/config_emhass.yaml'
 ```
 And the file `publish_data.sh` with the following content:
-```
+```bash
 #!/bin/bash
 . /home/user/emhassenv/bin/activate
 emhass --action 'publish-data' --config '/home/user/emhass/config_emhass.yaml'
 ```
 Then specify user rights and make the files executables:
-```
+```bash
 sudo chmod -R 755 /home/user/emhass/scripts/dayahead_optim.sh
 sudo chmod -R 755 /home/user/emhass/scripts/publish_data.sh
 sudo chmod +x /home/user/emhass/scripts/dayahead_optim.sh
@@ -224,7 +230,7 @@ sudo chmod +x /home/user/emhass/scripts/publish_data.sh
 ### Common for any installation method
 
 In `automations.yaml`:
-```
+```yaml
 - alias: EMHASS day-ahead optimization
   trigger:
     platform: time
@@ -241,7 +247,7 @@ In `automations.yaml`:
 In these automations the day-ahead optimization is performed everyday at 5:30am and the data is published every 5 minutes.
 
 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:
-```
+```yaml
 automation:
 - alias: Water Heater Optimized ON
   trigger:
@@ -256,7 +262,7 @@ automation:
       entity_id: switch.water_heater_switch
 ```
 A second automation should be used to turn off the switch:
-```
+```yaml
 automation:
 - alias: Water Heater Optimized OFF
   trigger:
@@ -278,7 +284,7 @@ The `publish-data` command will push to Home Assistant the optimization results
 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:
-```
+```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"
 ```
@@ -286,7 +292,7 @@ shell_command:
 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:
-```
+```yaml
 shell_command:
   publish_data: "curl -i -H \"Content-Type:application/json\" -X POST -d '{\"custom_deferrable_forecast_id\": [{\"entity_id\": \"sensor.p_deferrable0\",\"unit_of_measurement\": \"W\", \"friendly_name\": \"Deferrable Load 0\"},{\"entity_id\": \"sensor.p_deferrable1\",\"unit_of_measurement\": \"W\", \"friendly_name\": \"Deferrable Load 1\"}]}' http://localhost:5000/action/publish-data"
 ```
@@ -336,11 +342,11 @@ The valid values to pass for both forecast data and MPC related data are explain
 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. 
 
 For example if using the add-on or the standalone docker installation you can pass this data as list of values to the data dictionary during the `curl` POST:
-```
+```bash
 curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93, 1164.33, 1046.68, 1559.1, 2091.26, 1556.76, 1166.73, 1516.63, 1391.13, 1720.13, 820.75, 804.41, 251.63, 79.25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}' http://localhost:5000/action/dayahead-optim
 ```
 Or if using the legacy method using a Python virtual environment:
-```
+```bash
 emhass --action 'dayahead-optim' --config '/home/user/emhass/config_emhass.yaml' --runtimeparams '{"pv_power_forecast":[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93, 1164.33, 1046.68, 1559.1, 2091.26, 1556.76, 1166.73, 1516.63, 1391.13, 1720.13, 820.75, 804.41, 251.63, 79.25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}'
 ```
 
@@ -413,10 +419,16 @@ When applying this controller, the following `runtimeparams` should be defined:
 
 A correct call for a MPC optimization should look like:
 
+```bash
+curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93], "prediction_horizon":10, "soc_init":0.5,"soc_final":0.6}' http://192.168.3.159:5000/action/naive-mpc-optim
 ```
-curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93], "prediction_horizon":10, "soc_init":0.5,"soc_final":0.6,"def_total_hours":[1,3],"def_start_timestep":[0,3],"def_end_timestep":[0,6],}' http://localhost:5000/action/naive-mpc-optim
+*Example with :`def_total_hours`, `def_start_timestep`, `def_end_timestep`.*
+```bash
+curl -i -H 'Content-Type:application/json' -X POST -d '{"pv_power_forecast":[0, 70, 141.22, 246.18, 513.5, 753.27, 1049.89, 1797.93, 1697.3, 3078.93], "prediction_horizon":10, "soc_init":0.5,"soc_final":0.6,"def_total_hours":[1,3],"def_start_timestep":[0,3],"def_end_timestep":[0,6]}' http://localhost:5000/action/naive-mpc-optim
 ```
 
+
+
 ## A machine learning forecaster
 
 Starting in v0.4.0 a new machine learning forecaster class was introduced.

{emhass-0.8.0 → emhass-0.8.2}/setup.py

@@ -19,7 +19,7 @@ long_description = (here / 'README.md').read_text(encoding='utf-8')
 
 setup(
     name='emhass',  # Required
-    version='0.8.0',  # Required
+    version='0.8.2',  # Required
     description='An Energy Management System for Home Assistant',  # Optional
     long_description=long_description,  # Optional
     long_description_content_type='text/markdown',  # Optional (see note above)
@@ -40,8 +40,8 @@ setup(
     python_requires='>=3.9, <3.12',
     install_requires=[
         'wheel', 
-        'numpy<=1.26',
-        'scipy<=1.11.3',
+        'numpy==1.26.4',
+        'scipy==1.12.0',
         'pandas<=2.0.3',
         'pvlib>=0.10.2',
         'protobuf>=3.0.0',
@@ -62,6 +62,6 @@ setup(
             'emhass=emhass.command_line:main',
         ],
     },
-    package_data={'emhass': ['templates/index.html','templates/template.html',
-    'static/style.css','static/img/emhass_icon.png','static/img/emhass_logo_short.svg']},
+    package_data={'emhass': ['templates/index.html','templates/template.html','static/advanced.html','static/basic.html', 'static/script.js',
+    'static/style.css','static/img/emhass_icon.png','static/img/emhass_logo_short.svg', 'static/img/feather-sprite.svg']},
 )

{emhass-0.8.0 → emhass-0.8.2}/src/emhass/forecast.py

@@ -159,7 +159,7 @@ class Forecast(object):
         self.end_forecast = (self.start_forecast + self.optim_conf['delta_forecast']).replace(microsecond=0)
         self.forecast_dates = pd.date_range(start=self.start_forecast, 
                                             end=self.end_forecast-self.freq, 
-                                            freq=self.freq).round(self.freq)
+                                            freq=self.freq).round(self.freq, ambiguous='infer', nonexistent=self.freq)
         if params is not None:
             if 'prediction_horizon' in list(self.params['passed_data'].keys()):
                 if self.params['passed_data']['prediction_horizon'] is not None:
@@ -184,7 +184,7 @@ class Forecast(object):
             freq_scrap = pd.to_timedelta(60, "minutes") # The scrapping time step is 60min
             forecast_dates_scrap = pd.date_range(start=self.start_forecast,
                                                  end=self.end_forecast-freq_scrap, 
-                                                 freq=freq_scrap).round(freq_scrap)
+                                                 freq=freq_scrap).round(freq_scrap, ambiguous='infer', nonexistent=freq_scrap)
             # Using the clearoutside webpage
             response = get("https://clearoutside.com/forecast/"+str(round(self.lat, 2))+"/"+str(round(self.lon, 2))+"?desktop=true")
             '''import bz2 # Uncomment to save a serialized data for tests
@@ -476,7 +476,7 @@ class Forecast(object):
         end_forecast_csv = (start_forecast_csv + self.optim_conf['delta_forecast']).replace(microsecond=0)
         forecast_dates_csv = pd.date_range(start=start_forecast_csv, 
                                            end=end_forecast_csv+timedelta(days=timedelta_days)-self.freq, 
-                                           freq=self.freq).round(self.freq)
+                                           freq=self.freq).round(self.freq, ambiguous='infer', nonexistent=self.freq)
         if self.params is not None:
             if 'prediction_horizon' in list(self.params['passed_data'].keys()):
                 if self.params['passed_data']['prediction_horizon'] is not None:

{emhass-0.8.0 → emhass-0.8.2}/src/emhass/optimization.py

@@ -85,6 +85,9 @@ class Optimization:
             self.lp_solver_path = 'empty'
         if self.lp_solver != 'COIN_CMD' and self.lp_solver_path != 'empty':
             self.logger.error("Use COIN_CMD solver name if you want to set a path for the LP solver")
+        if self.lp_solver == 'COIN_CMD' and self.lp_solver_path == 'empty': #if COIN_CMD but lp_solver_path is empty
+            self.logger.warning("lp_solver=COIN_CMD but lp_solver_path=empty, attempting to use lp_solver_path=/usr/bin/cbc")
+            self.lp_solver_path = '/usr/bin/cbc'  
         
     def perform_optimization(self, data_opt: pd.DataFrame, P_PV: np.array, P_load: np.array, 
                              unit_load_cost: np.array, unit_prod_price: np.array,

{emhass-0.8.0 → emhass-0.8.2}/src/emhass/retrieve_hass.py

@@ -149,7 +149,7 @@ class RetrieveHass:
                     from_date = pd.to_datetime(df_raw['last_changed'], format="ISO8601").min()
                     to_date = pd.to_datetime(df_raw['last_changed'], format="ISO8601").max()
                     ts = pd.to_datetime(pd.date_range(start=from_date, end=to_date, freq=self.freq), 
-                                        format='%Y-%d-%m %H:%M').round(self.freq)
+                                        format='%Y-%d-%m %H:%M').round(self.freq, ambiguous='infer', nonexistent=self.freq)
                     df_day = pd.DataFrame(index = ts)
                 # Caution with undefined string data: unknown, unavailable, etc.
                 df_tp = df_raw.copy()[['state']].replace(

emhass-0.8.2/src/emhass/static/advanced.html

@@ -0,0 +1,32 @@
+<!-- action button elements section -->
+<div class="loading-div" id="advance">
+    <h4>Use the buttons below to manually launch different optimization tasks</h4>
+    <div id=loader></div> <!-- status dynamic element -->
+</div>
+<button type="button" id="perfect-optim" class="button button1">Perfect Optimization</button>
+<button type="button" id="dayahead-optim" class="button button2">Day-ahead Optimization</button>
+<button type="button" id="naive-mpc-optim" class="button button3">MPC Optimization</button>
+<!--ml toggled div button -->
+<h4>Use the button below to publish the optimized variables at the current timestamp</h4>
+<button type="button" id="publish-data" class="button button1">Publish Optimization Results</button>
+<h4>Use the buttons below to fit, predict and tune a machine learning model for testing</h4>
+<button type="button" id="forecast-model-fit" class="button button1">ML forecast model fit</button>
+<button type="button" id="forecast-model-predict" class="button button2">ML forecast model
+    predict</button>
+<button type="button" id="forecast-model-tune" class="button button3">ML forecast model tune</button>
+<!-- -->
+<!--dynamic input elements section -->
+<h4>Input Runtime Parameters</h4>
+<div class="input-button-container">
+    <div class="input-buttons">
+        <button type="button" id="input-plus">+</button>
+        <button type="button" id="input-minus">-</button>
+        <select name="Select" id="input-select">
+            <option value="List" selected>List</option>
+            <option value="Box">Box</option>
+        </select>
+        <button type="button" id="input-clear">Clear</button>
+    </div>
+</div>
+<div id="input-container"> <!-- (Box/List) dynamic input elements will be added here -->
+</div>

emhass-0.8.2/src/emhass/static/basic.html

@@ -0,0 +1,12 @@
+<!-- action button elements section -->
+<div class="loading-div" id="basic">
+    <h4>Use the button below to manually launch optimization task</h4>
+    <div id=loader></div> <!-- status dynamic element -->
+</div>
+<button type="button" id="dayahead-optim-basic" class="button button1">Day-ahead Optimization</button>
+<div class="info">
+    <p>The day-ahead optimization button will run once, based on the values entered into the configuration page.
+        </br>
+        After a few seconds, the charts and table below should be updated to reflect the optimization plan for the next 24 hours.
+    </p>
+</div>