Add _entity_component_unrecorded_attributes to exclude attributes from record

2023-10-28 18:04:51 +02:00
33 changed files with 628 additions and 2522 deletions
--- a/.devcontainer/configuration.yaml
+++ b/.devcontainer/configuration.yaml
@@ -219,4 +219,3 @@ frontend:
            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"
-            state-binary_sensor-running-on-color: "orange"
--- a/README-fr.md
+++ b/README-fr.md
@@ -59,7 +59,7 @@ Ce composant personnalisé pour Home Assistant est une mise à niveau et est une


 > ![Nouveau](https://github.com/jmcollin78/versatile_thermostat/blob/main/images/new-icon.png?raw=true) _*Nouveautés*_
-> * **Release 3.7**: Ajout du type de Versatile Thermostat `over valve` pour piloter une vanne TRV directement ou tout autre équipement type gradateur pour le chauffage. La régulation se fait alors directement en agissant sur le pourcentage d'ouverture de l'entité sous-jacente : 0 la vanne est coupée, 100 : la vanne est ouverte à fond. Cf. [#131](https://github.com/jmcollin78/versatile_thermostat/issues/131). Ajout d'une fonction permettant le bypass de la détection d'ouverture [#138](https://github.com/jmcollin78/versatile_thermostat/issues/138). Ajout de la langue Slovaque
+> * **Release 3.7**: Ajout du type de Versatile Thermostat `over valve` pour piloter une vanne TRV directement ou tout autre équipement type gradateur pour le chauffage. La régulation se fait alors directement en agissant sur le pourcentage d'ouverture de l'entité sous-jacente : 0 la vanne est coupée, 100 : la vanne est ouverte à fond. Cf. [#131](https://github.com/jmcollin78/versatile_thermostat/issues/131)
 > * **Release 3.6**: Ajout du paramètre `motion_off_delay` pour améliorer la gestion de des mouvements [#116](https://github.com/jmcollin78/versatile_thermostat/issues/116), [#128](https://github.com/jmcollin78/versatile_thermostat/issues/128). Ajout du mode AC (air conditionné) pour un VTherm over switch. Préparation du projet Github pour faciliter les contributions [#127](https://github.com/jmcollin78/versatile_thermostat/issues/127)
 > * **Release 3.5**: Plusieurs thermostats sont possibles en "thermostat over climate" mode [#113](https://github.com/jmcollin78/versatile_thermostat/issues/113)
 > * **Release 3.4**: bug fix et exposition des preset temperatures pour le mode AC [#103](https://github.com/jmcollin78/versatile_thermostat/issues/103)
@@ -76,7 +76,7 @@ Ce composant personnalisé pour Home Assistant est une mise à niveau et est une
 </details>

 # Merci pour la bière [buymecoffee](https://www.buymeacoffee.com/jmcollin78)
-Un grand merci à @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome pour les bières. Ca fait très plaisir.
+Un grand merci à @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69 pour les bières. Ca fait très plaisir.


 # Quand l'utiliser et ne pas l'utiliser
@@ -518,7 +518,6 @@ frontend:
      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"
-      state-binary_sensor-running-on-color: "orange"
 ```
 et choisissez le thème ```versatile_thermostat_theme``` dans la configuration du panel. Vous obtiendrez quelque-chose qui va ressembler à ça :

@@ -533,7 +532,7 @@ Ce service permet de forcer l'état de présence indépendamment du capteur de p

 Le code pour appeler ce service est le suivant :
 ```
-service : versatile_thermostat.set_presence
+service : thermostat_polyvalent.set_presence
 Les données:
    présence : "off"
 cible:
@@ -548,7 +547,7 @@ Vous pouvez modifier l'une ou les deux températures (lorsqu'elles sont présent

 Utilisez le code suivant pour régler la température du préréglage :
 ```
-service : versatile_thermostat.set_preset_temperature
+service : thermostat_polyvalent.set_preset_temperature
 date:
    preset : boost
    temperature : 17,8
@@ -577,8 +576,8 @@ Si le thermostat est en mode ``security`` les nouveaux paramètres sont appliqu

 Pour changer les paramètres de sécurité utilisez le code suivant :
 ```
-service : versatile_thermostat.set_security
-data:
+service : thermostat_polyvalent.set_security
+date:
    min_on_percent: "0.5"
    default_on_percent: "0.1"
    delay_min: 60
@@ -586,20 +585,6 @@ target:
    entity_id : climate.my_thermostat
 ```

-## ByPass Window Check
-Ce service permet d'activer ou non un bypass de la vérification des fenetres.
-Il permet de continuer à chauffer même si la fenetre est detectée ouverte.
-Mis à ``true`` les modifications de status de la fenetre n'auront plus d'effet sur le thermostat, remis à ``false`` cela s'assurera de désactiver le thermostat si la fenetre est toujours ouverte.
-
-Pour changer le paramètre de bypass utilisez le code suivant :
-```
-service : versatile_thermostat.set_window_bypass
-data:
-    window_bypass: true
-target:
-    entity_id : climate.my_thermostat
-```
-
 # Notifications
 Les évènements marquant du thermostat sont notifiés par l'intermédiaire du bus de message.
 Les évènements notifiés sont les suivants:
@@ -639,26 +624,25 @@ Les attributs personnalisés sont les suivants :
 | ``[eco/confort/boost]_temp`` | La température configurée pour le préréglage xxx |
 | ``[eco/confort/boost]_away_temp`` | La température configurée pour le préréglage xxx lorsque la présence est désactivée ou not_home |
 | ``temp_power`` | La température utilisée lors de la détection de la perte |
-| ``on_percent`` | Le pourcentage sur calculé par l'algorithme TPI |
-| ``on_time_sec`` | La période On en sec. Doit être ```on_percent * cycle_min``` |
-| ``off_time_sec`` | La période d'arrêt en sec. Doit être ```(1 - on_percent) * cycle_min``` |
+| ``on_percent`` | (déprécié) Le pourcentage sur calculé par l'algorithme TPI |
+| ``on_time_sec`` | (déprécié) La période On en sec. Doit être ```on_percent * cycle_min``` |
+| ``off_time_sec`` | (déprécié) La période d'arrêt en sec. Doit être ```(1 - on_percent) * cycle_min``` |
 | ``cycle_min`` | Le cycle de calcul en minutes |
 | ``function`` | L'algorithme utilisé pour le calcul du cycle |
 | ``tpi_coef_int`` | Le ``coef_int`` de l'algorithme TPI |
 | ``tpi_coef_ext`` | Le ``coef_ext`` de l'algorithme TPI |
 | ``saved_preset_mode`` | Le dernier preset utilisé avant le basculement automatique du preset |
 | ``saved_target_temp`` | La dernière température utilisée avant la commutation automatique |
-| ``window_state`` | Le dernier état connu du capteur de fenêtre. Aucun si la fenêtre n'est pas configurée |
-| ``window_bypass_state`` | True si le bypass de la détection d'ouverture et activé |
-| ``motion_state`` | Le dernier état connu du capteur de mouvement. Aucun si le mouvement n'est pas configuré |
-| ``overpowering_state`` | Le dernier état connu du capteur surpuissant. Aucun si la gestion de l'alimentation n'est pas configurée |
-| ``presence_state`` | Le dernier état connu du capteur de présence. Aucun si la gestion de présence n'est pas configurée |
+| ``window_state`` | (déprécié) Le dernier état connu du capteur de fenêtre. Aucun si la fenêtre n'est pas configurée |
+| ``motion_state`` | (déprécié) Le dernier état connu du capteur de mouvement. Aucun si le mouvement n'est pas configuré |
+| ``overpowering_state`` | (déprécié) Le dernier état connu du capteur surpuissant. Aucun si la gestion de l'alimentation n'est pas configurée |
+| ``presence_state`` | (déprécié) Le dernier état connu du capteur de présence. Aucun si la gestion de présence n'est pas configurée |
 | ``security_delay_min`` | Le délai avant de régler le mode de sécurité lorsque le capteur de température est éteint |
 | ``security_min_on_percent`` | Pourcentage de chauffe en dessous duquel le thermostat ne passera pas en sécurité |
 | ``security_default_on_percent`` | Pourcentage de chauffe utilisé lorsque le thermostat est en sécurité |
-| ``last_temperature_datetime`` | La date et l'heure au format ISO8866 de la dernière réception de température interne |
-| ``last_ext_temperature_datetime`` | La date et l'heure au format ISO8866 de la dernière réception de température extérieure |
-| ``security_state`` | L'état de sécurité. vrai ou faux |
+| ``last_temperature_datetime`` | (déprécié) La date et l'heure au format ISO8866 de la dernière réception de température interne |
+| ``last_ext_temperature_datetime`` | (déprécié) La date et l'heure au format ISO8866 de la dernière réception de température extérieure |
+| ``security_state`` | (déprécié) L'état de sécurité. vrai ou faux |
 | ``minimal_activation_delay_sec`` | Le délai d'activation minimal en secondes |
 | ``last_update_datetime`` | La date et l'heure au format ISO8866 de cet état |
 | ``friendly_name`` | Le nom du thermostat |
--- a/README.md
+++ b/README.md
@@ -58,7 +58,7 @@
 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.

 >![New](https://github.com/jmcollin78/versatile_thermostat/blob/main/images/new-icon.png?raw=true) _*News*_
-> * **Release 3.7**: Addition of the Versatile Thermostat type `over valve` to control a TRV valve directly or any other dimmer type equipment for heating. Regulation is then done directly by acting on the opening percentage of the underlying entity: 0 the valve is cut off, 100: the valve is fully opened. See [#131](https://github.com/jmcollin78/versatile_thermostat/issues/131). Added a function allowing the bypass of opening detection [#138](https://github.com/jmcollin78/versatile_thermostat/issues/138). Added Slovak language
+> * **Release 3.7**: Addition of the Versatile Thermostat type `over valve` to control a TRV valve directly or any other dimmer type equipment for heating. Regulation is then done directly by acting on the opening percentage of the underlying entity: 0 the valve is cut off, 100: the valve is fully opened. See [#131](https://github.com/jmcollin78/versatile_thermostat/issues/131)
 > * **Release 3.6**: Added the `motion_off_delay` parameter to improve motion management [#116](https://github.com/jmcollin78/versatile_thermostat/issues/116), [#128](https ://github.com/jmcollin78/versatile_thermostat/issues/128). Added AC (air conditioning) mode for a VTherm over switch. Preparing the Github project to facilitate contributions [#127](https://github.com/jmcollin78/versatile_thermostat/issues/127)
 > * **Release 3.5**: Multiple thermostats when using "thermostat over another thermostat" mode [#113](https://github.com/jmcollin78/versatile_thermostat/issues/113)
 > * **Release 3.4**: bug fixes and expose preset temperatures for AC mode [#103](https://github.com/jmcollin78/versatile_thermostat/issues/103)
@@ -75,7 +75,8 @@ This custom component for Home Assistant is an upgrade and is a complete rewrite
 </details>

 # Thanks for the beer [buymecoffee](https://www.buymeacoffee.com/jmcollin78)
-Many thanks to @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome for the beers. It's very pleasing.
+Many thanks to @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69 for the beers. It's very pleasing.
+

 # When to use / not use
 This thermostat can control 3 types of equipment:
@@ -504,7 +505,6 @@ frontend:
      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"
-      state-binary_sensor-running-on-color: "orange"
 ```
 and choose the ```versatile_thermostat_theme``` theme in the panel configuration. You will get something that will look like this:

@@ -564,25 +564,13 @@ If the thermostat is in ``security`` mode the new settings are applied immediate
 To change the security settings use the following code:
 ```
 service : thermostat_polyvalent.set_security
-data:
+date:
    min_on_percent: "0.5"
    default_on_percent: "0.1"
    delay_min: 60
 target:
    entity_id : climate.my_thermostat
 ```
-## ByPass Window Check
-This service is used to bypass the window check implemented to stop thermostat when an open window is detected.
-When set to ``true`` window event won't have any effect on the thermostat, when set back to ``false`` it will make sure to disable the thermostat if window is still open.
-
-To change the bypass setting use the following code:
-```
-service : thermostat_polyvalent.set_window_bypass
-data:
-    window_bypass: true
-target:
-    entity_id : climate.my_thermostat
-```

 # Notifications
 Significant thermostat events are notified via the message bus.
@@ -623,26 +611,25 @@ Custom attributes are the following:
 | ``[eco/comfort/boost]_temp`` | The temperature configured for the preset xxx |
 | ``[eco/comfort/boost]_away_temp`` | The temperature configured for the preset xxx when presence is off or not_home |
 | ``power_temp`` | The temperature used when shedding is detected |
-| ``on_percent`` | The percentage on calculated by the TPI algorithm |
-| ``on_time_sec`` | The On period in sec. Should be ```on_percent * cycle_min``` |
-| ``off_time_sec`` | The Off period in sec. Should be ```(1 - on_percent) * cycle_min``` |
+| ``on_percent`` | (deprecated) The percentage on calculated by the TPI algorithm |
+| ``on_time_sec`` | (deprecated) The On period in sec. Should be ```on_percent * cycle_min``` |
+| ``off_time_sec`` | (deprecated) The Off period in sec. Should be ```(1 - on_percent) * cycle_min``` |
 | ``cycle_min`` | The calculation cycle in minutes |
 | ``function`` | The algorithm used for cycle calculation |
 | ``tpi_coef_int`` | The ``coef_int`` of the TPI algorithm |
 | ``tpi_coef_ext`` | The ``coef_ext`` of the TPI algorithm |
 | ``saved_preset_mode`` | The last preset used before automatic switch of the preset |
 | ``saved_target_temp`` | The last temperature used before automatic switching |
-| ``window_state`` | The last known state of the window sensor. None if window is not configured |
-| ``window_bypass_state`` | True if the bypass of the window detection is activated |
-| ``motion_state`` | The last known state of the motion sensor. None if motion is not configured |
-| ``overpowering_state`` | The last known state of the overpowering sensor. None if power management is not configured |
-| ``presence_state`` | The last known state of the presence sensor. None if presence management is not configured |
+| ``window_state`` | (deprecated) The last known state of the window sensor. None if window is not configured |
+| ``motion_state`` | (deprecated) The last known state of the motion sensor. None if motion is not configured |
+| ``overpowering_state`` | (deprecated) The last known state of the overpowering sensor. None if power management is not configured |
+| ``presence_state`` | (deprecated) The last known state of the presence sensor. None if presence management is not configured |
 | ``security_delay_min`` | The delay before setting the security mode when temperature sensor are off |
 | ``security_min_on_percent`` | The minimal on_percent below which security preset won't be trigger |
 | ``security_default_on_percent`` | The on_percent used when thermostat is in ``security`` |
-| ``last_temperature_datetime`` | The date and time in ISO8866 format of the last internal temperature reception |
-| ``last_ext_temperature_datetime`` | The date and time in ISO8866 format of the last external temperature reception |
-| ``security_state`` | The security state. true or false |
+| ``last_temperature_datetime`` | (deprecated) The date and time in ISO8866 format of the last internal temperature reception |
+| ``last_ext_temperature_datetime`` | (deprecated) The date and time in ISO8866 format of the last external temperature reception |
+| ``security_state`` | (deprecated) The security state. true or false |
 | ``minimal_activation_delay_sec`` | The minimal activation delay in seconds |
 | ``last_update_datetime`` | The date and time in ISO8866 format of this state |
 | ``friendly_name`` | The name of the thermostat |
--- a/custom_components/versatile_thermostat/base_thermostat.py
+++ b/custom_components/versatile_thermostat/base_thermostat.py
@@ -130,8 +130,6 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
    _motion_state: bool
    _presence_state: bool
    _window_auto_state: bool
-    #PR - Adding Window ByPass
-    _window_bypass_state: bool
    _underlyings: list[UnderlyingEntity]
    _last_change_time: datetime

@@ -198,6 +196,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
        self._saved_hvac_mode = None
        self._window_call_cancel = None
        self._motion_call_cancel = None
+        self._cur_ext_temp = None
        self._cur_temp = None
        self._ac_mode = None
        self._last_ext_temperature_mesure = None
@@ -230,8 +229,6 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
        self._window_auto_state = False
        self._window_auto_on = False
        self._window_auto_algo = None
-        # PR - Adding Window ByPass
-        self._window_bypass_state = False

        self._current_tz = dt_util.get_time_zone(self._hass.config.time_zone)

@@ -414,6 +411,15 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
        # Initiate the ProportionalAlgorithm
        if self._prop_algorithm is not None:
            del self._prop_algorithm
+        if not self.is_over_climate:
+            self._prop_algorithm = PropAlgorithm(
+                self._proportional_function,
+                self._tpi_coef_int,
+                self._tpi_coef_ext,
+                self._cycle_min,
+                self._minimal_activation_delay,
+            )
+            self._should_relaunch_control_heating = False

        # Memory synthesis state
        self._motion_state = None
@@ -671,7 +677,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
                        self._hvac_mode == HVACMode.COOL,
                    )

-            self.hass.create_task(self._check_initial_state())
+            self.hass.create_task(self._check_switch_initial_state())

            self.reset_last_change_time()

@@ -814,6 +820,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

        Requires ClimateEntityFeature.FAN_MODE.
        """
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).fan_mode
+
        return None

    @property
@@ -822,6 +831,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

        Requires ClimateEntityFeature.FAN_MODE.
        """
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).fan_modes
+
        return []

    @property
@@ -830,6 +842,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

        Requires ClimateEntityFeature.SWING_MODE.
        """
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).swing_mode
+
        return None

    @property
@@ -838,11 +853,17 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

        Requires ClimateEntityFeature.SWING_MODE.
        """
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).swing_modes
+
        return None

    @property
    def temperature_unit(self) -> str:
        """Return the unit of measurement."""
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).temperature_unit
+
        return self._unit

    @property
@@ -883,6 +904,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
    @property
    def supported_features(self):
        """Return the list of supported features."""
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).supported_features | self._support_flags
+
        return self._support_flags

    @property
@@ -901,6 +925,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
    @property
    def target_temperature_step(self) -> float | None:
        """Return the supported step of target temperature."""
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).target_temperature_step
+
        return None

    @property
@@ -909,6 +936,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

        Requires ClimateEntityFeature.TARGET_TEMPERATURE_RANGE.
        """
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).target_temperature_high
+
        return None

    @property
@@ -917,6 +947,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

        Requires ClimateEntityFeature.TARGET_TEMPERATURE_RANGE.
        """
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).target_temperature_low
+
        return None

    @property
