PySwitchbot 0.66.0__tar.gz → 0.68.0__tar.gz

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySwitchbot
-Version: 0.66.0
+Version: 0.68.0
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/sblibs/pySwitchbot/
 Author: Daniel Hjelseth Hoyer

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/PySwitchbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySwitchbot
-Version: 0.66.0
+Version: 0.68.0
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/sblibs/pySwitchbot/
 Author: Daniel Hjelseth Hoyer

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/setup.py

@@ -20,7 +20,7 @@ setup(
         "cryptography>=39.0.0",
         "pyOpenSSL>=23.0.0",
     ],
-    version="0.66.0",
+    version="0.68.0",
     description="A library to communicate with Switchbot",
     long_description=long_description,
     long_description_content_type="text/markdown",

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/switchbot/__init__.py

@@ -32,7 +32,11 @@ from .devices.bot import Switchbot
 from .devices.bulb import SwitchbotBulb
 from .devices.ceiling_light import SwitchbotCeilingLight
 from .devices.curtain import SwitchbotCurtain
-from .devices.device import SwitchbotDevice, SwitchbotEncryptedDevice
+from .devices.device import (
+    SwitchbotDevice,
+    SwitchbotEncryptedDevice,
+    SwitchbotOperationError,
+)
 from .devices.evaporative_humidifier import SwitchbotEvaporativeHumidifier
 from .devices.fan import SwitchbotFan
 from .devices.humidifier import SwitchbotHumidifier
