aioWiserHeatAPI 1.7.8__tar.gz → 1.7.9__tar.gz

aiowiserheatapi-1.7.9/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: aioWiserHeatAPI
+Version: 1.7.9
+Summary: An AsyncIO API for controlling the Drayton Wiser Heating system
+Home-page: https://github.com/msp1974/aioWiserHeatAPI
+Author: Mark Parker
+Author-email: msparker@sky.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: zeroconf>=0.131.0
+Requires-Dist: aiohttp>=3.9.3
+Requires-Dist: aiofiles>=23.2.1
+Requires-Dist: pyyaml>=6.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Drayton Wiser Hub API Async
+
+An asynchronous Python API for the Drayton Wiser heating system used in the UK.
+It supports one-, two-, and three-channel HeatHubs, Smart Plugs, shutters, lights,
+and other Wiser devices.
+
+## Requirements
+
+Python 3.12 or later.
+
+## Installation
+
+```sh
+python -m pip install aioWiserHeatAPI
+```
+
+## Hub setup
+
+### 1. Find your HeatHub secret key
+
+1. Press the setup button on your HeatHub. The light will start flashing.
+2. Connect your computer or phone to the Wi-Fi network named `WiserHeatXXXXXX`,
+   where `XXXXXX` is the last six digits of the hub's MAC address.
+3. Open `http://192.168.8.1/secret` in a browser. Save the returned string as your
+   hub's secret key.
+4. Press the setup button again to return the HeatHub to normal operation.
+
+See the [HeatHub connection guide](https://it.knightnet.org.uk/kb/nr-qa/drayton-wiser-heating-control/#controlling-the-system)
+for more information.
+
+### 2. Find your HeatHub IP address
+
+Use your router's connected-device list to find the HeatHub's IP address. The hub
+usually identifies itself as `WiserHeatXXXXXX`.
+
+Hub discovery is also available through the API; see
+[discovery.py](aioWiserHeatAPI/discovery.py).
+
+## Documentation
+
+- [API documentation](docs/info.md)
+- [API implementation](aioWiserHeatAPI/wiserhub.py)
+- [Release history](CHANGELOG.md)

aiowiserheatapi-1.7.9/README.md

@@ -0,0 +1,43 @@
+# Drayton Wiser Hub API Async
+
+An asynchronous Python API for the Drayton Wiser heating system used in the UK.
+It supports one-, two-, and three-channel HeatHubs, Smart Plugs, shutters, lights,
+and other Wiser devices.
+
+## Requirements
+
+Python 3.12 or later.
+
+## Installation
+
+```sh
+python -m pip install aioWiserHeatAPI
+```
+
+## Hub setup
+
+### 1. Find your HeatHub secret key
+
+1. Press the setup button on your HeatHub. The light will start flashing.
+2. Connect your computer or phone to the Wi-Fi network named `WiserHeatXXXXXX`,
+   where `XXXXXX` is the last six digits of the hub's MAC address.
+3. Open `http://192.168.8.1/secret` in a browser. Save the returned string as your
+   hub's secret key.
+4. Press the setup button again to return the HeatHub to normal operation.
+
+See the [HeatHub connection guide](https://it.knightnet.org.uk/kb/nr-qa/drayton-wiser-heating-control/#controlling-the-system)
+for more information.
+
+### 2. Find your HeatHub IP address
+
+Use your router's connected-device list to find the HeatHub's IP address. The hub
+usually identifies itself as `WiserHeatXXXXXX`.
+
+Hub discovery is also available through the API; see
+[discovery.py](aioWiserHeatAPI/discovery.py).
+
+## Documentation
+
+- [API documentation](docs/info.md)
+- [API implementation](aioWiserHeatAPI/wiserhub.py)
+- [Release history](CHANGELOG.md)

{aiowiserheatapi-1.7.8 → aiowiserheatapi-1.7.9}/aioWiserHeatAPI/__init__.py

@@ -3,6 +3,6 @@ import logging
 name = "aioWiserHeatAPI"
 __all__ = ["wiserAPI", "wiserDiscovery"]
 
-__VERSION__ = "1.7.8"
+__VERSION__ = "1.7.9"
 
 _LOGGER = logging.getLogger(__name__)

{aiowiserheatapi-1.7.8 → aiowiserheatapi-1.7.9}/aioWiserHeatAPI/const.py

@@ -63,7 +63,6 @@ TEXT_WEEKDAYS = "Weekdays"
 TEXT_WEEKENDS = "Weekends"
 TEXT_ALL = "All"
 TEXT_UNABLE = "Unable"
-# added by Lgo44
 
 TEXT_REVERSE = "ReverseWithLoad"
 TEXT_CONSISTENT = "ConsistentWithLoad"
@@ -74,7 +73,10 @@ TEXT_OFF_AFTER_2S = "OffAfter2s"
 TEXT_LASTON = "LastOnBrightness"
 TEXT_LEVELPERCENT = "LevelPercent"
 
-# End added by Lgo44
+TEXT_RL_LED = "RL_LED"
+
+TEXT_RELAY = "Relay"
+TEXT_FIL_PILOTE = "FilPilote"
 
 # Day Value Lists
 WEEKDAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
@@ -152,7 +154,6 @@ class WiserShutterAwayActionEnum(enum.Enum):
     nochange = TEXT_NO_CHANGE
 
 
-# added by Lgo44
 class WiserLightLedIndicatorEnum(enum.Enum):
     reverse = TEXT_REVERSE
     consistent = TEXT_CONSISTENT
@@ -166,7 +167,21 @@ class WiserLightPowerOnBehaviourEnum(enum.Enum):
     levelpercent = TEXT_LEVELPERCENT
 
 
-# End added by Lgo44
+class WiserLightOutputModeEnum(enum.Enum):
+    auto = TEXT_AUTO
+    rl_led = TEXT_RL_LED
+
+
+class WiserSmartPlugLedIndicatorEnum(enum.Enum):
+    reverse = TEXT_REVERSE
+    consistent = TEXT_CONSISTENT
+    allwayson = TEXT_ALWAYSON
+    allwaysoff = TEXT_ALWAYSOFF
+
+
+class WiserHeatingActuatorOutputTypeEnum(enum.Enum):
+    relay = TEXT_RELAY
+    fil_pilote = TEXT_FIL_PILOTE
 
 
 class WiserDeviceModeEnum(enum.Enum):

{aiowiserheatapi-1.7.8 → aiowiserheatapi-1.7.9}/aioWiserHeatAPI/heating_actuator.py

@@ -1,4 +1,13 @@
-from .const import TEMP_OFF, TEXT_UNKNOWN, WISERHEATINGACTUATOR, WiserTempLimitsEnum
+from typing import Union
+
+from .const import (
+    TEMP_OFF,
+    TEXT_UNKNOWN,
+    WISERDEVICE,
+    WISERHEATINGACTUATOR,
+    WiserHeatingActuatorOutputTypeEnum,
+    WiserTempLimitsEnum,
+)
 from .helpers.device import _WiserDevice
 from .helpers.equipment import _WiserEquipment
 from .helpers.temp import _WiserTemperatureFunctions as tf
@@ -115,6 +124,22 @@ class _WiserHeatingActuator(_WiserDevice):
         self._threshold_sensors: list[_WiserThresholdSensor] = []
         self._uiconfig_sensors: list[_WiserUIConfigSensor] = []
 
+    async def _send_command(self, cmd: dict, device_level: bool = False) -> bool:
+        """Send commands using the ID belonging to the requested endpoint."""
+        endpoint = (
+            WISERDEVICE.format(self.id)
+            if device_level
+            else self._endpoint.format(self.device_type_id)
+        )
+        result = await self._wiser_rest_controller._send_command(endpoint, cmd)
+        if not result:
+            return False
+        if device_level:
+            self._data = result
+        else:
+            self._device_type_data = result
+        return True
+
     @property
     def current_target_temperature(self) -> float:
         """Get the current target temperature setting"""
@@ -164,11 +189,6 @@ class _WiserHeatingActuator(_WiserDevice):
         """Get the amount of current passing through the device now"""
         return self._device_type_data.get("InstantaneousDemand", None)
 
-    @property
-    def output_type(self) -> str:
-        """Get output type"""
-        return self._device_type_data.get("OutputType", TEXT_UNKNOWN)
-
     @property
     def threshold_sensors(self) -> list[_WiserThresholdSensor]:
         """Get threshold sensors."""
@@ -179,6 +199,30 @@ class _WiserHeatingActuator(_WiserDevice):
         """Get ui configuration sensors."""
         return self._uiconfig_sensors
 
+    @property
+    def available_output_type(self) -> list[str]:
+        """Get available heating-actuator output types."""
+        return [output_type.value for output_type in WiserHeatingActuatorOutputTypeEnum]
+
+    @property
+    def output_type(self) -> str:
+        """Get the output type for the heating actuator."""
+        return self._device_type_data.get("OutputType", TEXT_UNKNOWN)
+
+    async def set_output_type(
+        self, output_type: Union[WiserHeatingActuatorOutputTypeEnum, str]
+    ) -> bool:
+        """Set the output type using an enum or case-insensitive string."""
+        if isinstance(output_type, WiserHeatingActuatorOutputTypeEnum):
+            output_type = output_type.value
+        if isinstance(output_type, str):
+            for mode in WiserHeatingActuatorOutputTypeEnum:
+                if output_type.casefold() == mode.value.casefold():
+                    return await self._send_command({"OutputType": mode.value})
+        raise ValueError(
+            f"{output_type} is not a valid type.  Valid types are {self.available_output_type}"
+        )
+
 
 class _WiserHeatingActuatorCollection(object):
     """Class holding all wiser heating actuators"""

{aiowiserheatapi-1.7.8 → aiowiserheatapi-1.7.9}/aioWiserHeatAPI/light.py

@@ -10,6 +10,7 @@ from .const import (
     WiserDeviceModeEnum,
     WiserLightLedIndicatorEnum,
     WiserLightPowerOnBehaviourEnum,
+    WiserLightOutputModeEnum,
 )
 from .helpers.device import _WiserElectricalDevice
 from .helpers.misc import is_value_in_list
@@ -169,6 +170,21 @@ class _WiserLight(_WiserElectricalDevice):
 
     # end added by LGO
 
+    @property
+    def manual_level(self) -> int:
+        """Get manual level of light"""
+        return self._device_type_data.get("ManualLevel", 0)
+
+    @property
+    def scheduled_percentage(self) -> int:
+        """Get the scheduled percentage for the light"""
+        return self._data.get("ScheduledPercentage", 0)
+
+    @property
+    def target_percentage(self) -> int:
+        """Get target percentage brightness of light"""
+        return self._device_type_data.get("TargetPercentage", 0)
+
     @property
     def target_state(self) -> int:
         """Get target state of light"""
@@ -216,11 +232,6 @@ class _WiserDimmableLight(_WiserLight):
         else:
             raise ValueError("Brightness level percentage must be between 0 and 100")
 
-    @property
-    def manual_level(self) -> int:
-        """Get manual level of light"""
-        return self._device_type_data.get("ManualLevel", 0)
-
     @property
     def override_level(self) -> int:
         """Get override level of light"""
@@ -232,16 +243,6 @@ class _WiserDimmableLight(_WiserLight):
         # TODO: Add setter for min max values
         return _WiserOutputRange(self._device_type_data.get("OutputRange", None))
 
-    @property
-    def scheduled_percentage(self) -> int:
-        """Get the scheduled percentage for the light"""
-        return self._data.get("ScheduledPercentage", 0)
-
-    @property
-    def target_percentage(self) -> int:
-        """Get target percentage brightness of light"""
-        return self._device_type_data.get("TargetPercentage", 0)
-
     # added by LGO
     # Hub V2  new features
 
@@ -268,10 +269,35 @@ class _WiserDimmableLight(_WiserLight):
             )
 
     @property
-    def power_on_level(self) -> int:
+    def power_on_level(self) -> int | None:
         """Get power on level for the light"""
         return self._device_type_data.get("PowerOnLevel", None)
 
+    async def set_power_on_level(self, level: int) -> bool:
+        """Set power on level to a whole percentage between 0 and 100."""
+        if isinstance(level, bool) or not isinstance(level, int) or not 0 <= level <= 100:
+            raise ValueError("Power on level must be an integer between 0 and 100")
+        return await self._send_command({"PowerOnLevel": level})
+
+    @property
+    def available_output_mode(self) -> list[str]:
+        """Get available output modes."""
+        return [mode.value for mode in WiserLightOutputModeEnum]
+
+    async def set_output_mode(
+        self, output_mode: Union[WiserLightOutputModeEnum, str]
+    ) -> bool:
+        """Set output mode, accepting enum values or case-insensitive strings."""
+        if isinstance(output_mode, WiserLightOutputModeEnum):
+            output_mode = output_mode.value
+        if isinstance(output_mode, str):
+            for mode in WiserLightOutputModeEnum:
+                if output_mode.casefold() == mode.value.casefold():
+                    return await self._send_command({"OutputMode": mode.value})
+        raise ValueError(
+            f"{output_mode} is not a valid mode.  Valid modes are {self.available_output_mode}"
+        )
+
     # end added by LGO
 
 

{aiowiserheatapi-1.7.8 → aiowiserheatapi-1.7.9}/aioWiserHeatAPI/ptc.py

@@ -117,20 +117,20 @@ class _WiserPowerTagControl(_WiserElectricalDevice):
 
     async def turn_on(self) -> bool:
         """
-        Turn on the smart plug
+        Turn on the PowerTag Control using its manual state.
         return: boolean
         """
-        result = await self._send_command({"RequestOutput": TEXT_ON})
+        result = await self._send_command({"ManualState": TEXT_ON})
         if result:
             self._output_state = TEXT_ON
         return result
 
     async def turn_off(self) -> bool:
         """
-        Turn off the smart plug
+        Turn off the PowerTag Control using its manual state.
         return: boolean
         """
-        result = await self._send_command({"RequestOutput": TEXT_OFF})
+        result = await self._send_command({"ManualState": TEXT_OFF})
         if result:
             self._output_state = TEXT_OFF
         return result

{aiowiserheatapi-1.7.8 → aiowiserheatapi-1.7.9}/aioWiserHeatAPI/smartplug.py

@@ -1,4 +1,13 @@
-from .const import TEXT_OFF, TEXT_ON, TEXT_UNKNOWN, WiserDeviceModeEnum
+from typing import Union
+
+from .const import (
+    TEXT_OFF,
+    TEXT_ON,
+    TEXT_UNKNOWN,
+    WISERDEVICE,
+    WiserDeviceModeEnum,
+    WiserSmartPlugLedIndicatorEnum,
+)
 from .helpers.device import _WiserElectricalDevice
 from .helpers.equipment import _WiserEquipment
 
@@ -6,6 +15,22 @@ from .helpers.equipment import _WiserEquipment
 class _WiserSmartPlug(_WiserElectricalDevice):
     """Class representing a Wiser Smart Plug device"""
 
+    async def _send_command(self, cmd: dict, device_level: bool = False) -> bool:
+        """Send commands using the ID belonging to the requested endpoint."""
+        endpoint = (
+            WISERDEVICE.format(self.id)
+            if device_level
+            else self._endpoint.format(self.device_type_id)
+        )
+        result = await self._wiser_rest_controller._send_command(endpoint, cmd)
+        if not result:
+            return False
+        if device_level:
+            self._data = result
+        else:
+            self._device_type_data = result
+        return True
+
     @property
     def control_source(self) -> str:
         """Get the current control source of the smart plug"""
@@ -55,6 +80,45 @@ class _WiserSmartPlug(_WiserElectricalDevice):
         """Get the current scheduled state of the smart plug"""
         return self._device_type_data.get("ScheduledState", TEXT_UNKNOWN)
 
+    @property
+    def is_led_indicator_supported(self) -> bool:
+        """Return whether the smart plug supports LED indicator configuration."""
+        return bool(self._device_type_data.get("IsLedIndicatorSupported", False))
+
+    @property
+    def available_led_indicator(self) -> list[str]:
+        """Get available LED indicator modes."""
+        return [mode.value for mode in WiserSmartPlugLedIndicatorEnum]
+
+    @property
+    def led_indicator(self) -> str:
+        """Get the LED indicator mode for the smart plug."""
+        return self._device_type_data.get("LedIndicator", TEXT_UNKNOWN)
+
+    async def set_led_indicator(
+        self, led_indicator: Union[WiserSmartPlugLedIndicatorEnum, str]
+    ) -> bool:
+        """Set the LED indicator using an enum or case-insensitive string."""
+        if isinstance(led_indicator, WiserSmartPlugLedIndicatorEnum):
+            led_indicator = led_indicator.value
+        if isinstance(led_indicator, str):
+            for mode in WiserSmartPlugLedIndicatorEnum:
+                if led_indicator.casefold() == mode.value.casefold():
+                    return await self._send_command({"LedIndicator": mode.value})
+        raise ValueError(
+            f"{led_indicator} is not a valid mode.  Valid modes are {self.available_led_indicator}"
+        )
+
+    @property
+    def next_scheduled_date(self) -> str:
+        """Get the next scheduled date for the smart plug"""
+        return self._device_type_data.get("NextScheduledDate", TEXT_UNKNOWN)
+
+    @property
+    def next_scheduled_end_date(self) -> str:
+        """Get the next scheduled end date for the smart plug"""
+        return self._device_type_data.get("NextScheduledEndDate", TEXT_UNKNOWN)
+
     async def turn_on(self) -> bool:
         """
         Turn on the smart plug

aiowiserheatapi-1.7.9/aioWiserHeatAPI.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: aioWiserHeatAPI
+Version: 1.7.9
+Summary: An AsyncIO API for controlling the Drayton Wiser Heating system
+Home-page: https://github.com/msp1974/aioWiserHeatAPI
+Author: Mark Parker
+Author-email: msparker@sky.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: zeroconf>=0.131.0
+Requires-Dist: aiohttp>=3.9.3
+Requires-Dist: aiofiles>=23.2.1
+Requires-Dist: pyyaml>=6.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Drayton Wiser Hub API Async
+
+An asynchronous Python API for the Drayton Wiser heating system used in the UK.
+It supports one-, two-, and three-channel HeatHubs, Smart Plugs, shutters, lights,
+and other Wiser devices.
+
+## Requirements
+
+Python 3.12 or later.
+
+## Installation
+
+```sh
+python -m pip install aioWiserHeatAPI
+```
+
+## Hub setup
+
+### 1. Find your HeatHub secret key
+
+1. Press the setup button on your HeatHub. The light will start flashing.
+2. Connect your computer or phone to the Wi-Fi network named `WiserHeatXXXXXX`,
+   where `XXXXXX` is the last six digits of the hub's MAC address.
+3. Open `http://192.168.8.1/secret` in a browser. Save the returned string as your
+   hub's secret key.
+4. Press the setup button again to return the HeatHub to normal operation.
+
+See the [HeatHub connection guide](https://it.knightnet.org.uk/kb/nr-qa/drayton-wiser-heating-control/#controlling-the-system)
+for more information.
+
+### 2. Find your HeatHub IP address
+
+Use your router's connected-device list to find the HeatHub's IP address. The hub
+usually identifies itself as `WiserHeatXXXXXX`.
+
+Hub discovery is also available through the API; see
+[discovery.py](aioWiserHeatAPI/discovery.py).
+
+## Documentation
+
+- [API documentation](docs/info.md)
+- [API implementation](aioWiserHeatAPI/wiserhub.py)
+- [Release history](CHANGELOG.md)

{aiowiserheatapi-1.7.8 → aiowiserheatapi-1.7.9}/aioWiserHeatAPI.egg-info/SOURCES.txt

@@ -65,6 +65,10 @@ tests/test_device_notifications.py
 tests/test_equipment.py
 tests/test_equipments.py
 tests/test_evse.py
+tests/test_heating_actuator.py
+tests/test_light.py
+tests/test_ptc.py
 tests/test_rest_controller.py
 tests/test_rest_payloads.py
-tests/test_schedule.py
+tests/test_schedule.py
+tests/test_smartplug.py

aiowiserheatapi-1.7.9/tests/test_heating_actuator.py

@@ -0,0 +1,103 @@
+"""Heating-actuator output type validation and command routing tests."""
+
+import unittest
+from unittest.mock import AsyncMock
+
+from aioWiserHeatAPI.const import TEXT_UNKNOWN, WiserHeatingActuatorOutputTypeEnum
+from aioWiserHeatAPI.heating_actuator import _WiserHeatingActuator
+
+
+def make_actuator(data=None, response=False):
+    controller = AsyncMock()
+    controller._send_command.return_value = response
+    actuator = _WiserHeatingActuator(
+        controller,
+        "HeatingActuator/{}",
+        {"id": 12},
+        {"id": 4, **(data or {})},
+        None,
+    )
+    return actuator, controller
+
+
+class WiserHeatingActuatorPropertiesTest(unittest.TestCase):
+    """Preserve reported output types and missing-field defaults."""
+
+    def test_missing_output_type(self) -> None:
+        actuator, _ = make_actuator()
+        self.assertEqual(actuator.output_type, TEXT_UNKNOWN)
+
+    def test_reported_output_type(self) -> None:
+        for value in ("Relay", "FilPilote", "FutureType"):
+            with self.subTest(value=value):
+                actuator, _ = make_actuator({"OutputType": value})
+                self.assertEqual(actuator.output_type, value)
+
+    def test_available_output_types(self) -> None:
+        actuator, _ = make_actuator()
+        self.assertEqual(actuator.available_output_type, ["Relay", "FilPilote"])
+
+
+class WiserHeatingActuatorCommandsTest(unittest.IsolatedAsyncioTestCase):
+    """Validate commands and distinguish actuator IDs from generic device IDs."""
+
+    async def test_output_types_send_canonical_values_and_update_state(self) -> None:
+        for mode in WiserHeatingActuatorOutputTypeEnum:
+            for value in (mode, mode.value, mode.value.lower(), mode.value.upper()):
+                with self.subTest(value=value):
+                    actuator, controller = make_actuator(
+                        {"OutputType": "Relay"},
+                        {"id": 4, "OutputType": mode.value},
+                    )
+                    self.assertTrue(await actuator.set_output_type(value))
+                    controller._send_command.assert_awaited_once_with(
+                        "HeatingActuator/4", {"OutputType": mode.value}
+                    )
+                    self.assertEqual(actuator.output_type, mode.value)
+                    self.assertEqual(actuator.id, 12)
+
+    async def test_invalid_output_types_never_send(self) -> None:
+        for value in ("", "invalid", " Relay ", None, True, 1, []):
+            with self.subTest(value=value):
+                actuator, controller = make_actuator({"OutputType": "Relay"})
+                with self.assertRaises(ValueError):
+                    await actuator.set_output_type(value)
+                controller._send_command.assert_not_awaited()
+                self.assertEqual(actuator.output_type, "Relay")
+
+    async def test_failed_output_type_command_preserves_state(self) -> None:
+        actuator, controller = make_actuator({"OutputType": "Relay"})
+        self.assertFalse(await actuator.set_output_type("FilPilote"))
+        controller._send_command.assert_awaited_once_with(
+            "HeatingActuator/4", {"OutputType": "FilPilote"}
+        )
+        self.assertEqual(actuator.output_type, "Relay")
+        self.assertEqual(actuator.device_type_id, 4)
+
+    async def test_device_commands_use_generic_device_id(self) -> None:
+        actuator, controller = make_actuator(
+            {"OutputType": "Relay"}, {"id": 12, "DeviceLockEnabled": True}
+        )
+        await actuator.set_device_lock_enabled(True)
+        controller._send_command.assert_awaited_once_with(
+            "Device/12", {"DeviceLockEnabled": True}
+        )
+        self.assertTrue(actuator.device_lock_enabled)
+        self.assertEqual(actuator.output_type, "Relay")
+        self.assertEqual(actuator.device_type_id, 4)
+
+    async def test_failed_device_commands_preserve_state(self) -> None:
+        actuator, controller = make_actuator({"OutputType": "Relay"})
+        self.assertFalse(
+            await actuator._send_command({"DeviceLockEnabled": True}, True)
+        )
+        controller._send_command.assert_awaited_once_with(
+            "Device/12", {"DeviceLockEnabled": True}
+        )
+        self.assertFalse(actuator.device_lock_enabled)
+        self.assertEqual(actuator.id, 12)
+        self.assertEqual(actuator.output_type, "Relay")
+
+
+if __name__ == "__main__":
+    unittest.main()