PySwitchbot 0.58.0__tar.gz → 0.60.0__tar.gz

pyswitchbot-0.60.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: PySwitchbot
+Version: 0.60.0
+Summary: A library to communicate with Switchbot
+Home-page: https://github.com/sblibs/pySwitchbot/
+Author: Daniel Hjelseth Hoyer
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: bleak>=0.19.0
+Requires-Dist: bleak-retry-connector>=3.4.0
+Requires-Dist: cryptography>=39.0.0
+Requires-Dist: pyOpenSSL>=23.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pySwitchbot [![Build Status](https://travis-ci.org/sblibs/pySwitchbot.svg?branch=master)](https://travis-ci.org/sblibs/pySwitchbot)
+
+Library to control Switchbot IoT devices https://www.switch-bot.com/bot
+
+## Obtaining encryption key for Switchbot Locks
+
+Using the script `scripts/get_encryption_key.py` you can manually obtain locks encryption key.
+
+Usage:
+
+```shell
+$ python3 get_encryption_key.py MAC USERNAME
+Key ID: XX
+Encryption key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+```
+
+Where `MAC` is MAC address of the lock and `USERNAME` is your SwitchBot account username, after that script will ask for your password.
+If authentication succeeds then script should output your key id and encryption key.
+
+## Examples:
+
+#### WoLock (Lock-Pro)
+
+Unlock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).unlock()
+
+
+asyncio.run(main())
+```
+
+Lock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).lock()
+
+
+asyncio.run(main())
+```
+
+#### WoCurtain (Curtain 3)
+
+```python
+import asyncio
+from pprint import pprint
+from switchbot import GetSwitchbotDevices
+from switchbot.devices import curtain
+
+
+async def main():
+    # get the BLE advertisement data of all switchbot devices in the vicinity
+    advertisement_data = await GetSwitchbotDevices().discover()
+
+    for i in advertisement_data.values():
+        pprint(i)
+        print()  # print newline so that devices' data is separated visually
+
+    # find your device's BLE address by inspecting the above printed debug logs, example below
+    ble_address = "9915077C-C6FD-5FF6-27D3-45087898790B"
+    # get the BLE device (via its address) and construct a curtain device
+    ble_device = advertisement_data[ble_address].device
+    curtain_device = curtain.SwitchbotCurtain(ble_device, reverse_mode=False)
+
+    pprint(await curtain_device.get_device_data())
+    pprint(await curtain_device.get_basic_info())
+    await curtain_device.set_position(100)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

pyswitchbot-0.60.0/PySwitchbot.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: PySwitchbot
+Version: 0.60.0
+Summary: A library to communicate with Switchbot
+Home-page: https://github.com/sblibs/pySwitchbot/
+Author: Daniel Hjelseth Hoyer
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: bleak>=0.19.0
+Requires-Dist: bleak-retry-connector>=3.4.0
+Requires-Dist: cryptography>=39.0.0
+Requires-Dist: pyOpenSSL>=23.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pySwitchbot [![Build Status](https://travis-ci.org/sblibs/pySwitchbot.svg?branch=master)](https://travis-ci.org/sblibs/pySwitchbot)
+
+Library to control Switchbot IoT devices https://www.switch-bot.com/bot
+
+## Obtaining encryption key for Switchbot Locks
+
+Using the script `scripts/get_encryption_key.py` you can manually obtain locks encryption key.
+
+Usage:
+
+```shell
+$ python3 get_encryption_key.py MAC USERNAME
+Key ID: XX
+Encryption key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+```
+
+Where `MAC` is MAC address of the lock and `USERNAME` is your SwitchBot account username, after that script will ask for your password.
+If authentication succeeds then script should output your key id and encryption key.
+
+## Examples:
+
+#### WoLock (Lock-Pro)
+
+Unlock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).unlock()
+
+
+asyncio.run(main())
+```
+
+Lock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).lock()
+
+
+asyncio.run(main())
+```
+
+#### WoCurtain (Curtain 3)
+
+```python
+import asyncio
+from pprint import pprint
+from switchbot import GetSwitchbotDevices
+from switchbot.devices import curtain
+
+
+async def main():
+    # get the BLE advertisement data of all switchbot devices in the vicinity
+    advertisement_data = await GetSwitchbotDevices().discover()
+
+    for i in advertisement_data.values():
+        pprint(i)
+        print()  # print newline so that devices' data is separated visually
+
+    # find your device's BLE address by inspecting the above printed debug logs, example below
+    ble_address = "9915077C-C6FD-5FF6-27D3-45087898790B"
+    # get the BLE device (via its address) and construct a curtain device
+    ble_device = advertisement_data[ble_address].device
+    curtain_device = curtain.SwitchbotCurtain(ble_device, reverse_mode=False)
+
+    pprint(await curtain_device.get_device_data())
+    pprint(await curtain_device.get_basic_info())
+    await curtain_device.set_position(100)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