@@ -925,12 +958,15 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

        Requires ClimateEntityFeature.AUX_HEAT.
        """
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).is_aux_heat
+
        return None

    @property
    def mean_cycle_power(self) -> float | None:
        """Returns the mean power consumption during the cycle"""
-        if not self._device_power:
+        if not self._device_power or self.is_over_climate:
            return None

        return float(
@@ -942,7 +978,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
    @property
    def total_energy(self) -> float | None:
        """Returns the total energy calculated for this thermostast"""
-        return round(self._total_energy, 2)
+        return self._total_energy

    @property
    def device_power(self) -> float | None:
@@ -964,12 +1000,6 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
        """Get the window_auto_state"""
        return STATE_ON if self._window_auto_state else STATE_OFF

-    #PR - Adding Window ByPass
-    @property
-    def window_bypass_state(self) -> bool | None:
-        """Get the Window Bypass"""
-        return self._window_bypass_state
-
    @property
    def security_state(self) -> bool | None:
        """Get the security_state"""
@@ -1050,18 +1080,33 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

    def turn_aux_heat_on(self) -> None:
        """Turn auxiliary heater on."""
+        if self.is_over_climate and self.underlying_entity(0):
+            return self.underlying_entity(0).turn_aux_heat_on()
+
        raise NotImplementedError()

    async def async_turn_aux_heat_on(self) -> None:
        """Turn auxiliary heater on."""
+        if self.is_over_climate:
+            for under in self._underlyings:
+                await under.async_turn_aux_heat_on()
+
        raise NotImplementedError()

    def turn_aux_heat_off(self) -> None:
        """Turn auxiliary heater off."""
+        if self.is_over_climate:
+            for under in self._underlyings:
+                return under.turn_aux_heat_off()
+
        raise NotImplementedError()

    async def async_turn_aux_heat_off(self) -> None:
        """Turn auxiliary heater off."""
+        if self.is_over_climate:
+            for under in self._underlyings:
+                await under.async_turn_aux_heat_off()
+
        raise NotImplementedError()

    async def async_set_hvac_mode(self, hvac_mode, need_control_heating=True):
@@ -1194,17 +1239,33 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
    async def async_set_fan_mode(self, fan_mode):
        """Set new target fan mode."""
        _LOGGER.info("%s - Set fan mode: %s", self, fan_mode)
-        return
+        if fan_mode is None or not self.is_over_climate:
+            return
+
+        for under in self._underlyings:
+            await under.set_fan_mode(fan_mode)
+        self._fan_mode = fan_mode
+        self.async_write_ha_state()

    async def async_set_humidity(self, humidity: int):
        """Set new target humidity."""
        _LOGGER.info("%s - Set fan mode: %s", self, humidity)
-        return
+        if humidity is None or not self.is_over_climate:
+            return
+        for under in self._underlyings:
+            await under.set_humidity(humidity)
+        self._humidity = humidity
+        self.async_write_ha_state()

    async def async_set_swing_mode(self, swing_mode):
        """Set new target swing operation."""
        _LOGGER.info("%s - Set fan mode: %s", self, swing_mode)
-        return
+        if swing_mode is None or not self.is_over_climate:
+            return
+        for under in self._underlyings:
+            await under.set_swing_mode(swing_mode)
+        self._swing_mode = swing_mode
+        self.async_write_ha_state()

    async def async_set_temperature(self, **kwargs):
        """Set new target temperature."""
@@ -1219,11 +1280,15 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
        await self.async_control_heating(force=True)

    async def _async_internal_set_temperature(self, temperature):
-        """Set the target temperature and the target temperature of underlying climate if any
-           For testing purpose you can pass an event_timestamp.
-        """
+        """Set the target temperature and the target temperature of underlying climate if any"""
        self._target_temp = temperature
-        return
+        if not self.is_over_climate:
+            return
+
+        for under in self._underlyings:
+            await under.set_temperature(
+                temperature, self._attr_max_temp, self._attr_min_temp
+            )

    def get_state_date_or_now(self, state: State):
        """Extract the last_changed state from State or return now if not available"""
@@ -1319,27 +1384,20 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
                _LOGGER.debug("%s - no change in window state. Forget the event")
                return

-
            self._window_state = new_state.state
-
-            #PR - Adding Window ByPass
-            _LOGGER.debug("%s - Window ByPass is : %s", self, self._window_bypass_state)
-            if self._window_bypass_state:
-                _LOGGER.info("%s - Window ByPass is activated. Ignore window event", self)
-            else:
-                if self._window_state == STATE_OFF:
-                    _LOGGER.info(
-                        "%s - Window is closed. Restoring hvac_mode '%s'",
-                        self,
-                        self._saved_hvac_mode,
-                    )
-                    await self.restore_hvac_mode(True)
-                elif self._window_state == STATE_ON:
-                    _LOGGER.info(
-                        "%s - Window is open. Set hvac_mode to '%s'", self, HVACMode.OFF
-                    )
-                    self.save_hvac_mode()
-                    await self.async_set_hvac_mode(HVACMode.OFF)
+            if self._window_state == STATE_OFF:
+                _LOGGER.info(
+                    "%s - Window is closed. Restoring hvac_mode '%s'",
+                    self,
+                    self._saved_hvac_mode,
+                )
+                await self.restore_hvac_mode(True)
+            elif self._window_state == STATE_ON:
+                _LOGGER.info(
+                    "%s - Window is open. Set hvac_mode to '%s'", self, HVACMode.OFF
+                )
+                self.save_hvac_mode()
+                await self.async_set_hvac_mode(HVACMode.OFF)
            self.update_custom_attributes()

        if new_state is None or old_state is None or new_state.state == old_state.state:
@@ -1462,12 +1520,197 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
            return None

    @callback
-    async def _check_initial_state(self):
+    async def _check_switch_initial_state(self):
        """Prevent the device from keep running if HVAC_MODE_OFF."""
-        _LOGGER.debug("%s - Calling _check_initial_state", self)
+        _LOGGER.debug("%s - Calling _check_switch_initial_state", self)
+        # We need to do the same check for over_climate underlyings
+        # if self.is_over_climate:
+        #    return
        for under in self._underlyings:
            await under.check_initial_state(self._hvac_mode)

+    @callback
+    def _async_switch_changed(self, event):
+        """Handle heater switch state changes."""
+        new_state = event.data.get("new_state")
+        old_state = event.data.get("old_state")
+        if new_state is None:
+            return
+        if old_state is None:
+            self.hass.create_task(self._check_switch_initial_state())
+        self.async_write_ha_state()
+
+    @callback
+    async def _async_climate_changed(self, event):
+        """Handle unerdlying climate state changes.
+        This method takes the underlying values and update the VTherm with them.
+        To avoid loops (issues #121 #101 #95 #99), we discard the event if it is received
+        less than 10 sec after the last command. What we want here is to take the values
+        from underlyings ONLY if someone have change directly on the underlying and not
+        as a return of the command. The only thing we take all the time is the HVACAction
+        which is important for feedaback and which cannot generates loops.
+        """
+
+        async def end_climate_changed(changes):
+            """To end the event management"""
+            if changes:
+                self.async_write_ha_state()
+                self.update_custom_attributes()
+                await self.async_control_heating()
+
+        new_state = event.data.get("new_state")
+        _LOGGER.debug("%s - _async_climate_changed new_state is %s", self, new_state)
+        if not new_state:
+            return
+
+        changes = False
+        new_hvac_mode = new_state.state
+
+        old_state = event.data.get("old_state")
+        old_hvac_action = (
+            old_state.attributes.get("hvac_action")
+            if old_state and old_state.attributes
+            else None
+        )
+        new_hvac_action = (
+            new_state.attributes.get("hvac_action")
+            if new_state and new_state.attributes
+            else None
+        )
+
+        old_state_date_changed = (
+            old_state.last_changed if old_state and old_state.last_changed else None
+        )
+        old_state_date_updated = (
+            old_state.last_updated if old_state and old_state.last_updated else None
+        )
+        new_state_date_changed = (
+            new_state.last_changed if new_state and new_state.last_changed else None
+        )
+        new_state_date_updated = (
+            new_state.last_updated if new_state and new_state.last_updated else None
+        )
+
+        # Issue 99 - some AC turn hvac_mode=cool and hvac_action=idle when sending a HVACMode_OFF command
+        # Issue 114 - Remove this because hvac_mode is now managed by local _hvac_mode and use idle action as is
+        # if self._hvac_mode == HVACMode.OFF and new_hvac_action == HVACAction.IDLE:
+        #    _LOGGER.debug("The underlying switch to idle instead of OFF. We will consider it as OFF")
+        #    new_hvac_mode = HVACMode.OFF
+
+        _LOGGER.info(
+            "%s - Underlying climate changed. Event.new_hvac_mode is %s, current_hvac_mode=%s, new_hvac_action=%s, old_hvac_action=%s",
+            self,
+            new_hvac_mode,
+            self._hvac_mode,
+            new_hvac_action,
+            old_hvac_action,
+        )
+
+        _LOGGER.debug(
+            "%s - last_change_time=%s old_state_date_changed=%s old_state_date_updated=%s new_state_date_changed=%s new_state_date_updated=%s",
+            self,
+            self._last_change_time,
+            old_state_date_changed,
+            old_state_date_updated,
+            new_state_date_changed,
+            new_state_date_updated,
+        )
+
+        # Interpretation of hvac action
+        HVAC_ACTION_ON = [  # pylint: disable=invalid-name
+            HVACAction.COOLING,
+            HVACAction.DRYING,
+            HVACAction.FAN,
+            HVACAction.HEATING,
+        ]
+        if old_hvac_action not in HVAC_ACTION_ON and new_hvac_action in HVAC_ACTION_ON:
+            self._underlying_climate_start_hvac_action_date = (
+                self.get_last_updated_date_or_now(new_state)
+            )
+            _LOGGER.info(
+                "%s - underlying just switch ON. Set power and energy start date %s",
+                self,
+                self._underlying_climate_start_hvac_action_date.isoformat(),
+            )
+            changes = True
+
+        if old_hvac_action in HVAC_ACTION_ON and new_hvac_action not in HVAC_ACTION_ON:
+            stop_power_date = self.get_last_updated_date_or_now(new_state)
+            if self._underlying_climate_start_hvac_action_date:
+                delta = (
+                    stop_power_date - self._underlying_climate_start_hvac_action_date
+                )
+                self._underlying_climate_delta_t = delta.total_seconds() / 3600.0
+
+                # increment energy at the end of the cycle
+                self.incremente_energy()
+
+                self._underlying_climate_start_hvac_action_date = None
+
+            _LOGGER.info(
+                "%s - underlying just switch OFF at %s. delta_h=%.3f h",
+                self,
+                stop_power_date.isoformat(),
+                self._underlying_climate_delta_t,
+            )
+            changes = True
+
+        # Issue #120 - Some TRV are chaning target temperature a very long time (6 sec) after the change.
+        # In that case a loop is possible if a user change multiple times during this 6 sec.
+        if new_state_date_updated and self._last_change_time:
+            delta = (new_state_date_updated - self._last_change_time).total_seconds()
+            if delta < 10:
+                _LOGGER.info(
+                    "%s - underlying event is received less than 10 sec after command. Forget it to avoid loop",
+                    self,
+                )
+                await end_climate_changed(changes)
+                return
+
+        if (
+            new_hvac_mode
+            in [
+                HVACMode.OFF,
+                HVACMode.HEAT,
+                HVACMode.COOL,
+                HVACMode.HEAT_COOL,
+                HVACMode.DRY,
+                HVACMode.AUTO,
+                HVACMode.FAN_ONLY,
+                None,
+            ]
+            and self._hvac_mode != new_hvac_mode
+        ):
+            changes = True
+            self._hvac_mode = new_hvac_mode
+            # Update all underlyings state
+            if self.is_over_climate:
+                for under in self._underlyings:
+                    await under.set_hvac_mode(new_hvac_mode)
+
+        if not changes:
+            # try to manage new target temperature set if state
+            _LOGGER.debug(
+                "Do temperature check. temperature is %s, new_state.attributes is %s",
+                self.target_temperature,
+                new_state.attributes,
+            )
+            if (
+                self.is_over_climate
+                and new_state.attributes
+                and (new_target_temp := new_state.attributes.get("temperature"))
+                and new_target_temp != self.target_temperature
+            ):
+                _LOGGER.info(
+                    "%s - Target temp in underlying have change to %s",
+                    self,
+                    new_target_temp,
+                )
+                await self.async_set_temperature(temperature=new_target_temp)
+                changes = True
+
+        await end_climate_changed(changes)
+
    @callback
    async def _async_update_temp(self, state: State):
        """Update thermostat with latest state from sensor."""
@@ -1705,11 +1948,6 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
            self,
            slope if slope is not None else 0.0,
        )
-
-        if self.window_bypass_state:
-            _LOGGER.info("%s - Window auto event is ignored because bypass is ON", self)
-            return
-
        if (
            self._window_auto_algo.is_window_open_detected()
            and self._window_auto_state is False
@@ -1791,6 +2029,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

    async def restore_hvac_mode(self, need_control_heating=False):
        """Restore a previous hvac_mod"""
+        old_hvac_mode = self.hvac_mode
        await self.async_set_hvac_mode(self._saved_hvac_mode, need_control_heating)
        _LOGGER.debug(
            "%s - Restored hvac_mode - saved_hvac_mode is %s, hvac_mode is %s",
@@ -1798,6 +2037,16 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
            self._saved_hvac_mode,
            self._hvac_mode,
        )
+        # Issue 133 - force the temperature in over_climate mode if unerlying are turned on
+        if (
+            old_hvac_mode == HVACMode.OFF
+            and self.hvac_mode != HVACMode.OFF
+            and self.is_over_climate
+        ):
+            _LOGGER.info(
+                "%s - force resent target temp cause we turn on some over climate"
+            )
+            await self._async_internal_set_temperature(self._target_temp)

    async def check_overpowering(self) -> bool:
        """Check the overpowering condition
@@ -2084,16 +2333,38 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

    def recalculate(self):
        """A utility function to force the calculation of a the algo and
-        update the custom attributes and write the state.
-        Should be overriden by super class
+        update the custom attributes and write the state
        """
-        raise NotImplementedError()
+        _LOGGER.debug("%s - recalculate all", self)
+        if not self.is_over_climate:
+            self._prop_algorithm.calculate(
+                self._target_temp,
+                self._cur_temp,
+                self._cur_ext_temp,
+                self._hvac_mode == HVACMode.COOL,
+            )
+        self.update_custom_attributes()
+        self.async_write_ha_state()

    def incremente_energy(self):
-        """increment the energy counter if device is active
-        Should be overriden by super class
-        """
-        raise NotImplementedError()
+        """increment the energy counter if device is active"""
+        if self.hvac_mode == HVACMode.OFF:
+            return
+
+        added_energy = 0
+        if self.is_over_climate and self._underlying_climate_delta_t is not None:
+            added_energy = self._device_power * self._underlying_climate_delta_t
+
+        if not self.is_over_climate and self.mean_cycle_power is not None:
+            added_energy = self.mean_cycle_power * float(self._cycle_min) / 60.0
+
+        self._total_energy += added_energy
+        _LOGGER.debug(
+            "%s - added energy is %.3f . Total energy is now: %.3f",
+            self,
+            added_energy,
+            self._total_energy,
+        )

    def update_custom_attributes(self):
        """Update the custom extra attributes for the entity"""
@@ -2116,8 +2387,8 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
                self.get_preset_away_name(PRESET_COMFORT)
            ),
            "power_temp": self._power_temp,
-            # Already in super class - "target_temp": self.target_temperature,
-            # Already in super class - "current_temp": self._cur_temp,
+            "target_temp": self.target_temperature,
+            "current_temp": self._cur_temp,
            "ext_current_temperature": self._cur_ext_temp,
            "ac_mode": self._ac_mode,
            "current_power": self._current_power,
@@ -2130,8 +2401,6 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
            "overpowering_state": self._overpowering_state,
            "presence_state": self._presence_state,
            "window_auto_state": self._window_auto_state,
-            #PR - Adding Window ByPass
-            "window_bypass_state": self._window_bypass_state,
            "security_delay_min": self._security_delay_min,
            "security_min_on_percent": self._security_min_on_percent,
            "security_default_on_percent": self._security_default_on_percent,
@@ -2249,25 +2518,6 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
        await self.async_control_heating()
        self.update_custom_attributes()

-    async def service_set_window_bypass_state(self, window_bypass):
-        """Called by a service call:
-        service: versatile_thermostat.set_window_bypass
-        data:
-            window_bypass: True
-        target:
-            entity_id: climate.thermostat_1
-        """
-        _LOGGER.info("%s - Calling service_set_window_bypass, window_bypass: %s", self, window_bypass)
-        self._window_bypass_state = window_bypass
-        if not self._window_bypass_state and self._window_state == STATE_ON:
-            _LOGGER.info("%s - Last window state was open & ByPass is now off. Set hvac_mode to '%s'", self, HVACMode.OFF)
-            self.save_hvac_mode()
-            await self.async_set_hvac_mode(HVACMode.OFF)
-        if self._window_bypass_state and self._window_state == STATE_ON:
-            _LOGGER.info("%s - Last window state was open & ByPass is now on. Set hvac_mode to last available mode", self)
-            await self.restore_hvac_mode(True)
-        self.update_custom_attributes()
-
    def send_event(self, event_type: EventType, data: dict):
        """Send an event"""
        _LOGGER.info("%s - Sending event %s with data: %s", self, event_type, data)
--- a/custom_components/versatile_thermostat/binary_sensor.py
+++ b/custom_components/versatile_thermostat/binary_sensor.py
@@ -38,7 +38,7 @@ async def async_setup_entry(
    unique_id = entry.entry_id
    name = entry.data.get(CONF_NAME)

-    entities = [SecurityBinarySensor(hass, unique_id, name, entry.data),WindowByPassBinarySensor(hass, unique_id, name, entry.data)]
+    entities = [SecurityBinarySensor(hass, unique_id, name, entry.data)]
    if entry.data.get(CONF_USE_MOTION_FEATURE):
        entities.append(MotionBinarySensor(hass, unique_id, name, entry.data))
    if entry.data.get(CONF_USE_WINDOW_FEATURE):
@@ -238,38 +238,3 @@ class PresenceBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
            return "mdi:home-account"
        else:
            return "mdi:nature-people"
-
-#PR - Adding Window ByPass
-class WindowByPassBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
-    """Representation of a BinarySensor which exposes the Window ByPass state"""
-
-    def __init__(
-        self, hass: HomeAssistant, unique_id, name, entry_infos
-    ) -> None:  # pylint: disable=unused-argument
-        """Initialize the WindowByPass Binary sensor"""
-        super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
-        self._attr_name = "Window bypass"
-        self._attr_unique_id = f"{self._device_name}_window_bypass_state"
-        self._attr_is_on = False
-
-    @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)
-        old_state = self._attr_is_on
-        if self.my_climate.window_bypass_state in [True, False]:
-            self._attr_is_on = self.my_climate.window_bypass_state
-            if old_state != self._attr_is_on:
-                self.async_write_ha_state()
-        return
-
-    @property
-    def device_class(self) -> BinarySensorDeviceClass | None:
-        return BinarySensorDeviceClass.RUNNING
-
-    @property
-    def icon(self) -> str | None:
-        if self._attr_is_on:
-            return "mdi:window-shutter-cog"
-        else:
-            return "mdi:window-shutter-auto"
--- a/custom_components/versatile_thermostat/climate.py
+++ b/custom_components/versatile_thermostat/climate.py
@@ -24,12 +24,10 @@ from .const import (
    SERVICE_SET_PRESENCE,
    SERVICE_SET_PRESET_TEMPERATURE,
    SERVICE_SET_SECURITY,
-    SERVICE_SET_WINDOW_BYPASS,
-    SERVICE_SET_AUTO_REGULATION_MODE,
    CONF_THERMOSTAT_TYPE,
    CONF_THERMOSTAT_SWITCH,
    CONF_THERMOSTAT_CLIMATE,
-    CONF_THERMOSTAT_VALVE
+    CONF_THERMOSTAT_VALVE,
 )

 from .thermostat_switch import ThermostatOverSwitch
@@ -66,6 +64,8 @@ async def async_setup_entry(
        entity = ThermostatOverValve(hass, unique_id, name, entry.data)

    async_add_entities([entity], True)
+    # No more needed
+    # VersatileThermostat.add_entity(entry.entry_id, entity)

    # Add services
    platform = entity_platform.async_get_current_platform()
@@ -98,20 +98,3 @@ async def async_setup_entry(
        },
        "service_set_security",
    )
-
-    platform.async_register_entity_service(
-        SERVICE_SET_WINDOW_BYPASS,
-        {
-            vol.Required("window_bypass"): vol.In([True, False]
-            ),
-        },
-        "service_set_window_bypass_state",
-    )
-
-    platform.async_register_entity_service(
-        SERVICE_SET_AUTO_REGULATION_MODE,
-        {
-            vol.Required("auto_regulation_mode"): vol.In(["None", "Light", "Medium", "Strong"]),
-        },
-        "service_set_auto_regulation_mode",
-    )
--- a/custom_components/versatile_thermostat/commons.py
+++ b/custom_components/versatile_thermostat/commons.py
@@ -1,50 +1,18 @@
 """ Some usefull commons class """
 import logging
-from datetime import timedelta, datetime
+from datetime import timedelta
 from homeassistant.core import HomeAssistant, callback, Event
 from homeassistant.components.climate import ClimateEntity, DOMAIN as CLIMATE_DOMAIN
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.device_registry import DeviceInfo, DeviceEntryType
 from homeassistant.helpers.event import async_track_state_change_event, async_call_later
-from homeassistant.util import dt as dt_util

 from .base_thermostat import BaseThermostat
 from .const import DOMAIN, DEVICE_MANUFACTURER

 _LOGGER = logging.getLogger(__name__)

-def get_tz(hass: HomeAssistant):
-    """Get the current timezone"""
-
-    return dt_util.get_time_zone(hass.config.time_zone)
-
-class NowClass:
-    """ For testing purpose only"""
-
-    @staticmethod
-    def get_now(hass: HomeAssistant) -> datetime:
-        """ A test function to get the now.
-            For testing purpose this method can be overriden to get a specific
-            timestamp.
-        """
-        return datetime.now( get_tz(hass))
-
-def round_to_nearest(n:float, x: float)->float:
-    """ Round a number to the nearest x (which should be decimal but not null)
-        Example:
-            nombre1 = 3.2
-            nombre2 = 4.7
-            x = 0.3
-
-            nombre_arrondi1 = round_to_nearest(nombre1, x)
-            nombre_arrondi2 = round_to_nearest(nombre2, x)
-
-            print(nombre_arrondi1)  # Output: 3.3
-            print(nombre_arrondi2)  # Output: 4.6
-    """
-    assert x > 0
-    return round(n * (1/x)) / (1/x)

 class VersatileThermostatBaseEntity(Entity):
    """A base class for all entities"""
@@ -130,7 +98,7 @@ class VersatileThermostatBaseEntity(Entity):
        await try_find_climate(None)

    @callback
-    async def async_my_climate_changed(self, event: Event):         # pylint: disable=unused-argument
+    async def async_my_climate_changed(self, event: Event):
        """Called when my climate have change
        This method aims to be overriden to take the status change
        """
--- a/custom_components/versatile_thermostat/config_flow.py
+++ b/custom_components/versatile_thermostat/config_flow.py
@@ -1,4 +1,6 @@
-# pylint: disable=line-too-long, too-many-lines, invalid-name
+# pylint: disable=line-too-long
+# pylint: disable=too-many-lines
+# pylint: disable=invalid-name

 """Config flow for Versatile Thermostat integration."""
 from __future__ import annotations
@@ -99,11 +101,6 @@ from .const import (
    CONF_VALVE_2,
    CONF_VALVE_3,
    CONF_VALVE_4,
-    CONF_AUTO_REGULATION_MODES,
-    CONF_AUTO_REGULATION_MODE,
-    CONF_AUTO_REGULATION_NONE,
-    CONF_AUTO_REGULATION_DTEMP,
-    CONF_AUTO_REGULATION_PERIOD_MIN,
    UnknownEntity,
    WindowOpenDetectionMethod,
 )
@@ -259,16 +256,6 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                    selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
                ),
                vol.Optional(CONF_AC_MODE, default=False): cv.boolean,
