plugwise 0.36.2__py3-none-any.whl → 0.37.0__py3-none-any.whl

plugwise/legacy/smile.py

@@ -0,0 +1,272 @@
+"""Use of this source code is governed by the MIT license found in the LICENSE file.
+
+Plugwise backend module for Home Assistant Core - covering the legacy P1, Anna, and Stretch devices.
+"""
+from __future__ import annotations
+
+import datetime as dt
+
+# Version detection
+from plugwise.constants import (
+    APPLIANCES,
+    DEFAULT_PORT,
+    DEFAULT_TIMEOUT,
+    DEFAULT_USERNAME,
+    DOMAIN_OBJECTS,
+    LOCATIONS,
+    LOGGER,
+    MODULES,
+    REQUIRE_APPLIANCES,
+    RULES,
+    DeviceData,
+    GatewayData,
+    PlugwiseData,
+    ThermoLoc,
+)
+from plugwise.exceptions import PlugwiseError
+from plugwise.helper import SmileComm
+from plugwise.legacy.data import SmileLegacyData
+
+import aiohttp
+from munch import Munch
+import semver
+
+
+class SmileLegacyAPI(SmileComm, SmileLegacyData):
+    """The Plugwise SmileLegacyAPI class."""
+
+    # pylint: disable=too-many-instance-attributes, too-many-public-methods
+
+    def __init__(
+        self,
+        host: str,
+        password: str,
+        websession: aiohttp.ClientSession,
+        _is_thermostat: bool,
+        _on_off_device: bool,
+        _opentherm_device: bool,
+        _stretch_v2: bool,
+        _target_smile: str,
+        loc_data: dict[str, ThermoLoc],
+        smile_fw_version: str | None,
+        smile_hostname: str,
+        smile_hw_version: str | None,
+        smile_mac_address: str | None,
+        smile_model: str,
+        smile_name: str,
+        smile_type: str,
+        smile_version: tuple[str, semver.version.Version],
+        smile_zigbee_mac_address: str | None,
+        username: str = DEFAULT_USERNAME,
+        port: int = DEFAULT_PORT,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        """Set the constructor for this class."""
+        super().__init__(
+            host,
+            password,
+            websession,
+            username,
+            port,
+            timeout,
+        )
+        SmileLegacyData.__init__(self)
+
+        self._is_thermostat = _is_thermostat
+        self._on_off_device = _on_off_device
+        self._opentherm_device = _opentherm_device
+        self._stretch_v2 = _stretch_v2
+        self._target_smile = _target_smile
+        self.loc_data = loc_data
+        self.smile_fw_version = smile_fw_version
+        self.smile_hostname = smile_hostname
+        self.smile_hw_version = smile_hw_version
+        self.smile_mac_address = smile_mac_address
+        self.smile_model = smile_model
+        self.smile_name = smile_name
+        self.smile_type = smile_type
+        self.smile_version = smile_version
+        self.smile_zigbee_mac_address = smile_zigbee_mac_address
+
+        self._previous_day_number: str = "0"
+
+    async def full_update_device(self) -> None:
+        """Perform a first fetch of all XML data, needed for initialization."""
+        self._domain_objects = await self._request(DOMAIN_OBJECTS)
+        self._locations = await self._request(LOCATIONS)
+        self._modules = await self._request(MODULES)
+        # P1 legacy has no appliances
+        if self.smile_type != "power":
+            self._appliances = await self._request(APPLIANCES)
+
+    def get_all_devices(self) -> None:
+        """Determine the evices present from the obtained XML-data.
+
+        Run this functions once to gather the initial device configuration,
+        then regularly run async_update() to refresh the device data.
+        """
+        # Gather all the devices and their initial data
+        self._all_appliances()
+
+        # Collect and add switching- and/or pump-group devices
+        if group_data := self._get_group_switches():
+            self.gw_devices.update(group_data)
+
+        # Collect the remaining data for all devices
+        self._all_device_data()
+
+    async def async_update(self) -> PlugwiseData:
+        """Perform an incremental update for updating the various device states."""
+        # Perform a full update at day-change
+        day_number = dt.datetime.now().strftime("%w")
+        if (
+            day_number  # pylint: disable=consider-using-assignment-expr
+            != self._previous_day_number
+        ):
+            LOGGER.info(
+                "Performing daily full-update, reload the Plugwise integration when a single entity becomes unavailable."
+            )
+            self.gw_data: GatewayData = {}
+            self.gw_devices: dict[str, DeviceData] = {}
+            await self.full_update_device()
+            self.get_all_devices()
+        # Otherwise perform an incremental update
+        else:
+            self._domain_objects = await self._request(DOMAIN_OBJECTS)
+            match self._target_smile:
+                case "smile_v2":
+                    self._modules = await self._request(MODULES)
+                case self._target_smile if self._target_smile in REQUIRE_APPLIANCES:
+                    self._appliances = await self._request(APPLIANCES)
+
+            self._update_gw_devices()
+
+        self._previous_day_number = day_number
+        return PlugwiseData(self.gw_data, self.gw_devices)
+
+########################################################################################################
+###  API Set and HA Service-related Functions                                                        ###
+########################################################################################################
+
+    async def set_schedule_state(self, _: str, state: str, __: str | None) -> None:
+        """Activate/deactivate the Schedule.
+
+        Determined from - DOMAIN_OBJECTS.
+        Used in HA Core to set the hvac_mode: in practice switch between schedule on - off.
+        """
+        if state not in ["on", "off"]:
+            raise PlugwiseError("Plugwise: invalid schedule state.")
+
+        name = "Thermostat schedule"
+        schedule_rule_id: str | None = None
+        for rule in self._domain_objects.findall("rule"):
+            if rule.find("name").text == name:
+                schedule_rule_id = rule.attrib["id"]
+
+        if schedule_rule_id is None:
+            raise PlugwiseError("Plugwise: no schedule with this name available.")  # pragma: no cover
+
+        new_state = "false"
+        if state == "on":
+            new_state = "true"
+
+        locator = f'.//*[@id="{schedule_rule_id}"]/template'
+        for rule in self._domain_objects.findall(locator):
+            template_id = rule.attrib["id"]
+
+        uri = f"{RULES};id={schedule_rule_id}"
+        data = (
+            "<rules><rule"
+            f' id="{schedule_rule_id}"><name><![CDATA[{name}]]></name><template'
+            f' id="{template_id}" /><active>{new_state}</active></rule></rules>'
+        )
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_preset(self, _: str, preset: str) -> None:
+        """Set the given Preset on the relevant Thermostat - from DOMAIN_OBJECTS."""
+        if (presets := self._presets()) is None:
+            raise PlugwiseError("Plugwise: no presets available.")  # pragma: no cover
+        if preset not in list(presets):
+            raise PlugwiseError("Plugwise: invalid preset.")
+
+        locator = f'rule/directives/when/then[@icon="{preset}"].../.../...'
+        rule = self._domain_objects.find(locator)
+        data = f'<rules><rule id="{rule.attrib["id"]}"><active>true</active></rule></rules>'
+
+        await self._request(RULES, method="put", data=data)
+
+    async def set_temperature(self, setpoint: str, _: dict[str, float]) -> None:
+        """Set the given Temperature on the relevant Thermostat."""
+        if setpoint is None:
+            raise PlugwiseError(
+                "Plugwise: failed setting temperature: no valid input provided"
+            )  # pragma: no cover"
+
+        temperature = str(setpoint)
+        uri = self._thermostat_uri()
+        data = (
+            "<thermostat_functionality><setpoint>"
+            f"{temperature}</setpoint></thermostat_functionality>"
+        )
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_switch_state(
+        self, appl_id: str, members: list[str] | None, model: str, state: str
+    ) -> None:
+        """Set the given State of the relevant Switch."""
+        switch = Munch()
+        switch.actuator = "actuator_functionalities"
+        switch.func_type = "relay_functionality"
+        if self._stretch_v2:
+            switch.actuator = "actuators"
+            switch.func_type = "relay"
+        switch.func = "state"
+
+        if members is not None:
+            return await self._set_groupswitch_member_state(members, state, switch)
+
+        data = f"<{switch.func_type}><{switch.func}>{state}</{switch.func}></{switch.func_type}>"
+        uri = f"{APPLIANCES};id={appl_id}/{switch.func_type}"
+
+        if model == "relay":
+            locator = (
+                f'appliance[@id="{appl_id}"]/{switch.actuator}/{switch.func_type}/lock'
+            )
+            # Don't bother switching a relay when the corresponding lock-state is true
+            if self._appliances.find(locator).text == "true":
+                raise PlugwiseError("Plugwise: the locked Relay was not switched.")
+
+        await self._request(uri, method="put", data=data)
+
+    async def _set_groupswitch_member_state(
+        self, members: list[str], state: str, switch: Munch
+    ) -> None:
+        """Helper-function for set_switch_state().
+
+        Set the given State of the relevant Switch within a group of members.
+        """
+        for member in members:
+            uri = f"{APPLIANCES};id={member}/{switch.func_type}"
+            data = f"<{switch.func_type}><{switch.func}>{state}</{switch.func}></{switch.func_type}>"
+
+            await self._request(uri, method="put", data=data)
+
+    async def set_number_setpoint(self, key: str, temperature: float) -> None:
+        """Set-function placeholder for legacy devices."""
+
+    async def set_temperature_offset(self, dev_id: str, offset: float) -> None:
+        """Set-function placeholder for legacy devices."""
+
+    async def set_gateway_mode(self, mode: str) -> None:
+        """Set-function placeholder for legacy devices."""
+
+    async def set_regulation_mode(self, mode: str) -> None:
+        """Set-function placeholder for legacy devices."""
+
+    async def set_dhw_mode(self, mode: str) -> None:
+        """Set-function placeholder for legacy devices."""
+
+    async def delete_notification(self) -> None:
+        """Set-function placeholder for legacy devices."""

plugwise/smile.py

@@ -0,0 +1,426 @@
+"""Use of this source code is governed by the MIT license found in the LICENSE file.
+
+Plugwise backend module for Home Assistant Core.
+"""
+from __future__ import annotations
+
+import datetime as dt
+
+from plugwise.constants import (
+    ADAM,
+    ANNA,
+    APPLIANCES,
+    DEFAULT_PORT,
+    DEFAULT_TIMEOUT,
+    DEFAULT_USERNAME,
+    DOMAIN_OBJECTS,
+    LOCATIONS,
+    MAX_SETPOINT,
+    MIN_SETPOINT,
+    NOTIFICATIONS,
+    OFF,
+    RULES,
+    DeviceData,
+    GatewayData,
+    PlugwiseData,
+    ThermoLoc,
+)
+from plugwise.data import SmileData
+from plugwise.exceptions import PlugwiseError
+from plugwise.helper import SmileComm
+
+import aiohttp
+from defusedxml import ElementTree as etree
+
+# Dict as class
+from munch import Munch
+
+# Version detection
+import semver
+
+
+class SmileAPI(SmileComm, SmileData):
+    """The Plugwise SmileAPI helper class for actual Plugwise devices."""
+
+    # pylint: disable=too-many-instance-attributes, too-many-public-methods
+
+    def __init__(
+        self,
+        host: str,
+        password: str,
+        websession: aiohttp.ClientSession,
+        _cooling_present: bool,
+        _elga: bool,
+        _is_thermostat: bool,
+        _last_active: dict[str, str | None],
+        _on_off_device: bool,
+        _opentherm_device: bool,
+        _schedule_old_states: dict[str, dict[str, str]],
+        gateway_id: str,
+        loc_data: dict[str, ThermoLoc],
+        smile_fw_version: str | None,
+        smile_hostname: str | None,
+        smile_hw_version: str | None,
+        smile_legacy: bool,
+        smile_mac_address: str | None,
+        smile_model: str,
+        smile_name: str,
+        smile_type: str,
+        smile_version: tuple[str, semver.version.Version],
+        username: str = DEFAULT_USERNAME,
+        port: int = DEFAULT_PORT,
+        timeout: float = DEFAULT_TIMEOUT,
+
+    ) -> None:
+        """Set the constructor for this class."""
+        super().__init__(
+            host,
+            password,
+            websession,
+            username,
+            port,
+            timeout,
+        )
+        SmileData.__init__(self)
+
+        self._cooling_present = _cooling_present
+        self._elga = _elga
+        self._is_thermostat = _is_thermostat
+        self._last_active = _last_active
+        self._on_off_device = _on_off_device
+        self._opentherm_device = _opentherm_device
+        self._schedule_old_states = _schedule_old_states
+        self.gateway_id = gateway_id
+        self.loc_data = loc_data
+        self.smile_fw_version = smile_fw_version
+        self.smile_hostname = smile_hostname
+        self.smile_hw_version = smile_hw_version
+        self.smile_legacy = smile_legacy
+        self.smile_mac_address = smile_mac_address
+        self.smile_model = smile_model
+        self.smile_name = smile_name
+        self.smile_type = smile_type
+        self.smile_version = smile_version
+
+        self._heater_id: str
+        self._cooling_enabled = False
+
+    async def full_update_device(self) -> None:
+        """Perform a first fetch of all XML data, needed for initialization."""
+        self._domain_objects = await self._request(DOMAIN_OBJECTS)
+        self._get_plugwise_notifications()
+
+    def get_all_devices(self) -> None:
+        """Determine the evices present from the obtained XML-data.
+
+        Run this functions once to gather the initial device configuration,
+        then regularly run async_update() to refresh the device data.
+        """
+        # Gather all the devices and their initial data
+        self._all_appliances()
+        if self._is_thermostat:
+            if self.smile(ADAM):
+                self._scan_thermostats()
+            # Collect a list of thermostats with offset-capability
+            self.therms_with_offset_func = (
+                self._get_appliances_with_offset_functionality()
+            )
+
+        # Collect and add switching- and/or pump-group devices
+        if group_data := self._get_group_switches():
+            self.gw_devices.update(group_data)
+
+        # Collect the remaining data for all devices
+        self._all_device_data()
+
+    async def async_update(self) -> PlugwiseData:
+        """Perform an incremental update for updating the various device states."""
+        # Perform a full update at day-change
+        self.gw_data: GatewayData = {}
+        self.gw_devices: dict[str, DeviceData] = {}
+        await self.full_update_device()
+        self.get_all_devices()
+
+        if "heater_id" in self.gw_data:
+            self._heater_id = self.gw_data["heater_id"]
+            if "cooling_enabled" in self.gw_devices[self._heater_id]["binary_sensors"]:
+                self._cooling_enabled = self.gw_devices[self._heater_id]["binary_sensors"]["cooling_enabled"]
+
+        return PlugwiseData(self.gw_data, self.gw_devices)
+
+########################################################################################################
+###  API Set and HA Service-related Functions                                                        ###
+########################################################################################################
+
+    async def set_schedule_state(
+        self,
+        loc_id: str,
+        new_state: str,
+        name: str | None = None,
+    ) -> None:
+        """Activate/deactivate the Schedule, with the given name, on the relevant Thermostat.
+
+        Determined from - DOMAIN_OBJECTS.
+        Used in HA Core to set the hvac_mode: in practice switch between schedule on - off.
+        """
+        # Input checking
+        if new_state not in ["on", "off"]:
+            raise PlugwiseError("Plugwise: invalid schedule state.")
+
+        # Translate selection of Off-schedule-option to disabling the active schedule
+        if name == OFF:
+            new_state = "off"
+
+        # Handle no schedule-name / Off-schedule provided
+        if name is None or name == OFF:
+            if schedule_name := self._last_active[loc_id]:
+                name = schedule_name
+            else:
+                return
+
+        assert isinstance(name, str)
+        schedule_rule = self._rule_ids_by_name(name, loc_id)
+        # Raise an error when the schedule name does not exist
+        if not schedule_rule or schedule_rule is None:
+            raise PlugwiseError("Plugwise: no schedule with this name available.")
+
+        # If no state change is requested, do nothing
+        if new_state == self._schedule_old_states[loc_id][name]:
+            return
+
+        schedule_rule_id: str = next(iter(schedule_rule))
+        template = (
+            '<template tag="zone_preset_based_on_time_and_presence_with_override" />'
+        )
+        if self.smile(ANNA):
+            locator = f'.//*[@id="{schedule_rule_id}"]/template'
+            template_id = self._domain_objects.find(locator).attrib["id"]
+            template = f'<template id="{template_id}" />'
+
+        contexts = self.determine_contexts(loc_id, name, new_state, schedule_rule_id)
+        uri = f"{RULES};id={schedule_rule_id}"
+        data = (
+            f'<rules><rule id="{schedule_rule_id}"><name><![CDATA[{name}]]></name>'
+            f"{template}{contexts}</rule></rules>"
+        )
+
+        await self._request(uri, method="put", data=data)
+        self._schedule_old_states[loc_id][name] = new_state
+
+    def determine_contexts(
+        self, loc_id: str, name: str, state: str, sched_id: str
+    ) -> etree:
+        """Helper-function for set_schedule_state()."""
+        locator = f'.//*[@id="{sched_id}"]/contexts'
+        contexts = self._domain_objects.find(locator)
+        locator = f'.//*[@id="{loc_id}"].../...'
+        if (subject := contexts.find(locator)) is None:
+            subject = f'<context><zone><location id="{loc_id}" /></zone></context>'
+            subject = etree.fromstring(subject)
+
+        if state == "off":
+            self._last_active[loc_id] = name
+            contexts.remove(subject)
+        if state == "on":
+            contexts.append(subject)
+
+        return etree.tostring(contexts, encoding="unicode").rstrip()
+
+    async def set_preset(self, loc_id: str, preset: str) -> None:
+        """Set the given Preset on the relevant Thermostat - from LOCATIONS."""
+        if (presets := self._presets(loc_id)) is None:
+            raise PlugwiseError("Plugwise: no presets available.")  # pragma: no cover
+        if preset not in list(presets):
+            raise PlugwiseError("Plugwise: invalid preset.")
+
+        current_location = self._domain_objects.find(f'location[@id="{loc_id}"]')
+        location_name = current_location.find("name").text
+        location_type = current_location.find("type").text
+
+        uri = f"{LOCATIONS};id={loc_id}"
+        data = (
+            "<locations><location"
+            f' id="{loc_id}"><name>{location_name}</name><type>{location_type}'
+            f"</type><preset>{preset}</preset></location></locations>"
+        )
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_temperature(self, loc_id: str, items: dict[str, float]) -> None:
+        """Set the given Temperature on the relevant Thermostat."""
+        setpoint: float | None = None
+
+        if "setpoint" in items:
+            setpoint = items["setpoint"]
+
+        if self.smile(ANNA) and self._cooling_present:
+            if "setpoint_high" not in items:
+                raise PlugwiseError
+            tmp_setpoint_high = items["setpoint_high"]
+            tmp_setpoint_low = items["setpoint_low"]
+            if self._cooling_enabled:  # in cooling mode
+                setpoint = tmp_setpoint_high
+                if tmp_setpoint_low != MIN_SETPOINT:
+                    raise PlugwiseError(
+                        "Plugwise: heating setpoint cannot be changed when in cooling mode"
+                    )
+            else:  # in heating mode
+                setpoint = tmp_setpoint_low
+                if tmp_setpoint_high != MAX_SETPOINT:
+                    raise PlugwiseError(
+                        "Plugwise: cooling setpoint cannot be changed when in heating mode"
+                    )
+
+        if setpoint is None:
+            raise PlugwiseError  # pragma: no cover"
+
+        temperature = str(setpoint)
+        uri = self._thermostat_uri(loc_id)
+        data = (
+            "<thermostat_functionality><setpoint>"
+            f"{temperature}</setpoint></thermostat_functionality>"
+        )
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_number_setpoint(self, key: str, temperature: float) -> None:
+        """Set the max. Boiler or DHW setpoint on the Central Heating boiler."""
+        temp = str(temperature)
+        thermostat_id: str | None = None
+        locator = f'appliance[@id="{self._heater_id}"]/actuator_functionalities/thermostat_functionality'
+        if th_func_list := self._domain_objects.findall(locator):
+            for th_func in th_func_list:
+                if th_func.find("type").text == key:
+                    thermostat_id = th_func.attrib["id"]
+
+        if thermostat_id is None:
+            raise PlugwiseError
+
+        uri = f"{APPLIANCES};id={self._heater_id}/thermostat;id={thermostat_id}"
+        data = f"<thermostat_functionality><setpoint>{temp}</setpoint></thermostat_functionality>"
+        await self._request(uri, method="put", data=data)
+
+    async def set_temperature_offset(self, dev_id: str, offset: float) -> None:
+        """Set the Temperature offset for thermostats that support this feature."""
+        if dev_id not in self.therms_with_offset_func:
+            raise PlugwiseError
+
+        value = str(offset)
+        uri = f"{APPLIANCES};id={dev_id}/offset;type=temperature_offset"
+        data = f"<offset_functionality><offset>{value}</offset></offset_functionality>"
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_switch_state(
+        self, appl_id: str, members: list[str] | None, model: str, state: str
+    ) -> None:
+        """Set the given State of the relevant Switch."""
+        switch = Munch()
+        switch.actuator = "actuator_functionalities"
+        switch.device = "relay"
+        switch.func_type = "relay_functionality"
+        switch.func = "state"
+        if model == "dhw_cm_switch":
+            switch.device = "toggle"
+            switch.func_type = "toggle_functionality"
+            switch.act_type = "domestic_hot_water_comfort_mode"
+
+        if model == "cooling_ena_switch":
+            switch.device = "toggle"
+            switch.func_type = "toggle_functionality"
+            switch.act_type = "cooling_enabled"
+
+        if model == "lock":
+            switch.func = "lock"
+            state = "false" if state == "off" else "true"
+
+        if members is not None:
+            return await self._set_groupswitch_member_state(members, state, switch)
+
+        locator = f'appliance[@id="{appl_id}"]/{switch.actuator}/{switch.func_type}'
+        found: list[etree] = self._domain_objects.findall(locator)
+        for item in found:
+            if (sw_type := item.find("type")) is not None:
+                if sw_type.text == switch.act_type:
+                    switch_id = item.attrib["id"]
+            else:
+                switch_id = item.attrib["id"]
+                break
+
+        uri = f"{APPLIANCES};id={appl_id}/{switch.device};id={switch_id}"
+        data = f"<{switch.func_type}><{switch.func}>{state}</{switch.func}></{switch.func_type}>"
+
+        if model == "relay":
+            locator = (
+                f'appliance[@id="{appl_id}"]/{switch.actuator}/{switch.func_type}/lock'
+            )
+            # Don't bother switching a relay when the corresponding lock-state is true
+            if self._domain_objects.find(locator).text == "true":
+                raise PlugwiseError
+
+        await self._request(uri, method="put", data=data)
+
+    async def _set_groupswitch_member_state(
+        self, members: list[str], state: str, switch: Munch
+    ) -> None:
+        """Helper-function for set_switch_state().
+
+        Set the given State of the relevant Switch within a group of members.
+        """
+        for member in members:
+            locator = f'appliance[@id="{member}"]/{switch.actuator}/{switch.func_type}'
+            switch_id = self._domain_objects.find(locator).attrib["id"]
+            uri = f"{APPLIANCES};id={member}/{switch.device};id={switch_id}"
+            data = f"<{switch.func_type}><{switch.func}>{state}</{switch.func}></{switch.func_type}>"
+
+            await self._request(uri, method="put", data=data)
+
+    async def set_gateway_mode(self, mode: str) -> None:
+        """Set the gateway mode."""
+        if mode not in self._gw_allowed_modes:
+            raise PlugwiseError
+
+        end_time = "2037-04-21T08:00:53.000Z"
+        valid = ""
+        if mode == "away":
+            time_1 = self._domain_objects.find("./gateway/time").text
+            away_time = dt.datetime.fromisoformat(time_1).astimezone(dt.UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+            valid = (
+                f"<valid_from>{away_time}</valid_from><valid_to>{end_time}</valid_to>"
+            )
+        if mode == "vacation":
+            time_2 = str(dt.date.today() - dt.timedelta(1))
+            vacation_time = time_2 + "T23:00:00.000Z"
+            valid = f"<valid_from>{vacation_time}</valid_from><valid_to>{end_time}</valid_to>"
+
+        uri = f"{APPLIANCES};id={self.gateway_id}/gateway_mode_control"
+        data = f"<gateway_mode_control_functionality><mode>{mode}</mode>{valid}</gateway_mode_control_functionality>"
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_regulation_mode(self, mode: str) -> None:
+        """Set the heating regulation mode."""
+        if mode not in self._reg_allowed_modes:
+            raise PlugwiseError
+
+        uri = f"{APPLIANCES};type=gateway/regulation_mode_control"
+        duration = ""
+        if "bleeding" in mode:
+            duration = "<duration>300</duration>"
+        data = f"<regulation_mode_control_functionality>{duration}<mode>{mode}</mode></regulation_mode_control_functionality>"
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_dhw_mode(self, mode: str) -> None:
+        """Set the domestic hot water heating regulation mode."""
+        if mode not in self._dhw_allowed_modes:
+            raise PlugwiseError("Plugwise: invalid dhw mode.")
+
+        uri = f"{APPLIANCES};type=heater_central/domestic_hot_water_mode_control"
+        data = f"<domestic_hot_water_mode_control_functionality><mode>{mode}</mode></domestic_hot_water_mode_control_functionality>"
+
+        await self._request(uri, method="put", data=data)
+
+    async def delete_notification(self) -> None:
+        """Delete the active Plugwise Notification."""
+        await self._request(NOTIFICATIONS, method="delete")