{pyswitchbot-0.58.0 → pyswitchbot-0.60.0}/PySwitchbot.egg-info/SOURCES.txt

@@ -22,7 +22,9 @@ switchbot/adv_parsers/bulb.py
 switchbot/adv_parsers/ceiling_light.py
 switchbot/adv_parsers/contact.py
 switchbot/adv_parsers/curtain.py
+switchbot/adv_parsers/fan.py
 switchbot/adv_parsers/hub2.py
+switchbot/adv_parsers/hubmini_matter.py
 switchbot/adv_parsers/humidifier.py
 switchbot/adv_parsers/keypad.py
 switchbot/adv_parsers/leak.py
@@ -33,8 +35,10 @@ switchbot/adv_parsers/motion.py
 switchbot/adv_parsers/plug.py
 switchbot/adv_parsers/relay_switch.py
 switchbot/adv_parsers/remote.py
+switchbot/adv_parsers/roller_shade.py
 switchbot/const/__init__.py
 switchbot/const/evaporative_humidifier.py
+switchbot/const/fan.py
 switchbot/const/hub2.py
 switchbot/const/lock.py
 switchbot/devices/__init__.py
@@ -48,6 +52,7 @@ switchbot/devices/contact.py
 switchbot/devices/curtain.py
 switchbot/devices/device.py
 switchbot/devices/evaporative_humidifier.py
+switchbot/devices/fan.py
 switchbot/devices/humidifier.py
 switchbot/devices/keypad.py
 switchbot/devices/light_strip.py
@@ -56,10 +61,13 @@ switchbot/devices/meter.py
 switchbot/devices/motion.py
 switchbot/devices/plug.py
 switchbot/devices/relay_switch.py
+switchbot/devices/roller_shade.py
 tests/test_adv_parser.py
 tests/test_base_cover.py
 tests/test_blind_tilt.py
 tests/test_curtain.py
 tests/test_evaporative_humidifier.py
+tests/test_fan.py
 tests/test_hub2.py
-tests/test_relay_switch.py
+tests/test_relay_switch.py
+tests/test_roller_shade.py

pyswitchbot-0.60.0/README.md