-                vol.Optional(
-                    CONF_AUTO_REGULATION_MODE, default=CONF_AUTO_REGULATION_NONE
-                ): selector.SelectSelector(
-                    selector.SelectSelectorConfig(
-                        options=CONF_AUTO_REGULATION_MODES, translation_key="auto_regulation_mode"
-                    )
-                ),
-                vol.Optional(CONF_AUTO_REGULATION_DTEMP, default=0.5): vol.Coerce(float),
-                vol.Optional(CONF_AUTO_REGULATION_PERIOD_MIN, default=5): cv.positive_int
-
            }
        )

--- a/custom_components/versatile_thermostat/const.py
+++ b/custom_components/versatile_thermostat/const.py
@@ -1,4 +1,3 @@
-# pylint: disable=line-too-long
 """Constants for the Versatile Thermostat integration."""

 from enum import Enum
@@ -83,13 +82,6 @@ CONF_VALVE = "valve_entity_id"
 CONF_VALVE_2 = "valve_entity2_id"
 CONF_VALVE_3 = "valve_entity3_id"
 CONF_VALVE_4 = "valve_entity4_id"
-CONF_AUTO_REGULATION_MODE= "auto_regulation_mode"
-CONF_AUTO_REGULATION_NONE= "auto_regulation_none"
-CONF_AUTO_REGULATION_LIGHT= "auto_regulation_light"
-CONF_AUTO_REGULATION_MEDIUM= "auto_regulation_medium"
-CONF_AUTO_REGULATION_STRONG= "auto_regulation_strong"
-CONF_AUTO_REGULATION_DTEMP="auto_regulation_dtemp"
-CONF_AUTO_REGULATION_PERIOD_MIN="auto_regulation_periode_min"

 CONF_PRESETS = {
    p: f"{p}_temp"
@@ -191,9 +183,7 @@ ALL_CONF = (
        CONF_VALVE_2,
        CONF_VALVE_3,
        CONF_VALVE_4,
-        CONF_AUTO_REGULATION_MODE,
-        CONF_AUTO_REGULATION_DTEMP,
-        CONF_AUTO_REGULATION_PERIOD_MIN
+
    ]
    + CONF_PRESETS_VALUES
    + CONF_PRESETS_AWAY_VALUES
@@ -205,8 +195,6 @@ CONF_FUNCTIONS = [
    PROPORTIONAL_FUNCTION_TPI,
 ]

-CONF_AUTO_REGULATION_MODES = [CONF_AUTO_REGULATION_NONE, CONF_AUTO_REGULATION_LIGHT, CONF_AUTO_REGULATION_MEDIUM, CONF_AUTO_REGULATION_STRONG]
-
 CONF_THERMOSTAT_TYPES = [CONF_THERMOSTAT_SWITCH, CONF_THERMOSTAT_CLIMATE, CONF_THERMOSTAT_VALVE]

 SUPPORT_FLAGS = ClimateEntityFeature.TARGET_TEMPERATURE
@@ -214,8 +202,6 @@ SUPPORT_FLAGS = ClimateEntityFeature.TARGET_TEMPERATURE
 SERVICE_SET_PRESENCE = "set_presence"
 SERVICE_SET_PRESET_TEMPERATURE = "set_preset_temperature"
 SERVICE_SET_SECURITY = "set_security"
-SERVICE_SET_WINDOW_BYPASS = "set_window_bypass"
-SERVICE_SET_AUTO_REGULATION_MODE = "set_auto_regulation_mode"

 DEFAULT_SECURITY_MIN_ON_PERCENT = 0.5
 DEFAULT_SECURITY_DEFAULT_ON_PERCENT = 0.1
@@ -223,33 +209,6 @@ DEFAULT_SECURITY_DEFAULT_ON_PERCENT = 0.1
 ATTR_TOTAL_ENERGY = "total_energy"
 ATTR_MEAN_POWER_CYCLE = "mean_cycle_power"

-class RegulationParamLight:
-    """ Light parameters for regulation"""
-    kp:float = 0.2
-    ki:float = 0.05
-    k_ext:float = 0.1
-    offset_max:float = 2
-    stabilization_threshold:float = 0.1
-    accumulated_error_threshold:float = 20
-
-
-class RegulationParamMedium:
-    """ Medium parameters for regulation"""
-    kp:float = 0.4
-    ki:float = 0.08
-    k_ext:float = 0.1
-    offset_max:float = 3
-    stabilization_threshold:float = 0.1
-    accumulated_error_threshold:float = 25
-
-class RegulationParamStrong:
-    """ Strong parameters for regulation"""
-    kp:float = 0.6
-    ki:float = 0.1
-    k_ext:float = 0.2
-    offset_max:float = 4
-    stabilization_threshold:float = 0.1
-    accumulated_error_threshold:float = 30

 class EventType(Enum):
    """The event type that can be sent"""
--- a/custom_components/versatile_thermostat/manifest.json
+++ b/custom_components/versatile_thermostat/manifest.json
@@ -14,6 +14,6 @@
  "quality_scale": "silver",
  "requirements": [],
  "ssdp": [],
-  "version": "3.7.0",
+  "version": "3.6.0",
  "zeroconf": []
 }
--- a/custom_components/versatile_thermostat/pi_algorithm.py
+++ b/custom_components/versatile_thermostat/pi_algorithm.py
@@ -1,70 +0,0 @@
-# pylint: disable=line-too-long
-""" The PI algorithm implementation """
-
-import logging
-
-_LOGGER = logging.getLogger(__name__)
-
-class PITemperatureRegulator:
-    """ A class implementing a PI Algorithm
-    PI algorithms calculate a target temperature by adding an offset which is calculating as follow:
-    - offset = kp * error + ki * accumulated_error
-
-    To use it you must:
-    - instanciate the class and gives the algorithm parameters: kp, ki, offset_max, stabilization_threshold, accumulated_error_threshold
-    - call calculate_regulated_temperature with the internal and external temperature
-    - call set_target_temp when the target temperature change.
-    """
-
-    def __init__(self, target_temp: float, kp: float, ki: float, k_ext: float, offset_max: float, stabilization_threshold: float, accumulated_error_threshold: float):
-        self.target_temp:float = target_temp
-        self.kp:float = kp  # proportionnel gain
-        self.ki:float = ki  # integral gain
-        self.k_ext:float = k_ext # exterior gain
-        self.offset_max:float = offset_max
-        self.stabilization_threshold:float = stabilization_threshold
-        self.accumulated_error:float = 0
-        self.accumulated_error_threshold:float = accumulated_error_threshold
-
-    def set_target_temp(self, target_temp):
-        """ Set the new target_temp"""
-        self.target_temp = target_temp
-        self.accumulated_error = 0
-
-    def calculate_regulated_temperature(self, internal_temp: float, external_temp:float): # pylint: disable=unused-argument
-        """ Calculate a new target_temp given some temperature"""
-        if internal_temp is None or external_temp is None:
-            _LOGGER.warning("Internal_temp or external_temp are not set. Regulation will be suspended")
-            return self.target_temp
-
-        # Calculate the error factor (P)
-        error = self.target_temp - internal_temp
-
-        # Calculate the sum of error (I)
-        self.accumulated_error += error
-
-        # Capping of the error
-        self.accumulated_error = min(self.accumulated_error_threshold, max(-self.accumulated_error_threshold, self.accumulated_error))
-
-        # Calculate the offset (proportionnel + intégral)
-        offset = self.kp * error + self.ki * self.accumulated_error
-
-        # Calculate the exterior offset
-        offset_ext = self.k_ext * (self.target_temp - external_temp)
-
-        # Capping of offset_ext
-        total_offset = offset + offset_ext
-        total_offset = min(self.offset_max, max(-self.offset_max, total_offset))
-
-
-        # If temperature is near the target_temp, reset the accumulated_error
-        if abs(error) < self.stabilization_threshold:
-            _LOGGER.debug("Stabilisation")
-            self.accumulated_error = 0
-
-        result = round(self.target_temp + total_offset, 1)
-
-        _LOGGER.debug("PITemperatureRegulator - Error: %.2f accumulated_error: %.2f offset: %.2f offset_ext: %.2f target_tem: %.1f regulatedTemp: %.1f",
-            error, self.accumulated_error, offset, offset_ext, self.target_temp, result)
-
-        return result
--- a/custom_components/versatile_thermostat/sensor.py
+++ b/custom_components/versatile_thermostat/sensor.py
@@ -11,7 +11,6 @@ from homeassistant.components.sensor import (
    SensorEntity,
    SensorDeviceClass,
    SensorStateClass,
-    UnitOfTemperature
 )
 from homeassistant.config_entries import ConfigEntry

@@ -25,7 +24,6 @@ from .const import (
    PROPORTIONAL_FUNCTION_TPI,
    CONF_THERMOSTAT_SWITCH,
    CONF_THERMOSTAT_VALVE,
-    CONF_THERMOSTAT_CLIMATE,
    CONF_THERMOSTAT_TYPE,
 )

@@ -65,9 +63,6 @@ async def async_setup_entry(
    if entry.data.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_VALVE:
        entities.append(ValveOpenPercentSensor(hass, unique_id, name, entry.data))

-    if entry.data.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CLIMATE:
-        entities.append(RegulatedTemperatureSensor(hass, unique_id, name, entry.data))
-
    async_add_entities(entities, True)


@@ -475,53 +470,3 @@ class TemperatureSlopeSensor(VersatileThermostatBaseEntity, SensorEntity):
    def suggested_display_precision(self) -> int | None:
        """Return the suggested number of decimal digits for display."""
        return 2
-
-class RegulatedTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
-    """Representation of a Energy sensor which exposes the energy"""
-
-    def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
-        """Initialize the regulated temperature sensor"""
-        super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
-        self._attr_name = "Regulated temperature"
-        self._attr_unique_id = f"{self._device_name}_regulated_temperature"
-
-    @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)
-
-        if math.isnan(self.my_climate.regulated_target_temp) or math.isinf(
-            self.my_climate.regulated_target_temp
-        ):
-            raise ValueError(f"Sensor has illegal state {self.my_climate.regulated_target_temp}")
-
-        old_state = self._attr_native_value
-        self._attr_native_value = round(
-            self.my_climate.regulated_target_temp, self.suggested_display_precision
-        )
-        if old_state != self._attr_native_value:
-            self.async_write_ha_state()
-        return
-
-    @property
-    def icon(self) -> str | None:
-        return "mdi:thermometer-auto"
-
-    @property
-    def device_class(self) -> SensorDeviceClass | None:
-        return SensorDeviceClass.TEMPERATURE
-
-    @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 UnitOfTemperature.CELSIUS
-        return self.my_climate.temperature_unit
-
-    @property
-    def suggested_display_precision(self) -> int | None:
-        """Return the suggested number of decimal digits for display."""
-        return 1
--- a/custom_components/versatile_thermostat/services.yaml
+++ b/custom_components/versatile_thermostat/services.yaml
@@ -122,40 +122,3 @@ set_security:
                    step: 0.05
                    unit_of_measurement: "%"
                    mode: slider
-
-set_window_bypass:
-    name: Set Window ByPass
-    description: Bypass the window state to enable heating with window open.
-    target:
-        entity:
-            integration: versatile_thermostat
-    fields:
-        window_bypass:
-            name: Window ByPass
-            description: ByPass value
-            required: true
-            advanced: false
-            default: true
-            selector:
-                boolean:
-
-set_auto_regulation_mode:
-    name: Set Auto Regulation mode
-    description: Change the mode of self-regulation (only for VTherm over climate)
-    target:
-        entity:
-            integration: versatile_thermostat
-    fields:
-        auto_regulation_mode:
-            name: Auto regulation mode
-            description: Possible values
-            required: true
-            advanced: false
-            default: true
-            selector:
-                select:
-                    options:
-                        - "None"
-                        - "Light"
-                        - "Medium"
-                        - "Strong"
--- a/custom_components/versatile_thermostat/strings.json
+++ b/custom_components/versatile_thermostat/strings.json
@@ -38,10 +38,7 @@
          "valve_entity_id": "1rst valve number",
          "valve_entity2_id": "2nd valve number",
          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
-          "auto_regulation_mode": "Self-regulation",
-          "auto_regulation_dtemp": "Regulation threshold",
-          "auto_regulation_periode_min": "Regulation minimal period"
+          "valve_entity4_id": "4th valve number"
        },
        "data_description": {
          "heater_entity_id": "Mandatory heater entity id",
@@ -57,10 +54,7 @@
          "valve_entity_id": "1rst valve number entity id",
          "valve_entity2_id": "2nd valve number entity id",
          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
-          "auto_regulation_mode": "Auto adjustment of the target temperature",
-          "auto_regulation_dtemp": "The threshold in ° under which the temperature change will not be send",
-          "auto_regulation_periode_min": "Duration in minutes between two regulation update"
+          "valve_entity4_id": "4th valve number entity id"
        }
      },
      "tpi": {
@@ -205,10 +199,7 @@
          "valve_entity_id": "1rst valve number",
          "valve_entity2_id": "2nd valve number",
          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
-          "auto_regulation_mode": "Self-regulation",
-          "auto_regulation_dtemp": "Regulation threshold",
-          "auto_regulation_periode_min": "Regulation minimal period"
+          "valve_entity4_id": "4th valve number"
        },
        "data_description": {
          "heater_entity_id": "Mandatory heater entity id",
@@ -224,10 +215,7 @@
          "valve_entity_id": "1rst valve number entity id",
          "valve_entity2_id": "2nd valve number entity id",
          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
-          "auto_regulation_mode": "Auto adjustment of the target temperature",
-          "auto_regulation_dtemp": "The threshold in ° under which the temperature change will not be send",
-          "auto_regulation_periode_min": "Duration in minutes between two regulation update"
+          "valve_entity4_id": "4th valve number entity id"
        }
      },
      "tpi": {
@@ -341,14 +329,6 @@
        "thermostat_over_climate": "Thermostat over a climate",
        "thermostat_over_valve": "Thermostat over a valve"
      }
-    },
-    "auto_regulation_mode": {
-      "options": {
-        "auto_regulation_strong": "Strong",
-        "auto_regulation_medium": "Medium",
-        "auto_regulation_light": "Light",
-        "auto_regulation_none": "No auto-regulation"
-      }
    }
  },
  "entity": {
--- a/custom_components/versatile_thermostat/thermostat_climate.py
+++ b/custom_components/versatile_thermostat/thermostat_climate.py
@@ -1,34 +1,16 @@
 # pylint: disable=line-too-long
 """ A climate over switch classe """
 import logging
-from datetime import timedelta, datetime
+from datetime import timedelta

-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.event import async_track_state_change_event, async_track_time_interval

-from homeassistant.components.climate import HVACAction, HVACMode
+from homeassistant.components.climate import HVACAction

-from .commons import NowClass, round_to_nearest
 from .base_thermostat import BaseThermostat
-from .pi_algorithm import PITemperatureRegulator

-from .const import (
-    overrides,
-    CONF_CLIMATE,
-    CONF_CLIMATE_2,
-    CONF_CLIMATE_3,
-    CONF_CLIMATE_4,
-    CONF_AUTO_REGULATION_MODE,
-    CONF_AUTO_REGULATION_NONE,
-    CONF_AUTO_REGULATION_LIGHT,
-    CONF_AUTO_REGULATION_MEDIUM,
-    CONF_AUTO_REGULATION_STRONG,
-    CONF_AUTO_REGULATION_DTEMP,
-    CONF_AUTO_REGULATION_PERIOD_MIN,
-    RegulationParamLight,
-    RegulationParamMedium,
-    RegulationParamStrong
-)
+from .const import CONF_CLIMATE, CONF_CLIMATE_2, CONF_CLIMATE_3, CONF_CLIMATE_4

 from .underlyings import UnderlyingClimate

@@ -36,25 +18,16 @@ _LOGGER = logging.getLogger(__name__)

 class ThermostatOverClimate(BaseThermostat):
    """Representation of a base class for a Versatile Thermostat over a climate"""
-    _auto_regulation_mode:str = None
-    _regulation_algo = None
-    _regulated_target_temp: float = None
-    _auto_regulation_dtemp: float = None
-    _auto_regulation_period_min: int = None
-    _last_regulation_change: datetime = None

    _entity_component_unrecorded_attributes = BaseThermostat._entity_component_unrecorded_attributes.union(frozenset(
        {
            "is_over_climate", "start_hvac_action_date", "underlying_climate_0", "underlying_climate_1",
-            "underlying_climate_2", "underlying_climate_3", "regulation_accumulated_error"
+            "underlying_climate_2", "underlying_climate_3"
        }))

    def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
        """Initialize the thermostat over switch."""
-        # super.__init__ calls post_init at the end. So it must be called after regulation initialization
        super().__init__(hass, unique_id, name, entry_infos)
-        self._regulated_target_temp = self.target_temperature
-        self._last_regulation_change = NowClass.get_now(hass)

    @property
    def is_over_climate(self) -> bool:
@@ -81,45 +54,14 @@ class ThermostatOverClimate(BaseThermostat):
            return HVACAction.IDLE
        return HVACAction.OFF

-    @overrides
-    async def _async_internal_set_temperature(self, temperature):
-        """Set the target temperature and the target temperature of underlying climate if any"""
-        await super()._async_internal_set_temperature(temperature)
+    @property
+    def hvac_modes(self):
+        """List of available operation modes."""
+        if self.underlying_entity(0):
+            return self.underlying_entity(0).hvac_modes
+        else:
+            return super.hvac_modes

-        self._regulation_algo.set_target_temp(self.target_temperature)
-        await self._send_regulated_temperature()
-
-    async def _send_regulated_temperature(self):
-        """ Sends the regulated temperature to all underlying """
-        if not self._regulated_target_temp:
-            self._regulated_target_temp = self.target_temperature
-
-        new_regulated_temp = round_to_nearest(
-            self._regulation_algo.calculate_regulated_temperature(self.current_temperature, self._cur_ext_temp),
-            self._auto_regulation_dtemp)
-        dtemp = new_regulated_temp - self._regulated_target_temp
-
-        if abs(dtemp) < self._auto_regulation_dtemp:
-            _LOGGER.debug("%s - dtemp (%.1f) is < %.1f -> forget the regulation send", self, dtemp, self._auto_regulation_dtemp)
-            return
-
-        now:datetime = NowClass.get_now(self._hass)
-        period = float((now - self._last_regulation_change).total_seconds()) / 60.
-        if period < self._auto_regulation_period_min:
-            _LOGGER.debug("%s - period (%.1f) is < %.0f -> forget the regulation send", self, period, self._auto_regulation_period_min)
-            return
-
-
-        self._regulated_target_temp = new_regulated_temp
-        _LOGGER.info("%s - Regulated temp have changed to %.1f. Resend it to underlyings", self, new_regulated_temp)
-        self._last_regulation_change = now
-
-        for under in self._underlyings:
-            await under.set_temperature(
-                self.regulated_target_temp, self._attr_max_temp, self._attr_min_temp
-            )
-
-    @overrides
    def post_init(self, entry_infos):
        """ Initialize the Thermostat"""

@@ -139,49 +81,6 @@ class ThermostatOverClimate(BaseThermostat):
                    )
                )

-        self.choose_auto_regulation_mode(
-            entry_infos.get(CONF_AUTO_REGULATION_MODE) if entry_infos.get(CONF_AUTO_REGULATION_MODE) is not None else CONF_AUTO_REGULATION_NONE
-        )
-
-        self._auto_regulation_dtemp = entry_infos.get(CONF_AUTO_REGULATION_DTEMP) if entry_infos.get(CONF_AUTO_REGULATION_DTEMP) is not None else 0.5
-        self._auto_regulation_period_min = entry_infos.get(CONF_AUTO_REGULATION_PERIOD_MIN) if entry_infos.get(CONF_AUTO_REGULATION_PERIOD_MIN) is not None else 5
-
-    def choose_auto_regulation_mode(self, auto_regulation_mode):
-        """ Choose or change the regulation mode"""
-        self._auto_regulation_mode = auto_regulation_mode
-        if self._auto_regulation_mode == CONF_AUTO_REGULATION_LIGHT:
-            self._regulation_algo = PITemperatureRegulator(
-                self.target_temperature,
-                RegulationParamLight.kp,
-                RegulationParamLight.ki,
-                RegulationParamLight.k_ext,
-                RegulationParamLight.offset_max,
-                RegulationParamLight.stabilization_threshold,
-                RegulationParamLight.accumulated_error_threshold)
-        elif self._auto_regulation_mode == CONF_AUTO_REGULATION_MEDIUM:
-            self._regulation_algo = PITemperatureRegulator(
-                self.target_temperature,
-                RegulationParamMedium.kp,
-                RegulationParamMedium.ki,
-                RegulationParamMedium.k_ext,
-                RegulationParamMedium.offset_max,
-                RegulationParamMedium.stabilization_threshold,
-                RegulationParamMedium.accumulated_error_threshold)
-        elif self._auto_regulation_mode == CONF_AUTO_REGULATION_STRONG:
-            self._regulation_algo = PITemperatureRegulator(
-                self.target_temperature,
-                RegulationParamStrong.kp,
-                RegulationParamStrong.ki,
-                RegulationParamStrong.k_ext,
-                RegulationParamStrong.offset_max,
-                RegulationParamStrong.stabilization_threshold,
-                RegulationParamStrong.accumulated_error_threshold)
-        else:
-            # A default empty algo (which does nothing)
-            self._regulation_algo = PITemperatureRegulator(
-                self.target_temperature, 0, 0, 0, 0, 0.1, 0)
-
-    @overrides
    async def async_added_to_hass(self):
        """Run when entity about to be added."""
        _LOGGER.debug("Calling async_added_to_hass")