@@ -78,6 +82,7 @@ __all__ = [
     "SwitchbotLock",
     "SwitchbotModel",
     "SwitchbotModel",
+    "SwitchbotOperationError",
     "SwitchbotPlugMini",
     "SwitchbotPlugMini",
     "SwitchbotRelaySwitch",

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/switchbot/adv_parser.py

@@ -25,7 +25,12 @@ from .adv_parsers.humidifier import process_evaporative_humidifier, process_wohu
 from .adv_parsers.keypad import process_wokeypad
 from .adv_parsers.leak import process_leak
 from .adv_parsers.light_strip import process_light, process_wostrip
-from .adv_parsers.lock import process_lock2, process_wolock, process_wolock_pro
+from .adv_parsers.lock import (
+    process_lock2,
+    process_locklite,
+    process_wolock,
+    process_wolock_pro,
+)
 from .adv_parsers.meter import process_wosensorth, process_wosensorth_c
 from .adv_parsers.motion import process_wopresence
 from .adv_parsers.plug import process_woplugmini
@@ -304,7 +309,7 @@ SUPPORTED_TYPES: dict[str | bytes, SwitchbotSupportedType] = {
     "-": {
         "modelName": SwitchbotModel.LOCK_LITE,
         "modelFriendlyName": "Lock Lite",
-        "func": process_wolock,
+        "func": process_locklite,
         "manufacturer_id": 2409,
     },
     b"\x00\x10\xa5\xb8": {

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/switchbot/adv_parsers/lock.py

@@ -11,6 +11,21 @@ _LOGGER = logging.getLogger(__name__)
 
 def process_wolock(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool | int]:
     """Support for lock and lock lite process data."""
+    common_data = process_locklite(data, mfr_data)
+    if not common_data:
+        return {}
+
+    common_data["door_open"] = bool(mfr_data[7] & 0b00000100)
+    common_data["unclosed_alarm"] = bool(mfr_data[8] & 0b00100000)
+    common_data["auto_lock_paused"] = bool(mfr_data[8] & 0b00000010)
+
+    return common_data
+
+
+def process_locklite(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, bool | int]:
+    """Support for lock lite process data."""
     if mfr_data is None:
         return {}
 
@@ -24,11 +39,8 @@ def process_wolock(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool
         "calibration": bool(mfr_data[7] & 0b10000000),
         "status": LockStatus((mfr_data[7] & 0b01110000) >> 4),
         "update_from_secondary_lock": bool(mfr_data[7] & 0b00001000),
-        "door_open": bool(mfr_data[7] & 0b00000100),
         "double_lock_mode": bool(mfr_data[8] & 0b10000000),
-        "unclosed_alarm": bool(mfr_data[8] & 0b00100000),
         "unlocked_alarm": bool(mfr_data[8] & 0b00010000),
-        "auto_lock_paused": bool(mfr_data[8] & 0b00000010),
         "night_latch": bool(mfr_data[9] & 0b00000001) if len(mfr_data) > 9 else False,
     }
 
@@ -37,10 +49,11 @@ def parse_common_data(mfr_data: bytes | None) -> dict[str, bool | int]:
     if mfr_data is None:
         return {}
 
+    _LOGGER.debug("mfr_data: %s", mfr_data.hex())
     return {
         "sequence_number": mfr_data[6],
         "calibration": bool(mfr_data[7] & 0b10000000),
-        "status": LockStatus((mfr_data[7] & 0b01111000) >> 4),
+        "status": LockStatus((mfr_data[7] & 0b01111000) >> 3),
         "update_from_secondary_lock": bool(mfr_data[8] & 0b11000000),
         "door_open_from_secondary_lock": bool(mfr_data[8] & 0b00100000),
         "door_open": bool(mfr_data[8] & 0b00010000),

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/switchbot/devices/air_purifier.py

@@ -21,8 +21,6 @@ _LOGGER = logging.getLogger(__name__)
 
 
 COMMAND_HEAD = "570f4c"
-COMMAND_TURN_OFF = f"{COMMAND_HEAD}010000"
-COMMAND_TURN_ON = f"{COMMAND_HEAD}010100"
 COMMAND_SET_MODE = {
     AirPurifierMode.LEVEL_1.name.lower(): f"{COMMAND_HEAD}01010100",
     AirPurifierMode.LEVEL_2.name.lower(): f"{COMMAND_HEAD}01010132",
@@ -37,6 +35,9 @@ DEVICE_GET_BASIC_SETTINGS_KEY = "570f4d81"
 class SwitchbotAirPurifier(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
     """Representation of a Switchbot Air Purifier."""
 
+    _turn_on_command = f"{COMMAND_HEAD}010100"
+    _turn_off_command = f"{COMMAND_HEAD}010000"
+
     def __init__(
         self,
         device: BLEDevice,
@@ -109,18 +110,6 @@ class SwitchbotAirPurifier(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
         result = await self._send_command(COMMAND_SET_MODE[preset_mode])
         return self._check_command_result(result, 0, {1})
 
-    @update_after_operation
-    async def turn_on(self) -> bool:
-        """Turn on the air purifier."""
-        result = await self._send_command(COMMAND_TURN_ON)
-        return self._check_command_result(result, 0, {1})
-
-    @update_after_operation
-    async def turn_off(self) -> bool:
-        """Turn off the air purifier."""
-        result = await self._send_command(COMMAND_TURN_OFF)
-        return self._check_command_result(result, 0, {1})
-
     def get_current_percentage(self) -> Any:
         """Return cached percentage."""
         return self._get_adv_value("speed")

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/switchbot/devices/base_light.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from ..helpers import create_background_task
 from ..models import SwitchBotAdvertisement
-from .device import SwitchbotDevice
+from .device import SwitchbotDevice, SwitchbotOperationError, update_after_operation
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -14,14 +14,19 @@ _LOGGER = logging.getLogger(__name__)
 class SwitchbotBaseLight(SwitchbotDevice):
     """Representation of a Switchbot light."""
 
+    _effect_dict: dict[str, list[str]] = {}
+    _set_brightness_command: str = ""
+    _set_color_temp_command: str = ""
+    _set_rgb_command: str = ""
+
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        """Switchbot bulb constructor."""
+        """Switchbot base light constructor."""
         super().__init__(*args, **kwargs)
         self._state: dict[str, Any] = {}
 
     @property
     def on(self) -> bool | None:
-        """Return if bulb is on."""
+        """Return if light is on."""
         return self.is_on()
 
     @property
@@ -60,7 +65,7 @@ class SwitchbotBaseLight(SwitchbotDevice):
     @property
     def get_effect_list(self) -> list[str] | None:
         """Return the list of supported effects."""
-        return None
+        return list(self._effect_dict) if self._effect_dict else None
 
     def is_on(self) -> bool | None:
         """Return bulb state from cache."""
@@ -70,25 +75,49 @@ class SwitchbotBaseLight(SwitchbotDevice):
         """Return the current effect."""
         return self._get_adv_value("effect")
 
-    @abstractmethod
-    async def turn_on(self) -> bool:
-        """Turn device on."""
-
-    @abstractmethod
-    async def turn_off(self) -> bool:
-        """Turn device off."""
-
-    @abstractmethod
+    @update_after_operation
     async def set_brightness(self, brightness: int) -> bool:
         """Set brightness."""
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        hex_brightness = f"{brightness:02X}"
+        self._check_function_support(self._set_brightness_command)
+        result = await self._send_command(
+            self._set_brightness_command.format(hex_brightness)
+        )
+        return self._check_command_result(result, 0, {1})
 
-    @abstractmethod
+    @update_after_operation
     async def set_color_temp(self, brightness: int, color_temp: int) -> bool:
         """Set color temp."""
-
-    @abstractmethod
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        assert 2700 <= color_temp <= 6500, "Color Temp must be between 2700 and 6500"
+        hex_data = f"{brightness:02X}{color_temp:04X}"
+        self._check_function_support(self._set_color_temp_command)
+        result = await self._send_command(self._set_color_temp_command.format(hex_data))
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
     async def set_rgb(self, brightness: int, r: int, g: int, b: int) -> bool:
         """Set rgb."""
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        assert 0 <= r <= 255, "r must be between 0 and 255"
+        assert 0 <= g <= 255, "g must be between 0 and 255"
+        assert 0 <= b <= 255, "b must be between 0 and 255"
+        self._check_function_support(self._set_rgb_command)
+        hex_data = f"{brightness:02X}{r:02X}{g:02X}{b:02X}"
+        result = await self._send_command(self._set_rgb_command.format(hex_data))
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def set_effect(self, effect: str) -> bool:
+        """Set effect."""
+        effect_template = self._effect_dict.get(effect.lower())
+        if not effect_template:
+            raise SwitchbotOperationError(f"Effect {effect} not supported")
+        result = await self._send_multiple_commands(effect_template)
+        if result:
+            self._override_state({"effect": effect})
+        return result
 
     async def _send_multiple_commands(self, keys: list[str]) -> bool:
         """
@@ -103,6 +132,33 @@ class SwitchbotBaseLight(SwitchbotDevice):
             final_result |= self._check_command_result(result, 0, {1})
         return final_result
 
+    async def _get_multi_commands_results(
+        self, commands: list[str]
+    ) -> tuple[bytes, bytes] | None:
+        """Check results after sending multiple commands."""
+        if not (results := await self._get_basic_info_by_multi_commands(commands)):
+            return None
+
+        _version_info, _data = results[0], results[1]
+        _LOGGER.debug(
+            "version info: %s, data: %s, address: %s",
+            _version_info,
+            _data,
+            self._device.address,
+        )
+        return _version_info, _data
+
+    async def _get_basic_info_by_multi_commands(
+        self, commands: list[str]
+    ) -> list[bytes] | None:
+        """Get device basic settings by sending multiple commands."""
+        results = []
+        for command in commands:
+            if not (result := await self._get_basic_info(command)):
+                return None
+            results.append(result)
+        return results
+
 
 class SwitchbotSequenceBaseLight(SwitchbotBaseLight):
     """Representation of a Switchbot light."""

pyswitchbot-0.68.0/switchbot/devices/bulb.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..const.light import BulbColorMode, ColorMode
+from .base_light import SwitchbotSequenceBaseLight
+
+# Private mapping from device-specific color modes to original ColorMode enum
+_BULB_COLOR_MODE_MAP = {
+    BulbColorMode.COLOR_TEMP: ColorMode.COLOR_TEMP,
+    BulbColorMode.RGB: ColorMode.RGB,
+    BulbColorMode.DYNAMIC: ColorMode.EFFECT,
+    BulbColorMode.UNKNOWN: ColorMode.OFF,
+}
+COLOR_BULB_CONTROL_HEADER = "570F4701"
+
+
+class SwitchbotBulb(SwitchbotSequenceBaseLight):
+    """Representation of a Switchbot bulb."""
+
+    _turn_on_command = f"{COLOR_BULB_CONTROL_HEADER}01"
+    _turn_off_command = f"{COLOR_BULB_CONTROL_HEADER}02"
+    _set_rgb_command = f"{COLOR_BULB_CONTROL_HEADER}12{{}}"
+    _set_color_temp_command = f"{COLOR_BULB_CONTROL_HEADER}13{{}}"
+    _set_brightness_command = f"{COLOR_BULB_CONTROL_HEADER}14{{}}"
+    _get_basic_info_command = ["570003", "570f4801"]
+    _effect_dict = {
+        "colorful": ["570F4701010300"],
+        "flickering": ["570F4701010301"],
+        "breathing": ["570F4701010302"],
+    }
+
+    @property
+    def color_modes(self) -> set[ColorMode]:
+        """Return the supported color modes."""
+        return {ColorMode.RGB, ColorMode.COLOR_TEMP}
+
+    @property
+    def color_mode(self) -> ColorMode:
+        """Return the current color mode."""
+        device_mode = BulbColorMode(self._get_adv_value("color_mode") or 10)
+        return _BULB_COLOR_MODE_MAP.get(device_mode, ColorMode.OFF)
+
+    async def get_basic_info(self) -> dict[str, Any] | None:
+        """Get device basic settings."""
+        if not (
+            res := await self._get_multi_commands_results(self._get_basic_info_command)
+        ):
+            return None
+        _version_info, _data = res
+
+        self._state["r"] = _data[3]
+        self._state["g"] = _data[4]
+        self._state["b"] = _data[5]
+        self._state["cw"] = int.from_bytes(_data[6:8], "big")
+
+        return {
+            "isOn": bool(_data[1] & 0b10000000),
+            "brightness": _data[2] & 0b01111111,
+            "r": self._state["r"],
+            "g": self._state["g"],
+            "b": self._state["b"],
+            "cw": self._state["cw"],
+            "color_mode": _data[10] & 0b00001111,
+            "firmware": _version_info[2] / 10.0,
+        }

pyswitchbot-0.68.0/switchbot/devices/ceiling_light.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..const.light import (
+    DEFAULT_COLOR_TEMP,
+    CeilingLightColorMode,
+    ColorMode,
+)
+from .base_light import SwitchbotSequenceBaseLight
+from .device import update_after_operation
+
+# Private mapping from device-specific color modes to original ColorMode enum
+_CEILING_LIGHT_COLOR_MODE_MAP = {
+    CeilingLightColorMode.COLOR_TEMP: ColorMode.COLOR_TEMP,
+    CeilingLightColorMode.NIGHT: ColorMode.COLOR_TEMP,
+    CeilingLightColorMode.MUSIC: ColorMode.EFFECT,
+    CeilingLightColorMode.UNKNOWN: ColorMode.OFF,
+}
+CEILING_LIGHT_CONTROL_HEADER = "570F5401"
+
+
+class SwitchbotCeilingLight(SwitchbotSequenceBaseLight):
+    """Representation of a Switchbot ceiling light."""
+
+    _turn_on_command = f"{CEILING_LIGHT_CONTROL_HEADER}01FF01FFFF"
+    _turn_off_command = f"{CEILING_LIGHT_CONTROL_HEADER}02FF01FFFF"
+    _set_brightness_command = f"{CEILING_LIGHT_CONTROL_HEADER}01FF01{{}}"
+    _set_color_temp_command = f"{CEILING_LIGHT_CONTROL_HEADER}01FF01{{}}"
+    _get_basic_info_command = ["5702", "570f5581"]
+
+    @property
+    def color_modes(self) -> set[ColorMode]:
+        """Return the supported color modes."""
+        return {ColorMode.COLOR_TEMP}
+
+    @property
+    def color_mode(self) -> ColorMode:
+        """Return the current color mode."""
+        device_mode = CeilingLightColorMode(self._get_adv_value("color_mode") or 10)
+        return _CEILING_LIGHT_COLOR_MODE_MAP.get(device_mode, ColorMode.OFF)
+
+    @update_after_operation
+    async def set_brightness(self, brightness: int) -> bool:
+        """Set brightness."""
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        hex_brightness = f"{brightness:02X}"
+        color_temp = self._state.get("cw", DEFAULT_COLOR_TEMP)
+        hex_data = f"{hex_brightness}{color_temp:04X}"
+        result = await self._send_command(self._set_brightness_command.format(hex_data))
+        return self._check_command_result(result, 0, {1})
+
+    async def get_basic_info(self) -> dict[str, Any] | None:
+        """Get device basic settings."""
+        if not (
+            res := await self._get_multi_commands_results(self._get_basic_info_command)
+        ):
+            return None
+        _version_info, _data = res
+
+        self._state["cw"] = int.from_bytes(_data[3:5], "big")
+
+        return {
+            "isOn": bool(_data[1] & 0b10000000),
+            "color_mode": _data[1] & 0b01000000,
+            "brightness": _data[2] & 0b01111111,
+            "cw": self._state["cw"],
+            "firmware": _version_info[2] / 10.0,
+        }

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/switchbot/devices/device.py

@@ -125,6 +125,10 @@ def _handle_timeout(fut: asyncio.Future[None]) -> None:
 class SwitchbotBaseDevice:
     """Base Representation of a Switchbot Device."""
 
+    _turn_on_command: str | None = None
+    _turn_off_command: str | None = None
+    _press_command: str | None = None
+
     def __init__(
         self,
         device: BLEDevice,
@@ -291,7 +295,7 @@ class SwitchbotBaseDevice:
         """Return RSSI of device."""
         if self._sb_adv_data:
             return self._sb_adv_data.rssi
-        return self._device.rssi
+        return -127
 
     async def _ensure_connected(self):
         """Ensure connection to device is established."""
@@ -694,6 +698,34 @@ class SwitchbotBaseDevice:
         time_since_last_full_update = time.monotonic() - self._last_full_update
         return not time_since_last_full_update < PASSIVE_POLL_INTERVAL
 
+    def _check_function_support(self, cmd: str | None = None) -> None:
+        """Check if the command is supported by the device model."""
+        if not cmd:
+            raise SwitchbotOperationError(
+                f"Current device {self._device.address} does not support this functionality"
+            )
+
+    @update_after_operation
+    async def turn_on(self) -> bool:
+        """Turn device on."""
+        self._check_function_support(self._turn_on_command)
+        result = await self._send_command(self._turn_on_command)
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def turn_off(self) -> bool:
+        """Turn device off."""
+        self._check_function_support(self._turn_off_command)
+        result = await self._send_command(self._turn_off_command)
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def press(self) -> bool:
+        """Press the device."""
+        self._check_function_support(self._press_command)
+        result = await self._send_command(self._press_command)
+        return self._check_command_result(result, 0, {1})
+
 
 class SwitchbotDevice(SwitchbotBaseDevice):
     """
@@ -735,8 +767,8 @@ class SwitchbotEncryptedDevice(SwitchbotDevice):
         self._encryption_key = bytearray.fromhex(encryption_key)
         self._iv: bytes | None = None
         self._cipher: bytes | None = None
-        self._model = model
         super().__init__(device, None, interface, **kwargs)
+        self._model = model
 
     # Old non-async method preserved for backwards compatibility
     @classmethod

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/switchbot/devices/evaporative_humidifier.py

@@ -23,7 +23,6 @@ _LOGGER = logging.getLogger(__name__)
 COMMAND_HEADER = "57"
 COMMAND_GET_CK_IV = f"{COMMAND_HEADER}0f2103"
 COMMAND_TURN_ON = f"{COMMAND_HEADER}0f430101"
-COMMAND_TURN_OFF = f"{COMMAND_HEADER}0f430100"
 COMMAND_CHILD_LOCK_ON = f"{COMMAND_HEADER}0f430501"
 COMMAND_CHILD_LOCK_OFF = f"{COMMAND_HEADER}0f430500"
 COMMAND_AUTO_DRY_ON = f"{COMMAND_HEADER}0f430a01"
@@ -48,6 +47,9 @@ DEVICE_GET_BASIC_SETTINGS_KEY = "570f4481"
 class SwitchbotEvaporativeHumidifier(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
     """Representation of a Switchbot Evaporative Humidifier"""
 
+    _turn_on_command = COMMAND_TURN_ON
+    _turn_off_command = f"{COMMAND_HEADER}0f430100"
+
     def __init__(
         self,
         device: BLEDevice,
@@ -113,18 +115,6 @@ class SwitchbotEvaporativeHumidifier(SwitchbotSequenceDevice, SwitchbotEncrypted
             "target_humidity": target_humidity,
         }
 
-    @update_after_operation
-    async def turn_on(self) -> bool:
-        """Turn device on."""
-        result = await self._send_command(COMMAND_TURN_ON)
-        return self._check_command_result(result, 0, {1})
-
-    @update_after_operation
-    async def turn_off(self) -> bool:
-        """Turn device off."""
-        result = await self._send_command(COMMAND_TURN_OFF)
-        return self._check_command_result(result, 0, {1})
-
     @update_after_operation
     async def set_target_humidity(self, target_humidity: int) -> bool:
         """Set target humidity."""

{pyswitchbot-0.66.0 → pyswitchbot-0.68.0}/switchbot/devices/fan.py

@@ -16,8 +16,6 @@ _LOGGER = logging.getLogger(__name__)
 
 
 COMMAND_HEAD = "570f41"
-COMMAND_TURN_ON = f"{COMMAND_HEAD}0101"
-COMMAND_TURN_OFF = f"{COMMAND_HEAD}0102"
 COMMAND_START_OSCILLATION = f"{COMMAND_HEAD}020101ff"
 COMMAND_STOP_OSCILLATION = f"{COMMAND_HEAD}020102ff"
 COMMAND_SET_MODE = {
@@ -33,8 +31,8 @@ COMMAND_GET_BASIC_INFO = "570f428102"
 class SwitchbotFan(SwitchbotSequenceDevice):
     """Representation of a Switchbot Circulator Fan."""
 
-    def __init__(self, device, password=None, interface=0, **kwargs):
-        super().__init__(device, password, interface, **kwargs)
+    _turn_on_command = f"{COMMAND_HEAD}0101"
+    _turn_off_command = f"{COMMAND_HEAD}0102"
 
     async def get_basic_info(self) -> dict[str, Any] | None:
         """Get device basic settings."""
@@ -88,16 +86,6 @@ class SwitchbotFan(SwitchbotSequenceDevice):
             return await self._send_command(COMMAND_START_OSCILLATION)
         return await self._send_command(COMMAND_STOP_OSCILLATION)
 
-    @update_after_operation
-    async def turn_on(self) -> bool:
-        """Turn on the fan."""
-        return await self._send_command(COMMAND_TURN_ON)
-
-    @update_after_operation
-    async def turn_off(self) -> bool:
-        """Turn off the fan."""
-        return await self._send_command(COMMAND_TURN_OFF)
-
     def get_current_percentage(self) -> Any:
         """Return cached percentage."""
         return self._get_adv_value("speed")