PySwitchbot 0.46.1__tar.gz → 0.48.0__tar.gz

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySwitchbot
-Version: 0.46.1
+Version: 0.48.0
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/Danielhiversen/pySwitchbot/
 Author: Daniel Hjelseth Hoyer

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/PySwitchbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySwitchbot
-Version: 0.46.1
+Version: 0.48.0
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/Danielhiversen/pySwitchbot/
 Author: Daniel Hjelseth Hoyer

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/PySwitchbot.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ switchbot/adv_parsers/bulb.py
 switchbot/adv_parsers/ceiling_light.py
 switchbot/adv_parsers/contact.py
 switchbot/adv_parsers/curtain.py
+switchbot/adv_parsers/hub2.py
 switchbot/adv_parsers/humidifier.py
 switchbot/adv_parsers/light_strip.py
 switchbot/adv_parsers/lock.py

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/README.md

@@ -1,10 +1,13 @@
 # pySwitchbot [![Build Status](https://travis-ci.org/Danielhiversen/pySwitchbot.svg?branch=master)](https://travis-ci.org/Danielhiversen/pySwitchbot)
+
 Library to control Switchbot IoT devices https://www.switch-bot.com/bot
 
 ## Obtaining locks encryption key
+
 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
@@ -16,7 +19,7 @@ If authentication succeeds then script should output your key id and encryption
 
 Examples:
 