@@ -206,7 +105,6 @@ class ThermostatOverClimate(BaseThermostat):
            )
        )

-    @overrides
    def update_custom_attributes(self):
        """ Custom attributes """
        super().update_custom_attributes()
@@ -226,10 +124,6 @@ class ThermostatOverClimate(BaseThermostat):
                self._underlyings[3].entity_id if len(self._underlyings) > 3 else None
            )

-        if self.is_regulated:
-            self._attr_extra_state_attributes["regulated_target_temp"] = self._regulated_target_temp
-            self._attr_extra_state_attributes["regulation_accumulated_error"] = self._regulation_algo.accumulated_error
-
        self.async_write_ha_state()
        _LOGGER.debug(
            "%s - Calling update_custom_attributes: %s",
@@ -237,7 +131,6 @@ class ThermostatOverClimate(BaseThermostat):
            self._attr_extra_state_attributes,
        )

-    @overrides
    def recalculate(self):
        """A utility function to force the calculation of a the algo and
        update the custom attributes and write the state
@@ -245,427 +138,3 @@ class ThermostatOverClimate(BaseThermostat):
        _LOGGER.debug("%s - recalculate all", self)
        self.update_custom_attributes()
        self.async_write_ha_state()
-
-    @overrides
-    async def restore_hvac_mode(self, need_control_heating=False):
-        """Restore a previous hvac_mod"""
-        old_hvac_mode = self.hvac_mode
-
-        await super().restore_hvac_mode(need_control_heating=need_control_heating)
-
-        # Issue 133 - force the temperature in over_climate mode if unerlying are turned on
-        if old_hvac_mode == HVACMode.OFF and self.hvac_mode != HVACMode.OFF:
-            _LOGGER.info(
-                "%s - Force resent target temp cause we turn on some over climate"
-            )
-            await self._async_internal_set_temperature(self._target_temp)
-
-    @overrides
-    def incremente_energy(self):
-        """increment the energy counter if device is active"""
-
-        if self.hvac_mode == HVACMode.OFF:
-            return
-
-        added_energy = 0
-        if self.is_over_climate and self._underlying_climate_delta_t is not None:
-            added_energy = self._device_power * self._underlying_climate_delta_t
-
-        self._total_energy += added_energy
-        _LOGGER.debug(
-            "%s - added energy is %.3f . Total energy is now: %.3f",
-            self,
-            added_energy,
-            self._total_energy,
-        )
-
-    @callback
-    async def _async_climate_changed(self, event):
-        """Handle unerdlying climate state changes.
-        This method takes the underlying values and update the VTherm with them.
-        To avoid loops (issues #121 #101 #95 #99), we discard the event if it is received
-        less than 10 sec after the last command. What we want here is to take the values
-        from underlyings ONLY if someone have change directly on the underlying and not
-        as a return of the command. The only thing we take all the time is the HVACAction
-        which is important for feedaback and which cannot generates loops.
-        """
-
-        async def end_climate_changed(changes):
-            """To end the event management"""
-            if changes:
-                self.async_write_ha_state()
-                self.update_custom_attributes()
-                await self.async_control_heating()
-
-        new_state = event.data.get("new_state")
-        _LOGGER.debug("%s - _async_climate_changed new_state is %s", self, new_state)
-        if not new_state:
-            return
-
-        changes = False
-        new_hvac_mode = new_state.state
-
-        old_state = event.data.get("old_state")
-        old_hvac_action = (
-            old_state.attributes.get("hvac_action")
-            if old_state and old_state.attributes
-            else None
-        )
-        new_hvac_action = (
-            new_state.attributes.get("hvac_action")
-            if new_state and new_state.attributes
-            else None
-        )
-
-        old_state_date_changed = (
-            old_state.last_changed if old_state and old_state.last_changed else None
-        )
-        old_state_date_updated = (
-            old_state.last_updated if old_state and old_state.last_updated else None
-        )
-        new_state_date_changed = (
-            new_state.last_changed if new_state and new_state.last_changed else None
-        )
-        new_state_date_updated = (
-            new_state.last_updated if new_state and new_state.last_updated else None
-        )
-
-        # Issue 99 - some AC turn hvac_mode=cool and hvac_action=idle when sending a HVACMode_OFF command
-        # Issue 114 - Remove this because hvac_mode is now managed by local _hvac_mode and use idle action as is
-        # if self._hvac_mode == HVACMode.OFF and new_hvac_action == HVACAction.IDLE:
-        #    _LOGGER.debug("The underlying switch to idle instead of OFF. We will consider it as OFF")
-        #    new_hvac_mode = HVACMode.OFF
-
-        _LOGGER.info(
-            "%s - Underlying climate changed. Event.new_hvac_mode is %s, current_hvac_mode=%s, new_hvac_action=%s, old_hvac_action=%s",
-            self,
-            new_hvac_mode,
-            self._hvac_mode,
-            new_hvac_action,
-            old_hvac_action,
-        )
-
-        _LOGGER.debug(
-            "%s - last_change_time=%s old_state_date_changed=%s old_state_date_updated=%s new_state_date_changed=%s new_state_date_updated=%s",
-            self,
-            self._last_change_time,
-            old_state_date_changed,
-            old_state_date_updated,
-            new_state_date_changed,
-            new_state_date_updated,
-        )
-
-        # Interpretation of hvac action
-        HVAC_ACTION_ON = [  # pylint: disable=invalid-name
-            HVACAction.COOLING,
-            HVACAction.DRYING,
-            HVACAction.FAN,
-            HVACAction.HEATING,
-        ]
-        if old_hvac_action not in HVAC_ACTION_ON and new_hvac_action in HVAC_ACTION_ON:
-            self._underlying_climate_start_hvac_action_date = (
-                self.get_last_updated_date_or_now(new_state)
-            )
-            _LOGGER.info(
-                "%s - underlying just switch ON. Set power and energy start date %s",
-                self,
-                self._underlying_climate_start_hvac_action_date.isoformat(),
-            )
-            changes = True
-
-        if old_hvac_action in HVAC_ACTION_ON and new_hvac_action not in HVAC_ACTION_ON:
-            stop_power_date = self.get_last_updated_date_or_now(new_state)
-            if self._underlying_climate_start_hvac_action_date:
-                delta = (
-                    stop_power_date - self._underlying_climate_start_hvac_action_date
-                )
-                self._underlying_climate_delta_t = delta.total_seconds() / 3600.0
-
-                # increment energy at the end of the cycle
-                self.incremente_energy()
-
-                self._underlying_climate_start_hvac_action_date = None
-
-            _LOGGER.info(
-                "%s - underlying just switch OFF at %s. delta_h=%.3f h",
-                self,
-                stop_power_date.isoformat(),
-                self._underlying_climate_delta_t,
-            )
-            changes = True
-
-        # Issue #120 - Some TRV are chaning target temperature a very long time (6 sec) after the change.
-        # In that case a loop is possible if a user change multiple times during this 6 sec.
-        if new_state_date_updated and self._last_change_time:
-            delta = (new_state_date_updated - self._last_change_time).total_seconds()
-            if delta < 10:
-                _LOGGER.info(
-                    "%s - underlying event is received less than 10 sec after command. Forget it to avoid loop",
-                    self,
-                )
-                await end_climate_changed(changes)
-                return
-
-        if (
-            new_hvac_mode
-            in [
-                HVACMode.OFF,
-                HVACMode.HEAT,
-                HVACMode.COOL,
-                HVACMode.HEAT_COOL,
-                HVACMode.DRY,
-                HVACMode.AUTO,
-                HVACMode.FAN_ONLY,
-                None,
-            ]
-            and self._hvac_mode != new_hvac_mode
-        ):
-            changes = True
-            self._hvac_mode = new_hvac_mode
-            # Update all underlyings state
-            if self.is_over_climate:
-                for under in self._underlyings:
-                    await under.set_hvac_mode(new_hvac_mode)
-
-        if not changes:
-            # try to manage new target temperature set if state
-            _LOGGER.debug(
-                "Do temperature check. temperature is %s, new_state.attributes is %s",
-                self.target_temperature,
-                new_state.attributes,
-            )
-            if (
-                # we do not change target temperature on regulated VTherm
-                not self.is_regulated
-                and new_state.attributes
-                and (new_target_temp := new_state.attributes.get("temperature"))
-                and new_target_temp != self.target_temperature
-            ):
-                _LOGGER.info(
-                    "%s - Target temp in underlying have change to %s",
-                    self,
-                    new_target_temp,
-                )
-                await self.async_set_temperature(temperature=new_target_temp)
-                changes = True
-
-        await end_climate_changed(changes)
-
-    @overrides
-    async def async_control_heating(self, force=False, _=None):
-        """The main function used to run the calculation at each cycle"""
-        ret = await super().async_control_heating(force, _)
-
-        await self._send_regulated_temperature()
-
-        return ret
-
-    @property
-    def auto_regulation_mode(self):
-        """ Get the regulation mode """
-        return self._auto_regulation_mode
-
-    @property
-    def regulated_target_temp(self):
-        """ Get the regulated target temperature """
-        return self._regulated_target_temp
-
-    @property
-    def is_regulated(self):
-        """ Check if the ThermostatOverClimate is regulated """
-        return self.auto_regulation_mode != CONF_AUTO_REGULATION_NONE
-
-    @property
-    def hvac_modes(self):
-        """List of available operation modes."""
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).hvac_modes
-        else:
-            return super.hvac_modes
-
-    @property
-    def mean_cycle_power(self) -> float | None:
-        """Returns the mean power consumption during the cycle"""
-        return None
-
-    @property
-    def fan_mode(self) -> str | None:
-        """Return the fan setting.
-
-        Requires ClimateEntityFeature.FAN_MODE.
-        """
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).fan_mode
-
-        return None
-
-    @property
-    def fan_modes(self) -> list[str] | None:
-        """Return the list of available fan modes.
-
-        Requires ClimateEntityFeature.FAN_MODE.
-        """
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).fan_modes
-
-        return []
-
-    @property
-    def swing_mode(self) -> str | None:
-        """Return the swing setting.
-
-        Requires ClimateEntityFeature.SWING_MODE.
-        """
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).swing_mode
-
-        return None
-
-    @property
-    def swing_modes(self) -> list[str] | None:
-        """Return the list of available swing modes.
-
-        Requires ClimateEntityFeature.SWING_MODE.
-        """
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).swing_modes
-
-        return None
-
-    @property
-    def temperature_unit(self) -> str:
-        """Return the unit of measurement."""
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).temperature_unit
-
-        return self._unit
-
-    @property
-    def supported_features(self):
-        """Return the list of supported features."""
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).supported_features | self._support_flags
-
-        return self._support_flags
-
-    @property
-    def target_temperature_step(self) -> float | None:
-        """Return the supported step of target temperature."""
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).target_temperature_step
-
-        return None
-
-    @property
-    def target_temperature_high(self) -> float | None:
-        """Return the highbound target temperature we try to reach.
-
-        Requires ClimateEntityFeature.TARGET_TEMPERATURE_RANGE.
-        """
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).target_temperature_high
-
-        return None
-
-    @property
-    def target_temperature_low(self) -> float | None:
-        """Return the lowbound target temperature we try to reach.
-
-        Requires ClimateEntityFeature.TARGET_TEMPERATURE_RANGE.
-        """
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).target_temperature_low
-
-        return None
-
-    @property
-    def is_aux_heat(self) -> bool | None:
-        """Return true if aux heater.
-
-        Requires ClimateEntityFeature.AUX_HEAT.
-        """
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).is_aux_heat
-
-        return None
-
-    @overrides
-    def turn_aux_heat_on(self) -> None:
-        """Turn auxiliary heater on."""
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).turn_aux_heat_on()
-
-        raise NotImplementedError()
-
-    @overrides
-    async def async_turn_aux_heat_on(self) -> None:
-        """Turn auxiliary heater on."""
-        for under in self._underlyings:
-            await under.async_turn_aux_heat_on()
-
-    @overrides
-    def turn_aux_heat_off(self) -> None:
-        """Turn auxiliary heater off."""
-        for under in self._underlyings:
-            return under.turn_aux_heat_off()
-
-    @overrides
-    async def async_turn_aux_heat_off(self) -> None:
-        """Turn auxiliary heater off."""
-        for under in self._underlyings:
-            await under.async_turn_aux_heat_off()
-
-    @overrides
-    async def async_set_fan_mode(self, fan_mode):
-        """Set new target fan mode."""
-        _LOGGER.info("%s - Set fan mode: %s", self, fan_mode)
-        if fan_mode is None:
-            return
-
-        for under in self._underlyings:
-            await under.set_fan_mode(fan_mode)
-        self._fan_mode = fan_mode
-        self.async_write_ha_state()
-
-    @overrides
-    async def async_set_humidity(self, humidity: int):
-        """Set new target humidity."""
-        _LOGGER.info("%s - Set fan mode: %s", self, humidity)
-        if humidity is None:
-            return
-        for under in self._underlyings:
-            await under.set_humidity(humidity)
-        self._humidity = humidity
-        self.async_write_ha_state()
-
-    @overrides
-    async def async_set_swing_mode(self, swing_mode):
-        """Set new target swing operation."""
-        _LOGGER.info("%s - Set fan mode: %s", self, swing_mode)
-        if swing_mode is None:
-            return
-        for under in self._underlyings:
-            await under.set_swing_mode(swing_mode)
-        self._swing_mode = swing_mode
-        self.async_write_ha_state()
-
-    async def service_set_auto_regulation_mode(self, auto_regulation_mode):
-        """Called by a service call:
-        service: versatile_thermostat.set_auto_regulation_mode
-        data:
-            auto_regulation_mode: [None | Light | Medium | Strong]
-        target:
-            entity_id: climate.thermostat_1
-        """
-        _LOGGER.info("%s - Calling service_set_auto_regulation_mode, auto_regulation_mode: %s", self, auto_regulation_mode)
-        if auto_regulation_mode == "None":
-            self.choose_auto_regulation_mode(CONF_AUTO_REGULATION_NONE)
-        elif auto_regulation_mode == "Light":
-            self.choose_auto_regulation_mode(CONF_AUTO_REGULATION_LIGHT)
-        elif auto_regulation_mode == "Medium":
-            self.choose_auto_regulation_mode(CONF_AUTO_REGULATION_MEDIUM)
-        elif auto_regulation_mode == "Strong":
-            self.choose_auto_regulation_mode(CONF_AUTO_REGULATION_STRONG)
-
-        await self._send_regulated_temperature()
-        self.update_custom_attributes()
--- a/custom_components/versatile_thermostat/thermostat_switch.py
+++ b/custom_components/versatile_thermostat/thermostat_switch.py
@@ -2,7 +2,7 @@

 """ A climate over switch classe """
 import logging
-from homeassistant.core import callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.event import async_track_state_change_event
 from homeassistant.components.climate import HVACMode

@@ -10,13 +10,12 @@ from .const import (
    CONF_HEATER,
    CONF_HEATER_2,
    CONF_HEATER_3,
-    CONF_HEATER_4,
-    overrides
+    CONF_HEATER_4
 )

 from .base_thermostat import BaseThermostat
+
 from .underlyings import UnderlyingSwitch
-from .prop_algorithm import PropAlgorithm

 _LOGGER = logging.getLogger(__name__)

@@ -30,30 +29,19 @@ class ThermostatOverSwitch(BaseThermostat):
            "cycle_min", "function", "tpi_coef_int", "tpi_coef_ext"
        }))

-    # useless for now
-    # def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
-    #    """Initialize the thermostat over switch."""
-    #    super().__init__(hass, unique_id, name, entry_infos)
+    def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
+        """Initialize the thermostat over switch."""
+        super().__init__(hass, unique_id, name, entry_infos)

    @property
    def is_over_switch(self) -> bool:
        """ True if the Thermostat is over_switch"""
        return True

-    @overrides
    def post_init(self, entry_infos):
        """ Initialize the Thermostat"""

        super().post_init(entry_infos)
-
-        self._prop_algorithm = PropAlgorithm(
-            self._proportional_function,
-            self._tpi_coef_int,
-            self._tpi_coef_ext,
-            self._cycle_min,
-            self._minimal_activation_delay,
-        )
-
        lst_switches = [entry_infos.get(CONF_HEATER)]
        if entry_infos.get(CONF_HEATER_2):
            lst_switches.append(entry_infos.get(CONF_HEATER_2))
@@ -73,9 +61,6 @@ class ThermostatOverSwitch(BaseThermostat):
                )
            )

-        self._should_relaunch_control_heating = False
-
-    @overrides
    async def async_added_to_hass(self):
        """Run when entity about to be added."""
        _LOGGER.debug("Calling async_added_to_hass")
@@ -92,7 +77,6 @@ class ThermostatOverSwitch(BaseThermostat):

        self.hass.create_task(self.async_control_heating())

-    @overrides
    def update_custom_attributes(self):
        """ Custom attributes """
        super().update_custom_attributes()
@@ -131,7 +115,6 @@ class ThermostatOverSwitch(BaseThermostat):
            self._attr_extra_state_attributes,
        )

-    @overrides
    def recalculate(self):
        """A utility function to force the calculation of a the algo and
        update the custom attributes and write the state
@@ -145,32 +128,3 @@ class ThermostatOverSwitch(BaseThermostat):
        )
        self.update_custom_attributes()
        self.async_write_ha_state()
-
-    @overrides
-    def incremente_energy(self):
-        """increment the energy counter if device is active"""
-        if self.hvac_mode == HVACMode.OFF:
-            return
-
-        added_energy = 0
-        if not self.is_over_climate and self.mean_cycle_power is not None:
-            added_energy = self.mean_cycle_power * float(self._cycle_min) / 60.0
-
-        self._total_energy += added_energy
-        _LOGGER.debug(
-            "%s - added energy is %.3f . Total energy is now: %.3f",
-            self,
-            added_energy,
-            self._total_energy,
-        )
-
-    @callback
-    def _async_switch_changed(self, event):
-        """Handle heater switch state changes."""
-        new_state = event.data.get("new_state")
-        old_state = event.data.get("old_state")
-        if new_state is None:
-            return
-        if old_state is None:
-            self.hass.create_task(self._check_initial_state())
-        self.async_write_ha_state()
--- a/custom_components/versatile_thermostat/thermostat_valve.py
+++ b/custom_components/versatile_thermostat/thermostat_valve.py
@@ -3,14 +3,14 @@
 import logging
 from datetime import timedelta

+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.event import async_track_state_change_event, async_track_time_interval
 from homeassistant.core import callback
-from homeassistant.components.climate import HVACMode
+from homeassistant.components.climate import HVACMode, HVACAction

 from .base_thermostat import BaseThermostat
-from .prop_algorithm import PropAlgorithm

-from .const import CONF_VALVE, CONF_VALVE_2, CONF_VALVE_3, CONF_VALVE_4, overrides
+from .const import CONF_VALVE, CONF_VALVE_2, CONF_VALVE_3, CONF_VALVE_4

 from .underlyings import UnderlyingValve

@@ -26,10 +26,9 @@ class ThermostatOverValve(BaseThermostat):
            "cycle_min", "function", "tpi_coef_int", "tpi_coef_ext"
        }))

-    # Useless for now
-    # def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
-    #    """Initialize the thermostat over switch."""
-    #    super().__init__(hass, unique_id, name, entry_infos)
+    def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
+        """Initialize the thermostat over switch."""
+        super().__init__(hass, unique_id, name, entry_infos)

    @property
    def is_over_valve(self) -> bool:
@@ -44,19 +43,10 @@ class ThermostatOverValve(BaseThermostat):
        else:
            return round(max(0, min(self.proportional_algorithm.on_percent, 1)) * 100)

-    @overrides
    def post_init(self, entry_infos):
        """ Initialize the Thermostat"""

        super().post_init(entry_infos)
-        self._prop_algorithm = PropAlgorithm(
-            self._proportional_function,
-            self._tpi_coef_int,
-            self._tpi_coef_ext,
-            self._cycle_min,
-            self._minimal_activation_delay,
-        )
-
        lst_valves = [entry_infos.get(CONF_VALVE)]
        if entry_infos.get(CONF_VALVE_2):
            lst_valves.append(entry_infos.get(CONF_VALVE_2))
@@ -74,9 +64,6 @@ class ThermostatOverValve(BaseThermostat):
                )
            )

-        self._should_relaunch_control_heating = False
-
-    @overrides
    async def async_added_to_hass(self):
        """Run when entity about to be added."""
        _LOGGER.debug("Calling async_added_to_hass")
@@ -104,12 +91,174 @@ class ThermostatOverValve(BaseThermostat):
    @callback
    async def _async_valve_changed(self, event):
        """Handle unerdlying valve state changes.
-        This method just log the change. It changes nothing to avoid loops.
+        This method takes the underlying values and update the VTherm with them.
+        To avoid loops (issues #121 #101 #95 #99), we discard the event if it is received
+        less than 10 sec after the last command. What we want here is to take the values
+        from underlyings ONLY if someone have change directly on the underlying and not
+        as a return of the command. The only thing we take all the time is the HVACAction
+        which is important for feedaback and which cannot generates loops.
        """
-        new_state = event.data.get("new_state")
-        _LOGGER.debug("%s - _async_valve_changed new_state is %s", self, new_state.state)