@@ -0,0 +1,102 @@
+# pySwitchbot [![Build Status](https://travis-ci.org/sblibs/pySwitchbot.svg?branch=master)](https://travis-ci.org/sblibs/pySwitchbot)
+
+Library to control Switchbot IoT devices https://www.switch-bot.com/bot
+
+## Obtaining encryption key for Switchbot Locks
+
+Using the script `scripts/get_encryption_key.py` you can manually obtain locks encryption key.
+
+Usage:
+
+```shell
+$ python3 get_encryption_key.py MAC USERNAME
+Key ID: XX
+Encryption key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+```
+
+Where `MAC` is MAC address of the lock and `USERNAME` is your SwitchBot account username, after that script will ask for your password.
+If authentication succeeds then script should output your key id and encryption key.
+
+## Examples:
+
+#### WoLock (Lock-Pro)
+
+Unlock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).unlock()
+
+
+asyncio.run(main())
+```
+
+Lock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).lock()
+
+
+asyncio.run(main())
+```
+
+#### WoCurtain (Curtain 3)
+
+```python
+import asyncio
+from pprint import pprint
+from switchbot import GetSwitchbotDevices
+from switchbot.devices import curtain
+
+
+async def main():
+    # get the BLE advertisement data of all switchbot devices in the vicinity
+    advertisement_data = await GetSwitchbotDevices().discover()
+
+    for i in advertisement_data.values():
+        pprint(i)
+        print()  # print newline so that devices' data is separated visually
+
+    # find your device's BLE address by inspecting the above printed debug logs, example below
+    ble_address = "9915077C-C6FD-5FF6-27D3-45087898790B"
+    # get the BLE device (via its address) and construct a curtain device
+    ble_device = advertisement_data[ble_address].device
+    curtain_device = curtain.SwitchbotCurtain(ble_device, reverse_mode=False)
+
+    pprint(await curtain_device.get_device_data())
+    pprint(await curtain_device.get_basic_info())
+    await curtain_device.set_position(100)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

{pyswitchbot-0.58.0 → pyswitchbot-0.60.0}/setup.py

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

{pyswitchbot-0.58.0 → pyswitchbot-0.60.0}/switchbot/__init__.py

@@ -10,6 +10,7 @@ from bleak_retry_connector import (
 
 from .adv_parser import SwitchbotSupportedType, parse_advertisement_data
 from .const import (
+    FanMode,
     LockStatus,
     SwitchbotAccountConnectionError,
     SwitchbotApiError,
@@ -24,16 +25,19 @@ from .devices.ceiling_light import SwitchbotCeilingLight
 from .devices.curtain import SwitchbotCurtain
 from .devices.device import ColorMode, SwitchbotDevice, SwitchbotEncryptedDevice
 from .devices.evaporative_humidifier import SwitchbotEvaporativeHumidifier
+from .devices.fan import SwitchbotFan
 from .devices.humidifier import SwitchbotHumidifier
 from .devices.light_strip import SwitchbotLightStrip
 from .devices.lock import SwitchbotLock
 from .devices.plug import SwitchbotPlugMini
 from .devices.relay_switch import SwitchbotRelaySwitch
+from .devices.roller_shade import SwitchbotRollerShade
 from .discovery import GetSwitchbotDevices
 from .models import SwitchBotAdvertisement
 
 __all__ = [
     "ColorMode",
+    "FanMode",
     "GetSwitchbotDevices",
     "LockStatus",
     "SwitchBotAdvertisement",
@@ -50,6 +54,7 @@ __all__ = [
     "SwitchbotDevice",
     "SwitchbotEncryptedDevice",
     "SwitchbotEvaporativeHumidifier",
+    "SwitchbotFan",
     "SwitchbotHumidifier",
     "SwitchbotLightStrip",
     "SwitchbotLock",
@@ -58,6 +63,7 @@ __all__ = [
     "SwitchbotPlugMini",
     "SwitchbotPlugMini",
     "SwitchbotRelaySwitch",
+    "SwitchbotRollerShade",
     "SwitchbotSupportedType",
     "SwitchbotSupportedType",
     "close_stale_connections",

{pyswitchbot-0.58.0 → pyswitchbot-0.60.0}/switchbot/adv_parser.py

@@ -16,7 +16,9 @@ from .adv_parsers.bulb import process_color_bulb
 from .adv_parsers.ceiling_light import process_woceiling
 from .adv_parsers.contact import process_wocontact
 from .adv_parsers.curtain import process_wocurtain
+from .adv_parsers.fan import process_fan
 from .adv_parsers.hub2 import process_wohub2
+from .adv_parsers.hubmini_matter import process_hubmini_matter
 from .adv_parsers.humidifier import process_evaporative_humidifier, process_wohumidifier
 from .adv_parsers.keypad import process_wokeypad
 from .adv_parsers.leak import process_leak
@@ -30,6 +32,7 @@ from .adv_parsers.relay_switch import (
     process_worelay_switch_1pm,
 )
 from .adv_parsers.remote import process_woremote
+from .adv_parsers.roller_shade import process_worollershade
 from .const import SwitchbotModel
 from .models import SwitchBotAdvertisement
 
@@ -216,6 +219,24 @@ SUPPORTED_TYPES: dict[str, SwitchbotSupportedType] = {
         "func": process_woremote,
         "manufacturer_id": 89,
     },
+    ",": {
+        "modelName": SwitchbotModel.ROLLER_SHADE,
+        "modelFriendlyName": "Roller Shade",
+        "func": process_worollershade,
+        "manufacturer_id": 2409,
+    },
+    "%": {
+        "modelName": SwitchbotModel.HUBMINI_MATTER,
+        "modelFriendlyName": "HubMini Matter",
+        "func": process_hubmini_matter,
+        "manufacturer_id": 2409,
+    },
+    "~": {
+        "modelName": SwitchbotModel.CIRCULATOR_FAN,
+        "modelFriendlyName": "Circulator Fan",
+        "func": process_fan,
+        "manufacturer_id": 2409,
+    },
 }
 
 _SWITCHBOT_MODEL_TO_CHAR = {

pyswitchbot-0.60.0/switchbot/adv_parsers/fan.py

@@ -0,0 +1,33 @@
+"""Fan adv parser."""
+
+from __future__ import annotations
+
+from ..const.fan import FanMode
+
+
+def process_fan(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool | int]:
+    """Process fan services data."""
+    if mfr_data is None:
+        return {}
+
+    device_data = mfr_data[6:]
+
+    _seq_num = device_data[0]
+    _isOn = bool(device_data[1] & 0b10000000)
+    _mode = (device_data[1] & 0b01110000) >> 4
+    _mode = FanMode(_mode).name if 1 <= _mode <= 4 else None
+    _nightLight = (device_data[1] & 0b00001100) >> 2
+    _oscillate_left_and_right = bool(device_data[1] & 0b00000010)
+    _oscillate_up_and_down = bool(device_data[1] & 0b00000001)
+    _battery = device_data[2] & 0b01111111
+    _speed = device_data[3] & 0b01111111
+
+    return {
+        "sequence_number": _seq_num,
+        "isOn": _isOn,
+        "mode": _mode,
+        "nightLight": _nightLight,
+        "oscillating": _oscillate_left_and_right | _oscillate_up_and_down,
+        "battery": _battery,
+        "speed": _speed,
+    }

pyswitchbot-0.60.0/switchbot/adv_parsers/hubmini_matter.py

@@ -0,0 +1,37 @@
+"""Hubmini matter parser."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def process_hubmini_matter(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, Any]:
+    """Process Hubmini matter sensor manufacturer data."""
+    temp_data = None
+
+    if mfr_data:
+        temp_data = mfr_data[13:16]
+
+    if not temp_data:
+        return {}
+
+    _temp_sign = 1 if temp_data[1] & 0b10000000 else -1
+    _temp_c = _temp_sign * (
+        (temp_data[1] & 0b01111111) + ((temp_data[0] & 0b00001111) / 10)
+    )
+    _temp_f = (_temp_c * 9 / 5) + 32
+    _temp_f = (_temp_f * 10) / 10
+    humidity = temp_data[2] & 0b01111111
+
+    if _temp_c == 0 and humidity == 0:
+        return {}
+
+    paraser_data = {
+        "temp": {"c": _temp_c, "f": _temp_f},
+        "temperature": _temp_c,
+        "fahrenheit": bool(temp_data[2] & 0b10000000),
+        "humidity": humidity,
+    }
+    return paraser_data

pyswitchbot-0.60.0/switchbot/adv_parsers/roller_shade.py

@@ -0,0 +1,29 @@
+"""Library to handle connection with Switchbot."""
+
+from __future__ import annotations
+
+
+def process_worollershade(
+    data: bytes | None, mfr_data: bytes | None, reverse: bool = True
+) -> dict[str, bool | int]:
+    """Process woRollerShade services data."""
+    if mfr_data is None:
+        return {}
+
+    device_data = mfr_data[6:]
+
+    _position = max(min(device_data[2] & 0b01111111, 100), 0)
+    _calibrated = bool(device_data[2] & 0b10000000)
+    _in_motion = bool(device_data[1] & 0b00000110)
+    _light_level = (device_data[3] >> 4) & 0b00001111
+    _device_chain = device_data[3] & 0b00001111
+
+    return {
+        "calibration": _calibrated,
+        "battery": data[2] & 0b01111111 if data else None,
+        "inMotion": _in_motion,
+        "position": (100 - _position) if reverse else _position,
+        "lightLevel": _light_level,
+        "deviceChain": _device_chain,
+        "sequence_number": device_data[0],
+    }

{pyswitchbot-0.58.0 → pyswitchbot-0.60.0}/switchbot/const/__init__.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from ..enum import StrEnum
+from .fan import FanMode as FanMode
 
 # Preserve old LockStatus export for backwards compatibility
 from .lock import LockStatus as LockStatus
@@ -63,3 +64,6 @@ class SwitchbotModel(StrEnum):
     RELAY_SWITCH_1 = "Relay Switch 1"
     REMOTE = "WoRemote"
     EVAPORATIVE_HUMIDIFIER = "Evaporative Humidifier"
+    ROLLER_SHADE = "Roller Shade"
+    HUBMINI_MATTER = "HubMini Matter"
+    CIRCULATOR_FAN = "Circulator Fan"

pyswitchbot-0.60.0/switchbot/const/fan.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class FanMode(Enum):
+    NORMAL = 1
+    NATURAL = 2
+    SLEEP = 3
+    BABY = 4
+
+    @classmethod
+    def get_modes(cls) -> list[str]:
+        return [mode.name for mode in cls]

{pyswitchbot-0.58.0 → pyswitchbot-0.60.0}/switchbot/devices/base_cover.py

@@ -10,6 +10,8 @@ from .device import REQ_HEADER, SwitchbotDevice, update_after_operation
 
 # Cover keys
 COVER_COMMAND = "4501"
+ROLLERSHADE_COMMAND = "4701"
+CONTROL_SOURCE = "00"
 
 # For second element of open and close arrs we should add two bytes i.e. ff00
 # First byte [ff] stands for speed (00 or ff - normal, 01 - slow) *