-* WoLock
+- WoLock
 
 ```python
 import asyncio

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/setup.py

@@ -10,7 +10,7 @@ setup(
         "cryptography>=39.0.0",
         "pyOpenSSL>=23.0.0",
     ],
-    version="0.46.1",
+    version="0.48.0",
     description="A library to communicate with Switchbot",
     author="Daniel Hjelseth Hoyer",
     url="https://github.com/Danielhiversen/pySwitchbot/",

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/switchbot/adv_parser.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 import logging
@@ -15,6 +16,7 @@ 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.hub2 import process_wohub2
 from .adv_parsers.humidifier import process_wohumidifier
 from .adv_parsers.light_strip import process_wostrip
 from .adv_parsers.lock import process_wolock
@@ -54,7 +56,6 @@ SUPPORTED_TYPES: dict[str, SwitchbotSupportedType] = {
         "modelName": SwitchbotModel.BOT,
         "modelFriendlyName": "Bot",
         "func": process_wohand,
-        "service_uuids": {"cba20d00-224d-11e6-9fb8-0002a5d5c51b"},
         "manufacturer_id": 89,
     },
     "s": {
@@ -100,6 +101,12 @@ SUPPORTED_TYPES: dict[str, SwitchbotSupportedType] = {
         "func": process_wosensorth,
         "manufacturer_id": 2409,
     },
+    "v": {
+        "modelName": SwitchbotModel.HUB2,
+        "modelFriendlyName": "Hub 2",
+        "func": process_wohub2,
+        "manufacturer_id": 2409,
+    },
     "g": {
         "modelName": SwitchbotModel.PLUG_MINI,
         "modelFriendlyName": "Plug Mini",
@@ -143,6 +150,12 @@ SUPPORTED_TYPES: dict[str, SwitchbotSupportedType] = {
         "func": process_wolock,
         "manufacturer_id": 2409,
     },
+    "$": {
+        "modelName": SwitchbotModel.LOCK_PRO,
+        "modelFriendlyName": "Lock Pro",
+        "func": process_wolock,
+        "manufacturer_id": 2409,
+    },
     "x": {
         "modelName": SwitchbotModel.BLIND_TILT,
         "modelFriendlyName": "Blind Tilt",

pyswitchbot-0.48.0/switchbot/adv_parsers/hub2.py

@@ -0,0 +1,40 @@
+"""Hub2 parser."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def process_wohub2(data: bytes | None, mfr_data: bytes | None) -> dict[str, Any]:
+    """Process woHub2 sensor manufacturer data."""
+    temp_data = None
+
+    if mfr_data:
+        status = mfr_data[12]
+        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
+    light_level = status & 0b11111
+
+    if _temp_c == 0 and humidity == 0:
+        return {}
+
+    _wohub2_data = {
+        # Data should be flat, but we keep the original structure for now
+        "temp": {"c": _temp_c, "f": _temp_f},
+        "temperature": _temp_c,
+        "fahrenheit": bool(temp_data[2] & 0b10000000),
+        "humidity": humidity,
+        "lightLevel": light_level,
+    }
+
+    return _wohub2_data

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/switchbot/const.py

@@ -47,7 +47,9 @@ class SwitchbotModel(StrEnum):
     COLOR_BULB = "WoBulb"
     CEILING_LIGHT = "WoCeiling"
     LOCK = "WoLock"
+    LOCK_PRO = "WoLockPro"
     BLIND_TILT = "WoBlindTilt"
+    HUB2 = "WoHub2"
 
 
 class LockStatus(Enum):

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/switchbot/devices/lock.py

@@ -16,15 +16,28 @@ from ..const import (
     SwitchbotAccountConnectionError,
     SwitchbotApiError,
     SwitchbotAuthenticationError,
+    SwitchbotModel,
 )
 from .device import SwitchbotDevice, SwitchbotOperationError
 
 COMMAND_HEADER = "57"
 COMMAND_GET_CK_IV = f"{COMMAND_HEADER}0f2103"
-COMMAND_LOCK_INFO = f"{COMMAND_HEADER}0f4f8101"
-COMMAND_UNLOCK = f"{COMMAND_HEADER}0f4e01011080"
-COMMAND_UNLOCK_WITHOUT_UNLATCH = f"{COMMAND_HEADER}0f4e010110a0"
-COMMAND_LOCK = f"{COMMAND_HEADER}0f4e01011000"
+COMMAND_LOCK_INFO = {
+    SwitchbotModel.LOCK: f"{COMMAND_HEADER}0f4f8101",
+    SwitchbotModel.LOCK_PRO: f"{COMMAND_HEADER}0f4f8102",
+}
+COMMAND_UNLOCK = {
+    SwitchbotModel.LOCK: f"{COMMAND_HEADER}0f4e01011080",
+    SwitchbotModel.LOCK_PRO: f"{COMMAND_HEADER}0f4e0101000080",
+}
+COMMAND_UNLOCK_WITHOUT_UNLATCH = {
+    SwitchbotModel.LOCK: f"{COMMAND_HEADER}0f4e010110a0",
+    SwitchbotModel.LOCK_PRO: f"{COMMAND_HEADER}0f4e01010000a0",
+}
+COMMAND_LOCK = {
+    SwitchbotModel.LOCK: f"{COMMAND_HEADER}0f4e01011000",
+    SwitchbotModel.LOCK_PRO: f"{COMMAND_HEADER}0f4e0101000000",
+}
 COMMAND_ENABLE_NOTIFICATIONS = f"{COMMAND_HEADER}0e01001e00008101"
 COMMAND_DISABLE_NOTIFICATIONS = f"{COMMAND_HEADER}0e00"
 
@@ -49,6 +62,7 @@ class SwitchbotLock(SwitchbotDevice):
         key_id: str,
         encryption_key: str,
         interface: int = 0,
+        model: SwitchbotModel = SwitchbotModel.LOCK,
         **kwargs: Any,
     ) -> None:
         if len(key_id) == 0:
@@ -59,20 +73,27 @@ class SwitchbotLock(SwitchbotDevice):
             raise ValueError("encryption_key is missing")
         elif len(encryption_key) != 32:
             raise ValueError("encryption_key is invalid")
+        if model not in (SwitchbotModel.LOCK, SwitchbotModel.LOCK_PRO):
+            raise ValueError("initializing SwitchbotLock with a non-lock model")
         self._iv = None
         self._cipher = None
         self._key_id = key_id
         self._encryption_key = bytearray.fromhex(encryption_key)
         self._notifications_enabled: bool = False
+        self._model: SwitchbotModel = model
         super().__init__(device, None, interface, **kwargs)
 
     @staticmethod
     async def verify_encryption_key(
-        device: BLEDevice, key_id: str, encryption_key: str
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        model: SwitchbotModel = SwitchbotModel.LOCK,
+        **kwargs: Any,
     ) -> bool:
         try:
             lock = SwitchbotLock(
-                device=device, key_id=key_id, encryption_key=encryption_key
+                device, key_id=key_id, encryption_key=encryption_key, model=model
             )
         except ValueError:
             return False
@@ -183,19 +204,19 @@ class SwitchbotLock(SwitchbotDevice):
     async def lock(self) -> bool:
         """Send lock command."""
         return await self._lock_unlock(
-            COMMAND_LOCK, {LockStatus.LOCKED, LockStatus.LOCKING}
+            COMMAND_LOCK[self._model], {LockStatus.LOCKED, LockStatus.LOCKING}
         )
 
     async def unlock(self) -> bool:
         """Send unlock command. If unlatch feature is enabled in EU firmware, also unlatches door"""
         return await self._lock_unlock(
-            COMMAND_UNLOCK, {LockStatus.UNLOCKED, LockStatus.UNLOCKING}
+            COMMAND_UNLOCK[self._model], {LockStatus.UNLOCKED, LockStatus.UNLOCKING}
         )
 
     async def unlock_without_unlatch(self) -> bool:
         """Send unlock command. This command will not unlatch the door."""
         return await self._lock_unlock(
-            COMMAND_UNLOCK_WITHOUT_UNLATCH,
+            COMMAND_UNLOCK_WITHOUT_UNLATCH[self._model],
             {LockStatus.UNLOCKED, LockStatus.UNLOCKING, LockStatus.NOT_FULLY_LOCKED},
         )
 
@@ -275,7 +296,9 @@ class SwitchbotLock(SwitchbotDevice):
 
     async def _get_lock_info(self) -> bytes | None:
         """Return lock info of device."""
-        _data = await self._send_command(key=COMMAND_LOCK_INFO, retry=self._retry_count)
+        _data = await self._send_command(
+            key=COMMAND_LOCK_INFO[self._model], retry=self._retry_count
+        )
 
         if not self._check_command_result(_data, 0, COMMAND_RESULT_EXPECTED_VALUES):
             _LOGGER.error("Unsuccessful, please try again")

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/switchbot/discovery.py

@@ -42,11 +42,11 @@ class GetSwitchbotDevices:
 
         devices = None
         devices = bleak.BleakScanner(
+            detection_callback=self.detection_callback,
             # TODO: Find new UUIDs to filter on. For example, see
             # https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/4ad138bb09f0fbbfa41b152ca327a78c1d0b6ba9/devicetypes/meter.md
             adapter=self._interface,
         )
-        devices.register_detection_callback(self.detection_callback)
 
         async with CONNECT_LOCK:
             await devices.start()
@@ -111,7 +111,8 @@ class GetSwitchbotDevices:
         base_meters = await self._get_devices_by_model("T")
         plus_meters = await self._get_devices_by_model("i")
         io_meters = await self._get_devices_by_model("w")
-        return {**base_meters, **plus_meters, **io_meters}
+        hub2_meters = await self._get_devices_by_model("v")
+        return {**base_meters, **plus_meters, **io_meters, **hub2_meters}
 
     async def get_contactsensors(self) -> dict[str, SwitchBotAdvertisement]:
         """Return all WoContact/Contact sensor devices with services data."""
@@ -119,7 +120,9 @@ class GetSwitchbotDevices:
 
     async def get_locks(self) -> dict[str, SwitchBotAdvertisement]:
         """Return all WoLock/Locks devices with services data."""
-        return await self._get_devices_by_model("o")
+        locks = await self._get_devices_by_model("o")
+        lock_pros = await self._get_devices_by_model("$")
+        return {**locks, **lock_pros}
 
     async def get_device_data(
         self, address: str

{pyswitchbot-0.46.1 → pyswitchbot-0.48.0}/tests/test_adv_parser.py

@@ -964,6 +964,40 @@ def test_wosensor_active_zero_data():
     )
 
 
+def test_wohub2_passive_and_active():
+    """Test parsing wosensor as passive with active data as well."""
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={
+            2409: b"\xaa\xbb\xcc\xdd\xee\xff\x00\xfffT\x1a\xf1\x82\x07\x9a2\x00"
+        },
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"v\x00"},
+        tx_power=-127,
+        rssi=-50,
+    )
+    result = parse_advertisement_data(ble_device, adv_data)
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {
+                "fahrenheit": False,
+                "humidity": 50,
+                "lightLevel": 2,
+                "temp": {"c": 26.7, "f": 80.06},
+                "temperature": 26.7,
+            },
+            "isEncrypted": False,
+            "model": "v",
+            "modelFriendlyName": "Hub 2",
+            "modelName": SwitchbotModel.HUB2,
+            "rawAdvData": b"v\x00",
+        },
+        device=ble_device,
+        rssi=-50,
+        active=True,
+    )
+
+
 def test_woiosensor_passive_and_active():
     """Test parsing woiosensor as passive with active data as well."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
@@ -1286,43 +1320,6 @@ def test_motion_with_light_detected():
     )
 
 
-def test_motion_sensor_motion_passive():
-    """Test parsing motion sensor with motion data."""
-    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
-    adv_data = generate_advertisement_data(
-        manufacturer_data={2409: b"\xc0!\x9a\xe8\xbcIi\\\x008"},
-        service_data={},
-        tx_power=-127,
-        rssi=-87,
-    )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.MOTION_SENSOR
-    )
-    assert result == SwitchBotAdvertisement(
-        address="aa:bb:cc:dd:ee:ff",
-        data={
-            "data": {
-                "battery": None,
-                "iot": None,
-                "is_light": False,
-                "led": None,
-                "light_intensity": None,
-                "motion_detected": True,
-                "sense_distance": None,
-                "tested": None,
-            },
-            "isEncrypted": False,
-            "model": "s",
-            "modelFriendlyName": "Motion Sensor",
-            "modelName": SwitchbotModel.MOTION_SENSOR,
-            "rawAdvData": None,
-        },
-        device=ble_device,
-        rssi=-87,
-        active=False,
-    )
-
-
 def test_parsing_lock_active():
     """Test parsing lock with active data."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
@@ -1393,6 +1390,75 @@ def test_parsing_lock_passive():
     )
 
 
+def test_parsing_lock_pro_active():
+    """Test parsing lock pro with active data."""
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={2409: b"\xc8\xf5,\xd9-V\x07\x82\x00d\x00\x00"},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"$\x80d"},
+        rssi=-80,
+    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.LOCK_PRO)
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {
+                "battery": 100,
+                "calibration": True,
+                "status": LockStatus.LOCKED,
+                "update_from_secondary_lock": False,
+                "door_open": False,
+                "double_lock_mode": False,
+                "unclosed_alarm": False,
+                "unlocked_alarm": False,
+                "auto_lock_paused": False,
+                "night_latch": False,
+            },
+            "model": "$",
+            "isEncrypted": False,
+            "modelFriendlyName": "Lock Pro",
+            "modelName": SwitchbotModel.LOCK_PRO,
+            "rawAdvData": b"$\x80d",
+        },
+        device=ble_device,
+        rssi=-80,
+        active=True,
+    )
+
+
+def test_parsing_lock_pro_passive():
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={2409: bytes.fromhex("aabbccddeeff208200640000")}, rssi=-67
+    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.LOCK_PRO)
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {
+                "battery": None,
+                "calibration": True,
+                "status": LockStatus.LOCKED,
+                "update_from_secondary_lock": False,
+                "door_open": False,
+                "double_lock_mode": False,
+                "unclosed_alarm": False,
+                "unlocked_alarm": False,
+                "auto_lock_paused": False,
+                "night_latch": False,
+            },
+            "model": "$",
+            "isEncrypted": False,
+            "modelFriendlyName": "Lock Pro",
+            "modelName": SwitchbotModel.LOCK_PRO,
+            "rawAdvData": None,
+        },
+        device=ble_device,
+        rssi=-67,
+        active=False,
+    )
+
+
 def test_parsing_lock_active_old_firmware():
     """Test parsing lock with active data. Old firmware."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")