-    @overrides
+        async def end_climate_changed(changes):
+            """To end the event management"""
+            if changes:
+                self.async_write_ha_state()
+                self.update_custom_attributes()
+                await self.async_control_heating()
+
+        new_state = event.data.get("new_state")
+        _LOGGER.debug("%s - _async_climate_changed new_state is %s", self, new_state)
+        if not new_state:
+            return
+
+        changes = False
+        new_hvac_mode = new_state.state
+
+        old_state = event.data.get("old_state")
+        old_hvac_action = (
+            old_state.attributes.get("hvac_action")
+            if old_state and old_state.attributes
+            else None
+        )
+        new_hvac_action = (
+            new_state.attributes.get("hvac_action")
+            if new_state and new_state.attributes
+            else None
+        )
+
+        old_state_date_changed = (
+            old_state.last_changed if old_state and old_state.last_changed else None
+        )
+        old_state_date_updated = (
+            old_state.last_updated if old_state and old_state.last_updated else None
+        )
+        new_state_date_changed = (
+            new_state.last_changed if new_state and new_state.last_changed else None
+        )
+        new_state_date_updated = (
+            new_state.last_updated if new_state and new_state.last_updated else None
+        )
+
+        # Issue 99 - some AC turn hvac_mode=cool and hvac_action=idle when sending a HVACMode_OFF command
+        # Issue 114 - Remove this because hvac_mode is now managed by local _hvac_mode and use idle action as is
+        # if self._hvac_mode == HVACMode.OFF and new_hvac_action == HVACAction.IDLE:
+        #    _LOGGER.debug("The underlying switch to idle instead of OFF. We will consider it as OFF")
+        #    new_hvac_mode = HVACMode.OFF
+
+        _LOGGER.info(
+            "%s - Underlying climate changed. Event.new_hvac_mode is %s, current_hvac_mode=%s, new_hvac_action=%s, old_hvac_action=%s",
+            self,
+            new_hvac_mode,
+            self._hvac_mode,
+            new_hvac_action,
+            old_hvac_action,
+        )
+
+        _LOGGER.debug(
+            "%s - last_change_time=%s old_state_date_changed=%s old_state_date_updated=%s new_state_date_changed=%s new_state_date_updated=%s",
+            self,
+            self._last_change_time,
+            old_state_date_changed,
+            old_state_date_updated,
+            new_state_date_changed,
+            new_state_date_updated,
+        )
+
+        # Interpretation of hvac action
+        HVAC_ACTION_ON = [  # pylint: disable=invalid-name
+            HVACAction.COOLING,
+            HVACAction.DRYING,
+            HVACAction.FAN,
+            HVACAction.HEATING,
+        ]
+        if old_hvac_action not in HVAC_ACTION_ON and new_hvac_action in HVAC_ACTION_ON:
+            self._underlying_climate_start_hvac_action_date = (
+                self.get_last_updated_date_or_now(new_state)
+            )
+            _LOGGER.info(
+                "%s - underlying just switch ON. Set power and energy start date %s",
+                self,
+                self._underlying_climate_start_hvac_action_date.isoformat(),
+            )
+            changes = True
+
+        if old_hvac_action in HVAC_ACTION_ON and new_hvac_action not in HVAC_ACTION_ON:
+            stop_power_date = self.get_last_updated_date_or_now(new_state)
+            if self._underlying_climate_start_hvac_action_date:
+                delta = (
+                    stop_power_date - self._underlying_climate_start_hvac_action_date
+                )
+                self._underlying_climate_delta_t = delta.total_seconds() / 3600.0
+
+                # increment energy at the end of the cycle
+                self.incremente_energy()
+
+                self._underlying_climate_start_hvac_action_date = None
+
+            _LOGGER.info(
+                "%s - underlying just switch OFF at %s. delta_h=%.3f h",
+                self,
+                stop_power_date.isoformat(),
+                self._underlying_climate_delta_t,
+            )
+            changes = True
+
+        # Issue #120 - Some TRV are chaning target temperature a very long time (6 sec) after the change.
+        # In that case a loop is possible if a user change multiple times during this 6 sec.
+        if new_state_date_updated and self._last_change_time:
+            delta = (new_state_date_updated - self._last_change_time).total_seconds()
+            if delta < 10:
+                _LOGGER.info(
+                    "%s - underlying event is received less than 10 sec after command. Forget it to avoid loop",
+                    self,
+                )
+                await end_climate_changed(changes)
+                return
+
+        if (
+            new_hvac_mode
+            in [
+                HVACMode.OFF,
+                HVACMode.HEAT,
+                HVACMode.COOL,
+                HVACMode.HEAT_COOL,
+                HVACMode.DRY,
+                HVACMode.AUTO,
+                HVACMode.FAN_ONLY,
+                None,
+            ]
+            and self._hvac_mode != new_hvac_mode
+        ):
+            changes = True
+            self._hvac_mode = new_hvac_mode
+            # Update all underlyings state
+            if self.is_over_climate:
+                for under in self._underlyings:
+                    await under.set_hvac_mode(new_hvac_mode)
+
+        if not changes:
+            # try to manage new target temperature set if state
+            _LOGGER.debug(
+                "Do temperature check. temperature is %s, new_state.attributes is %s",
+                self.target_temperature,
+                new_state.attributes,
+            )
+            if (
+                self.is_over_climate
+                and new_state.attributes
+                and (new_target_temp := new_state.attributes.get("temperature"))
+                and new_target_temp != self.target_temperature
+            ):
+                _LOGGER.info(
+                    "%s - Target temp in underlying have change to %s",
+                    self,
+                    new_target_temp,
+                )
+                await self.async_set_temperature(temperature=new_target_temp)
+                changes = True
+
+        await end_climate_changed(changes)
+
    def update_custom_attributes(self):
        """ Custom attributes """
        super().update_custom_attributes()
@@ -148,7 +297,6 @@ class ThermostatOverValve(BaseThermostat):
            self._attr_extra_state_attributes,
        )

