[#28] Add a window open detection based on internal temperature change

Remove warnings #48
Add theme colors #27

.devcontainer/configuration.yaml

@@ -169,3 +169,12 @@ switch:
             option: comfort-2
           target:
             entity_id: select.seche_serviettes_sdb_rdc_cable_outlet_mode
+
+frontend:
+  themes:
+    versatile_thermostat_theme:
+      state-binary_sensor-safety-on-color: "#FF0B0B"
+      state-binary_sensor-power-on-color: "#FF0B0B"
+      state-binary_sensor-window-on-color: "rgb(156, 39, 176)"
+      state-binary_sensor-motion-on-color: "rgb(156, 39, 176)"
+      state-binary_sensor-presence-on-color: "lightgreen"

README-fr.md

@@ -45,8 +45,6 @@
   - [Et toujours de mieux en mieux avec l'AappDaemon NOTIFIER pour notifier les évènements](#et-toujours-de-mieux-en-mieux-avec-laappdaemon-notifier-pour-notifier-les-évènements)
 - [Les contributions sont les bienvenues !](#les-contributions-sont-les-bienvenues)
 
-_Composant développé à l'aide de l'incroyable modèle de développement [[blueprint](https://github.com/custom-components/integration_blueprint)]._
-
 Ce composant personnalisé pour Home Assistant est une mise à niveau et est une réécriture complète du composant "Awesome thermostat" (voir [Github](https://github.com/dadge/awesome_thermostat)) avec l'ajout de fonctionnalités.
 
 # Quand l'utiliser et ne pas l'utiliser
@@ -354,6 +352,22 @@ Dans l'ordre, il y a :
 12. l'état de l'ouverture (si la gestion des ouvertures est configurée),
 13. l'état du mouvement (si la gestion du mouvements est configurée)
 
+Pour colorer les capteurs, ajouter ces lignes et personnalisez les au besoin, dans votre configuration.yaml :
+
+```
+frontend:
+  themes:
+    versatile_thermostat_theme:
+      state-binary_sensor-safety-on-color: "#FF0B0B"
+      state-binary_sensor-power-on-color: "#FF0B0B"
+      state-binary_sensor-window-on-color: "rgb(156, 39, 176)"
+      state-binary_sensor-motion-on-color: "rgb(156, 39, 176)"
+      state-binary_sensor-presence-on-color: "lightgreen"
+```
+et choisissez le thème ```versatile_thermostat_theme``` dans la configuration du panel. Vous obtiendrez quelque-chose qui va ressembler à ça :
+
+![image](https://github.com/jmcollin78/versatile_thermostat/blob/main/images/colored-thermostat-sensors.png?raw=true)
+
 # Services
 
 Cette implémentation personnalisée offre des services spécifiques pour faciliter l'intégration avec d'autres composants Home Assistant.

README.md

@@ -45,7 +45,6 @@
   - [And always better and better with the NOTIFIER daemon app to notify events](#and-always-better-and-better-with-the-notifier-daemon-app-to-notify-events)
 - [Contributions are welcome!](#contributions-are-welcome)
 
-_Component developed by using the amazing development template [[blueprint](https://github.com/custom-components/integration_blueprint)]._
 
 This custom component for Home Assistant is an upgrade and is a complete rewrite of the component "Awesome thermostat" (see [Github](https://github.com/dadge/awesome_thermostat)) with addition of features.
 
@@ -340,6 +339,22 @@ In order, there are:
 12. opening status (if opening management is configured),
 13. motion status (if motion management is configured)
 
+To color the sensors, add these lines and customize them as needed, in your configuration.yaml:
+
+```
+frontend:
+  themes:
+    versatile_thermostat_theme:
+      state-binary_sensor-safety-on-color: "#FF0B0B"
+      state-binary_sensor-power-on-color: "#FF0B0B"
+      state-binary_sensor-window-on-color: "rgb(156, 39, 176)"
+      state-binary_sensor-motion-on-color: "rgb(156, 39, 176)"
+      state-binary_sensor-presence-on-color: "lightgreen"
+```
+and choose the ```versatile_thermostat_theme``` theme in the panel configuration. You will get something that will look like this:
+
+![image](https://github.com/jmcollin78/versatile_thermostat/blob/main/images/colored-thermostat-sensors.png?raw=true)
+
 # Services
 
 This custom implementation offers some specific services to facilitate integration with others Home Assisstant components.

custom_components/versatile_thermostat/__init__.py

@@ -99,7 +99,7 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry):
 
     if config_entry.version == 1:
         new = {**config_entry.data}
-        # TODO: modify Config Entry data
+        # TO DO: modify Config Entry data if there will be something to migrate
 
         config_entry.version = 2
         hass.config_entries.async_update_entry(config_entry, data=new)

custom_components/versatile_thermostat/binary_sensor.py

@@ -5,7 +5,10 @@ from homeassistant.core import HomeAssistant, callback, Event
 
 from homeassistant.const import STATE_ON
 
-from homeassistant.components.binary_sensor import BinarySensorEntity
+from homeassistant.components.binary_sensor import (
+    BinarySensorEntity,
+    BinarySensorDeviceClass,
+)
 from homeassistant.config_entries import ConfigEntry
 
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -56,17 +59,23 @@ class SecurityBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
         super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
         self._attr_name = "Security state"
         self._attr_unique_id = f"{self._device_name}_security_state"
+        self._attr_is_on = False
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+
         old_state = self._attr_is_on
-        self._attr_is_on = self.my_climate.security_state
+        self._attr_is_on = self.my_climate.security_state is True
         if old_state != self._attr_is_on:
             self.async_write_ha_state()
         return
 
+    @property
+    def device_class(self) -> BinarySensorDeviceClass | None:
+        return BinarySensorDeviceClass.SAFETY
+
     @property
     def icon(self) -> str | None:
         if self._attr_is_on:
@@ -83,17 +92,23 @@ class OverpoweringBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity
         super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
         self._attr_name = "Overpowering state"
         self._attr_unique_id = f"{self._device_name}_overpowering_state"
+        self._attr_is_on = False
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+
         old_state = self._attr_is_on
-        self._attr_is_on = self.my_climate.overpowering_state
+        self._attr_is_on = self.my_climate.overpowering_state is True
         if old_state != self._attr_is_on:
             self.async_write_ha_state()
         return
 
+    @property
+    def device_class(self) -> BinarySensorDeviceClass | None:
+        return BinarySensorDeviceClass.POWER
+
     @property
     def icon(self) -> str | None:
         if self._attr_is_on:
@@ -110,21 +125,33 @@ class WindowBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
         super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
         self._attr_name = "Window state"
         self._attr_unique_id = f"{self._device_name}_window_state"
+        self._attr_is_on = False
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+
         old_state = self._attr_is_on
-        self._attr_is_on = self.my_climate.window_state == STATE_ON
+        self._attr_is_on = (
+            self.my_climate.window_state == STATE_ON
+            or self.my_climate.window_auto_state == STATE_ON
+        )
         if old_state != self._attr_is_on:
             self.async_write_ha_state()
         return
 
+    @property
+    def device_class(self) -> BinarySensorDeviceClass | None:
+        return BinarySensorDeviceClass.WINDOW
+
     @property
     def icon(self) -> str | None:
         if self._attr_is_on:
-            return "mdi:window-open-variant"
+            if self.my_climate.window_state == STATE_ON:
+                return "mdi:window-open-variant"
+            else:
+                return "mdi:window-open"
         else:
             return "mdi:window-closed-variant"
 
@@ -137,17 +164,22 @@ class MotionBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
         super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
         self._attr_name = "Motion state"
         self._attr_unique_id = f"{self._device_name}_motion_state"
+        self._attr_is_on = False
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
         old_state = self._attr_is_on
         self._attr_is_on = self.my_climate.motion_state == STATE_ON
         if old_state != self._attr_is_on:
             self.async_write_ha_state()
         return
 
+    @property
+    def device_class(self) -> BinarySensorDeviceClass | None:
+        return BinarySensorDeviceClass.MOTION
+
     @property
     def icon(self) -> str | None:
         if self._attr_is_on:
@@ -164,18 +196,23 @@ class PresenceBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
         super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
         self._attr_name = "Presence state"
         self._attr_unique_id = f"{self._device_name}_presence_state"
+        self._attr_is_on = False
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
 
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
         old_state = self._attr_is_on
         self._attr_is_on = self.my_climate.presence_state == STATE_ON
         if old_state != self._attr_is_on:
             self.async_write_ha_state()
         return
 
+    @property
+    def device_class(self) -> BinarySensorDeviceClass | None:
+        return BinarySensorDeviceClass.PRESENCE
+
     @property
     def icon(self) -> str | None:
         if self._attr_is_on:

custom_components/versatile_thermostat/climate.py

@@ -103,6 +103,9 @@ from .const import (
     CONF_MAX_POWER_SENSOR,
     CONF_WINDOW_SENSOR,
     CONF_WINDOW_DELAY,
+    CONF_WINDOW_AUTO_CLOSE_THRESHOLD,
+    CONF_WINDOW_AUTO_OPEN_THRESHOLD,
+    CONF_WINDOW_AUTO_MAX_DURATION,
     CONF_MOTION_SENSOR,
     CONF_MOTION_DELAY,
     CONF_MOTION_PRESET,
@@ -144,6 +147,7 @@ from .const import (
 )
 
 from .prop_algorithm import PropAlgorithm
+from .open_window_algorithm import WindowOpenDetectionAlgorithm
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -216,6 +220,7 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
     _motion_state: bool
     _presence_state: bool
     _security_state: bool
+    _window_auto_state: bool
 
     def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
         """Initialize the thermostat."""
@@ -270,6 +275,13 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
         self._underlying_climate_start_hvac_action_date = None
         self._underlying_climate_delta_t = 0
 
+        self._window_auto_open_threshold = 0
+        self._window_auto_close_threshold = 0
+        self._window_auto_max_duration = 0
+        self._window_auto_state = False
+        self._window_auto_on = False
+        self._window_auto_algo = None
+
         self._current_tz = dt_util.get_time_zone(self._hass.config.time_zone)
 
         self.post_init(entry_infos)
@@ -340,6 +352,27 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
         self._max_power_sensor_entity_id = entry_infos.get(CONF_MAX_POWER_SENSOR)
         self._window_sensor_entity_id = entry_infos.get(CONF_WINDOW_SENSOR)
         self._window_delay_sec = entry_infos.get(CONF_WINDOW_DELAY)
+
+        self._window_auto_open_threshold = entry_infos.get(
+            CONF_WINDOW_AUTO_OPEN_THRESHOLD
+        )
+        self._window_auto_close_threshold = entry_infos.get(
+            CONF_WINDOW_AUTO_CLOSE_THRESHOLD
+        )
+        self._window_auto_max_duration = entry_infos.get(CONF_WINDOW_AUTO_MAX_DURATION)
+        self._window_auto_on = (
+            self._window_auto_open_threshold is not None
+            and self._window_auto_open_threshold > 0.0
+            and self._window_auto_close_threshold is not None
+            and self._window_auto_max_duration is not None
+            and self._window_auto_max_duration > 0
+        )
+        self._window_auto_state = False
+        self._window_auto_algo = WindowOpenDetectionAlgorithm(
+            alert_threshold=self._window_auto_open_threshold,
+            end_alert_threshold=self._window_auto_close_threshold,
+        )
+
         self._motion_sensor_entity_id = entry_infos.get(CONF_MOTION_SENSOR)
         self._motion_delay_sec = entry_infos.get(CONF_MOTION_DELAY)
         self._motion_preset = entry_infos.get(CONF_MOTION_PRESET)
@@ -357,7 +390,7 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
 
         self._presence_on = self._presence_sensor_entity_id is not None
 
-        # TODO if self.ac_mode:
+        # if self.ac_mode: -> MODE_COOL should be better to use thermostat_over_climate type
         #    self.hvac_list = [HVAC_MODE_COOL, HVAC_MODE_OFF]
         # else:
         self._hvac_list = [HVACMode.HEAT, HVACMode.OFF]
@@ -1044,6 +1077,11 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
         """Get the window_state"""
         return self._window_state
 
+    @property
+    def window_auto_state(self) -> bool | None:
+        """Get the window_auto_state"""
+        return STATE_ON if self._window_auto_state else STATE_OFF
+
     @property
     def security_state(self) -> bool | None:
         """Get the security_state"""
@@ -1074,6 +1112,41 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
         """Get the last external temperature datetime"""
         return self._last_ext_temperature_mesure
 
+    @property
+    def preset_mode(self) -> str | None:
+        """Return the current preset mode, e.g., home, away, temp.
+
+        Requires ClimateEntityFeature.PRESET_MODE.
+        """
+        return self._attr_preset_mode
+
+    @property
+    def preset_modes(self) -> list[str] | None:
+        """Return a list of available preset modes.
+
+        Requires ClimateEntityFeature.PRESET_MODE.
+        """
+        return self._attr_preset_modes
+
+    @property
+    def is_over_climate(self) -> bool | None:
+        """return True is the thermostat is over a climate
+        or False is over switch"""
+        return self._is_over_climate
+
+    @property
+    def last_temperature_slope(self) -> float | None:
+        """Return the last temperature slope curve if any"""
+        if not self._window_auto_algo:
+            return None
+        else:
+            return self._window_auto_algo.last_slope
+
+    @property
+    def is_window_auto_enabled(self) -> bool:
+        """True if the Window auto feature is enabled"""
+        return self._window_auto_on
+
     def turn_aux_heat_on(self) -> None:
         """Turn auxiliary heater on."""
         if self._is_over_climate and self._underlying_climate:
@@ -1102,22 +1175,6 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
 
         raise NotImplementedError()
 
-    @property
-    def preset_mode(self) -> str | None:
-        """Return the current preset mode, e.g., home, away, temp.
-
-        Requires ClimateEntityFeature.PRESET_MODE.
-        """
-        return self._attr_preset_mode
-
-    @property
-    def preset_modes(self) -> list[str] | None:
-        """Return a list of available preset modes.
-
-        Requires ClimateEntityFeature.PRESET_MODE.
-        """
-        return self._attr_preset_modes
-
     async def async_set_hvac_mode(self, hvac_mode):
         """Set new target hvac mode."""
         _LOGGER.info("%s - Set hvac mode: %s", self, hvac_mode)
@@ -1488,6 +1545,9 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             self.hass, timedelta(seconds=self._motion_delay_sec), try_motion_condition
         )
 
+        # For testing purpose we need to access the inner function
+        return try_motion_condition
+
     @callback
     async def _check_switch_initial_state(self):
         """Prevent the device from keep running if HVAC_MODE_OFF."""
@@ -1551,7 +1611,7 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             self._hvac_mode = new_state.state
 
         # Interpretation of hvac
-        HVAC_ACTION_ON = [
+        HVAC_ACTION_ON = [  # pylint: disable=invalid-name
             HVACAction.COOLING,
             HVACAction.DRYING,
             HVACAction.FAN,
@@ -1612,6 +1672,9 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             if self._security_state:
                 await self.check_security()
 
+            # check window_auto
+            await self._async_manage_window_auto()
+
         except ValueError as ex:
             _LOGGER.error("Unable to update temperature from sensor: %s", ex)
 
@@ -1806,6 +1869,80 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
                 HA_DOMAIN, SERVICE_TURN_OFF, data, context=self._context
             )
 
+    async def _async_manage_window_auto(self):
+        """The management of the window auto feature"""
+
+        async def dearm_window_auto(_):
+            """Callback that will be called after end of WINDOW_AUTO_MAX_DURATION"""
+            _LOGGER.info("Unset window auto because MAX_DURATION is exceeded")
+            await deactivate_window_auto(auto=True)
+
+        async def deactivate_window_auto(auto=False):
+            """Deactivation of the Window auto state"""
+            _LOGGER.warning(
+                "%s - End auto detection of open window slope=%.3f", self, slope
+            )
+            # Send an event
+            cause = "max duration expiration" if auto else "end of slope alert"
+            self.send_event(
+                EventType.WINDOW_AUTO_EVENT,
+                {"type": "end", "cause": cause, "curve_slope": slope},
+            )
+            # Set attributes
+            self._window_auto_state = False
+            await self.restore_hvac_mode()
+
+            if self._window_call_cancel:
+                self._window_call_cancel()
+            self._window_call_cancel = None
+
+        if not self._window_auto_algo:
+            return
+
+        slope = self._window_auto_algo.add_temp_measurement(
+            temperature=self._cur_temp, datetime_measure=self._last_temperature_mesure
+        )
+        _LOGGER.debug(
+            "%s - Window auto is on, check the alert. last slope is %.3f",
+            self,
+            slope if slope is not None else 0.0,
+        )
+        if (
+            self._window_auto_algo.is_window_open_detected()
+            and self._window_auto_state is False
+        ):
+            _LOGGER.warning(
+                "%s - Start auto detection of open window slope=%.3f", self, slope
+            )
+            # Send an event
+            self.send_event(
+                EventType.WINDOW_AUTO_EVENT,
+                {"type": "start", "cause": "slope alert", "curve_slope": slope},
+            )
+            # Set attributes
+            self._window_auto_state = True
+            self.save_hvac_mode()
+            await self.async_set_hvac_mode(HVACMode.OFF)
+
+            # Arm the end trigger
+            if self._window_call_cancel:
+                self._window_call_cancel()
+                self._window_call_cancel = None
+            self._window_call_cancel = async_call_later(
+                self.hass,
+                timedelta(minutes=self._window_auto_max_duration),
+                dearm_window_auto,
+            )
+
+        elif (
+            self._window_auto_algo.is_window_close_detected()
+            and self._window_auto_state is True
+        ):
+            await deactivate_window_auto(False)
+
+        # For testing purpose we need to return the inner function
+        return dearm_window_auto
+
     def save_preset_mode(self):
         """Save the current preset mode to be restored later
         We never save a hidden preset mode
@@ -2126,7 +2263,10 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             if self._hvac_mode == HVACMode.HEAT and on_time_sec > 0:
 
                 async def _turn_on_off_later(
-                    on: bool, time, heater_action, next_cycle_action
+                    on: bool,  # pylint: disable=invalid-name
+                    time,
+                    heater_action,
+                    next_cycle_action,
                 ):
                     if self._async_cancel_cycle:
                         self._async_cancel_cycle()

custom_components/versatile_thermostat/commons.py

@@ -58,7 +58,7 @@ class VersatileThermostatBaseEntity(Entity):
         try:
             component: EntityComponent[ClimateEntity] = self.hass.data[CLIMATE_DOMAIN]
             for entity in component.entities:
-                _LOGGER.debug("Device_info is %s", entity.device_info)
+                # _LOGGER.debug("Device_info is %s", entity.device_info)
                 if entity.device_info == self.device_info:
                     _LOGGER.debug("Found %s!", entity)
                     return entity

custom_components/versatile_thermostat/config_flow.py

@@ -47,6 +47,9 @@ from .const import (
     CONF_MAX_POWER_SENSOR,
     CONF_WINDOW_SENSOR,
     CONF_WINDOW_DELAY,
+    CONF_WINDOW_AUTO_MAX_DURATION,
+    CONF_WINDOW_AUTO_CLOSE_THRESHOLD,
+    CONF_WINDOW_AUTO_OPEN_THRESHOLD,
     CONF_MOTION_SENSOR,
     CONF_MOTION_DELAY,
     CONF_MOTION_PRESET,
@@ -79,6 +82,7 @@ from .const import (
     CONF_USE_POWER_FEATURE,
     CONF_THERMOSTAT_TYPES,
     UnknownEntity,
+    WindowOpenDetectionMethod,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -167,7 +171,9 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         is_empty: bool = not bool(infos)
         # Fix features selection depending to infos
         self._infos[CONF_USE_WINDOW_FEATURE] = (
-            is_empty or self._infos.get(CONF_WINDOW_SENSOR) is not None
+            is_empty
+            or self._infos.get(CONF_WINDOW_SENSOR) is not None
+            or self._infos.get(CONF_WINDOW_AUTO_OPEN_THRESHOLD) is not None
         )
         self._infos[CONF_USE_MOTION_FEATURE] = (
             is_empty or self._infos.get(CONF_MOTION_SENSOR) is not None
@@ -180,7 +186,7 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             is_empty or self._infos.get(CONF_PRESENCE_SENSOR) is not None
         )
 
-        self.STEP_USER_DATA_SCHEMA = vol.Schema(
+        self.STEP_USER_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Required(CONF_NAME): cv.string,
                 vol.Required(
@@ -195,12 +201,11 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                         domain=[SENSOR_DOMAIN, INPUT_NUMBER_DOMAIN]
                     ),
                 ),
-                #  vol.In(temp_sensors),
                 vol.Required(CONF_EXTERNAL_TEMP_SENSOR): selector.EntitySelector(
                     selector.EntitySelectorConfig(
                         domain=[SENSOR_DOMAIN, INPUT_NUMBER_DOMAIN]
                     ),
-                ),  # vol.In(temp_sensors),
+                ),
                 vol.Required(CONF_CYCLE_MIN, default=5): cv.positive_int,
                 vol.Required(CONF_TEMP_MIN, default=7): vol.Coerce(float),
                 vol.Required(CONF_TEMP_MAX, default=35): vol.Coerce(float),
@@ -212,13 +217,13 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             }
         )
 
-        self.STEP_THERMOSTAT_SWITCH = vol.Schema(
+        self.STEP_THERMOSTAT_SWITCH = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Required(CONF_HEATER): selector.EntitySelector(
                     selector.EntitySelectorConfig(
                         domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]
                     ),
-                ),  # vol.In(switches),
+                ),
                 vol.Required(
                     CONF_PROP_FUNCTION, default=PROPORTIONAL_FUNCTION_TPI
                 ): vol.In(
@@ -229,46 +234,49 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             }
         )
 
-        self.STEP_THERMOSTAT_CLIMATE = vol.Schema(
+        self.STEP_THERMOSTAT_CLIMATE = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Required(CONF_CLIMATE): selector.EntitySelector(
                     selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
-                ),  # vol.In(climates),
+                ),
             }
         )
 
-        self.STEP_TPI_DATA_SCHEMA = vol.Schema(
+        self.STEP_TPI_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Required(CONF_TPI_COEF_INT, default=0.6): vol.Coerce(float),
                 vol.Required(CONF_TPI_COEF_EXT, default=0.01): vol.Coerce(float),
             }
         )
 
-        self.STEP_PRESETS_DATA_SCHEMA = vol.Schema(
+        self.STEP_PRESETS_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Optional(v, default=0.0): vol.Coerce(float)
                 for (k, v) in CONF_PRESETS.items()
             }
         )
 
-        self.STEP_WINDOW_DATA_SCHEMA = vol.Schema(
+        self.STEP_WINDOW_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Optional(CONF_WINDOW_SENSOR): selector.EntitySelector(
                     selector.EntitySelectorConfig(
                         domain=[BINARY_SENSOR_DOMAIN, INPUT_BOOLEAN_DOMAIN]
                     ),
-                ),  # vol.In(window_sensors),
+                ),
                 vol.Optional(CONF_WINDOW_DELAY, default=30): cv.positive_int,
+                vol.Optional(CONF_WINDOW_AUTO_OPEN_THRESHOLD): vol.Coerce(float),
+                vol.Optional(CONF_WINDOW_AUTO_CLOSE_THRESHOLD): vol.Coerce(float),
+                vol.Optional(CONF_WINDOW_AUTO_MAX_DURATION): cv.positive_int,
             }
         )
 
-        self.STEP_MOTION_DATA_SCHEMA = vol.Schema(
+        self.STEP_MOTION_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Optional(CONF_MOTION_SENSOR): selector.EntitySelector(
                     selector.EntitySelectorConfig(
                         domain=[BINARY_SENSOR_DOMAIN, INPUT_BOOLEAN_DOMAIN]
                     ),
-                ),  # vol.In(window_sensors),
+                ),
                 vol.Optional(CONF_MOTION_DELAY, default=30): cv.positive_int,
                 vol.Optional(CONF_MOTION_PRESET, default="comfort"): vol.In(
                     CONF_PRESETS_SELECTIONABLE
@@ -279,23 +287,23 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             }
         )
 
-        self.STEP_POWER_DATA_SCHEMA = vol.Schema(
+        self.STEP_POWER_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Optional(CONF_POWER_SENSOR): selector.EntitySelector(
                     selector.EntitySelectorConfig(
                         domain=[SENSOR_DOMAIN, INPUT_NUMBER_DOMAIN]
                     ),
-                ),  # vol.In(power_sensors),
+                ),
                 vol.Optional(CONF_MAX_POWER_SENSOR): selector.EntitySelector(
                     selector.EntitySelectorConfig(
                         domain=[SENSOR_DOMAIN, INPUT_NUMBER_DOMAIN]
                     ),
-                ),  # vol.In(power_sensors),
+                ),
                 vol.Optional(CONF_PRESET_POWER, default="13"): vol.Coerce(float),
             }
         )
 
-        self.STEP_PRESENCE_DATA_SCHEMA = vol.Schema(
+        self.STEP_PRESENCE_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Optional(CONF_PRESENCE_SENSOR): selector.EntitySelector(
                     selector.EntitySelectorConfig(
@@ -305,7 +313,7 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                             INPUT_BOOLEAN_DOMAIN,
                         ]
                     ),
-                ),  # vol.In(presence_sensors),
+                ),
             }
         ).extend(
             {
@@ -314,7 +322,7 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             }
         )
 
-        self.STEP_ADVANCED_DATA_SCHEMA = vol.Schema(
+        self.STEP_ADVANCED_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
             {
                 vol.Required(
                     CONF_MINIMAL_ACTIVATION_DELAY, default=10
@@ -357,6 +365,19 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                 )
                 raise UnknownEntity(conf)
 
+        # Check that only one window feature is used
+        ws = data.get(CONF_WINDOW_SENSOR)  # pylint: disable=invalid-name
+        waot = data.get(CONF_WINDOW_AUTO_OPEN_THRESHOLD)
+        wact = data.get(CONF_WINDOW_AUTO_CLOSE_THRESHOLD)
+        wamd = data.get(CONF_WINDOW_AUTO_MAX_DURATION)
+        if ws is not None and (
+            waot is not None or wact is not None or wamd is not None
+        ):
+            _LOGGER.error(
+                "Only one window detection method should be used. Use window_sensor or auto window open detection but not both"
+            )
+            raise WindowOpenDetectionMethod(CONF_WINDOW_SENSOR)
+
     def merge_user_input(self, data_schema: vol.Schema, user_input: dict):
         """For each schema entry not in user_input, set or remove values in infos"""
         self._infos.update(user_input)
@@ -387,6 +408,8 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                 await self.validate_input(user_input)
             except UnknownEntity as err:
                 errors[str(err)] = "unknown_entity"
+            except WindowOpenDetectionMethod as err:
+                errors[str(err)] = "window_open_detection_method"
             except Exception:  # pylint: disable=broad-except
                 _LOGGER.exception("Unexpected exception")
                 errors["base"] = "unknown"

custom_components/versatile_thermostat/const.py

@@ -13,13 +13,13 @@ from homeassistant.components.climate import (
 
 from homeassistant.exceptions import HomeAssistantError
 
-DEVICE_MANUFACTURER = "JMCOLLIN"
-DEVICE_MODEL = "Versatile Thermostat"
-
 from .prop_algorithm import (
     PROPORTIONAL_FUNCTION_TPI,
 )
 
+DEVICE_MANUFACTURER = "JMCOLLIN"
+DEVICE_MODEL = "Versatile Thermostat"
+
 PRESET_POWER = "power"
 PRESET_SECURITY = "security"
 
@@ -61,6 +61,9 @@ CONF_USE_WINDOW_FEATURE = "use_window_feature"
 CONF_USE_MOTION_FEATURE = "use_motion_feature"
 CONF_USE_PRESENCE_FEATURE = "use_presence_feature"
 CONF_USE_POWER_FEATURE = "use_power_feature"
+CONF_WINDOW_AUTO_OPEN_THRESHOLD = "window_auto_open_threshold"
+CONF_WINDOW_AUTO_CLOSE_THRESHOLD = "window_auto_close_threshold"
+CONF_WINDOW_AUTO_MAX_DURATION = "window_auto_max_duration"
 
 CONF_PRESETS = {
     p: f"{p}_temp"
@@ -97,6 +100,9 @@ ALL_CONF = (
         CONF_MAX_POWER_SENSOR,
         CONF_WINDOW_SENSOR,
         CONF_WINDOW_DELAY,
+        CONF_WINDOW_AUTO_OPEN_THRESHOLD,
+        CONF_WINDOW_AUTO_CLOSE_THRESHOLD,
+        CONF_WINDOW_AUTO_MAX_DURATION,
         CONF_MOTION_SENSOR,
         CONF_MOTION_DELAY,
         CONF_MOTION_PRESET,
@@ -153,7 +159,12 @@ class EventType(Enum):
     TEMPERATURE_EVENT: str = "versatile_thermostat_temperature_event"
     HVAC_MODE_EVENT: str = "versatile_thermostat_hvac_mode_event"
     PRESET_EVENT: str = "versatile_thermostat_preset_event"
+    WINDOW_AUTO_EVENT: str = "versatile_thermostat_window_auto_event"
 
 
 class UnknownEntity(HomeAssistantError):
     """Error to indicate there is an unknown entity_id given."""
+
+
+class WindowOpenDetectionMethod(HomeAssistantError):
+    """Error to indicate there is an error in the window open detection method given."""

custom_components/versatile_thermostat/open_window_algorithm.py

@@ -0,0 +1,102 @@
+""" This file implements the Open Window by temperature algorithm
+    This algo works the following way:
+    - each time a new temperature is measured
+    -    calculate the slope of the temperature curve. For this we calculate the slope(t) = 1/2 slope(t-1) + 1/2 * dTemp / dt
+    -    if the slope is lower than a threshold the window opens alert is notified
+    -    if the slope regain positive the end of the window open alert is notified
+"""
+
+import logging
+from datetime import datetime
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class WindowOpenDetectionAlgorithm:
+    """The class that implements the algorithm listed above"""
+
+    _alert_threshold: float
+    _end_alert_threshold: float
+    _last_slope: float
+    _last_datetime: datetime
+    _last_temperature: float
+
+    def __init__(self, alert_threshold, end_alert_threshold) -> None:
+        """Initalize a new algorithm with the both threshold"""
+        self._alert_threshold = alert_threshold
+        self._end_alert_threshold = end_alert_threshold
+        self._last_slope = None
+        self._last_datetime = None
+
+    def add_temp_measurement(
+        self, temperature: float, datetime_measure: datetime
+    ) -> float:
+        """Add a new temperature measurement
+        returns the last slope
+        """
+        if self._last_datetime is None or self._last_temperature is None:
+            _LOGGER.debug("First initialisation")
+            self._last_datetime = datetime_measure
+            self._last_temperature = temperature
+            return None
+
+        _LOGGER.debug(
+            "We are already initialized slope=%s last_temp=%0.2f",
+            self._last_slope,
+            self._last_temperature,
+        )
+        delta_t = float((datetime_measure - self._last_datetime).total_seconds() / 60.0)
+        if delta_t <= 0:
+            _LOGGER.warning(
+                "Delta t is 0 or < 0 which should be not possible. We stop here the open window detection algorithm"
+            )
+            return None
+
+        delta_temp = float(temperature - self._last_temperature)
+        new_slope = delta_temp / delta_t
+
+        lspe = self._last_slope
+        if self._last_slope is None:
+            self._last_slope = new_slope
+        else:
+            self._last_slope = (0.5 * self._last_slope) + (0.5 * new_slope)
+
+        self._last_datetime = datetime_measure
+        self._last_temperature = temperature
+
+        _LOGGER.debug(
+            "delta_t=%.3f delta_temp=%.3f new_slope=%.3f last_slope=%s slope=%.3f",
+            delta_t,
+            delta_temp,
+            new_slope,
+            lspe,
+            self._last_slope,
+        )
+        return self._last_slope
+
+    def is_window_open_detected(self) -> bool:
+        """True if the last calculated slope is under (because negative value) the _alert_threshold"""
+        if self._alert_threshold is None:
+            return False
+
+        return (
+            self._last_slope < -self._alert_threshold
+            if self._last_slope is not None
+            else False
+        )
+
+    def is_window_close_detected(self) -> bool:
+        """True if the last calculated slope is above (cause negative) the _end_alert_threshold"""
+        if self._end_alert_threshold is None:
+            return False
+
+        return (
+            self._last_slope >= self._end_alert_threshold
+            if self._last_slope is not None
+            else False
+        )
+
+    @property
+    def last_slope(self) -> float:
+        """Return the last calculated slope"""
+        return self._last_slope

custom_components/versatile_thermostat/requirements_test.txt

@@ -1,3 +1,4 @@
 # -r requirements_dev.txt
 # aiodiscover
+ulid_transform
 pytest-homeassistant-custom-component

custom_components/versatile_thermostat/sensor.py

@@ -46,6 +46,7 @@ async def async_setup_entry(
     entities = [
         LastTemperatureSensor(hass, unique_id, name, entry.data),
         LastExtTemperatureSensor(hass, unique_id, name, entry.data),
+        TemperatureSlopeSensor(hass, unique_id, name, entry.data),
     ]
     if entry.data.get(CONF_DEVICE_POWER):
         entities.append(EnergySensor(hass, unique_id, name, entry.data))
@@ -70,9 +71,9 @@ class EnergySensor(VersatileThermostatBaseEntity, SensorEntity):
         self._attr_unique_id = f"{self._device_name}_energy"
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         if math.isnan(self.my_climate.total_energy) or math.isinf(
             self.my_climate.total_energy
@@ -125,9 +126,9 @@ class MeanPowerSensor(VersatileThermostatBaseEntity, SensorEntity):
         self._attr_unique_id = f"{self._device_name}_mean_power_cycle"
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         if math.isnan(float(self.my_climate.mean_cycle_power)) or math.isinf(
             self.my_climate.mean_cycle_power
@@ -182,9 +183,9 @@ class OnPercentSensor(VersatileThermostatBaseEntity, SensorEntity):
         self._attr_unique_id = f"{self._device_name}_power_percent"
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         on_percent = (
             float(self.my_climate.proportional_algorithm.on_percent)
@@ -234,9 +235,9 @@ class OnTimeSensor(VersatileThermostatBaseEntity, SensorEntity):
         self._attr_unique_id = f"{self._device_name}_on_time"
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         on_time = (
             float(self.my_climate.proportional_algorithm.on_time_sec)
@@ -279,9 +280,9 @@ class OffTimeSensor(VersatileThermostatBaseEntity, SensorEntity):
         self._attr_unique_id = f"{self._device_name}_off_time"
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         off_time = (
             float(self.my_climate.proportional_algorithm.off_time_sec)
@@ -324,9 +325,9 @@ class LastTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
         self._attr_unique_id = f"{self._device_name}_last_temp_datetime"
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         old_state = self._attr_native_value
         self._attr_native_value = self.my_climate.last_temperature_mesure
@@ -353,9 +354,9 @@ class LastExtTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
         self._attr_unique_id = f"{self._device_name}_last_ext_temp_datetime"
 
     @callback
-    async def async_my_climate_changed(self, event: Event):
+    async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", event.origin.name)
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         old_state = self._attr_native_value
         self._attr_native_value = self.my_climate.last_ext_temperature_mesure
@@ -370,3 +371,56 @@ class LastExtTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
     @property
     def device_class(self) -> SensorDeviceClass | None:
         return SensorDeviceClass.TIMESTAMP
+
+
+class TemperatureSlopeSensor(VersatileThermostatBaseEntity, SensorEntity):
+    """Representation of a sensor which exposes the temperature slope curve"""
+
+    def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
+        """Initialize the slope sensor"""
+        super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
+        self._attr_name = "Temperature slope"
+        self._attr_unique_id = f"{self._device_name}_temperature_slope"
+
+    @callback
+    async def async_my_climate_changed(self, event: Event = None):
+        """Called when my climate have change"""
+        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+
+        last_slope = self.my_climate.last_temperature_slope
+        if last_slope is None:
+            return
+
+        if math.isnan(last_slope) or math.isinf(last_slope):
+            raise ValueError(f"Sensor has illegal state {last_slope}")
+
+        old_state = self._attr_native_value
+        self._attr_native_value = round(last_slope, self.suggested_display_precision)
+        if old_state != self._attr_native_value:
+            self.async_write_ha_state()
+        return
+
+    @property
+    def icon(self) -> str | None:
+        if self._attr_native_value is None or self._attr_native_value == 0:
+            return "mdi:thermometer"
+        elif self._attr_native_value > 0:
+            return "mdi:thermometer-chevron-up"
+        else:
+            return "mdi:thermometer-chevron-down"
+
+    @property
+    def state_class(self) -> SensorStateClass | None:
+        return SensorStateClass.MEASUREMENT
+
+    @property
+    def native_unit_of_measurement(self) -> str | None:
+        if not self.my_climate:
+            return None
+
+        return self.my_climate.temperature_unit + "/min"
+
+    @property
+    def suggested_display_precision(self) -> int | None:
+        """Return the suggested number of decimal digits for display."""
+        return 2

custom_components/versatile_thermostat/strings.json

@@ -49,10 +49,19 @@
       },
       "window": {
         "title": "Window management",
-        "description": "Open window management.\nLeave corresponding entity_id empty if not used.",
+        "description": "Open window management.\nLeave corresponding entity_id empty if not used\nYou can also configure automatic window open detection based on temperature decrease",
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
-          "window_delay": "Window delay (seconds)"
+          "window_delay": "Window sensor delay (seconds)",
+          "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/min)",
+          "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/min)",
+          "window_auto_max_duration": "Maximum duration of automatic window open detection (in min)"
+        },
+        "data_description": {
+          "window_sensor_entity_id": "Leave empty if no window sensor should be use",
+          "window_auto_open_threshold": "Recommended value: 0.5. Leave empty if automatic window open detection is not use",
+          "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not use",
+          "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not use"
         }
       },
       "motion": {
@@ -97,7 +106,8 @@
     },
     "error": {
       "unknown": "Unexpected error",
-      "unknown_entity": "Unknown entity id"
+      "unknown_entity": "Unknown entity id",
+      "window_open_detection_method": "Only one window open detection method should be used. Use sensor or automatic detection through temperature threshold but not both"
     },
     "abort": {
       "already_configured": "Device is already configured"
@@ -151,11 +161,20 @@
         }
       },
       "window": {
-        "title": "Window management",
-        "description": "Open window management.\nLeave corresponding entity_id empty if not used.",
+        "title": "[%key:component::versatile_thermostat::config::step::window::title%]",
+        "description": "[%key:component::versatile_thermostat::config::step::window::description%]",
         "data": {
-          "window_sensor_entity_id": "Window sensor entity id",
-          "window_delay": "Window delay (seconds)"
+          "window_sensor_entity_id": "[%key:component::versatile_thermostat::config::step::window::data::window_sensor_entity_id%]",
+          "window_delay": "[%key:component::versatile_thermostat::config::step::window::data::window_delay%]",
+          "window_auto_open_threshold": "[%key:component::versatile_thermostat::config::step::window::data::window_auto_open_threshold%]",
+          "window_auto_close_threshold": "[%key:component::versatile_thermostat::config::step::window::data::window_auto_close_threshold%]",
+          "window_auto_max_duration": "[%key:component::versatile_thermostat::config::step::window::data::window_auto_max_duration%]"
+        },
+        "data_description": {
+          "window_sensor_entity_id": "[%key:component::versatile_thermostat::config::step::window::data_description::window_sensor_entity_id%]",
+          "window_auto_open_threshold": "[%key:component::versatile_thermostat::config::step::window::data_description::window_auto_open_threshold%]",
+          "window_auto_close_threshold": "[%key:component::versatile_thermostat::config::step::window::data_description::window_auto_close_threshold%]",
+          "window_auto_max_duration": "[%key:component::versatile_thermostat::config::step::window::data_description::window_auto_max_duration%]"
         }
       },
       "motion": {
@@ -199,11 +218,12 @@
       }
     },
     "error": {
-      "unknown": "Unexpected error",
-      "unknown_entity": "Unknown entity id"
+      "unknown": "[%key:component::versatile_thermostat::config::error::unknown%]",
+      "unknown_entity": "[%key:component::versatile_thermostat::config::error::unknown_entity%]",
+      "window_open_detection_method": "[%key:component::versatile_thermostat::config::error::window_open_detection_method%]"
     },
     "abort": {
-      "already_configured": "Device is already configured"
+      "already_configured": "[%key:component::versatile_thermostat::config::abort::already_configured%]"
     }
   },
   "selector": {

custom_components/versatile_thermostat/tests/commons.py

@@ -1,5 +1,4 @@
 """ Some common resources """
-from typing import Mapping
 from unittest.mock import patch, MagicMock
 
 from homeassistant.core import HomeAssistant, Event, EVENT_STATE_CHANGED, State
@@ -7,22 +6,21 @@ from homeassistant.const import UnitOfTemperature, STATE_ON, STATE_OFF
 
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.util import dt as dt_util
-from homeassistant.helpers.entity_component import EntityComponent
-from pytest_homeassistant_custom_component.common import MockConfigEntry
-
-from ..climate import VersatileThermostat
-from ..const import *
-
+from homeassistant.helpers.entity import Entity
 from homeassistant.components.climate import (
     ClimateEntity,
     DOMAIN as CLIMATE_DOMAIN,
-    ATTR_PRESET_MODE,
     HVACMode,
     HVACAction,
     ClimateEntityFeature,
 )
 
-from .const import (
+from pytest_homeassistant_custom_component.common import MockConfigEntry
+
+from ..climate import VersatileThermostat
+from ..const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+
+from .const import (  # pylint: disable=unused-import
     MOCK_TH_OVER_SWITCH_USER_CONFIG,
     MOCK_TH_OVER_CLIMATE_USER_CONFIG,
     MOCK_TH_OVER_SWITCH_TYPE_CONFIG,
@@ -81,60 +79,74 @@ class MockClimate(ClimateEntity):
 
 
 class MagicMockClimate(MagicMock):
+    """A Magic Mock class for a underlying climate entity"""
+
     @property
-    def temperature_unit(self):
+    def temperature_unit(self):  # pylint: disable=missing-function-docstring
         return UnitOfTemperature.CELSIUS
 
     @property
-    def hvac_mode(self):
+    def hvac_mode(self):  # pylint: disable=missing-function-docstring
         return HVACMode.HEAT
 
     @property
-    def hvac_action(self):
+    def hvac_action(self):  # pylint: disable=missing-function-docstring
         return HVACAction.IDLE
 
     @property
-    def target_temperature(self):
+    def target_temperature(self):  # pylint: disable=missing-function-docstring
         return 15
 
     @property
-    def current_temperature(self):
+    def current_temperature(self):  # pylint: disable=missing-function-docstring
         return 14
 
     @property
-    def target_temperature_step(self) -> float | None:
+    def target_temperature_step(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> float | None:
         return 0.5
 
     @property
-    def target_temperature_high(self) -> float | None:
+    def target_temperature_high(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> float | None:
         return 35
 
     @property
-    def target_temperature_low(self) -> float | None:
+    def target_temperature_low(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> float | None:
         return 7
 
     @property
-    def hvac_modes(self) -> list[str] | None:
+    def hvac_modes(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> list[str] | None:
         return [HVACMode.HEAT, HVACMode.OFF, HVACMode.COOL]
 
     @property
-    def fan_modes(self) -> list[str] | None:
+    def fan_modes(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> list[str] | None:
         return None
 
     @property
-    def swing_modes(self) -> list[str] | None:
+    def swing_modes(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> list[str] | None:
         return None
 
     @property
-    def fan_mode(self) -> str | None:
+    def fan_mode(self) -> str | None:  # pylint: disable=missing-function-docstring
         return None
 
     @property
-    def swing_mode(self) -> str | None:
+    def swing_mode(self) -> str | None:  # pylint: disable=missing-function-docstring
         return None
 
     @property
-    def supported_features(self):
+    def supported_features(self):  # pylint: disable=missing-function-docstring
         return ClimateEntityFeature.TARGET_TEMPERATURE
 
 
@@ -149,16 +161,23 @@ async def create_thermostat(
         await hass.config_entries.async_setup(entry.entry_id)
         assert entry.state is ConfigEntryState.LOADED
 
-        def find_my_entity(entity_id) -> ClimateEntity:
-            """Find my new entity"""
-            component: EntityComponent[ClimateEntity] = hass.data[CLIMATE_DOMAIN]
-            for entity in component.entities:
-                if entity.entity_id == entity_id:
-                    return entity
+        # def find_my_entity(entity_id) -> ClimateEntity:
+        #     """Find my new entity"""
+        #     component: EntityComponent[ClimateEntity] = hass.data[CLIMATE_DOMAIN]
+        #     for entity in component.entities:
+        #         if entity.entity_id == entity_id:
+        #             return entity
 
-        entity = find_my_entity(entity_id)
+        return search_entity(hass, entity_id, CLIMATE_DOMAIN)
 
-        return entity
+
+def search_entity(hass: HomeAssistant, entity_id, domain) -> Entity:
+    """Search and return the entity in the domain"""
+    component = hass.data[domain]
+    for entity in component.entities:
+        if entity.entity_id == entity_id:
+            return entity
+    return None
 
 
 async def send_temperature_change_event(entity: VersatileThermostat, new_temp, date):
@@ -177,6 +196,24 @@ async def send_temperature_change_event(entity: VersatileThermostat, new_temp, d
     return await entity._async_temperature_changed(temp_event)
 
 
+async def send_ext_temperature_change_event(
+    entity: VersatileThermostat, new_temp, date
+):
+    """Sending a new external temperature event simulating a change on temperature sensor"""
+    temp_event = Event(
+        EVENT_STATE_CHANGED,
+        {
+            "new_state": State(
+                entity_id=entity.entity_id,
+                state=new_temp,
+                last_changed=date,
+                last_updated=date,
+            )
+        },
+    )
+    return await entity._async_ext_temperature_changed(temp_event)
+
+
 async def send_power_change_event(entity: VersatileThermostat, new_power, date):
     """Sending a new power event simulating a change on power sensor"""
     power_event = Event(
@@ -234,7 +271,57 @@ async def send_window_change_event(
     return ret
 
 
-def get_tz(hass):
+async def send_motion_change_event(
+    entity: VersatileThermostat, new_state: bool, old_state: bool, date
+):
+    """Sending a new motion event simulating a change on the window state"""
+    motion_event = Event(
+        EVENT_STATE_CHANGED,
+        {
+            "new_state": State(
+                entity_id=entity.entity_id,
+                state=STATE_ON if new_state else STATE_OFF,
+                last_changed=date,
+                last_updated=date,
+            ),
+            "old_state": State(
+                entity_id=entity.entity_id,
+                state=STATE_ON if old_state else STATE_OFF,
+                last_changed=date,
+                last_updated=date,
+            ),
+        },
+    )
+    ret = await entity._async_motion_changed(motion_event)
+    return ret
+
+
+async def send_presence_change_event(
+    entity: VersatileThermostat, new_state: bool, old_state: bool, date
+):
+    """Sending a new presence event simulating a change on the window state"""
+    presence_event = Event(
+        EVENT_STATE_CHANGED,
+        {
+            "new_state": State(
+                entity_id=entity.entity_id,
+                state=STATE_ON if new_state else STATE_OFF,
+                last_changed=date,
+                last_updated=date,
+            ),
+            "old_state": State(
+                entity_id=entity.entity_id,
+                state=STATE_ON if old_state else STATE_OFF,
+                last_changed=date,
+                last_updated=date,
+            ),
+        },
+    )
+    ret = await entity._async_presence_changed(presence_event)
+    return ret
+
+
+def get_tz(hass: HomeAssistant):
     """Get the current timezone"""
 
     return dt_util.get_time_zone(hass.config.time_zone)
@@ -269,3 +356,4 @@ async def send_climate_change_event(
         },
     )
     ret = await entity._async_climate_changed(climate_event)
+    return ret

custom_components/versatile_thermostat/tests/conftest.py

@@ -18,7 +18,7 @@ from unittest.mock import patch
 
 import pytest
 
-from homeassistant.core import HomeAssistant, StateMachine
+from homeassistant.core import StateMachine
 
 from custom_components.versatile_thermostat.config_flow import (
     VersatileThermostatBaseConfigFlow,
@@ -28,13 +28,14 @@ from custom_components.versatile_thermostat.climate import (
     VersatileThermostat,
 )
 
-pytest_plugins = "pytest_homeassistant_custom_component"
+pytest_plugins = "pytest_homeassistant_custom_component"  # pylint: disable=invalid-name
 
 
 # This fixture enables loading custom integrations in all tests.
 # Remove to enable selective use of this fixture
 @pytest.fixture(autouse=True)
 def auto_enable_custom_integrations(enable_custom_integrations):
+    """Enable all integration in tests"""
     yield
 
 
@@ -50,6 +51,17 @@ def skip_notifications_fixture():
         yield
 
 
+@pytest.fixture(name="skip_turn_on_off_heater")
+def skip_turn_on_off_heater():
+    """Skip turning on and off the heater"""
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+    ), patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+    ):
+        yield
+
+
 # This fixture is used to bypass the validate_input function in config_flow
 # NOT USED Now (keeped for memory)
 @pytest.fixture(name="skip_validate_input")

custom_components/versatile_thermostat/tests/test_binary_sensors.py

@@ -0,0 +1,503 @@
+""" Test the normal start of a Thermostat """
+from unittest.mock import patch
+from datetime import timedelta, datetime
+
+from homeassistant.core import HomeAssistant
+from homeassistant.components.climate import HVACMode
+
+from homeassistant.components.binary_sensor import BinarySensorDeviceClass
+
+from pytest_homeassistant_custom_component.common import MockConfigEntry
+
+from ..climate import VersatileThermostat
+from ..binary_sensor import (
+    SecurityBinarySensor,
+    OverpoweringBinarySensor,
+    WindowBinarySensor,
+    MotionBinarySensor,
+    PresenceBinarySensor,
+)
+
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+
+
+async def test_security_binary_sensors(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test the security binary sensors in thermostat type"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    security_binary_sensor: SecurityBinarySensor = search_entity(
+        hass, "binary_sensor.theoverswitchmockname_security_state", "binary_sensor"
+    )
+    assert security_binary_sensor
+
+    now: datetime = datetime.now(tz=get_tz(hass))
+
+    # Security should be disabled
+    await entity.async_set_preset_mode(PRESET_COMFORT)
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+
+    assert security_binary_sensor.state == STATE_OFF
+    assert security_binary_sensor.device_class == BinarySensorDeviceClass.SAFETY
+
+    # Set temperature in the past
+    event_timestamp = now - timedelta(minutes=6)
+
+    # set temperature to 15 so that on_percent will be > security_min_on_percent (0.2)
+    await send_temperature_change_event(entity, 15, event_timestamp)
+
+    assert entity.security_state is True
+    # Simulate the event reception
+    await security_binary_sensor.async_my_climate_changed()
+    assert security_binary_sensor.state == STATE_ON
+
+    # set temperature now
+    await send_temperature_change_event(entity, 15, now)
+    assert entity.security_state is False
+    # Simulate the event reception
+    await security_binary_sensor.async_my_climate_changed()
+    assert security_binary_sensor.state == STATE_OFF
+
+
+async def test_overpowering_binary_sensors(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test the overpowering binary sensors in thermostat type"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: True,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_POWER_SENSOR: "sensor.mock_power_sensor",
+            CONF_MAX_POWER_SENSOR: "sensor.mock_power_max_sensor",
+            CONF_DEVICE_POWER: 100,
+            CONF_PRESET_POWER: 12,
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    overpowering_binary_sensor: OverpoweringBinarySensor = search_entity(
+        hass, "binary_sensor.theoverswitchmockname_overpowering_state", "binary_sensor"
+    )
+    assert overpowering_binary_sensor
+
+    now: datetime = datetime.now(tz=get_tz(hass))
+
+    # Overpowering should be not set because poer have not been received
+    await entity.async_set_preset_mode(PRESET_COMFORT)
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    await send_temperature_change_event(entity, 15, now)
+    assert await entity.check_overpowering() is False
+    assert entity.overpowering_state is None
+
+    await overpowering_binary_sensor.async_my_climate_changed()
+    assert overpowering_binary_sensor.state is STATE_OFF
+    assert overpowering_binary_sensor.device_class == BinarySensorDeviceClass.POWER
+
+    await send_power_change_event(entity, 100, now)
+    await send_max_power_change_event(entity, 150, now)
+    assert await entity.check_overpowering() is True
+    assert entity.overpowering_state is True
+
+    # Simulate the event reception
+    await overpowering_binary_sensor.async_my_climate_changed()
+    assert overpowering_binary_sensor.state == STATE_ON
+
+    # set max power to a low value
+    await send_max_power_change_event(entity, 201, now)
+    assert await entity.check_overpowering() is False
+    assert entity.overpowering_state is False
+    # Simulate the event reception
+    await overpowering_binary_sensor.async_my_climate_changed()
+    assert overpowering_binary_sensor.state == STATE_OFF
+
+
+async def test_window_binary_sensors(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test the window binary sensors in thermostat type"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: True,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_WINDOW_SENSOR: "binary_sensor.mock_window_sensor",
+            CONF_WINDOW_DELAY: 0,  # important to not been obliged to wait
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    window_binary_sensor: WindowBinarySensor = search_entity(
+        hass, "binary_sensor.theoverswitchmockname_window_state", "binary_sensor"
+    )
+    assert window_binary_sensor
+
+    now: datetime = datetime.now(tz=get_tz(hass))
+
+    # Overpowering should be not set because poer have not been received
+    await entity.async_set_preset_mode(PRESET_COMFORT)
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    await send_temperature_change_event(entity, 15, now)
+    assert entity.window_state is None
+
+    await window_binary_sensor.async_my_climate_changed()
+    assert window_binary_sensor.state is STATE_OFF
+    assert window_binary_sensor.device_class == BinarySensorDeviceClass.WINDOW
+
+    # Open the window
+    with patch("homeassistant.helpers.condition.state", return_value=True):
+        try_window_condition = await send_window_change_event(entity, True, False, now)
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+
+    assert entity.window_state is STATE_ON
+
+    # Simulate the event reception
+    await window_binary_sensor.async_my_climate_changed()
+    assert window_binary_sensor.state == STATE_ON
+
+    # close the window
+    with patch("homeassistant.helpers.condition.state", return_value=True):
+        try_window_condition = await send_window_change_event(entity, False, True, now)
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+
+    assert entity.window_state is STATE_OFF
+
+    # Simulate the event reception
+    await window_binary_sensor.async_my_climate_changed()
+    assert window_binary_sensor.state == STATE_OFF
+
+
+async def test_motion_binary_sensors(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test the motion binary sensors in thermostat type"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: True,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_MOTION_SENSOR: "binary_sensor.mock_motion_sensor",
+            CONF_MOTION_DELAY: 0,  # important to not been obliged to wait
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    motion_binary_sensor: MotionBinarySensor = search_entity(
+        hass, "binary_sensor.theoverswitchmockname_motion_state", "binary_sensor"
+    )
+    assert motion_binary_sensor
+
+    now: datetime = datetime.now(tz=get_tz(hass))
+
+    # Overpowering should be not set because poer have not been received
+    await entity.async_set_preset_mode(PRESET_COMFORT)
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    await send_temperature_change_event(entity, 15, now)
+    assert entity.motion_state is None
+
+    await motion_binary_sensor.async_my_climate_changed()
+    assert motion_binary_sensor.state is STATE_OFF
+    assert motion_binary_sensor.device_class == BinarySensorDeviceClass.MOTION
+
+    # Detect motion
+    with patch("homeassistant.helpers.condition.state", return_value=True):
+        try_motion_condition = await send_motion_change_event(entity, True, False, now)
+        # simulate the call to try_window_condition
+        await try_motion_condition(None)
+
+    assert entity.motion_state is STATE_ON
+
+    # Simulate the event reception
+    await motion_binary_sensor.async_my_climate_changed()
+    assert motion_binary_sensor.state == STATE_ON
+
+    # Undetect motion
+    with patch("homeassistant.helpers.condition.state", return_value=True):
+        try_motion_condition = await send_motion_change_event(entity, False, True, now)
+        # simulate the call to try_motion_condition
+        await try_motion_condition(None)
+
+    assert entity.motion_state is STATE_OFF
+
+    # Simulate the event reception
+    await motion_binary_sensor.async_my_climate_changed()
+    assert motion_binary_sensor.state == STATE_OFF
+
+
+async def test_presence_binary_sensors(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test the presence binary sensors in thermostat type"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            "eco_away_temp": 12,
+            "comfort_away_temp": 13,
+            "boost_away_temp": 14,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: True,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_PRESENCE_SENSOR: "binary_sensor.mock_presence_sensor",
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    presence_binary_sensor: PresenceBinarySensor = search_entity(
+        hass, "binary_sensor.theoverswitchmockname_presence_state", "binary_sensor"
+    )
+    assert presence_binary_sensor
+
+    now: datetime = datetime.now(tz=get_tz(hass))
+
+    # Overpowering should be not set because poer have not been received
+    await entity.async_set_preset_mode(PRESET_COMFORT)
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    await send_temperature_change_event(entity, 15, now)
+    assert entity.presence_state is None
+
+    await presence_binary_sensor.async_my_climate_changed()
+    assert presence_binary_sensor.state is STATE_OFF
+    assert presence_binary_sensor.device_class == BinarySensorDeviceClass.PRESENCE
+
+    # Detect motion
+    await send_presence_change_event(entity, True, False, now)
+
+    assert entity.presence_state is STATE_ON
+
+    # Simulate the event reception
+    await presence_binary_sensor.async_my_climate_changed()
+    assert presence_binary_sensor.state == STATE_ON
+
+    # Undetect motion
+    await send_presence_change_event(entity, False, True, now)
+
+    assert entity.presence_state is STATE_OFF
+
+    # Simulate the event reception
+    await presence_binary_sensor.async_my_climate_changed()
+    assert presence_binary_sensor.state == STATE_OFF
+
+
+async def test_binary_sensors_over_climate_minimal(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test the binary sensors with thermostat over climate type"""
+
+    the_mock_underlying = MagicMockClimate()
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.find_underlying_climate",
+        return_value=the_mock_underlying,
+    ):
+        entry = MockConfigEntry(
+            domain=DOMAIN,
+            title="TheOverClimateMockName",
+            unique_id="uniqueId",
+            data={
+                CONF_NAME: "TheOverClimateMockName",
+                CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+                CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+                CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+                CONF_CYCLE_MIN: 5,
+                CONF_TEMP_MIN: 15,
+                CONF_TEMP_MAX: 30,
+                "eco_temp": 17,
+                "comfort_temp": 18,
+                "boost_temp": 19,
+                CONF_USE_WINDOW_FEATURE: False,
+                CONF_USE_MOTION_FEATURE: False,
+                CONF_USE_POWER_FEATURE: False,
+                CONF_USE_PRESENCE_FEATURE: False,
+                CONF_CLIMATE: "climate.mock_climate",
+                CONF_MINIMAL_ACTIVATION_DELAY: 30,
+                CONF_SECURITY_DELAY_MIN: 5,
+                CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            },
+        )
+
+        entity: VersatileThermostat = await create_thermostat(
+            hass, entry, "climate.theoverclimatemockname"
+        )
+        assert entity
+        assert entity.is_over_climate
+
+    security_binary_sensor: SecurityBinarySensor = search_entity(
+        hass, "binary_sensor.theoverclimatemockname_security_state", "binary_sensor"
+    )
+    assert security_binary_sensor is not None
+
+    overpowering_binary_sensor: OverpoweringBinarySensor = search_entity(
+        hass, "binary_sensor.theoverclimatemockname_overpowering_state", "binary_sensor"
+    )
+    assert overpowering_binary_sensor is None
+
+    window_binary_sensor: WindowBinarySensor = search_entity(
+        hass, "binary_sensor.theoverclimatemockname_window_state", "binary_sensor"
+    )
+    assert window_binary_sensor is None
+
+    motion_binary_sensor: MotionBinarySensor = search_entity(
+        hass, "binary_sensor.theoverclimatemockname_motion_state", "binary_sensor"
+    )
+    assert motion_binary_sensor is None
+
+    presence_binary_sensor: PresenceBinarySensor = search_entity(
+        hass, "binary_sensor.theoverclimatemockname_presence_state", "binary_sensor"
+    )
+    assert presence_binary_sensor is None

custom_components/versatile_thermostat/tests/test_config_flow.py

@@ -4,11 +4,7 @@ from homeassistant import data_entry_flow
 from homeassistant.core import HomeAssistant
 from homeassistant.config_entries import SOURCE_USER, ConfigEntry
 
-import pytest
-from pytest_homeassistant_custom_component.common import MockConfigEntry, load_fixture
-
 from custom_components.versatile_thermostat.const import DOMAIN
-from custom_components.versatile_thermostat import VersatileThermostatAPI
 
 from .const import (
     MOCK_TH_OVER_SWITCH_USER_CONFIG,
@@ -41,7 +37,7 @@ async def test_show_form(hass: HomeAssistant) -> None:
     assert result["step_id"] == SOURCE_USER
 
 
-async def test_user_config_flow_over_switch(hass, skip_hass_states_get):
+async def test_user_config_flow_over_switch(hass: HomeAssistant, skip_hass_states_get):
     """Test the config flow with all thermostat_over_switch features"""
     result = await hass.config_entries.flow.async_init(
         DOMAIN, context={"source": SOURCE_USER}
@@ -138,7 +134,7 @@ async def test_user_config_flow_over_switch(hass, skip_hass_states_get):
     assert isinstance(result["result"], ConfigEntry)
 
 
-async def test_user_config_flow_over_climate(hass, skip_hass_states_get):
+async def test_user_config_flow_over_climate(hass: HomeAssistant, skip_hass_states_get):
     """Test the config flow with all thermostat_over_climate features and no additional features"""
     result = await hass.config_entries.flow.async_init(
         DOMAIN, context={"source": SOURCE_USER}

custom_components/versatile_thermostat/tests/test_open_window_algo.py

@@ -0,0 +1,134 @@
+""" Test the OpenWindow algorithm """
+
+from datetime import datetime, timedelta
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from ..open_window_algorithm import WindowOpenDetectionAlgorithm
+
+
+async def test_open_window_algo(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+):
+    """Tests the Algo"""
+
+    the_algo = WindowOpenDetectionAlgorithm(1.0, 0.0)
+    assert the_algo.last_slope is None
+
+    tz = get_tz(hass)
+    now = datetime.now(tz)
+
+    event_timestamp = now - timedelta(minutes=5)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=10, datetime_measure=event_timestamp
+    )
+
+    # We need at least 2 measurement
+    assert last_slope is None
+    assert the_algo.last_slope is None
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is False
+
+    event_timestamp = now - timedelta(minutes=4)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=10, datetime_measure=event_timestamp
+    )
+
+    # No slope because same temperature
+    assert last_slope == 0
+    assert the_algo.last_slope == 0
+    assert the_algo.is_window_close_detected() is True
+    assert the_algo.is_window_open_detected() is False
+
+    event_timestamp = now - timedelta(minutes=3)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=9, datetime_measure=event_timestamp
+    )
+
+    # A slope is calculated
+    assert last_slope == -0.5
+    assert the_algo.last_slope == -0.5
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is False
+
+    # A new temperature with 2 degre less
+    event_timestamp = now - timedelta(minutes=2)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=7, datetime_measure=event_timestamp
+    )
+
+    # A slope is calculated
+    assert last_slope == -0.5 / 2.0 - 2.0 / 2.0
+    assert the_algo.last_slope == -1.25
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is True
+
+    # A new temperature with 1 degre less
+    event_timestamp = now - timedelta(minutes=1)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=6, datetime_measure=event_timestamp
+    )
+
+    # A slope is calculated
+    assert last_slope == -1.25 / 2 - 1.0 / 2.0
+    assert the_algo.last_slope == -1.125
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is True
+
+    # A new temperature with 0 degre less
+    event_timestamp = now - timedelta(minutes=0)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=6, datetime_measure=event_timestamp
+    )
+
+    # A slope is calculated
+    assert last_slope == -1.125 / 2
+    assert the_algo.last_slope == -1.125 / 2
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is False
+
+    # A new temperature with 1 degre more
+    event_timestamp = now + timedelta(minutes=1)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=7, datetime_measure=event_timestamp
+    )
+
+    # A slope is calculated
+    assert last_slope == -1.125 / 4 + 0.5
+    assert the_algo.last_slope == 0.21875
+    assert the_algo.is_window_close_detected() is True
+    assert the_algo.is_window_open_detected() is False
+
+
+async def test_open_window_algo_wrong(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+):
+    """Tests the Algo with wrong date"""
+    the_algo = WindowOpenDetectionAlgorithm(1.0, 0.0)
+    assert the_algo.last_slope is None
+
+    tz = get_tz(hass)
+    now = datetime.now(tz)
+
+    event_timestamp = now - timedelta(minutes=5)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=10, datetime_measure=event_timestamp
+    )
+
+    # We need at least 2 measurement
+    assert last_slope is None
+    assert the_algo.last_slope is None
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is False
+
+    # The next datetime_measurement cannot be in the past
+    event_timestamp = now - timedelta(minutes=6)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=18, datetime_measure=event_timestamp
+    )
+
+    # No slope because same temperature
+    assert last_slope is None
+    assert the_algo.last_slope is None
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is False

custom_components/versatile_thermostat/tests/test_power.py

@@ -1,5 +1,5 @@
 """ Test the Power management """
-from unittest.mock import patch, call, MagicMock
+from unittest.mock import patch, call
 from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
 from datetime import datetime, timedelta
 
@@ -44,7 +44,7 @@ async def test_power_management_hvac_off(
             CONF_POWER_SENSOR: "sensor.mock_power_sensor",
             CONF_MAX_POWER_SENSOR: "sensor.mock_power_max_sensor",
             CONF_DEVICE_POWER: 100,
-            CONF_PRESET_POWER: "eco",
+            CONF_PRESET_POWER: 12,
         },
     )
 
@@ -394,7 +394,7 @@ async def test_power_management_energy_over_climate(
             hass, entry, "climate.theoverclimatemockname"
         )
         assert entity
-        assert entity._is_over_climate
+        assert entity.is_over_climate
 
     now = datetime.now(tz=get_tz(hass))
     await send_temperature_change_event(entity, 15, now)

custom_components/versatile_thermostat/tests/test_security.py

@@ -19,7 +19,7 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
     6. check that security is off and preset is changed to boost
     """
 
-    tz = get_tz(hass)
+    tz = get_tz(hass)  # pylint: disable=invalid-name
 
     entry = MockConfigEntry(
         domain=DOMAIN,
@@ -93,7 +93,7 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
 
         # set temperature to 15 so that on_percent will be > security_min_on_percent (0.2)
         await send_temperature_change_event(entity, 15, event_timestamp)
-        assert entity._security_state is True
+        assert entity.security_state is True
         assert entity.preset_mode == PRESET_SECURITY
         assert entity._saved_preset_mode == PRESET_COMFORT
         assert entity._prop_algorithm.on_percent == 0.1

custom_components/versatile_thermostat/tests/test_sensors.py

@@ -0,0 +1,375 @@
+""" Test the normal start of a Thermostat """
+from datetime import timedelta, datetime
+
+from homeassistant.core import HomeAssistant
+from homeassistant.components.climate import HVACMode
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorStateClass,
+)
+from homeassistant.const import UnitOfTime, UnitOfPower, UnitOfEnergy, PERCENTAGE
+
+from pytest_homeassistant_custom_component.common import MockConfigEntry
+
+from ..climate import VersatileThermostat
+from ..sensor import (
+    EnergySensor,
+    MeanPowerSensor,
+    OnPercentSensor,
+    OnTimeSensor,
+    OffTimeSensor,
+    LastTemperatureSensor,
+    LastExtTemperatureSensor,
+)
+
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+
+
+async def test_sensors_over_switch(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test the sensors with a thermostat avec switch type"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_DEVICE_POWER: 200,
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    energy_sensor: EnergySensor = search_entity(
+        hass, "sensor.theoverswitchmockname_energy", "sensor"
+    )
+    assert energy_sensor
+
+    mean_power_sensor: MeanPowerSensor = search_entity(
+        hass, "sensor.theoverswitchmockname_mean_power_cycle", "sensor"
+    )
+    assert mean_power_sensor
+
+    on_percent_sensor: OnPercentSensor = search_entity(
+        hass, "sensor.theoverswitchmockname_power_percent", "sensor"
+    )
+    assert on_percent_sensor
+
+    on_time_sensor: OnTimeSensor = search_entity(
+        hass, "sensor.theoverswitchmockname_on_time", "sensor"
+    )
+    assert on_time_sensor
+
+    off_time_sensor: OffTimeSensor = search_entity(
+        hass, "sensor.theoverswitchmockname_off_time", "sensor"
+    )
+    assert off_time_sensor
+
+    last_temperature_sensor: LastTemperatureSensor = search_entity(
+        hass, "sensor.theoverswitchmockname_last_temperature_date", "sensor"
+    )
+    assert last_temperature_sensor
+
+    last_ext_temperature_sensor: LastExtTemperatureSensor = search_entity(
+        hass, "sensor.theoverswitchmockname_last_external_temperature_date", "sensor"
+    )
+    assert last_ext_temperature_sensor
+
+    # Simulate the event reception
+    await energy_sensor.async_my_climate_changed()
+    assert energy_sensor.state == 0.0
+    await mean_power_sensor.async_my_climate_changed()
+    assert mean_power_sensor.state == 0.0
+    await on_percent_sensor.async_my_climate_changed()
+    assert on_percent_sensor.state == 0.0
+    await on_time_sensor.async_my_climate_changed()
+    assert on_time_sensor.state == 0.0
+    await off_time_sensor.async_my_climate_changed()
+    assert off_time_sensor.state == 300.0
+    await last_temperature_sensor.async_my_climate_changed()
+    assert last_temperature_sensor.state is not None
+    await last_ext_temperature_sensor.async_my_climate_changed()
+    assert last_ext_temperature_sensor.state is not None
+
+    last_temp_date = last_temperature_sensor.state
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    event_timestamp = now - timedelta(minutes=1)
+
+    # Start the heater to get some values
+    await entity.async_set_preset_mode(PRESET_COMFORT)
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    await send_temperature_change_event(entity, 15, event_timestamp)
+    await send_ext_temperature_change_event(entity, 5, event_timestamp)
+
+    entity.incremente_energy()
+
+    await energy_sensor.async_my_climate_changed()
+    assert energy_sensor.state == 16.667
+    assert energy_sensor.device_class == SensorDeviceClass.ENERGY
+    assert energy_sensor.state_class == SensorStateClass.TOTAL_INCREASING
+    # because device_power is 200
+    assert energy_sensor.unit_of_measurement == UnitOfEnergy.WATT_HOUR
+
+    await mean_power_sensor.async_my_climate_changed()
+    assert mean_power_sensor.state == 200.0
+    assert mean_power_sensor.device_class == SensorDeviceClass.POWER
+    assert mean_power_sensor.state_class == SensorStateClass.MEASUREMENT
+    # because device_power is 200
+    assert mean_power_sensor.unit_of_measurement == UnitOfPower.WATT
+
+    await on_percent_sensor.async_my_climate_changed()
+    assert on_percent_sensor.state == 100.0
+    assert on_percent_sensor.unit_of_measurement == PERCENTAGE
+
+    await on_time_sensor.async_my_climate_changed()
+    assert on_time_sensor.state == 300.0
+    assert on_time_sensor.device_class == SensorDeviceClass.DURATION
+    assert on_time_sensor.state_class == SensorStateClass.MEASUREMENT
+    assert on_time_sensor.unit_of_measurement == UnitOfTime.SECONDS
+
+    await off_time_sensor.async_my_climate_changed()
+    assert off_time_sensor.state == 0.0
+    assert off_time_sensor.device_class == SensorDeviceClass.DURATION
+    assert off_time_sensor.state_class == SensorStateClass.MEASUREMENT
+    assert off_time_sensor.unit_of_measurement == UnitOfTime.SECONDS
+
+    await last_temperature_sensor.async_my_climate_changed()
+    assert (
+        last_temperature_sensor.state is not None
+        and last_temperature_sensor.state != last_temp_date
+    )
+    assert last_temperature_sensor.device_class == SensorDeviceClass.TIMESTAMP
+
+    await last_ext_temperature_sensor.async_my_climate_changed()
+    assert (
+        last_ext_temperature_sensor.state is not None
+        and last_ext_temperature_sensor.state != last_temp_date
+    )
+    assert last_ext_temperature_sensor.device_class == SensorDeviceClass.TIMESTAMP
+
+
+async def test_sensors_over_climate(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test the sensors with thermostat over climate type"""
+
+    the_mock_underlying = MagicMockClimate()
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.find_underlying_climate",
+        return_value=the_mock_underlying,
+    ):
+        entry = MockConfigEntry(
+            domain=DOMAIN,
+            title="TheOverClimateMockName",
+            unique_id="uniqueId",
+            data={
+                CONF_NAME: "TheOverClimateMockName",
+                CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+                CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+                CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+                CONF_CYCLE_MIN: 5,
+                CONF_TEMP_MIN: 15,
+                CONF_TEMP_MAX: 30,
+                "eco_temp": 17,
+                "comfort_temp": 18,
+                "boost_temp": 19,
+                CONF_USE_WINDOW_FEATURE: False,
+                CONF_USE_MOTION_FEATURE: False,
+                CONF_USE_POWER_FEATURE: True,
+                CONF_USE_PRESENCE_FEATURE: False,
+                CONF_CLIMATE: "climate.mock_climate",
+                CONF_MINIMAL_ACTIVATION_DELAY: 30,
+                CONF_SECURITY_DELAY_MIN: 5,
+                CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+                CONF_POWER_SENSOR: "sensor.mock_power_sensor",
+                CONF_MAX_POWER_SENSOR: "sensor.mock_power_max_sensor",
+                CONF_DEVICE_POWER: 1.5,
+                CONF_PRESET_POWER: 12,
+            },
+        )
+
+        entity: VersatileThermostat = await create_thermostat(
+            hass, entry, "climate.theoverclimatemockname"
+        )
+        assert entity
+        assert entity.is_over_climate
+
+    energy_sensor: EnergySensor = search_entity(
+        hass, "sensor.theoverclimatemockname_energy", "sensor"
+    )
+    assert energy_sensor
+
+    last_temperature_sensor: LastTemperatureSensor = search_entity(
+        hass, "sensor.theoverclimatemockname_last_temperature_date", "sensor"
+    )
+    assert last_temperature_sensor
+
+    last_ext_temperature_sensor: LastExtTemperatureSensor = search_entity(
+        hass, "sensor.theoverclimatemockname_last_external_temperature_date", "sensor"
+    )
+    assert last_ext_temperature_sensor
+
+    # Simulate the event reception
+    await energy_sensor.async_my_climate_changed()
+    assert energy_sensor.state == 0.0
+    await last_temperature_sensor.async_my_climate_changed()
+    assert last_temperature_sensor.state is not None
+    await last_ext_temperature_sensor.async_my_climate_changed()
+    assert last_ext_temperature_sensor.state is not None
+
+    last_temp_date = last_temperature_sensor.state
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    event_timestamp = now - timedelta(minutes=1)
+
+    # Start the heater to get some values
+    await entity.async_set_preset_mode(PRESET_COMFORT)
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    await send_temperature_change_event(entity, 15, event_timestamp)
+    await send_ext_temperature_change_event(entity, 5, event_timestamp)
+
+    # to add energy we must have HVACAction underlying climate event
+    # Send a climate_change event with HVACAction=HEATING
+    event_timestamp = now - timedelta(minutes=60)
+    await send_climate_change_event(
+        entity,
+        new_hvac_mode=HVACMode.HEAT,
+        old_hvac_mode=HVACMode.HEAT,
+        new_hvac_action=HVACAction.HEATING,
+        old_hvac_action=HVACAction.OFF,
+        date=event_timestamp,
+    )
+
+    # Send a climate_change event with HVACAction=IDLE (end of heating)
+    await send_climate_change_event(
+        entity,
+        new_hvac_mode=HVACMode.HEAT,
+        old_hvac_mode=HVACMode.HEAT,
+        new_hvac_action=HVACAction.IDLE,
+        old_hvac_action=HVACAction.HEATING,
+        date=now,
+    )
+
+    # 60 minutes heating with 1.5 kW heating -> 1.5 kWh
+    await energy_sensor.async_my_climate_changed()
+    assert energy_sensor.state == 1.5
+    assert energy_sensor.device_class == SensorDeviceClass.ENERGY
+    assert energy_sensor.state_class == SensorStateClass.TOTAL_INCREASING
+    # because device_power is 1.5 kW
+    assert energy_sensor.unit_of_measurement == UnitOfEnergy.KILO_WATT_HOUR
+
+    entity.incremente_energy()
+    await energy_sensor.async_my_climate_changed()
+    assert energy_sensor.state == 3.0
+
+    await last_temperature_sensor.async_my_climate_changed()
+    assert (
+        last_temperature_sensor.state is not None
+        and last_temperature_sensor.state != last_temp_date
+    )
+    assert last_temperature_sensor.device_class == SensorDeviceClass.TIMESTAMP
+
+    await last_ext_temperature_sensor.async_my_climate_changed()
+    assert (
+        last_ext_temperature_sensor.state is not None
+        and last_ext_temperature_sensor.state != last_temp_date
+    )
+    assert last_ext_temperature_sensor.device_class == SensorDeviceClass.TIMESTAMP
+
+
+async def test_sensors_over_climate_minimal(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test the sensors with thermostat over climate type"""
+
+    the_mock_underlying = MagicMockClimate()
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.find_underlying_climate",
+        return_value=the_mock_underlying,
+    ):
+        entry = MockConfigEntry(
+            domain=DOMAIN,
+            title="TheOverClimateMockName",
+            unique_id="uniqueId",
+            data={
+                CONF_NAME: "TheOverClimateMockName",
+                CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+                CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+                CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+                CONF_CYCLE_MIN: 5,
+                CONF_TEMP_MIN: 15,
+                CONF_TEMP_MAX: 30,
+                "eco_temp": 17,
+                "comfort_temp": 18,
+                "boost_temp": 19,
+                CONF_USE_WINDOW_FEATURE: False,
+                CONF_USE_MOTION_FEATURE: False,
+                CONF_USE_POWER_FEATURE: False,
+                CONF_USE_PRESENCE_FEATURE: False,
+                CONF_CLIMATE: "climate.mock_climate",
+                CONF_MINIMAL_ACTIVATION_DELAY: 30,
+                CONF_SECURITY_DELAY_MIN: 5,
+                CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            },
+        )
+
+        entity: VersatileThermostat = await create_thermostat(
+            hass, entry, "climate.theoverclimatemockname"
+        )
+        assert entity
+        assert entity.is_over_climate
+
+    energy_sensor: EnergySensor = search_entity(
+        hass, "sensor.theoverclimatemockname_energy", "sensor"
+    )
+    assert energy_sensor is None
+
+    last_temperature_sensor: LastTemperatureSensor = search_entity(
+        hass, "sensor.theoverclimatemockname_last_temperature_date", "sensor"
+    )
+    assert last_temperature_sensor
+
+    last_ext_temperature_sensor: LastExtTemperatureSensor = search_entity(
+        hass, "sensor.theoverclimatemockname_last_external_temperature_date", "sensor"
+    )
+    assert last_ext_temperature_sensor

custom_components/versatile_thermostat/tests/test_start.py

@@ -12,7 +12,7 @@ from pytest_homeassistant_custom_component.common import MockConfigEntry
 
 from ..climate import VersatileThermostat
 
-from .commons import *
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
 
 
 async def test_over_switch_full_start(hass: HomeAssistant, skip_hass_states_is_state):

custom_components/versatile_thermostat/tests/test_window.py

@@ -2,7 +2,6 @@
 from unittest.mock import patch, call
 from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
 from datetime import datetime
-import time
 
 import logging
 

custom_components/versatile_thermostat/translations/en.json

@@ -49,10 +49,19 @@
       },
       "window": {
         "title": "Window management",
-        "description": "Open window management.\nLeave corresponding entity_id empty if not used.",
+        "description": "Open window management.\nLeave corresponding entity_id empty if not used\nYou can also configure automatic window open detection based on temperature decrease",
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
-          "window_delay": "Window delay (seconds)"
+          "window_delay": "Window sensor delay (seconds)",
+          "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/min)",
+          "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/min)",
+          "window_auto_max_duration": "Maximum duration of automatic window open detection (in min)"
+        },
+        "data_description": {
+          "window_sensor_entity_id": "Leave empty if no window sensor should be use",
+          "window_auto_open_threshold": "Recommended value: 0.5. Leave empty if automatic window open detection is not use",
+          "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not use",
+          "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not use"
         }
       },
       "motion": {
@@ -97,7 +106,8 @@
     },
     "error": {
       "unknown": "Unexpected error",
-      "unknown_entity": "Unknown entity id"
+      "unknown_entity": "Unknown entity id",
+      "window_open_detection_method": "Only one window open detection method should be used. Use sensor or automatic detection through temperature threshold but not both"
     },
     "abort": {
       "already_configured": "Device is already configured"
@@ -151,11 +161,20 @@
         }
       },
       "window": {
-        "title": "Window management",
-        "description": "Open window management.\nLeave corresponding entity_id empty if not used.",
+        "title": "[%key:component::versatile_thermostat::config::step::window::title%]",
+        "description": "[%key:component::versatile_thermostat::config::step::window::description%]",
         "data": {
-          "window_sensor_entity_id": "Window sensor entity id",
-          "window_delay": "Window delay (seconds)"
+          "window_sensor_entity_id": "[%key:component::versatile_thermostat::config::step::window::data::window_sensor_entity_id%]",
+          "window_delay": "[%key:component::versatile_thermostat::config::step::window::data::window_delay%]",
+          "window_auto_open_threshold": "[%key:component::versatile_thermostat::config::step::window::data::window_auto_open_threshold%]",
+          "window_auto_close_threshold": "[%key:component::versatile_thermostat::config::step::window::data::window_auto_close_threshold%]",
+          "window_auto_max_duration": "[%key:component::versatile_thermostat::config::step::window::data::window_auto_max_duration%]"
+        },
+        "data_description": {
+          "window_sensor_entity_id": "[%key:component::versatile_thermostat::config::step::window::data_description::window_sensor_entity_id%]",
+          "window_auto_open_threshold": "[%key:component::versatile_thermostat::config::step::window::data_description::window_auto_open_threshold%]",
+          "window_auto_close_threshold": "[%key:component::versatile_thermostat::config::step::window::data_description::window_auto_close_threshold%]",
+          "window_auto_max_duration": "[%key:component::versatile_thermostat::config::step::window::data_description::window_auto_max_duration%]"
         }
       },
       "motion": {
@@ -192,18 +211,19 @@
         "description": "Configuration of advanced parameters. Leave the default values if you don't know what you are doing.\nThis parameters can lead to a very bad temperature or power regulation.",
         "data": {
           "minimal_activation_delay": "Delay in secondes under which the equipment will not be activated",
-          "security_delay_min": "Maximum allowed delay in minutes between two temperature mesures. Above this delay, the thermostat will turn to a sceurity off state",
+          "security_delay_min": "Maximum allowed delay in minutes between two temperature mesures. Above this delay, the thermostat will turn to a security off state",
           "security_min_on_percent": "Minimal heating percent value for security preset activation. Below this amount of on_percent the thermostat won't go into security preset",
           "security_default_on_percent": "The default heating percent value in security preset. Set to 0 to switch off heater in security present"
         }
       }
     },
     "error": {
-      "unknown": "Unexpected error",
-      "unknown_entity": "Unknown entity id"
+      "unknown": "[%key:component::versatile_thermostat::config::error::unknown%]",
+      "unknown_entity": "[%key:component::versatile_thermostat::config::error::unknown_entity%]",
+      "window_open_detection_method": "[%key:component::versatile_thermostat::config::error::window_open_detection_method%]"
     },
     "abort": {
-      "already_configured": "Device is already configured"
+      "already_configured": "[%key:component::versatile_thermostat::config::abort::already_configured%]"
     }
   },
   "selector": {

custom_components/versatile_thermostat/translations/fr.json

@@ -50,8 +50,17 @@
         "title": "Gestion d'une ouverture",
         "description": "Coupe le radiateur si l'ouverture est ouverte.\nLaissez l'entity id vide si non utilisé.",
         "data": {
-          "window_sensor_entity_id": "Ouverture sensor entity id",
-          "window_delay": "Délai avant extinction (seconds)"
+          "window_sensor_entity_id": "Détecteur d'ouverture (entity id)",
+          "window_delay": "Délai avant extinction (seconds)",
+          "window_auto_open_threshold": "seuil haut de chute de température pour la détection automatique (en °/min)",
+          "window_auto_close_threshold": "Seuil bas de chute de température pour la fin de détection automatique (en °/min)",
+          "window_auto_max_duration": "Durée maximum d'une extinction automatique (en min)"
+        },
+        "data_description": {
+          "window_sensor_entity_id": "Laissez vide si vous n'avez de détecteur",
+          "window_auto_open_threshold": "Valeur recommandée: 0.5. Laissez vide si vous n'utilisez pas la détection automatique",
+          "window_auto_close_threshold": "Valeur recommandée: 0. Laissez vide si vous n'utilisez pas la détection automatique",
+          "window_auto_max_duration": "Valeur recommandée: 60 (1 heure). Laissez vide si vous n'utilisez pas la détection automatique"
         }
       },
       "motion": {
@@ -96,7 +105,8 @@
     },
     "error": {
       "unknown": "Erreur inattendue",
-      "unknown_entity": "entity id inconnu"
+      "unknown_entity": "entity id inconnu",
+      "window_open_detection_method": "Une seule méthode de détection des ouvertures ouvertes doit être utilisée. Utilisez le détecteur d'ouverture ou les seuils de température mais pas les deux."
     },
     "abort": {
       "already_configured": "Le device est déjà configuré"
@@ -151,11 +161,20 @@
         }
       },
       "window": {
-        "title": "Gestion d'une ouverture",
-        "description": "Coupe le radiateur si l'ouverture est ouverte.\nLaissez l'entity id vide si non utilisé.",
+        "title": "[%key:component::versatile_thermostat::config::step::window::title%]",
+        "description": "[%key:component::versatile_thermostat::config::step::window::description%]",
         "data": {
-          "window_sensor_entity_id": "Ouverture sensor entity id",
-          "window_delay": "Délai avant extinction (seconds)"
+          "window_sensor_entity_id": "[%key:component::versatile_thermostat::config::step::window::data::window_sensor_entity_id%]",
+          "window_delay": "[%key:component::versatile_thermostat::config::step::window::data::window_delay%]",
+          "window_auto_open_threshold": "[%key:component::versatile_thermostat::config::step::window::data::window_auto_open_threshold%]",
+          "window_auto_close_threshold": "[%key:component::versatile_thermostat::config::step::window::data::window_auto_close_threshold%]",
+          "window_auto_max_duration": "[%key:component::versatile_thermostat::config::step::window::data::window_auto_max_duration%]"
+        },
+        "data_description": {
+          "window_sensor_entity_id": "[%key:component::versatile_thermostat::config::step::window::data_description::window_sensor_entity_id%]",
+          "window_auto_open_threshold": "[%key:component::versatile_thermostat::config::step::window::data_description::window_auto_open_threshold%]",
+          "window_auto_close_threshold": "[%key:component::versatile_thermostat::config::step::window::data_description::window_auto_close_threshold%]",
+          "window_auto_max_duration": "[%key:component::versatile_thermostat::config::step::window::data_description::window_auto_max_duration%]"
         }
       },
       "motion": {
@@ -199,11 +218,12 @@
       }
     },
     "error": {
-      "unknown": "Erreur inattendue",
-      "unknown_entity": "entity id inconnu"
+      "unknown": "[%key:component::versatile_thermostat::config::error::unknown%]",
+      "unknown_entity": "[%key:component::versatile_thermostat::config::error::unknown_entity%]",
+      "window_open_detection_method": "[%key:component::versatile_thermostat::config::error::window_open_detection_method%]"
     },
     "abort": {
-      "already_configured": "Le device est déjà configuré"
+      "already_configured": "[%key:component::versatile_thermostat::config::abort::already_configured%]"
     }
   },
   "selector": {