-    @overrides
    def recalculate(self):
        """A utility function to force the calculation of a the algo and
        update the custom attributes and write the state
@@ -168,21 +316,3 @@ class ThermostatOverValve(BaseThermostat):

        self.update_custom_attributes()
        self.async_write_ha_state()
-
-    @overrides
-    def incremente_energy(self):
-        """increment the energy counter if device is active"""
-        if self.hvac_mode == HVACMode.OFF:
-            return
-
-        added_energy = 0
-        if not self.is_over_climate and self.mean_cycle_power is not None:
-            added_energy = self.mean_cycle_power * float(self._cycle_min) / 60.0
-
-        self._total_energy += added_energy
-        _LOGGER.debug(
-            "%s - added energy is %.3f . Total energy is now: %.3f",
-            self,
-            added_energy,
-            self._total_energy,
-        )
--- a/custom_components/versatile_thermostat/translations/en.json
+++ b/custom_components/versatile_thermostat/translations/en.json
@@ -34,14 +34,7 @@
          "climate_entity2_id": "2nd underlying climate",
          "climate_entity3_id": "3rd underlying climate",
          "climate_entity4_id": "4th underlying climate",
-          "ac_mode": "AC mode",
-          "valve_entity_id": "1rst valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
-          "auto_regulation_mode": "Self-regulation",
-          "auto_regulation_dtemp": "Regulation threshold",
-          "auto_regulation_periode_min": "Regulation minimal period"
+          "ac_mode": "AC mode"
        },
        "data_description": {
          "heater_entity_id": "Mandatory heater entity id",
@@ -53,14 +46,7 @@
          "climate_entity2_id": "2nd underlying climate entity id",
          "climate_entity3_id": "3rd underlying climate entity id",
          "climate_entity4_id": "4th underlying climate entity id",
-          "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1rst valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
-          "auto_regulation_mode": "Auto adjustment of the target temperature",
-          "auto_regulation_dtemp": "The threshold in ° under which the temperature change will not be send",
-          "auto_regulation_periode_min": "Duration in minutes between two regulation update"
+          "ac_mode": "Use the Air Conditioning (AC) mode"
        }
      },
      "tpi": {
@@ -192,23 +178,16 @@
        "title": "Linked entities",
        "description": "Linked entities attributes",
        "data": {
-          "heater_entity_id": "1rst heater switch",
-          "heater_entity2_id": "2nd heater switch",
-          "heater_entity3_id": "3rd heater switch",
-          "heater_entity4_id": "4th heater switch",
+          "heater_entity_id": "Heater switch",
+          "heater_entity2_id": "2nd Heater switch",
+          "heater_entity3_id": "3rd Heater switch",
+          "heater_entity4_id": "4th Heater switch",
          "proportional_function": "Algorithm",
-          "climate_entity_id": "1rst underlying climate",
+          "climate_entity_id": "Underlying thermostat",
          "climate_entity2_id": "2nd underlying climate",
          "climate_entity3_id": "3rd underlying climate",
          "climate_entity4_id": "4th underlying climate",
-          "ac_mode": "AC mode",
-          "valve_entity_id": "1rst valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
-          "auto_regulation_mode": "Self-regulation",
-          "auto_regulation_dtemp": "Regulation threshold",
-          "auto_regulation_periode_min": "Regulation minimal period"
+          "ac_mode": "AC mode"
        },
        "data_description": {
          "heater_entity_id": "Mandatory heater entity id",
@@ -220,14 +199,7 @@
          "climate_entity2_id": "2nd underlying climate entity id",
          "climate_entity3_id": "3rd underlying climate entity id",
          "climate_entity4_id": "4th underlying climate entity id",
-          "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1rst valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
-          "auto_regulation_mode": "Auto adjustment of the target temperature",
-          "auto_regulation_dtemp": "The threshold in ° under which the temperature change will not be send",
-          "auto_regulation_periode_min": "Duration in minutes between two regulation update"
+          "ac_mode": "Use the Air Conditioning (AC) mode"
        }
      },
      "tpi": {
@@ -338,17 +310,9 @@
    "thermostat_type": {
      "options": {
        "thermostat_over_switch": "Thermostat over a switch",
-        "thermostat_over_climate": "Thermostat over a climate",
+        "thermostat_over_climate": "Thermostat over another thermostat",
        "thermostat_over_valve": "Thermostat over a valve"
      }
-    },
-    "auto_regulation_mode": {
-      "options": {
-        "auto_regulation_strong": "Strong",
-        "auto_regulation_medium": "Medium",
-        "auto_regulation_light": "Light",
-        "auto_regulation_none": "No auto-regulation"
-      }
    }
  },
  "entity": {
--- a/custom_components/versatile_thermostat/translations/fr.json
+++ b/custom_components/versatile_thermostat/translations/fr.json
@@ -38,10 +38,7 @@
          "valve_entity_id": "1ère valve number",
          "valve_entity2_id": "2ème valve number",
          "valve_entity3_id": "3ème valve number",
-          "valve_entity4_id": "4ème valve number",
-          "auto_regulation_mode": "Auto-régulation",
-          "auto_regulation_dtemp": "Seuil de régulation",
-          "auto_regulation_periode_min": "Période minimale de régulation"
+          "valve_entity4_id": "4ème valve number"
        },
        "data_description": {
          "heater_entity_id": "Entity id du 1er radiateur obligatoire",
@@ -57,10 +54,7 @@
          "valve_entity_id": "Entity id de la 1ère valve",
          "valve_entity2_id": "Entity id de la 2ème valve",
          "valve_entity3_id": "Entity id de la 3ème valve",
-          "valve_entity4_id": "Entity id de la 4ème valve",
-          "auto_regulation_mode": "Ajustement automatique de la température cible",
-          "auto_regulation_dtemp": "Le seuil en ° au-dessous duquel la régulation ne sera pas envoyée",
-          "auto_regulation_periode_min": "La durée en minutes entre deux mise à jour faites par la régulation"
+          "valve_entity4_id": "Entity id de la 4ème valve"
        }
      },
      "tpi": {
@@ -203,13 +197,10 @@
          "climate_entity3_id": "3ème thermostat sous-jacent",
          "climate_entity4_id": "4ème thermostat sous-jacent",
          "ac_mode": "AC mode ?",
-          "valve_entity_id": "1ère valve",
-          "valve_entity2_id": "2ème valve",
-          "valve_entity3_id": "3ème valve",
-          "valve_entity4_id": "4ème valve",
-          "auto_regulation_mode": "Auto-regulation",
-          "auto_regulation_dtemp": "Seuil de régulation",
-          "auto_regulation_periode_min": "Période minimale de régulation"
+          "valve_entity_id": "1ère valve number",
+          "valve_entity2_id": "2ème valve number",
+          "valve_entity3_id": "3ème valve number",
+          "valve_entity4_id": "4ème valve number"
        },
        "data_description": {
          "heater_entity_id": "Entity id du 1er radiateur obligatoire",
@@ -225,10 +216,7 @@
          "valve_entity_id": "Entity id de la 1ère valve",
          "valve_entity2_id": "Entity id de la 2ème valve",
          "valve_entity3_id": "Entity id de la 3ème valve",
-          "valve_entity4_id": "Entity id de la 4ème valve",
-          "auto_regulation_mode": "Ajustement automatique de la consigne",
-          "auto_regulation_dtemp": "Le seuil en ° au-dessous duquel la régulation ne sera pas envoyée",
-          "auto_regulation_periode_min": "La durée en minutes entre deux mise à jour faites par la régulation"
+          "valve_entity4_id": "Entity id de la 4ème valve"
        }
      },
      "tpi": {
@@ -342,14 +330,6 @@
        "thermostat_over_climate": "Thermostat sur un autre thermostat",
        "thermostat_over_valve": "Thermostat sur une valve"
      }
-    },
-    "auto_regulation_mode": {
-      "options": {
-        "auto_regulation_strong": "Forte",
-        "auto_regulation_medium": "Moyenne",
-        "auto_regulation_light": "Légère",
-        "auto_regulation_none": "Aucune"
-      }
    }
  },
  "entity": {
--- a/custom_components/versatile_thermostat/translations/it.json
+++ b/custom_components/versatile_thermostat/translations/it.json
@@ -38,8 +38,7 @@
          "valve_entity_id": "Primo valvola numero",
          "valve_entity2_id": "Secondo valvola numero",
          "valve_entity3_id": "Terzo valvola numero",
-          "valve_entity4_id": "Quarto valvola numero",
-          "auto_regulation_mode": "Autoregolamentazione"
+          "valve_entity4_id": "Quarto valvola numero"
        },
        "data_description": {
          "heater_entity_id": "Entity id obbligatoria del primo riscaldatore",
@@ -55,8 +54,7 @@
          "valve_entity_id": "Entity id del primo valvola numero",
          "valve_entity2_id": "Entity id del secondo valvola numero",
          "valve_entity3_id": "Entity id del terzo valvola numero",
-          "valve_entity4_id": "Entity id del quarto valvola numero",
-          "auto_regulation_mode": "Regolazione automatica della temperatura target"
+          "valve_entity4_id": "Entity id del quarto valvola numero"
        }
      },
      "tpi": {
@@ -194,8 +192,7 @@
          "valve_entity_id": "Primo valvola numero",
          "valve_entity2_id": "Secondo valvola numero",
          "valve_entity3_id": "Terzo valvola numero",
-          "valve_entity4_id": "Quarto valvola numero",
-          "auto_regulation_mode": "Autoregolamentazione"
+          "valve_entity4_id": "Quarto valvola numero"
        },
        "data_description": {
          "heater_entity_id": "Entity id obbligatoria del primo riscaldatore",
@@ -211,8 +208,7 @@
          "valve_entity_id": "Entity id del primo valvola numero",
          "valve_entity2_id": "Entity id del secondo valvola numero",
          "valve_entity3_id": "Entity id del terzo valvola numero",
-          "valve_entity4_id": "Entity id del quarto valvola numero",
-          "auto_regulation_mode": "Autoregolamentazione"
+          "valve_entity4_id": "Entity id del quarto valvola numero"
        }
      },
      "tpi": {
@@ -319,14 +315,6 @@
        "thermostat_over_climate": "Termostato sopra un altro termostato",
        "thermostat_over_valve": "Thermostato su una valvola"
      }
-    },
-    "auto_regulation_mode": {
-      "options": {
-        "auto_regulation_strong": "Forte",
-        "auto_regulation_medium": "Media",
-        "auto_regulation_light": "Leggera",
-        "auto_regulation_none": "Nessuna autoregolamentazione"
-      }
    }
  },
  "entity": {
--- a/custom_components/versatile_thermostat/translations/sk.json
+++ b/custom_components/versatile_thermostat/translations/sk.json
@@ -1,349 +0,0 @@
-{
-  "title": "Všestranná konfigurácia termostatu",
-  "config": {
-    "flow_title": "Všestranná konfigurácia termostatu",
-    "step": {
-      "user": {
-        "title": "Pridajte nový všestranný termostat",
-        "description": "Hlavné povinné atribúty",
-        "data": {
-          "name": "Názov",
-          "thermostat_type": "Termostat typ",
-          "temperature_sensor_entity_id": "ID entity snímača teploty",
-          "external_temperature_sensor_entity_id": "ID entity externého snímača teploty",
-          "cycle_min": "Trvanie cyklu (minúty)",
-          "temp_min": "Minimálna povolená teplota",
-          "temp_max": "Maximálna povolená teplota",
-          "device_power": "Napájanie zariadenia",
-          "use_window_feature": "Použite detekciu okien",
-          "use_motion_feature": "Použite detekciu pohybu",
-          "use_power_feature": "Použite správu napájania",
-          "use_presence_feature": "Použite detekciu prítomnosti"
-        }
-      },
-      "type": {
-        "title": "Prepojené entity",
-        "description": "Atribúty prepojených entít",
-        "data": {
-          "heater_entity_id": "1. spínač ohrievača",
-          "heater_entity2_id": "2. spínač ohrievača",
-          "heater_entity3_id": "3. spínač ohrievača",
-          "heater_entity4_id": "4. spínač ohrievača",
-          "proportional_function": "Algoritmus",
-          "climate_entity_id": "1. základná klíma",
-          "climate_entity2_id": "2. základná klíma",
-          "climate_entity3_id": "3. základná klíma",
-          "climate_entity4_id": "4. základná klíma",
-          "ac_mode": "AC režim",
-          "valve_entity_id": "1. ventil číslo",
-          "valve_entity2_id": "2. ventil číslo",
-          "valve_entity3_id": "3. ventil číslo",
-          "valve_entity4_id": "4. ventil číslo"
-        },
-        "data_description": {
-          "heater_entity_id": "ID entity povinného ohrievača",
-          "heater_entity2_id": "Voliteľné ID entity 2. ohrievača. Ak sa nepoužíva, nechajte prázdne",
-          "heater_entity3_id": "Voliteľné ID entity 3. ohrievača. Ak sa nepoužíva, nechajte prázdne",
-          "heater_entity4_id": "Voliteľné ID entity 4. ohrievača. Ak sa nepoužíva, nechajte prázdne",
-          "proportional_function": "Algoritmus, ktorý sa má použiť (TPI je zatiaľ jediný)",
-          "climate_entity_id": "ID základnej klimatickej entity",
-          "climate_entity2_id": "2. základné identifikačné číslo klimatickej entity",
-          "climate_entity3_id": "3. základné identifikačné číslo klimatickej entity",
-          "climate_entity4_id": "4. základné identifikačné číslo klimatickej entity",
-          "ac_mode": "Použite režim klimatizácie (AC)",
-          "valve_entity_id": "1. ventil číslo entity id",
-          "valve_entity2_id": "2. ventil číslo entity id",
-          "valve_entity3_id": "3. ventil číslo entity id",
-          "valve_entity4_id": "4. ventil číslo entity id"
-        }
-      },
-      "tpi": {
-        "title": "TPI",
-        "description": "Časovo proporcionálne integrálne atribúty",
-        "data": {
-          "tpi_coef_int": "Koeficient na použitie pre vnútornú teplotnú deltu",
-          "tpi_coef_ext": "Koeficient na použitie pre deltu vonkajšej teploty"
-        }
-      },
-      "presets": {
-        "title": "Predvoľby",
-        "description": "Pre každú predvoľbu zadajte cieľovú teplotu (0, ak chcete predvoľbu ignorovať)",
-        "data": {
-          "eco_temp": "Teplota v predvoľbe Eco",
-          "comfort_temp": "Prednastavená teplota v komfortnom režime",
-          "boost_temp": "Teplota v prednastavení Boost",
-          "eco_ac_temp": "Teplota v režime Eco prednastavená pre režim AC",
-          "comfort_ac_temp": "Teplota v režime Comfort je prednastavená pre režim AC",
-          "boost_ac_temp": "Prednastavená teplota v režime Boost pre režim AC"
-        }
-      },
-      "window": {
-        "title": "Správa okien",
-        "description": "Otvoriť správu okien.\nAk sa príslušné entity_id nepoužíva, ponechajte prázdne\nMôžete tiež nakonfigurovať automatickú detekciu otvoreného okna na základe poklesu teploty",
-        "data": {
-          "window_sensor_entity_id": "ID entity snímača okna",
-          "window_delay": "Oneskorenie snímača okna (sekundy)",
-          "window_auto_open_threshold": "Prah poklesu teploty pre automatickú detekciu otvoreného okna (v °/min)",
-          "window_auto_close_threshold": "Prahová hodnota zvýšenia teploty pre koniec automatickej detekcie (v °/min)",
-          "window_auto_max_duration": "Maximálne trvanie automatickej detekcie otvoreného okna (v min)"
-        },
-        "data_description": {
-          "window_sensor_entity_id": "Nechajte prázdne, ak nemáte použiť žiadny okenný senzor",
-          "window_delay": "Zohľadňuje sa oneskorenie v sekundách pred detekciou snímača",
-          "window_auto_open_threshold": "Odporúčaná hodnota: medzi 0,05 a 0,1. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
-          "window_auto_close_threshold": "Odporúčaná hodnota: 0. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
-          "window_auto_max_duration": "Odporúčaná hodnota: 60 (jedna hodina). Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne"
-        }
-      },
-      "motion": {
-        "title": "Riadenie pohybu",
-        "description": "Správa snímača pohybu. Predvoľba sa môže automaticky prepínať v závislosti od detekcie pohybu\nAk sa nepoužíva, ponechajte zodpovedajúce entity_id prázdne.\nmotion_preset a no_motion_preset by mali byť nastavené na zodpovedajúci názov predvoľby",
-        "data": {
-          "motion_sensor_entity_id": "ID entity snímača pohybu",
-          "motion_delay": "Oneskorenie aktivácie",
-          "motion_off_delay": "Oneskorenie deaktivácie",
-          "motion_preset": "Prednastavený pohyb",
-          "no_motion_preset": "Žiadna predvoľba pohybu"
-        },
-        "data_description": {
-          "motion_sensor_entity_id": "ID entity snímača pohybu",
-          "motion_delay": "Oneskorenie aktivácie pohybu (sekundy)",
-          "motion_off_delay": "Oneskorenie deaktivácie pohybu (sekundy)",
-          "motion_preset": "Prednastavené na použitie pri detekcii pohybu",
-          "no_motion_preset": "Prednastavené na použitie, keď nie je detekovaný žiadny pohyb"
-        }
-      },
-      "power": {
-        "title": "Správa napájania",
-        "description": "Atribúty správy napájania.\nPoskytuje senzor výkonu a maximálneho výkonu vášho domova.\nPotom zadajte spotrebu energie ohrievača, keď je zapnutý.\nVšetky senzory a výkon zariadenia by mali mať rovnakú jednotku (kW alebo W).\nPonechajte zodpovedajúce entity_id prázdne ak sa nepoužíva.",
-        "data": {
-          "power_sensor_entity_id": "ID entity snímača výkonu",
-          "max_power_sensor_entity_id": "ID entity snímača maximálneho výkonu",
-          "power_temp": "Teplota pre zníženie výkonu"
-        }
-      },
-      "presence": {
-        "title": "Riadenie prítomnosti",
-        "description": "Atribúty správy prítomnosti.\nPoskytuje senzor prítomnosti vášho domova (pravda, ak je niekto prítomný).\nPotom zadajte buď predvoľbu, ktorá sa má použiť, keď je senzor prítomnosti nepravdivý, alebo posun teploty, ktorý sa má použiť.\nAk je zadaná predvoľba, posun sa nepoužije.\nAk sa nepoužije, ponechajte zodpovedajúce entity_id prázdne.",
-        "data": {
-          "presence_sensor_entity_id": "ID entity senzora prítomnosti",
-          "eco_away_temp": "Teplota v prednastavenej Eco, keď nie je žiadna prítomnosť",
-          "comfort_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný",
-          "boost_away_temp": "Prednastavená teplota v režime Boost, keď nie je prítomný",
-          "eco_ac_away_temp": "Teplota v prednastavenej Eco, keď nie je prítomná v režime AC",
-          "comfort_ac_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný v režime AC",
-          "boost_ac_away_temp": "Teplota v prednastavenom Boost, keď nie je prítomný v režime AC"
-        }
-      },
-      "advanced": {
-        "title": "Pokročilé parametre",
-        "description": "Konfigurácia pokročilých parametrov. Ak neviete, čo robíte, ponechajte predvolené hodnoty.\nTento parameter môže viesť k veľmi zlej regulácii teploty alebo výkonu.",
-        "data": {
-          "minimal_activation_delay": "Minimálne oneskorenie aktivácie",
-          "security_delay_min": "Bezpečnostné oneskorenie (v minútach)",
-          "security_min_on_percent": "Minimálne percento výkonu na aktiváciu bezpečnostného režimu",
-          "security_default_on_percent": "Percento výkonu na použitie v bezpečnostnom režime"
-        },
-        "data_description": {
-          "minimal_activation_delay": "Oneskorenie v sekundách, pri ktorom sa zariadenie neaktivuje",
-          "security_delay_min": "Maximálne povolené oneskorenie v minútach medzi dvoma meraniami teploty. Po uplynutí tohto oneskorenia sa termostat prepne do bezpečnostného vypnutého stavu",
-          "security_min_on_percent": "Minimálna percentuálna hodnota ohrevu pre aktiváciu prednastavenej bezpečnosti. Pod týmto percentom výkonu termostat neprejde do prednastavenia zabezpečenia",
-          "security_default_on_percent": "Predvolená percentuálna hodnota vykurovacieho výkonu v bezpečnostnej predvoľbe. Nastavte na 0, ak chcete vypnúť ohrievač v zabezpečenom stave"
-        }
-      }
-    },
-    "error": {
-      "unknown": "Neočakávaná chyba",
-      "unknown_entity": "Neznáme ID entity",
-      "window_open_detection_method": "Mala by sa použiť iba jedna metóda detekcie otvoreného okna. Použite senzor alebo automatickú detekciu cez teplotný prah, ale nie oboje"
-    },
-    "abort": {
-      "already_configured": "Zariadenie je už nakonfigurované"
-    }
-  },
-  "options": {
-    "flow_title": "Všestranná konfigurácia termostatu",
-    "step": {
-      "user": {
-        "title": "Pridajte nový všestranný termostat",
-        "description": "Hlavné povinné atribúty",
-        "data": {
-          "name": "Názov",
-          "thermostat_type": "Termostat typ",
-          "temperature_sensor_entity_id": "ID entity snímača teploty",
-          "external_temperature_sensor_entity_id": "ID entity externého snímača teploty",
-          "cycle_min": "Trvanie cyklu (minúty)",
-          "temp_min": "Minimálna povolená teplota",
-          "temp_max": "Maximálna povolená teplota",
-          "device_power": "Výkon zariadenia (kW)",
-          "use_window_feature": "Použite detekciu okien",
-          "use_motion_feature": "Použite detekciu pohybu",
-          "use_power_feature": "Použite správu napájania",
-          "use_presence_feature": "Použite detekciu prítomnosti"
-        }
-      },
-      "type": {
-        "title": "Prepojené entity",
-        "description": "Atribúty prepojených entít",
-        "data": {
-          "heater_entity_id": "Spínač ohrievača",
-          "heater_entity2_id": "2. spínač ohrievača",
-          "heater_entity3_id": "3. spínač ohrievača",
-          "heater_entity4_id": "4. spínač ohrievača",
-          "proportional_function": "Algoritmus",
-          "climate_entity_id": "Základná klíma",
-          "climate_entity2_id": "2. základná klíma",
-          "climate_entity3_id": "3. základná klíma",
-          "climate_entity4_id": "4. základná klíma",
-          "ac_mode": "AC režim",
-          "valve_entity_id": "1. ventil číslo",
-          "valve_entity2_id": "2. ventil číslo",
-          "valve_entity3_id": "3. ventil číslo",
-          "valve_entity4_id": "4. ventil číslo"
-        },
-        "data_description": {
-          "heater_entity_id": "ID entity povinného ohrievača",
-          "heater_entity2_id": "Voliteľné ID entity 2. ohrievača. Ak sa nepoužíva, nechajte prázdne",
-          "heater_entity3_id": "Voliteľné ID entity 3. ohrievača. Ak sa nepoužíva, nechajte prázdne",
-          "heater_entity4_id": "Voliteľné ID entity 4. ohrievača. Ak sa nepoužíva, nechajte prázdne",
-          "proportional_function": "Algoritmus, ktorý sa má použiť (TPI je zatiaľ jediný)",
-          "climate_entity_id": "ID základnej klimatickej entity",
-          "climate_entity2_id": "2. základný identifikátor klimatickej entity",
-          "climate_entity3_id": "3. základný identifikátor klimatickej entity",
-          "climate_entity4_id": "4. základný identifikátor klimatickej entity",
-          "ac_mode": "Použite režim klimatizácie (AC)",
-          "valve_entity_id": "1. ventil číslo entity id",
-          "valve_entity2_id": "2. ventil číslo entity id",
-          "valve_entity3_id": "3. ventil číslo entity id",
-          "valve_entity4_id": "4. ventil číslo entity id"
-        }
-      },
-      "tpi": {
-        "title": "TPI",
-        "description": "Časovo proporcionálne integrálne atribúty",
-        "data": {
-          "tpi_coef_int": "Koeficient na použitie pre vnútornú teplotnú deltu",
-          "tpi_coef_ext": "Koeficient na použitie pre vonkajšiu teplotnú deltu"
-        }
-      },
-      "presets": {
-        "title": "Predvoľby",
-        "description": "Pre každú predvoľbu zadajte cieľovú teplotu (0, ak chcete predvoľbu ignorovať)",
-        "data": {
-          "eco_temp": "Teplota v predvoľbe Eco",
-          "comfort_temp": "Prednastavená teplota v komfortnom režime",
-          "boost_temp": "Teplota v prednastavení Boost",
-          "eco_ac_temp": "Teplota v režime Eco prednastavená pre režim AC",
-          "comfort_ac_temp": "Teplota v režime Comfort je prednastavená pre režim AC",
-          "boost_ac_temp": "Prednastavená teplota v režime Boost pre režim AC"
-        }
-      },
-      "window": {
-        "title": "Správa okien",
-        "description": "Otvoriť správu okien.\nAk sa príslušné entity_id nepoužíva, ponechajte prázdne\nMôžete tiež nakonfigurovať automatickú detekciu otvoreného okna na základe poklesu teploty",
-        "data": {
-          "window_sensor_entity_id": "ID entity snímača okna",
-          "window_delay": "Oneskorenie snímača okna (sekundy)",
-          "window_auto_open_threshold": "Prah poklesu teploty pre automatickú detekciu otvoreného okna (v °/min)",
-          "window_auto_close_threshold": "Prahová hodnota zvýšenia teploty pre koniec automatickej detekcie (v °/min)",
-          "window_auto_max_duration": "Maximálne trvanie automatickej detekcie otvoreného okna (v min)"
-        },
-        "data_description": {
-          "window_sensor_entity_id": "Nechajte prázdne, ak nemáte použiť žiadny okenný senzor",
-          "window_delay": "Zohľadňuje sa oneskorenie v sekundách pred detekciou snímača",
-          "window_auto_open_threshold": "Odporúčaná hodnota: medzi 0,05 a 0,1. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
-          "window_auto_close_threshold": "Odporúčaná hodnota: 0. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
-          "window_auto_max_duration": "Odporúčaná hodnota: 60 (jedna hodina). Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne"
-        }
-      },
-      "motion": {
-        "title": "Riadenie pohybu",
-        "description": "Správa snímača pohybu. Predvoľba sa môže automaticky prepínať v závislosti od detekcie pohybu\nAk sa nepoužíva, ponechajte zodpovedajúce entity_id prázdne.\nmotion_preset a no_motion_preset by mali byť nastavené na zodpovedajúci názov predvoľby",
-        "data": {
-          "motion_sensor_entity_id": "ID entity snímača pohybu",
-          "motion_delay": "Oneskorenie aktivácie",
-          "motion_off_delay": "Oneskorenie deaktivácie",
-          "motion_preset": "Prednastavený pohyb",
-          "no_motion_preset": "Žiadna predvoľba pohybu"
-        },
-        "data_description": {
-          "motion_sensor_entity_id": "ID entity snímača pohybu",
-          "motion_delay": "Oneskorenie aktivácie pohybu (sekundy)",
-          "motion_off_delay": "Oneskorenie deaktivácie pohybu (sekundy)",
-          "motion_preset": "Prednastavené na použitie pri detekcii pohybu",
-          "no_motion_preset": "Prednastavené na použitie, keď nie je detekovaný žiadny pohyb"
-        }
-      },
-      "power": {
-        "title": "Správa napájania",
-        "description": "Atribúty správy napájania.\nPoskytuje senzor výkonu a maximálneho výkonu vášho domova.\nPotom zadajte spotrebu energie ohrievača, keď je zapnutý.\nVšetky senzory a výkon zariadenia by mali mať rovnakú jednotku (kW alebo W).\nPonechajte zodpovedajúce entity_id prázdne ak sa nepoužíva.",
-        "data": {
-          "power_sensor_entity_id": "ID entity snímača výkonu",
-          "max_power_sensor_entity_id": "ID entity snímača maximálneho výkonu",
-          "power_temp": "Teplota pre zníženie výkonu"
-        }
-      },
-      "presence": {
-        "title": "Riadenie prítomnosti",
-        "description": "Atribúty správy prítomnosti.\nPoskytuje senzor prítomnosti vášho domova (pravda, ak je niekto prítomný).\nPotom zadajte buď predvoľbu, ktorá sa má použiť, keď je senzor prítomnosti nepravdivý, alebo posun teploty, ktorý sa má použiť.\nAk je zadaná predvoľba, posun sa nepoužije.\nAk sa nepoužije, ponechajte zodpovedajúce entity_id prázdne.",
-        "data": {
-          "presence_sensor_entity_id": "ID entity senzora prítomnosti (pravda je prítomná)",
-          "eco_away_temp": "Teplota v prednastavenej Eco, keď nie je žiadna prítomnosť",
-          "comfort_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný",
-          "boost_away_temp": "Prednastavená teplota v režime Boost, keď nie je prítomný",
-          "eco_ac_away_temp": "Teplota v prednastavenej Eco, keď nie je prítomná v režime AC",
-          "comfort_ac_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný v režime AC",
-          "boost_ac_away_temp": "Teplota v prednastavenom Boost, keď nie je prítomný v režime AC"
-        }
-      },
-      "advanced": {
-        "title": "Pokročilé parametre",
-        "description": "Konfigurácia pokročilých parametrov. Ak neviete, čo robíte, ponechajte predvolené hodnoty.\nTento parameter môže viesť k veľmi zlej regulácii teploty alebo výkonu.",
-        "data": {
-          "minimal_activation_delay": "Minimálne oneskorenie aktivácie",
-          "security_delay_min": "Bezpečnostné oneskorenie (v minútach)",
-          "security_min_on_percent": "Minimálne percento výkonu pre bezpečnostný režim",
-          "security_default_on_percent": "Percento výkonu na použitie v bezpečnostnom režime"
-        },
-        "data_description": {
-          "minimal_activation_delay": "Oneskorenie v sekundách, pri ktorom sa zariadenie neaktivuje",
-          "security_delay_min": "Maximálne povolené oneskorenie v minútach medzi dvoma meraniami teploty. Po uplynutí tohto oneskorenia sa termostat prepne do bezpečnostného vypnutého stavu",
-          "security_min_on_percent": "Minimálna percentuálna hodnota ohrevu pre aktiváciu prednastavenej bezpečnosti. Pod týmto percentom výkonu termostat neprejde do prednastavenia zabezpečenia",
-          "security_default_on_percent": "Predvolená percentuálna hodnota vykurovacieho výkonu v bezpečnostnej predvoľbe. Nastavte na 0, ak chcete vypnúť ohrievač v zabezpečenom stave"
-        }
-      }
-    },
-    "error": {
-      "unknown": "Neočakávaná chyba",
-      "unknown_entity": "Neznáme ID entity",
-      "window_open_detection_method": "Mala by sa použiť iba jedna metóda detekcie otvoreného okna. Použite senzor alebo automatickú detekciu cez teplotný prah, ale nie oboje"
-    },
-    "abort": {
-      "already_configured": "Zariadenie je už nakonfigurované"
-    }
-  },
-  "selector": {
-    "thermostat_type": {
-      "options": {
-        "thermostat_over_switch": "Termostat nad spínačom",
-        "thermostat_over_climate": "Termostat nad iným termostatom",
-        "thermostat_over_valve": "Thermostat over a valve"
-      }
-    }
-  },
-  "entity": {
-    "climate": {
-      "versatile_thermostat": {
-        "state_attributes": {
-          "preset_mode": {
-            "state": {
-              "power": "Vyradenie",
-              "security": "Zabezpečenie",
-              "none": "Manuálne"
-            }
-          }
-        }
-      }
-    }
-  }
-}
--- a/custom_components/versatile_thermostat/underlyings.py
+++ b/custom_components/versatile_thermostat/underlyings.py
@@ -148,7 +148,7 @@ class UnderlyingEntity:
                self._entity_id,
            )
            await self.set_hvac_mode(hvac_mode)
-        elif hvac_mode != HVACMode.OFF and not self.is_device_active:
+        elif hvac_mode != HVACMode.OFF and self.is_device_active:
            _LOGGER.warning(
                "%s - The hvac mode is ON, but the underlying device is not ON. Turning on device %s",
                self,
--- a/tests/commons.py
+++ b/tests/commons.py
@@ -10,6 +10,7 @@ from homeassistant.core import HomeAssistant, Event, EVENT_STATE_CHANGED, State
 from homeassistant.const import UnitOfTemperature, STATE_ON, STATE_OFF, ATTR_TEMPERATURE

 from homeassistant.config_entries import ConfigEntryState
+from homeassistant.util import dt as dt_util
 from homeassistant.helpers.entity import Entity
 from homeassistant.components.climate import (
    ClimateEntity,
@@ -24,7 +25,6 @@ from pytest_homeassistant_custom_component.common import MockConfigEntry
 from custom_components.versatile_thermostat.base_thermostat import BaseThermostat
 from custom_components.versatile_thermostat.const import *  # pylint: disable=wildcard-import, unused-wildcard-import
 from custom_components.versatile_thermostat.underlyings import *  # pylint: disable=wildcard-import, unused-wildcard-import
-from custom_components.versatile_thermostat.commons import get_tz, NowClass # pylint: disable=unused-import

 from .const import (  # pylint: disable=unused-import
    MOCK_TH_OVER_SWITCH_USER_CONFIG,
@@ -34,8 +34,6 @@ from .const import (  # pylint: disable=unused-import
    MOCK_TH_OVER_SWITCH_AC_TYPE_CONFIG,
    MOCK_TH_OVER_4SWITCH_TYPE_CONFIG,
    MOCK_TH_OVER_CLIMATE_TYPE_CONFIG,
-    MOCK_TH_OVER_CLIMATE_TYPE_AC_CONFIG,
-    MOCK_TH_OVER_CLIMATE_TYPE_NOT_REGULATED_CONFIG,
    MOCK_TH_OVER_SWITCH_TPI_CONFIG,
    MOCK_PRESETS_CONFIG,
    MOCK_PRESETS_AC_CONFIG,
@@ -85,20 +83,6 @@ PARTIAL_CLIMATE_CONFIG = (
    | MOCK_ADVANCED_CONFIG
 )

-PARTIAL_CLIMATE_NOT_REGULATED_CONFIG = (
-    MOCK_TH_OVER_CLIMATE_USER_CONFIG
-    | MOCK_TH_OVER_CLIMATE_TYPE_NOT_REGULATED_CONFIG
-    | MOCK_PRESETS_CONFIG
-    | MOCK_ADVANCED_CONFIG
-)
-
-PARTIAL_CLIMATE_AC_CONFIG = (
-    MOCK_TH_OVER_CLIMATE_USER_CONFIG
-    | MOCK_TH_OVER_CLIMATE_TYPE_AC_CONFIG
-    | MOCK_PRESETS_CONFIG
-    | MOCK_ADVANCED_CONFIG
-)
-
 FULL_4SWITCH_CONFIG = (
    MOCK_TH_OVER_4SWITCH_USER_CONFIG
    | MOCK_TH_OVER_4SWITCH_TYPE_CONFIG
@@ -117,7 +101,7 @@ _LOGGER = logging.getLogger(__name__)
 class MockClimate(ClimateEntity):
    """A Mock Climate class used for Underlying climate mode"""

-    def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos, hvac_mode:HVACMode = HVACMode.OFF, hvac_action:HVACAction = HVACAction.OFF) -> None:   # pylint: disable=unused-argument
+    def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos, hvac_mode:HVACMode = HVACMode.OFF) -> None:   # pylint: disable=unused-argument
        """Initialize the thermostat."""

        super().__init__()
@@ -134,25 +118,17 @@ class MockClimate(ClimateEntity):
        self._attr_temperature_unit = UnitOfTemperature.CELSIUS
        self._attr_target_temperature = 20
        self._attr_current_temperature = 15
-        self._attr_hvac_action = hvac_action

    def set_temperature(self, **kwargs):
        """ Set the target temperature"""
        temperature = kwargs.get(ATTR_TEMPERATURE)
        self._attr_target_temperature = temperature
+        self.async_write_ha_state()

    async def async_set_hvac_mode(self, hvac_mode):
        """ The hvac mode"""
        self._attr_hvac_mode = hvac_mode
-
-    @property
-    def hvac_action(self):
-        """ The hvac action of the mock climate"""
-        return self._attr_hvac_action
-
-    def set_hvac_action(self, hvac_action: HVACAction):
-        """ Set the HVACaction """
-        self._attr_hvac_action = hvac_action
+        self.async_write_ha_state()

 class MockUnavailableClimate(ClimateEntity):
    """A Mock Climate class used for Underlying climate mode"""
@@ -478,6 +454,13 @@ async def send_presence_change_event(
        await asyncio.sleep(0.1)
    return ret

+
+def get_tz(hass: HomeAssistant):
+    """Get the current timezone"""
+
+    return dt_util.get_time_zone(hass.config.time_zone)
+
+
 async def send_climate_change_event(
    entity: BaseThermostat,
    new_hvac_mode: HVACMode,
--- a/tests/const.py
+++ b/tests/const.py
@@ -50,11 +50,6 @@ from custom_components.versatile_thermostat.const import (
    CONF_PRESENCE_SENSOR,
    PRESET_AWAY_SUFFIX,
    CONF_CLIMATE,
-    CONF_AUTO_REGULATION_MODE,
-    CONF_AUTO_REGULATION_MEDIUM,
-    CONF_AUTO_REGULATION_NONE,
-    CONF_AUTO_REGULATION_DTEMP,
-    CONF_AUTO_REGULATION_PERIOD_MIN
 )
 MOCK_TH_OVER_SWITCH_USER_CONFIG = {
    CONF_NAME: "TheOverSwitchMockName",
@@ -94,14 +89,14 @@ MOCK_TH_OVER_CLIMATE_USER_CONFIG = {
    CONF_CYCLE_MIN: 5,
    CONF_TEMP_MIN: 15,
    CONF_TEMP_MAX: 30,
-    CONF_DEVICE_POWER: 1
+    CONF_DEVICE_POWER: 1,
    # Keep default values which are False
 }

 MOCK_TH_OVER_SWITCH_TYPE_CONFIG = {
    CONF_HEATER: "switch.mock_switch",
    CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
-    CONF_AC_MODE: False
+    CONF_AC_MODE: False,
 }

 MOCK_TH_OVER_SWITCH_AC_TYPE_CONFIG = {
@@ -127,23 +122,6 @@ MOCK_TH_OVER_SWITCH_TPI_CONFIG = {
 MOCK_TH_OVER_CLIMATE_TYPE_CONFIG = {
    CONF_CLIMATE: "climate.mock_climate",
    CONF_AC_MODE: False,
-    CONF_AUTO_REGULATION_MODE: CONF_AUTO_REGULATION_MEDIUM,
-    CONF_AUTO_REGULATION_DTEMP: 0.5,
-    CONF_AUTO_REGULATION_PERIOD_MIN: 2
-}
-
-MOCK_TH_OVER_CLIMATE_TYPE_NOT_REGULATED_CONFIG = {
-    CONF_CLIMATE: "climate.mock_climate",
-    CONF_AC_MODE: False,
-    CONF_AUTO_REGULATION_MODE: CONF_AUTO_REGULATION_NONE
-}
-
-MOCK_TH_OVER_CLIMATE_TYPE_AC_CONFIG = {
-    CONF_CLIMATE: "climate.mock_climate",
-    CONF_AC_MODE: True,
-    CONF_AUTO_REGULATION_MODE: CONF_AUTO_REGULATION_MEDIUM,
-    CONF_AUTO_REGULATION_DTEMP: 0.5,
-    CONF_AUTO_REGULATION_PERIOD_MIN: 1
 }

 MOCK_PRESETS_CONFIG = {
--- a/tests/test_auto_regulation.py
+++ b/tests/test_auto_regulation.py
@@ -1,334 +0,0 @@
-# pylint: disable=wildcard-import, unused-wildcard-import, protected-access, unused-argument, line-too-long
-
-""" Test the normal start of a Thermostat """
-from unittest.mock import patch #, call
-from datetime import datetime, timedelta
-
-from homeassistant.core import HomeAssistant
-from homeassistant.components.climate import HVACAction, HVACMode
-from homeassistant.config_entries import ConfigEntryState
-
-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.components.climate import ClimateEntity, DOMAIN as CLIMATE_DOMAIN
-
-from pytest_homeassistant_custom_component.common import MockConfigEntry
-
-# from custom_components.versatile_thermostat.base_thermostat import BaseThermostat
-from custom_components.versatile_thermostat.thermostat_climate import ThermostatOverClimate
-
-from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
-
-@pytest.mark.parametrize("expected_lingering_tasks", [True])
-@pytest.mark.parametrize("expected_lingering_timers", [True])
-async def test_over_climate_regulation(hass: HomeAssistant, skip_hass_states_is_state, skip_send_event):
-    """Test the regulation of an over climate thermostat"""
-
-    entry = MockConfigEntry(
-        domain=DOMAIN,
-        title="TheOverClimateMockName",
-        unique_id="uniqueId",
-        # This is include a medium regulation
-        data=PARTIAL_CLIMATE_CONFIG,
-    )
-
-    tz = get_tz(hass)  # pylint: disable=invalid-name
-    now: datetime = datetime.now(tz=tz)
-
-    fake_underlying_climate = MockClimate(hass, "mockUniqueId", "MockClimateName", {})
-
-    # Creates the regulated VTherm over climate
-    # change temperature so that the heating will start
-    event_timestamp = now - timedelta(minutes=10)
-
-    with patch(
-        "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-    ), patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
-        return_value=fake_underlying_climate,
-    ):
-        entry.add_to_hass(hass)
-        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
-
-        entity:ThermostatOverClimate = find_my_entity("climate.theoverclimatemockname")
-
-        assert entity
-        assert isinstance(entity, ThermostatOverClimate)
-
-        assert entity.name == "TheOverClimateMockName"
-        assert entity.is_over_climate is True
-        assert entity.is_regulated is True
-        assert entity.hvac_action is HVACAction.OFF
-        assert entity.hvac_mode is HVACMode.OFF
-        assert entity.target_temperature == entity.min_temp
-        assert entity.preset_modes == [
-            PRESET_NONE,
-            PRESET_ECO,
-            PRESET_COMFORT,
-            PRESET_BOOST,
-        ]
-        assert entity.preset_mode is PRESET_NONE
-
-        # Activate the heating by changing HVACMode and temperature
-        # Select a hvacmode, presence and preset
-        await entity.async_set_hvac_mode(HVACMode.HEAT)
-        assert entity.hvac_mode is HVACMode.HEAT
-        assert entity.hvac_action == HVACAction.OFF
-
-        assert entity.regulated_target_temp is entity.min_temp
-
-        await send_temperature_change_event(entity, 15, event_timestamp)
-        await send_ext_temperature_change_event(entity, 10, event_timestamp)
-
-        # set manual target temp (at now - 7) -> the regulation should occurs
-        event_timestamp = now - timedelta(minutes=7)
-        with patch(
-            "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-        ):
-            await entity.async_set_temperature(temperature=18)
-
-            fake_underlying_climate.set_hvac_action(HVACAction.HEATING) # simulate under heating
-            assert entity.hvac_action == HVACAction.HEATING
-            assert entity.preset_mode == PRESET_NONE # Manual mode
-
-            # the regulated temperature should be greater
-            assert entity.regulated_target_temp > entity.target_temperature
-            # In medium we could go up to +3 degre
-            # normally the calcul gives 18 + 2.2 but we round the result to the nearest 0.5 which is 2.0
-            assert entity.regulated_target_temp == 18+2.0
-            assert entity.hvac_action == HVACAction.HEATING
-
-        # change temperature so that the regulated temperature should slow down
-        event_timestamp = now - timedelta(minutes=5)
-        with patch(
-            "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-        ):
-            await send_temperature_change_event(entity, 22, event_timestamp)
-            await send_ext_temperature_change_event(entity, 19, event_timestamp)
-
-            # the regulated temperature should be under
-            assert entity.regulated_target_temp < entity.target_temperature
-            assert entity.regulated_target_temp == 18-0.5 # normally 0.6 but round_to_nearest gives 0.5
-
-@pytest.mark.parametrize("expected_lingering_tasks", [True])
-@pytest.mark.parametrize("expected_lingering_timers", [True])
-async def test_over_climate_regulation_ac_mode(hass: HomeAssistant, skip_hass_states_is_state, skip_send_event):
-    """Test the regulation of an over climate thermostat"""
-
-    entry = MockConfigEntry(
-        domain=DOMAIN,
-        title="TheOverClimateMockName",
-        unique_id="uniqueId",
-        # This is include a medium regulation
-        data=PARTIAL_CLIMATE_AC_CONFIG,
-    )
-
-    tz = get_tz(hass)  # pylint: disable=invalid-name
-    now: datetime = datetime.now(tz=tz)
-
-    fake_underlying_climate = MockClimate(hass, "mockUniqueId", "MockClimateName", {})
-
-    # Creates the regulated VTherm over climate
-    # change temperature so that the heating will start
-    event_timestamp = now - timedelta(minutes=10)
-
-    with patch(
-        "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-    ), patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
-        return_value=fake_underlying_climate,
-    ):
-        entry.add_to_hass(hass)
-        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
-
-        entity:ThermostatOverClimate = find_my_entity("climate.theoverclimatemockname")
-
-        assert entity
-        assert isinstance(entity, ThermostatOverClimate)
-
-        assert entity.name == "TheOverClimateMockName"
-        assert entity.is_over_climate is True
-        assert entity.is_regulated is True
-        assert entity.hvac_action is HVACAction.OFF
-        assert entity.hvac_mode is HVACMode.OFF
-        assert entity.target_temperature == entity.max_temp
-        assert entity.preset_modes == [
-            PRESET_NONE,
-            PRESET_ECO,
-            PRESET_COMFORT,
-            PRESET_BOOST,
-        ]
-        assert entity.preset_mode is PRESET_NONE
-
-        # Activate the heating by changing HVACMode and temperature
-        # Select a hvacmode, presence and preset
-        await entity.async_set_hvac_mode(HVACMode.HEAT)
-        assert entity.hvac_mode is HVACMode.HEAT
-        assert entity.hvac_action == HVACAction.OFF
-
-        # change temperature so that the heating will start
-        await send_temperature_change_event(entity, 30, event_timestamp)
-        await send_ext_temperature_change_event(entity, 35, event_timestamp)
-
-
-        # set manual target temp
-        event_timestamp = now - timedelta(minutes=7)
-        with patch(
-                "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-        ):
-            await entity.async_set_temperature(temperature=25)
-
-            fake_underlying_climate.set_hvac_action(HVACAction.COOLING) # simulate under heating
-            assert entity.hvac_action == HVACAction.COOLING
-            assert entity.preset_mode == PRESET_NONE # Manual mode
-
-            # the regulated temperature should be lower
-            assert entity.regulated_target_temp < entity.target_temperature
-            assert entity.regulated_target_temp == 25-3 # In medium we could go up to -3 degre
-            assert entity.hvac_action == HVACAction.COOLING
-
-        # change temperature so that the regulated temperature should slow down
-        event_timestamp = now - timedelta(minutes=5)
-        with patch(
-                "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-        ):
-            await send_temperature_change_event(entity, 26, event_timestamp)
-            await send_ext_temperature_change_event(entity, 35, event_timestamp)
-
-            # the regulated temperature should be under
-            assert entity.regulated_target_temp < entity.target_temperature
-            assert entity.regulated_target_temp == 25-2.5 # +2.3 without round_to_nearest
-
-            # change temperature so that the regulated temperature should slow down
-        event_timestamp = now - timedelta(minutes=3)
-        with patch(
-                "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-        ):
-            await send_temperature_change_event(entity, 20, event_timestamp)
-            await send_ext_temperature_change_event(entity, 25, event_timestamp)
-
-            # the regulated temperature should be greater
-            assert entity.regulated_target_temp > entity.target_temperature
-            assert entity.regulated_target_temp == 25+0.5 # +0.4 without round_to_nearest
-
-@pytest.mark.parametrize("expected_lingering_tasks", [True])
-@pytest.mark.parametrize("expected_lingering_timers", [True])
-async def test_over_climate_regulation_limitations(hass: HomeAssistant, skip_hass_states_is_state, skip_send_event):
-    """Test the limitations of the regulation of an over climate thermostat:
-       1. test the period_min parameter: do not send regulation event too frequently
-       2. test the dtemp parameter: do not send regulation event if offset temp is lower than dtemp
-    """
-
-    entry = MockConfigEntry(
-        domain=DOMAIN,
-        title="TheOverClimateMockName",
-        unique_id="uniqueId",
-        # This is include a medium regulation, dtemp=0.5, period_min=2
-        data=PARTIAL_CLIMATE_CONFIG,
-    )
-
-    tz = get_tz(hass)  # pylint: disable=invalid-name
-    now: datetime = datetime.now(tz=tz)
-
-    fake_underlying_climate = MockClimate(hass, "mockUniqueId", "MockClimateName", {})
-
-    # Creates the regulated VTherm over climate at t-20
-    # change temperature so that the heating will start
-    event_timestamp = now - timedelta(minutes=20)
-
-    with patch(
-        "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-    ), patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
-        return_value=fake_underlying_climate,
-    ):
-        entry.add_to_hass(hass)
-        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
-
-        entity:ThermostatOverClimate = find_my_entity("climate.theoverclimatemockname")
-
-        assert entity
-        assert isinstance(entity, ThermostatOverClimate)
-
-        assert entity.name == "TheOverClimateMockName"
-        assert entity.is_over_climate is True
-        assert entity.is_regulated is True
-
-        # Activate the heating by changing HVACMode and temperature
-        # Select a hvacmode, presence and preset
-        await entity.async_set_hvac_mode(HVACMode.HEAT)
-        assert entity.hvac_mode is HVACMode.HEAT
-
-        # it is cold today
-        await send_temperature_change_event(entity, 15, event_timestamp)
-        await send_ext_temperature_change_event(entity, 10, event_timestamp)
-
-        # set manual target temp (at now - 19) -> the regulation should be ignored because too early
-        event_timestamp = now - timedelta(minutes=19)
-        with patch(
-            "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-        ):
-            await entity.async_set_temperature(temperature=18)
-
-            fake_underlying_climate.set_hvac_action(HVACAction.HEATING) # simulate under heating
-            assert entity.hvac_action == HVACAction.HEATING
-
-            # the regulated temperature should be unchanged
-            assert entity.regulated_target_temp == 15
-
-        # set manual target temp (at now - 18) -> the regulation should be taken into account
-        event_timestamp = now - timedelta(minutes=18)
-        with patch(
-            "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-        ):
-            await entity.async_set_temperature(temperature=17)
-            assert entity.regulated_target_temp > entity.target_temperature
-            assert entity.regulated_target_temp == 18+0.5 # In medium we could go up to +3 degre. 0.7 without round_to_nearest
-            old_regulated_temp = entity.regulated_target_temp
-
-        # change temperature so that dtemp < 0.5 and time is > period_min (+ 3min)
-        event_timestamp = now - timedelta(minutes=15)
-        with patch(
-            "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-        ):
-            await send_temperature_change_event(entity, 16, event_timestamp)
-            await send_ext_temperature_change_event(entity, 10, event_timestamp)
-
-            # the regulated temperature should be under
-            assert entity.regulated_target_temp == old_regulated_temp
-
-        # change temperature so that dtemp > 0.5 and time is > period_min (+ 3min)
-        event_timestamp = now - timedelta(minutes=12)
-        with patch(
-            "custom_components.versatile_thermostat.commons.NowClass.get_now", return_value=event_timestamp
-        ):
-            await send_temperature_change_event(entity, 18, event_timestamp)
-            await send_ext_temperature_change_event(entity, 12, event_timestamp)
-
-            # the regulated should have been done
-            assert entity.regulated_target_temp != old_regulated_temp
-            assert entity.regulated_target_temp > entity.target_temperature
-            assert entity.regulated_target_temp == 17 + 0.5 # 0.7 without round_to_nearest
--- a/tests/test_bugs.py
+++ b/tests/test_bugs.py
@@ -463,11 +463,11 @@ async def test_bug_101(
        domain=DOMAIN,
        title="TheOverClimateMockName",
        unique_id="uniqueId",
-        data=PARTIAL_CLIMATE_NOT_REGULATED_CONFIG, # 5 minutes security delay
+        data=PARTIAL_CLIMATE_CONFIG, # 5 minutes security delay
    )

    # Underlying is in HEAT mode but should be shutdown at startup
-    fake_underlying_climate = MockClimate(hass, "mockUniqueId", "MockClimateName", {}, HVACMode.HEAT, HVACAction.HEATING)
+    fake_underlying_climate = MockClimate(hass, "mockUniqueId", "MockClimateName", {}, HVACMode.HEAT)

    with patch(
        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
@@ -495,7 +495,7 @@ async def test_bug_101(
        assert entity.name == "TheOverClimateMockName"
        assert entity.is_over_climate is True
        assert entity.hvac_mode is HVACMode.OFF
-        # because in MockClimate HVACAction is HEATING if hvac_mode is not set
+        # because the underlying is heating. In real life the underlying should be shut-off
        assert entity.hvac_action is HVACAction.HEATING
        # Underlying should have been shutdown
        assert mock_underlying_set_hvac_mode.call_count == 1
@@ -539,7 +539,6 @@ async def test_bug_101(
        # 2. Change the target temp of underlying thermostat at 11 sec later -> the event will be taken
        # Wait 11 sec
        event_timestamp = now + timedelta(seconds=11)
-        assert entity.is_regulated is False
        await send_climate_change_event_with_temperature(entity, HVACMode.HEAT, HVACMode.HEAT, HVACAction.OFF, HVACAction.OFF, event_timestamp, 12.75)
        assert entity.target_temperature == 12.75
        assert entity.preset_mode is PRESET_NONE
--- a/tests/test_open_window_algo.py
+++ b/tests/test_open_window_algo.py
@@ -1,10 +1,8 @@
-# pylint: disable=unused-argument, line-too-long
 """ Test the OpenWindow algorithm """

 from datetime import datetime, timedelta
-from custom_components.versatile_thermostat.open_window_algorithm import WindowOpenDetectionAlgorithm
-
 from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from custom_components.versatile_thermostat.open_window_algorithm import WindowOpenDetectionAlgorithm


 async def test_open_window_algo(
--- a/tests/test_pi.py
+++ b/tests/test_pi.py
@@ -1,171 +0,0 @@
-# pylint: disable=line-too-long
-""" Tests de PI algorithm used for auto-regulation """
-
-from custom_components.versatile_thermostat.pi_algorithm import PITemperatureRegulator
-
-def test_pi_algorithm_basics():
-    """ Test the PI algorithm """
-
-    the_algo = PITemperatureRegulator(target_temp=20, kp=0.2, ki=0.05, k_ext=0.1, offset_max=2, stabilization_threshold=0.1, accumulated_error_threshold=20)
-
-    assert the_algo
-
-    assert the_algo.calculate_regulated_temperature(20, 20) == 20
-
-    assert the_algo.calculate_regulated_temperature(20, 10) == 21
-
-    # to reset the accumulated erro
-    the_algo.set_target_temp(20)
-
-    # Test the accumulator threshold effect and offset_max
-    assert the_algo.calculate_regulated_temperature(10, 10) == 22   # +2
-    assert the_algo.calculate_regulated_temperature(10, 10) == 22
-    assert the_algo.calculate_regulated_temperature(10, 10) == 22
-    # Will keep infinitly 22.0
-
-    # to reset the accumulated erro
-    the_algo.set_target_temp(20)
-    assert the_algo.calculate_regulated_temperature(18, 10) == 21.5    # +1.5
-    assert the_algo.calculate_regulated_temperature(18.1, 10) == 21.6  # +1.6
-    assert the_algo.calculate_regulated_temperature(18.3, 10) == 21.6  # +1.6
-    assert the_algo.calculate_regulated_temperature(18.5, 10) == 21.7  # +1.7
-    assert the_algo.calculate_regulated_temperature(18.7, 10) == 21.7  # +1.7
-    assert the_algo.calculate_regulated_temperature(19, 10) == 21.7    # +1.7
-    assert the_algo.calculate_regulated_temperature(20, 10) == 21.5    # +1.5
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.8    # +0.8
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.7    # +0.7
-    assert the_algo.calculate_regulated_temperature(20, 10) == 20.9    # +0.7
-
-    # Test temperature external
-    assert the_algo.calculate_regulated_temperature(20, 12) == 20.8    # +0.8
-    assert the_algo.calculate_regulated_temperature(20, 15) == 20.5    # +0.5
-    assert the_algo.calculate_regulated_temperature(20, 18) == 20.2    # +0.2
-    assert the_algo.calculate_regulated_temperature(20, 20) == 20.0    # =
-
-
-def test_pi_algorithm_light():
-    """ Test the PI algorithm """
-
-    the_algo = PITemperatureRegulator(target_temp=20, kp=0.2, ki=0.05, k_ext=0.1, offset_max=2, stabilization_threshold=0.1, accumulated_error_threshold=20)
-
-    assert the_algo
-
-    # to reset the accumulated erro
-    the_algo.set_target_temp(20)
-
-    assert the_algo.calculate_regulated_temperature(18, 10) == 21.5    # +1.5
-    assert the_algo.calculate_regulated_temperature(18.1, 10) == 21.6  # +1.6
-    assert the_algo.calculate_regulated_temperature(18.3, 10) == 21.6  # +1.6
-    assert the_algo.calculate_regulated_temperature(18.5, 10) == 21.7  # +1.7
-    assert the_algo.calculate_regulated_temperature(18.7, 10) == 21.7  # +1.7
-    assert the_algo.calculate_regulated_temperature(19, 10) == 21.7    # +1.7
-    assert the_algo.calculate_regulated_temperature(20, 10) == 21.5    # +1.5
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.8    # +0.8
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.7    # +0.7
-    assert the_algo.calculate_regulated_temperature(20, 10) == 20.9    # +0.7
-
-    # Test temperature external
-    assert the_algo.calculate_regulated_temperature(20, 12) == 20.8    # +0.8
-    assert the_algo.calculate_regulated_temperature(20, 15) == 20.5    # +0.5
-    assert the_algo.calculate_regulated_temperature(20, 18) == 20.2    # +0.2
-    assert the_algo.calculate_regulated_temperature(20, 20) == 20.0    # =
-
-def test_pi_algorithm_medium():
-    """ Test the PI algorithm """
-
-    the_algo = PITemperatureRegulator(target_temp=20, kp=0.5, ki=0.1, k_ext=0.1, offset_max=3, stabilization_threshold=0.1, accumulated_error_threshold=30)
-
-    assert the_algo
-
-    # to reset the accumulated erro
-    the_algo.set_target_temp(20)
-
-    assert the_algo.calculate_regulated_temperature(18, 10) == 22.2
-    assert the_algo.calculate_regulated_temperature(18.1, 10) == 22.3
-    assert the_algo.calculate_regulated_temperature(18.3, 10) == 22.4
-    assert the_algo.calculate_regulated_temperature(18.5, 10) == 22.5
-    assert the_algo.calculate_regulated_temperature(18.7, 10) == 22.5
-    assert the_algo.calculate_regulated_temperature(19, 10) == 22.4
-    assert the_algo.calculate_regulated_temperature(20, 10) == 21.9
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.4
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.3
-    assert the_algo.calculate_regulated_temperature(20, 10) == 20.8
-
-    # Test temperature external
-    assert the_algo.calculate_regulated_temperature(20, 8) == 21.2
-    assert the_algo.calculate_regulated_temperature(20, 6) == 21.4
-    assert the_algo.calculate_regulated_temperature(20, 4) == 21.6
-    assert the_algo.calculate_regulated_temperature(20, 2) == 21.8
-    assert the_algo.calculate_regulated_temperature(20, 0) == 22.0
-    assert the_algo.calculate_regulated_temperature(20, -2) == 22.2
-    assert the_algo.calculate_regulated_temperature(20, -4) == 22.4
-    assert the_algo.calculate_regulated_temperature(20, -6) == 22.6
-    assert the_algo.calculate_regulated_temperature(20, -8) == 22.8
-
-    # to reset the accumulated erro
-    the_algo.set_target_temp(20)
-    # Test the error acculation effect
-    assert the_algo.calculate_regulated_temperature(19, 5) == 22.1
-    assert the_algo.calculate_regulated_temperature(19, 5) == 22.2
-    assert the_algo.calculate_regulated_temperature(19, 5) == 22.3
-    assert the_algo.calculate_regulated_temperature(19, 5) == 22.4
-    assert the_algo.calculate_regulated_temperature(19, 5) == 22.5
-    assert the_algo.calculate_regulated_temperature(19, 5) == 22.6
-    assert the_algo.calculate_regulated_temperature(19, 5) == 22.7
-    assert the_algo.calculate_regulated_temperature(19, 5) == 22.8
-    assert the_algo.calculate_regulated_temperature(19, 5) == 22.9
-    assert the_algo.calculate_regulated_temperature(19, 5) == 23
-    assert the_algo.calculate_regulated_temperature(19, 5) == 23
-    assert the_algo.calculate_regulated_temperature(19, 5) == 23
-    assert the_algo.calculate_regulated_temperature(19, 5) == 23
-
-def test_pi_algorithm_strong():
-    """ Test the PI algorithm """
-
-    the_algo = PITemperatureRegulator(target_temp=20, kp=0.6, ki=0.2, k_ext=0.2, offset_max=4, stabilization_threshold=0.1, accumulated_error_threshold=40)
-
-    assert the_algo
-
-    # to reset the accumulated erro
-    the_algo.set_target_temp(20)
-
-    assert the_algo.calculate_regulated_temperature(18, 10) == 23.6
-    assert the_algo.calculate_regulated_temperature(18.1, 10) == 23.9
-    assert the_algo.calculate_regulated_temperature(18.3, 10) == 24.0
-    assert the_algo.calculate_regulated_temperature(18.5, 10) == 24
-    assert the_algo.calculate_regulated_temperature(18.7, 10) == 24
-    assert the_algo.calculate_regulated_temperature(19, 10) == 24
-    assert the_algo.calculate_regulated_temperature(20, 10) == 23.9
-    assert the_algo.calculate_regulated_temperature(21, 10) == 21.2
-    assert the_algo.calculate_regulated_temperature(21, 10) == 21
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.8
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.6
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.4
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20.2
-    assert the_algo.calculate_regulated_temperature(21, 10) == 20
-
-    # Test temperature external
-    assert the_algo.calculate_regulated_temperature(20, 8) == 21.0
-    assert the_algo.calculate_regulated_temperature(20, 6) == 22.8
-    assert the_algo.calculate_regulated_temperature(20, 4) == 23.2
-    assert the_algo.calculate_regulated_temperature(20, 2) == 23.6
-    assert the_algo.calculate_regulated_temperature(20, 0) == 24
-    assert the_algo.calculate_regulated_temperature(20, -2) == 24
-    assert the_algo.calculate_regulated_temperature(20, -4) == 24
-    assert the_algo.calculate_regulated_temperature(20, -6) == 24
-    assert the_algo.calculate_regulated_temperature(20, -8) == 24
-
-    # to reset the accumulated erro
-    the_algo.set_target_temp(20)
-    # Test the error acculation effect
-    assert the_algo.calculate_regulated_temperature(19, 10) == 22.8
-    assert the_algo.calculate_regulated_temperature(19, 10) == 23
-    assert the_algo.calculate_regulated_temperature(19, 10) == 23.2
-    assert the_algo.calculate_regulated_temperature(19, 10) == 23.4
-    assert the_algo.calculate_regulated_temperature(19, 10) == 23.6
-    assert the_algo.calculate_regulated_temperature(19, 10) == 23.8
-    assert the_algo.calculate_regulated_temperature(19, 10) == 24
-    assert the_algo.calculate_regulated_temperature(19, 10) == 24
-    assert the_algo.calculate_regulated_temperature(19, 10) == 24
-    assert the_algo.calculate_regulated_temperature(19, 10) == 24
-    assert the_algo.calculate_regulated_temperature(19, 10) == 24
--- a/tests/test_power.py
+++ b/tests/test_power.py
@@ -1,11 +1,12 @@
-# pylint: disable=protected-access, unused-argument, line-too-long
 """ Test the Power management """
 from unittest.mock import patch, call
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
 from datetime import datetime, timedelta
+
+from homeassistant.const import UnitOfTemperature
+
 import logging

-from custom_components.versatile_thermostat.thermostat_switch import ThermostatOverSwitch
-from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
 logging.getLogger().setLevel(logging.DEBUG)


@@ -49,7 +50,7 @@ async def test_power_management_hvac_off(
        },
    )

-    entity: ThermostatOverSwitch = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
@@ -135,7 +136,7 @@ async def test_power_management_hvac_on(hass: HomeAssistant, skip_hass_states_is
        },
    )

-    entity: ThermostatOverSwitch = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
@@ -269,7 +270,7 @@ async def test_power_management_energy_over_switch(
        },
    )

-    entity: ThermostatOverSwitch = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
@@ -304,9 +305,9 @@ async def test_power_management_energy_over_switch(
        assert mock_heater_off.call_count == 0

    entity.incremente_energy()
-    assert entity.total_energy == round(100 * 5 / 60.0, 2)
+    assert entity.total_energy == 100 * 5 / 60.0
    entity.incremente_energy()
-    assert entity.total_energy == round(2 * 100 * 5 / 60.0, 2)
+    assert entity.total_energy == 2 * 100 * 5 / 60.0

    # change temperature to a higher value
    with patch(
@@ -397,7 +398,7 @@ async def test_power_management_energy_over_climate(
            },
        )

-        entity: ThermostatOverSwitch = await create_thermostat(
+        entity: VersatileThermostat = await create_thermostat(
            hass, entry, "climate.theoverclimatemockname"
        )
        assert entity
--- a/tests/test_security.py
+++ b/tests/test_security.py
@@ -1,14 +1,10 @@
-# pylint: disable=wildcard-import, unused-wildcard-import, protected-access, unused-argument, line-too-long
-
 """ Test the Security featrure """
 from unittest.mock import patch, call
-from datetime import timedelta, datetime
-import logging

-from custom_components.versatile_thermostat.thermostat_climate import ThermostatOverClimate
-from custom_components.versatile_thermostat.thermostat_switch import ThermostatOverSwitch
 from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import

+from datetime import timedelta, datetime
+import logging

 logging.getLogger().setLevel(logging.DEBUG)

@@ -59,7 +55,7 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):

    # 1. creates a thermostat and check that security is off
    now: datetime = datetime.now(tz=tz)
-    entity: ThermostatOverSwitch = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
@@ -215,7 +211,7 @@ async def test_security_over_climate(
        data=PARTIAL_CLIMATE_CONFIG, # 5 minutes security delay
    )

-    fake_underlying_climate = MockClimate(hass, "mockUniqueId", "MockClimateName", {}, HVACMode.HEAT, HVACAction.HEATING)
+    fake_underlying_climate = MockClimate(hass, "mockUniqueId", "MockClimateName", {}, HVACMode.HEAT)

    with patch(
        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
@@ -234,7 +230,7 @@ async def test_security_over_climate(
                if entity.entity_id == entity_id:
                    return entity

-        entity: ThermostatOverClimate = find_my_entity("climate.theoverclimatemockname")
+        entity = find_my_entity("climate.theoverclimatemockname")

        assert entity

@@ -299,11 +295,11 @@ async def test_security_over_climate(
            "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
        ) as mock_send_event, patch(
            "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
-        ):
+        ) as mock_heater_on:
            event_timestamp = now - timedelta(minutes=6)

            await send_temperature_change_event(entity, 15, event_timestamp)
            # Should stay False because a climate is never in security mode
            assert entity.security_state is False
            assert entity.preset_mode == 'none'
-            assert entity._saved_preset_mode == 'none'
+            assert entity._saved_preset_mode == 'none'
--- a/tests/test_sensors.py
+++ b/tests/test_sensors.py
@@ -140,7 +140,7 @@ async def test_sensors_over_switch(
    entity.incremente_energy()

    await energy_sensor.async_my_climate_changed()
-    assert energy_sensor.state == round(16.667, 2)
+    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
--- a/tests/test_tpi.py
+++ b/tests/test_tpi.py
@@ -1,6 +1,5 @@
 """ Test the TPI algorithm """

-from custom_components.versatile_thermostat.base_thermostat import BaseThermostat
 from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import


@@ -38,7 +37,7 @@ async def test_tpi_calculation(
        },
    )

-    entity: BaseThermostat = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
--- a/tests/test_window.py
+++ b/tests/test_window.py
@@ -1,12 +1,10 @@
-# pylint: disable=unused-argument, line-too-long, protected-access
 """ Test the Window management """
 import asyncio
-import logging
 from unittest.mock import patch, call, PropertyMock
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
 from datetime import datetime, timedelta

-from custom_components.versatile_thermostat.base_thermostat import BaseThermostat
-from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+import logging

 logging.getLogger().setLevel(logging.DEBUG)

@@ -49,7 +47,7 @@ async def test_window_management_time_not_enough(
        },
    )

-    entity: BaseThermostat = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
@@ -137,7 +135,7 @@ async def test_window_management_time_enough(
        },
    )

-    entity: BaseThermostat = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
@@ -276,7 +274,7 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
        },
    )

-    entity: BaseThermostat = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
@@ -426,7 +424,7 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
@pytest.mark.parametrize("expected_lingering_tasks", [True])
@pytest.mark.parametrize("expected_lingering_timers", [True])
 async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_state):
-    """Test the Window auto management"""
+    """Test the Power management"""

    entry = MockConfigEntry(
        domain=DOMAIN,
@@ -460,7 +458,7 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
        },
    )

-    entity: BaseThermostat = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
@@ -605,7 +603,7 @@ async def test_window_auto_no_on_percent(
        },
    )

-    entity: BaseThermostat = await create_thermostat(
+    entity: VersatileThermostat = await create_thermostat(
        hass, entry, "climate.theoverswitchmockname"
    )
    assert entity
@@ -673,380 +671,3 @@ async def test_window_auto_no_on_percent(

    # Clean the entity
    entity.remove_thermostat()
-
-#PR - Adding Window Bypass
-@pytest.mark.parametrize("expected_lingering_tasks", [True])
-@pytest.mark.parametrize("expected_lingering_timers", [True])
-async def test_window_bypass(
-    hass: HomeAssistant, skip_hass_states_is_state
-):
-    """Test the Window management when bypass enabled"""
-
-    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: BaseThermostat = await create_thermostat(
-        hass, entry, "climate.theoverswitchmockname"
-    )
-    assert entity
-
-    tpi_algo = entity._prop_algorithm
-    assert tpi_algo
-
-    await entity.async_set_hvac_mode(HVACMode.HEAT)
-    await entity.async_set_preset_mode(PRESET_BOOST)
-    assert entity.hvac_mode is HVACMode.HEAT
-    assert entity.preset_mode is PRESET_BOOST
-    assert entity.overpowering_state is None
-    assert entity.target_temperature == 19
-
-    assert entity.window_state is None
-
-    # change temperature to force turning on the heater
-    with patch(
-        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
-    ) as mock_send_event, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
-    ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
-    ) as mock_heater_off, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
-        return_value=False,
-    ):
-        await send_temperature_change_event(entity, 15, datetime.now())
-
-        # Heater shoud turn-on
-        assert mock_heater_on.call_count >= 1
-        assert mock_heater_off.call_count == 0
-        assert mock_send_event.call_count == 0
-
-    # Set Window ByPass to true
-    await entity.service_set_window_bypass_state(True)
-    assert entity.window_bypass_state is True
-
-    # entity._window_bypass_state = True
-
-    # Open the window, condition of time is satisfied, check the thermostat and heater turns off
-    with patch(
-        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
-    ) as mock_send_event, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
-    ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
-    ) as mock_heater_off, patch(
-        "homeassistant.helpers.condition.state", return_value=True
-    ) as mock_condition, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
-        return_value=True,
-    ):
-        await send_window_change_event(entity, True, False, datetime.now())
-
-        assert mock_send_event.call_count == 0
-
-        # Heater should not be on
-        assert mock_heater_on.call_count == 0
-        # One call in set_hvac_mode turn_off and one call in the control_heating for security
-        assert mock_heater_off.call_count == 0
-        assert mock_condition.call_count == 1
-        assert entity.hvac_mode is HVACMode.HEAT
-        assert entity.window_state == STATE_ON
-
-    # Close the window
-    with patch(
-        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
-    ) as mock_send_event, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
-    ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
-    ) as mock_heater_off, patch(
-        "homeassistant.helpers.condition.state", return_value=True
-    ) as mock_condition, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
-        return_value=False,
-    ):
-        try_function = await send_window_change_event(
-            entity, False, True, datetime.now(), sleep=False
-        )
-
-        await try_function(None)
-
-        # Wait for initial delay of heater
-        await asyncio.sleep(0.3)
-
-        assert entity.window_state == STATE_OFF
-        assert mock_heater_on.call_count == 0
-        assert mock_send_event.call_count == 0
-        assert entity.hvac_mode is HVACMode.HEAT
-        assert entity.preset_mode is PRESET_BOOST
-
-    # Clean the entity
-    entity.remove_thermostat()
-
-#PR - Adding Window bypass for window auto algorithm
-@pytest.mark.parametrize("expected_lingering_tasks", [True])
-@pytest.mark.parametrize("expected_lingering_timers", [True])
-async def test_window_auto_bypass(hass: HomeAssistant, skip_hass_states_is_state):
-    """Test the Window auto management"""
-
-    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": 21,
-            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_AUTO_OPEN_THRESHOLD: 0.1,
-            CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 0.1,
-            CONF_WINDOW_AUTO_MAX_DURATION: 0,  # Should be 0 for test
-        },
-    )
-
-    entity: BaseThermostat = await create_thermostat(
-        hass, entry, "climate.theoverswitchmockname"
-    )
-    assert entity
-
-    tz = get_tz(hass)  # pylint: disable=invalid-name
-    now = datetime.now(tz)
-
-    tpi_algo = entity._prop_algorithm
-    assert tpi_algo
-
-    await entity.async_set_hvac_mode(HVACMode.HEAT)
-    await entity.async_set_preset_mode(PRESET_BOOST)
-    assert entity.hvac_mode is HVACMode.HEAT
-    assert entity.preset_mode is PRESET_BOOST
-    assert entity.overpowering_state is None
-    assert entity.target_temperature == 21
-
-    assert entity.window_state is None
-
-    # Make the temperature down
-    with patch(
-        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
-    ) as mock_send_event, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
-    ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
-    ) as mock_heater_off, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
-        return_value=True,
-    ):
-        event_timestamp = now - timedelta(minutes=4)
-        await send_temperature_change_event(entity, 19, event_timestamp)
-
-        # The heater turns on
-        assert mock_heater_on.call_count == 1
-        assert entity.last_temperature_slope is None
-        assert entity._window_auto_algo.is_window_open_detected() is False
-        assert entity._window_auto_algo.is_window_close_detected() is False
-        assert entity.hvac_mode is HVACMode.HEAT
-
-    # send one degre down in one minute with window bypass on
-    await entity.service_set_window_bypass_state(True)
-    assert entity.window_bypass_state is True
-    # entity._window_bypass_state = True
-
-    with patch(
-        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
-    ) as mock_send_event, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
-    ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
-    ) as mock_heater_off, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
-        return_value=True,
-    ):
-        event_timestamp = now - timedelta(minutes=3)
-        await send_temperature_change_event(entity, 18, event_timestamp, sleep=False)
-
-        # No change should have been done
-        assert mock_send_event.call_count == 0
-
-        assert mock_heater_on.call_count == 0
-        assert mock_heater_off.call_count == 0
-        assert entity.last_temperature_slope == -1
-        assert entity._window_auto_algo.is_window_open_detected() is True
-        assert entity._window_auto_algo.is_window_close_detected() is False
-        assert entity.window_auto_state == STATE_OFF
-        assert entity.hvac_mode is HVACMode.HEAT
-
-    # Clean the entity
-    entity.remove_thermostat()
-
-#PR - Adding Window bypass AFTER detection have been done should reactivate the heater
-@pytest.mark.parametrize("expected_lingering_tasks", [True])
-@pytest.mark.parametrize("expected_lingering_timers", [True])
-async def test_window_bypass_reactivate(hass: HomeAssistant, skip_hass_states_is_state):
-    """Test the Window management when window is open and then bypass is set to on"""
-
-    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: BaseThermostat = await create_thermostat(
-        hass, entry, "climate.theoverswitchmockname"
-    )
-    assert entity
-
-    tpi_algo = entity._prop_algorithm
-    assert tpi_algo
-
-    await entity.async_set_hvac_mode(HVACMode.HEAT)
-    await entity.async_set_preset_mode(PRESET_BOOST)
-    assert entity.hvac_mode is HVACMode.HEAT
-    assert entity.preset_mode is PRESET_BOOST
-    assert entity.overpowering_state is None
-    assert entity.target_temperature == 19
-
-    assert entity.window_state is None
-
-    # change temperature to force turning on the heater
-    with patch(
-        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
-    ) as mock_send_event, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
-    ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
-    ) as mock_heater_off, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
-        return_value=False,
-    ):
-        await send_temperature_change_event(entity, 15, datetime.now())
-
-        # Heater shoud turn-on
-        assert mock_heater_on.call_count >= 1
-        assert mock_heater_off.call_count == 0
-        assert mock_send_event.call_count == 0
-
-    # Open the window, condition of time is satisfied, check the thermostat and heater turns off
-    with patch(
-        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
-    ) as mock_send_event, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
-    ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
-    ) as mock_heater_off, patch(
-        "homeassistant.helpers.condition.state", return_value=True
-    ) as mock_condition, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
-        return_value=True,
-    ):
-        await send_window_change_event(entity, True, False, datetime.now())
-
-        assert mock_send_event.call_count == 1
-        mock_send_event.assert_has_calls(
-            [call.send_event(EventType.HVAC_MODE_EVENT, {"hvac_mode": HVACMode.OFF})]
-        )
-
-        # Heater should not be on
-        assert mock_heater_on.call_count == 0
-        # One call in set_hvac_mode turn_off and one call in the control_heating for security
-        assert mock_heater_off.call_count == 2
-        assert mock_condition.call_count == 1
-        assert entity.hvac_mode is HVACMode.OFF
-        assert entity.window_state == STATE_ON
-
-    # Call the set bypass service to set bypass ON
-    with patch(
-        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
-    ) as mock_send_event, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
-    ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
-    ) as mock_heater_off, patch(
-        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
-        return_value=False,
-    ):
-        await entity.service_set_window_bypass_state(True)
-
-        assert entity.window_state == STATE_ON
-        assert entity.preset_mode is PRESET_BOOST
-        assert entity.hvac_mode is HVACMode.HEAT
-        # assert mock_heater_on.call_count == 1
-        assert mock_send_event.call_count == 1
-        mock_send_event.assert_has_calls(
-            [
-                call.send_event(
-                    EventType.HVAC_MODE_EVENT, {"hvac_mode": HVACMode.HEAT}
-                ),
-            ],
-            any_order=False,
-        )
-
-    # Clean the entity
-    entity.remove_thermostat()