PySwitchbot 0.53.2__tar.gz → 0.55.0__tar.gz

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySwitchbot
-Version: 0.53.2
+Version: 0.55.0
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/sblibs/pySwitchbot/
 Author: Daniel Hjelseth Hoyer
@@ -12,6 +12,7 @@ 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

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/PySwitchbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySwitchbot
-Version: 0.53.2
+Version: 0.55.0
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/sblibs/pySwitchbot/
 Author: Daniel Hjelseth Hoyer
@@ -12,6 +12,7 @@ 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

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/PySwitchbot.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ switchbot/adv_parsers/curtain.py
 switchbot/adv_parsers/hub2.py
 switchbot/adv_parsers/humidifier.py
 switchbot/adv_parsers/keypad.py
+switchbot/adv_parsers/leak.py
 switchbot/adv_parsers/light_strip.py
 switchbot/adv_parsers/lock.py
 switchbot/adv_parsers/meter.py
@@ -51,4 +52,5 @@ switchbot/devices/relay_switch.py
 tests/test_adv_parser.py
 tests/test_base_cover.py
 tests/test_blind_tilt.py
-tests/test_curtain.py
+tests/test_curtain.py
+tests/test_relay_switch.py

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/setup.py

@@ -15,13 +15,14 @@ setup(
         "cryptography>=39.0.0",
         "pyOpenSSL>=23.0.0",
     ],
-    version="0.53.2",
+    version="0.55.0",
     description="A library to communicate with Switchbot",
     long_description=long_description,
     long_description_content_type="text/markdown",
     author="Daniel Hjelseth Hoyer",
     url="https://github.com/sblibs/pySwitchbot/",
     license="MIT",
+    python_requires=">=3.11",
     classifiers=[
         "Development Status :: 3 - Alpha",
         "Environment :: Other Environment",

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/__init__.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 from bleak_retry_connector import (

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parser.py

@@ -19,13 +19,14 @@ from .adv_parsers.curtain import process_wocurtain
 from .adv_parsers.hub2 import process_wohub2
 from .adv_parsers.humidifier import process_wohumidifier
 from .adv_parsers.keypad import process_wokeypad
+from .adv_parsers.leak import process_leak
 from .adv_parsers.light_strip import process_wostrip
 from .adv_parsers.lock import 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
 from .adv_parsers.relay_switch import (
-    process_worelay_switch_1plus,
+    process_worelay_switch_1,
     process_worelay_switch_1pm,
 )
 from .const import SwitchbotModel
@@ -178,6 +179,12 @@ SUPPORTED_TYPES: dict[str, SwitchbotSupportedType] = {
         "func": process_woblindtilt,
         "manufacturer_id": 2409,
     },
+    "3": {
+        "modelName": SwitchbotModel.LEAK,
+        "modelFriendlyName": "Leak Detector",
+        "func": process_leak,
+        "manufacturer_id": 2409,
+    },
     "y": {
         "modelName": SwitchbotModel.KEYPAD,
         "modelFriendlyName": "Keypad",
@@ -191,9 +198,9 @@ SUPPORTED_TYPES: dict[str, SwitchbotSupportedType] = {
         "manufacturer_id": 2409,
     },
     ";": {
-        "modelName": SwitchbotModel.RELAY_SWITCH_1_PLUS,
+        "modelName": SwitchbotModel.RELAY_SWITCH_1,
         "modelFriendlyName": "Relay Switch 1",
-        "func": process_worelay_switch_1plus,
+        "func": process_worelay_switch_1,
         "manufacturer_id": 2409,
     },
 }

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/blind_tilt.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/bot.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/bulb.py

@@ -1,4 +1,5 @@
 """Bulb parser."""
+
 from __future__ import annotations
 
 

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/ceiling_light.py

@@ -1,4 +1,5 @@
 """Ceiling Light adv parser."""
+
 from __future__ import annotations
 
 import logging

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/contact.py

@@ -1,4 +1,5 @@
 """Contact sensor parser."""
+
 from __future__ import annotations
 
 

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/curtain.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/humidifier.py

@@ -1,4 +1,5 @@
 """Humidifier adv parser."""
+
 from __future__ import annotations
 
 import logging

pyswitchbot-0.55.0/switchbot/adv_parsers/leak.py

@@ -0,0 +1,29 @@
+"""Leak detector adv parser."""
+
+
+def process_leak(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool | int]:
+    """Process SwitchBot Water Leak Detector advertisement data."""
+    if data is None or len(data) < 3 or mfr_data is None or len(mfr_data) < 2:
+        return {}
+
+    water_leak_detected = None
+    device_tampered = None
+    battery_level = None
+    low_battery = None
+
+    # Byte 1: Event Flags
+    event_flags = mfr_data[8]
+    water_leak_detected = bool(event_flags & 0b00000001)  # Bit 0
+    device_tampered = bool(event_flags & 0b00000010)  # Bit 1
+
+    # Byte 2: Battery Info
+    battery_info = mfr_data[7]
+    battery_level = battery_info & 0b01111111  # Bits 0-6
+    low_battery = bool(battery_info & 0b10000000)  # Bit 7
+
+    return {
+        "leak": water_leak_detected,
+        "tampered": device_tampered,
+        "battery": battery_level,
+        "low_battery": low_battery,
+    }

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/light_strip.py

@@ -1,4 +1,5 @@
 """Light strip adv parser."""
+
 from __future__ import annotations
 
 

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/lock.py

@@ -1,4 +1,5 @@
 """Lock parser."""
+
 from __future__ import annotations
 
 import logging

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/meter.py

@@ -1,4 +1,5 @@
 """Meter parser."""
+
 from __future__ import annotations
 
 import struct

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/motion.py

@@ -1,4 +1,5 @@
 """Motion sensor parser."""
+
 from __future__ import annotations
 
 

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/plug.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/adv_parsers/relay_switch.py

@@ -1,4 +1,5 @@
 """Relay Switch adv parser."""
+
 from __future__ import annotations
 
 
@@ -18,7 +19,7 @@ def process_worelay_switch_1pm(
     }
 
 
-def process_worelay_switch_1plus(
+def process_worelay_switch_1(
     data: bytes | None, mfr_data: bytes | None
 ) -> dict[str, bool | int]:
     """Process WoStrip services data."""

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/const.py

@@ -53,9 +53,10 @@ class SwitchbotModel(StrEnum):
     LOCK_PRO = "WoLockPro"
     BLIND_TILT = "WoBlindTilt"
     HUB2 = "WoHub2"
+    LEAK = "Leak Detector"
     KEYPAD = "WoKeypad"
     RELAY_SWITCH_1PM = "Relay Switch 1PM"
-    RELAY_SWITCH_1_PLUS = "Relay Switch 1"
+    RELAY_SWITCH_1 = "Relay Switch 1"
 
 
 class LockStatus(Enum):

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/devices/base_cover.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 import logging

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/devices/blind_tilt.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 import logging

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/devices/bot.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 import logging

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/devices/curtain.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 import logging

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/devices/device.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 import asyncio
@@ -7,9 +8,11 @@ import logging
 import time
 from dataclasses import replace
 from enum import Enum
-from typing import Any, Callable, TypeVar, cast
+from typing import Any, TypeVar, cast
+from collections.abc import Callable
 from uuid import UUID
 
+import aiohttp
 from bleak.backends.device import BLEDevice
 from bleak.backends.service import BleakGATTCharacteristic, BleakGATTServiceCollection
 from bleak.exc import BleakDBusError
@@ -21,7 +24,15 @@ from bleak_retry_connector import (
     establish_connection,
 )
 
-from ..const import DEFAULT_RETRY_COUNT, DEFAULT_SCAN_TIMEOUT
+from ..api_config import SWITCHBOT_APP_API_BASE_URL, SWITCHBOT_APP_CLIENT_ID
+from ..const import (
+    DEFAULT_RETRY_COUNT,
+    DEFAULT_SCAN_TIMEOUT,
+    SwitchbotAccountConnectionError,
+    SwitchbotApiError,
+    SwitchbotAuthenticationError,
+    SwitchbotModel,
+)
 from ..discovery import GetSwitchbotDevices
 from ..models import SwitchBotAdvertisement
 
@@ -150,6 +161,35 @@ class SwitchbotBaseDevice:
         self._last_full_update: float = -PASSIVE_POLL_INTERVAL
         self._timed_disconnect_task: asyncio.Task[None] | None = None
 
+    @classmethod
+    async def api_request(
+        cls,
+        session: aiohttp.ClientSession,
+        subdomain: str,
+        path: str,
+        data: dict = None,
+        headers: dict = None,
+    ) -> dict:
+        url = f"https://{subdomain}.{SWITCHBOT_APP_API_BASE_URL}/{path}"
+        async with session.post(
+            url,
+            json=data,
+            headers=headers,
+            timeout=aiohttp.ClientTimeout(total=10),
+        ) as result:
+            if result.status > 299:
+                raise SwitchbotApiError(
+                    f"Unexpected status code returned by SwitchBot API: {result.status}"
+                )
+
+            response = await result.json()
+            if response["statusCode"] != 100:
+                raise SwitchbotApiError(
+                    f"{response['message']}, status code: {response['statusCode']}"
+                )
+
+            return response["body"]
+
     def advertisement_changed(self, advertisement: SwitchBotAdvertisement) -> bool:
         """Check if the advertisement has changed."""
         return bool(
@@ -469,7 +509,7 @@ class SwitchbotBaseDevice:
         timeout_expired = False
         try:
             notify_msg = await self._notify_future
-        except asyncio.TimeoutError:
+        except TimeoutError:
             timeout_expired = True
             raise
         finally:
@@ -664,6 +704,130 @@ class SwitchbotDevice(SwitchbotBaseDevice):
         self._set_advertisement_data(advertisement)
 
 
+class SwitchbotEncryptedDevice(SwitchbotDevice):
+    """A Switchbot device that uses encryption."""
+
+    def __init__(
+        self,
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        model: SwitchbotModel,
+        interface: int = 0,
+        **kwargs: Any,
+    ) -> None:
+        """Switchbot base class constructor for encrypted devices."""
+        if len(key_id) == 0:
+            raise ValueError("key_id is missing")
+        elif len(key_id) != 2:
+            raise ValueError("key_id is invalid")
+        if len(encryption_key) == 0:
+            raise ValueError("encryption_key is missing")
+        elif len(encryption_key) != 32:
+            raise ValueError("encryption_key is invalid")
+        self._key_id = key_id
+        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)
+
+    # Old non-async method preserved for backwards compatibility
+    @classmethod
+    def retrieve_encryption_key(cls, device_mac: str, username: str, password: str):
+        async def async_fn():
+            async with aiohttp.ClientSession() as session:
+                return await cls.async_retrieve_encryption_key(
+                    session, device_mac, username, password
+                )
+
+        return asyncio.run(async_fn())
+
+    @classmethod
+    async def async_retrieve_encryption_key(
+        cls,
+        session: aiohttp.ClientSession,
+        device_mac: str,
+        username: str,
+        password: str,
+    ) -> dict:
+        """Retrieve lock key from internal SwitchBot API."""
+        device_mac = device_mac.replace(":", "").replace("-", "").upper()
+
+        try:
+            auth_result = await cls.api_request(
+                session,
+                "account",
+                "account/api/v1/user/login",
+                {
+                    "clientId": SWITCHBOT_APP_CLIENT_ID,
+                    "username": username,
+                    "password": password,
+                    "grantType": "password",
+                    "verifyCode": "",
+                },
+            )
+            auth_headers = {"authorization": auth_result["access_token"]}
+        except Exception as err:
+            raise SwitchbotAuthenticationError(f"Authentication failed: {err}") from err
+
+        try:
+            userinfo = await cls.api_request(
+                session, "account", "account/api/v1/user/userinfo", {}, auth_headers
+            )
+            if "botRegion" in userinfo and userinfo["botRegion"] != "":
+                region = userinfo["botRegion"]
+            else:
+                region = "us"
+        except Exception as err:
+            raise SwitchbotAccountConnectionError(
+                f"Failed to retrieve SwitchBot Account user details: {err}"
+            ) from err
+
+        try:
+            device_info = await cls.api_request(
+                session,
+                f"wonderlabs.{region}",
+                "wonder/keys/v1/communicate",
+                {
+                    "device_mac": device_mac,
+                    "keyType": "user",
+                },
+                auth_headers,
+            )
+
+            return {
+                "key_id": device_info["communicationKey"]["keyId"],
+                "encryption_key": device_info["communicationKey"]["key"],
+            }
+        except Exception as err:
+            raise SwitchbotAccountConnectionError(
+                f"Failed to retrieve encryption key from SwitchBot Account: {err}"
+            ) from err
+
+    @classmethod
+    async def verify_encryption_key(
+        cls,
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        model: SwitchbotModel,
+        **kwargs: Any,
+    ) -> bool:
+        try:
+            device = cls(
+                device, key_id=key_id, encryption_key=encryption_key, model=model
+            )
+        except ValueError:
+            return False
+        try:
+            info = await device.get_basic_info()
+        except SwitchbotOperationError:
+            return False
+
+        return info is not None
+
+
 class SwitchbotDeviceOverrideStateDuringConnection(SwitchbotBaseDevice):
     """Base Representation of a Switchbot Device.
 

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/devices/humidifier.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 import time

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/devices/lock.py

@@ -1,24 +1,16 @@
 """Library to handle connection with Switchbot Lock."""
+
 from __future__ import annotations
 
-import asyncio
 import logging
 import time
 from typing import Any
 
-import aiohttp
 from bleak.backends.device import BLEDevice
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 
-from ..api_config import SWITCHBOT_APP_API_BASE_URL, SWITCHBOT_APP_CLIENT_ID
-from ..const import (
-    LockStatus,
-    SwitchbotAccountConnectionError,
-    SwitchbotApiError,
-    SwitchbotAuthenticationError,
-    SwitchbotModel,
-)
-from .device import SwitchbotDevice, SwitchbotOperationError
+from ..const import LockStatus, SwitchbotModel
+from .device import SwitchbotEncryptedDevice
 
 COMMAND_HEADER = "57"
 COMMAND_GET_CK_IV = f"{COMMAND_HEADER}0f2103"
@@ -53,7 +45,7 @@ COMMAND_RESULT_EXPECTED_VALUES = {1, 6}
 # The return value of the command is 6 when the command is successful but the battery is low.
 
 
-class SwitchbotLock(SwitchbotDevice):
+class SwitchbotLock(SwitchbotEncryptedDevice):
     """Representation of a Switchbot Lock."""
 
     def __init__(
@@ -65,141 +57,23 @@ class SwitchbotLock(SwitchbotDevice):
         model: SwitchbotModel = SwitchbotModel.LOCK,
         **kwargs: Any,
     ) -> None:
-        if len(key_id) == 0:
-            raise ValueError("key_id is missing")
-        elif len(key_id) != 2:
-            raise ValueError("key_id is invalid")
-        if len(encryption_key) == 0:
-            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)
+        super().__init__(device, key_id, encryption_key, model, interface, **kwargs)
 
-    @staticmethod
+    @classmethod
     async def verify_encryption_key(
+        cls,
         device: BLEDevice,
         key_id: str,
         encryption_key: str,
         model: SwitchbotModel = SwitchbotModel.LOCK,
         **kwargs: Any,
     ) -> bool:
-        try:
-            lock = SwitchbotLock(
-                device, key_id=key_id, encryption_key=encryption_key, model=model
-            )
-        except ValueError:
-            return False
-        try:
-            lock_info = await lock.get_basic_info()
-        except SwitchbotOperationError:
-            return False
-
-        return lock_info is not None
-
-    @staticmethod
-    async def api_request(
-        session: aiohttp.ClientSession,
-        subdomain: str,
-        path: str,
-        data: dict = None,
-        headers: dict = None,
-    ) -> dict:
-        url = f"https://{subdomain}.{SWITCHBOT_APP_API_BASE_URL}/{path}"
-        async with session.post(
-            url,
-            json=data,
-            headers=headers,
-            timeout=aiohttp.ClientTimeout(total=10),
-        ) as result:
-            if result.status > 299:
-                raise SwitchbotApiError(
-                    f"Unexpected status code returned by SwitchBot API: {result.status}"
-                )
-
-            response = await result.json()
-            if response["statusCode"] != 100:
-                raise SwitchbotApiError(
-                    f"{response['message']}, status code: {response['statusCode']}"
-                )
-
-            return response["body"]
-
-    # Old non-async method preserved for backwards compatibility
-    @staticmethod
-    def retrieve_encryption_key(device_mac: str, username: str, password: str):
-        async def async_fn():
-            async with aiohttp.ClientSession() as session:
-                return await SwitchbotLock.async_retrieve_encryption_key(
-                    session, device_mac, username, password
-                )
-
-        return asyncio.run(async_fn())
-
-    @staticmethod
-    async def async_retrieve_encryption_key(
-        session: aiohttp.ClientSession, device_mac: str, username: str, password: str
-    ) -> dict:
-        """Retrieve lock key from internal SwitchBot API."""
-        device_mac = device_mac.replace(":", "").replace("-", "").upper()
-
-        try:
-            auth_result = await SwitchbotLock.api_request(
-                session,
-                "account",
-                "account/api/v1/user/login",
-                {
-                    "clientId": SWITCHBOT_APP_CLIENT_ID,
-                    "username": username,
-                    "password": password,
-                    "grantType": "password",
-                    "verifyCode": "",
-                },
-            )
-            auth_headers = {"authorization": auth_result["access_token"]}
-        except Exception as err:
-            raise SwitchbotAuthenticationError(f"Authentication failed: {err}") from err
-
-        try:
-            userinfo = await SwitchbotLock.api_request(
-                session, "account", "account/api/v1/user/userinfo", {}, auth_headers
-            )
-            if "botRegion" in userinfo and userinfo["botRegion"] != "":
-                region = userinfo["botRegion"]
-            else:
-                region = "us"
-        except Exception as err:
-            raise SwitchbotAccountConnectionError(
-                f"Failed to retrieve SwitchBot Account user details: {err}"
-            ) from err
-
-        try:
-            device_info = await SwitchbotLock.api_request(
-                session,
-                f"wonderlabs.{region}",
-                "wonder/keys/v1/communicate",
-                {
-                    "device_mac": device_mac,
-                    "keyType": "user",
-                },
-                auth_headers,
-            )
-
-            return {
-                "key_id": device_info["communicationKey"]["keyId"],
-                "encryption_key": device_info["communicationKey"]["key"],
-            }
-        except Exception as err:
-            raise SwitchbotAccountConnectionError(
-                f"Failed to retrieve encryption key from SwitchBot Account: {err}"
-            ) from err
+        return super().verify_encryption_key(
+            device, key_id, encryption_key, model, **kwargs
+        )
 
     async def lock(self) -> bool:
         """Send lock command."""

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/devices/plug.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 import time

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/devices/relay_switch.py

@@ -1,3 +1,4 @@
+import logging
 import time
 from typing import Any
 
@@ -5,7 +6,10 @@ from bleak.backends.device import BLEDevice
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 
 from ..const import SwitchbotModel
-from .device import SwitchbotSequenceDevice
+from ..models import SwitchBotAdvertisement
+from .device import SwitchbotEncryptedDevice
+
+_LOGGER = logging.getLogger(__name__)
 
 COMMAND_HEADER = "57"
 COMMAND_GET_CK_IV = f"{COMMAND_HEADER}0f2103"
@@ -13,10 +17,10 @@ COMMAND_TURN_OFF = f"{COMMAND_HEADER}0f70010000"
 COMMAND_TURN_ON = f"{COMMAND_HEADER}0f70010100"
 COMMAND_TOGGLE = f"{COMMAND_HEADER}0f70010200"
 COMMAND_GET_VOLTAGE_AND_CURRENT = f"{COMMAND_HEADER}0f7106000000"
-PASSIVE_POLL_INTERVAL = 1 * 60
+PASSIVE_POLL_INTERVAL = 10 * 60
 
 
-class SwitchbotRelaySwitch(SwitchbotSequenceDevice):
+class SwitchbotRelaySwitch(SwitchbotEncryptedDevice):
     """Representation of a Switchbot relay switch 1pm."""
 
     def __init__(
@@ -28,20 +32,42 @@ class SwitchbotRelaySwitch(SwitchbotSequenceDevice):
         model: SwitchbotModel = SwitchbotModel.RELAY_SWITCH_1PM,
         **kwargs: Any,
     ) -> None:
-        if len(key_id) == 0:
-            raise ValueError("key_id is missing")
-        elif len(key_id) != 2:
-            raise ValueError("key_id is invalid")
-        if len(encryption_key) == 0:
-            raise ValueError("encryption_key is missing")
-        elif len(encryption_key) != 32:
-            raise ValueError("encryption_key is invalid")
-        self._iv = None
-        self._cipher = None
-        self._key_id = key_id
-        self._encryption_key = bytearray.fromhex(encryption_key)
-        self._model: SwitchbotModel = model
-        super().__init__(device, None, interface, **kwargs)
+        self._force_next_update = False
+        super().__init__(device, key_id, encryption_key, model, interface, **kwargs)
+
+    @classmethod
+    async def verify_encryption_key(
+        cls,
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        model: SwitchbotModel = SwitchbotModel.RELAY_SWITCH_1PM,
+        **kwargs: Any,
+    ) -> bool:
+        return super().verify_encryption_key(
+            device, key_id, encryption_key, model, **kwargs
+        )
+
+    def update_from_advertisement(self, advertisement: SwitchBotAdvertisement) -> None:
+        """Update device data from advertisement."""
+        # Obtain voltage and current through command.
+        adv_data = advertisement.data["data"]
+        if previous_voltage := self._get_adv_value("voltage"):
+            adv_data["voltage"] = previous_voltage
+        if previous_current := self._get_adv_value("current"):
+            adv_data["current"] = previous_current
+        current_state = self._get_adv_value("sequence_number")
+        super().update_from_advertisement(advertisement)
+        new_state = self._get_adv_value("sequence_number")
+        _LOGGER.debug(
+            "%s: update advertisement: %s (seq before: %s) (seq after: %s)",
+            self.name,
+            advertisement,
+            current_state,
+            new_state,
+        )
+        if current_state != new_state:
+            self._force_next_update = True
 
     async def update(self, interface: int | None = None) -> None:
         """Update state of device."""
@@ -56,13 +82,16 @@ class SwitchbotRelaySwitch(SwitchbotSequenceDevice):
         ok = self._check_command_result(result, 0, {1})
         if ok:
             return {
-                "voltage": (result[9] << 8) + result[10],
+                "voltage": ((result[9] << 8) + result[10]) / 10,
                 "current": (result[11] << 8) + result[12],
             }
         return None
 
     def poll_needed(self, seconds_since_last_poll: float | None) -> bool:
         """Return if device needs polling."""
+        if self._force_next_update:
+            self._force_next_update = False
+            return True
         if (
             seconds_since_last_poll is not None
             and seconds_since_last_poll < PASSIVE_POLL_INTERVAL

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/enum.py

@@ -1,4 +1,5 @@
 """Enum backports from standard lib."""
+
 from __future__ import annotations
 
 from enum import Enum

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/switchbot/models.py

@@ -1,4 +1,5 @@
 """Library to handle connection with Switchbot."""
+
 from __future__ import annotations
 
 from dataclasses import dataclass

{pyswitchbot-0.53.2 → pyswitchbot-0.55.0}/tests/test_adv_parser.py

@@ -1672,3 +1672,216 @@ def test_parse_advertisement_data_keypad():
         rssi=-67,
         active=True,
     )
+
+
+def test_parse_advertisement_data_relay_switch_1pm():
+    """Test parse_advertisement_data for the keypad."""
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={2409: b"$X|\x0866G\x81\x00\x00\x001\x00\x00\x00\x00"},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"<\x00\x00\x00"},
+        rssi=-67,
+    )
+    result = parse_advertisement_data(
+        ble_device, adv_data, SwitchbotModel.RELAY_SWITCH_1PM
+    )
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {
+                "switchMode": True,
+                "sequence_number": 71,
+                "isOn": True,
+                "power": 4.9,
+                "voltage": 0,
+                "current": 0,
+            },
+            "isEncrypted": False,
+            "model": "<",
+            "modelFriendlyName": "Relay Switch 1PM",
+            "modelName": SwitchbotModel.RELAY_SWITCH_1PM,
+            "rawAdvData": b"<\x00\x00\x00",
+        },
+        device=ble_device,
+        rssi=-67,
+        active=True,
+    )
+
+
+def test_parse_advertisement_data_relay_switch_1():
+    """Test parse_advertisement_data for the keypad."""
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={2409: b"$X|\x0866G\x81\x00\x00\x001\x00\x00\x00\x00"},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b";\x00\x00\x00"},
+        rssi=-67,
+    )
+    result = parse_advertisement_data(
+        ble_device, adv_data, SwitchbotModel.RELAY_SWITCH_1
+    )
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {
+                "switchMode": True,
+                "sequence_number": 71,
+                "isOn": True,
+            },
+            "isEncrypted": False,
+            "model": ";",
+            "modelFriendlyName": "Relay Switch 1",
+            "modelName": SwitchbotModel.RELAY_SWITCH_1,
+            "rawAdvData": b";\x00\x00\x00",
+        },
+        device=ble_device,
+        rssi=-67,
+        active=True,
+    )
+
+
+def test_leak_active():
+    """Test parse_advertisement_data for the leak detector."""
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={2409: b"\xc4407Lz\x18N\x98g^\x94Q<\x05\x00\x00\x00\x00"},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"&\x00N"},
+        rssi=-72,
+    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.LEAK)
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {
+                "leak": False,
+                "tampered": False,
+                "battery": 78,
+                "low_battery": False,
+            },
+            "isEncrypted": False,
+            "model": "3",
+            "modelFriendlyName": "Leak Detector",
+            "modelName": SwitchbotModel.LEAK,
+            "rawAdvData": b"&\x00N",
+        },
+        device=ble_device,
+        rssi=-72,
+        active=True,
+    )
+
+
+def test_leak_passive():
+    """Test parse_advertisement_data for the leak detector."""
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={2409: b"\xc4407Lz\x18N\x98g^\x94Q<\x05\x00\x00\x00\x00"},
+        rssi=-72,
+    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.LEAK)
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {},
+            "isEncrypted": False,
+            "model": "3",
+            "rawAdvData": None,
+        },
+        device=ble_device,
+        rssi=-72,
+        active=False,
+    )
+
+
+def test_leak_no_leak_detected():
+    """Test parse_advertisement_data for the leak detector."""
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "Any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={
+            2409: b"\xc4407LzJd\x98ga\xc4\n<\x05\x00\x00\x00\x00"
+        },  # no leak, batt
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"&\x00d"},
+        rssi=-73,
+    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.LEAK)
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {
+                "leak": False,
+                "tampered": False,
+                "battery": 100,
+                "low_battery": False,
+            },
+            "isEncrypted": False,
+            "model": "3",
+            "modelFriendlyName": "Leak Detector",
+            "modelName": SwitchbotModel.LEAK,
+            "rawAdvData": b"&\x00d",
+        },
+        device=ble_device,
+        rssi=-73,
+        active=True,
+    )
+
+
+def test_leak_leak_detected():
+    """Test parse_advertisement_data for the leak detector."""
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "Any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={
+            2409: b"\xc4407LzGd\xf9ga\xc4\x08<\x05\x00\x00\x00\x00"
+        },  # leak, batt
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"&\x00d"},
+        rssi=-73,
+    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.LEAK)
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {
+                "leak": True,
+                "tampered": False,
+                "battery": 100,
+                "low_battery": False,
+            },
+            "isEncrypted": False,
+            "model": "3",
+            "modelFriendlyName": "Leak Detector",
+            "modelName": SwitchbotModel.LEAK,
+            "rawAdvData": b"&\x00d",
+        },
+        device=ble_device,
+        rssi=-73,
+        active=True,
+    )
+
+
+def test_leak_low_battery():
+    """Test parse_advertisement_data for the leak detector."""
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "Any")
+    adv_data = generate_advertisement_data(
+        manufacturer_data={
+            2409: b"\xc4407Lz\x02\t\x98\x00\x00\x00\x00<\x05\x00\x00\x00\x00"
+        },  # no leak, low battery
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"&\x00d"},
+        rssi=-73,
+    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.LEAK)
+    assert result == SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "data": {
+                "leak": False,
+                "tampered": False,
+                "battery": 9,
+                "low_battery": False,
+            },
+            "isEncrypted": False,
+            "model": "3",
+            "modelFriendlyName": "Leak Detector",
+            "modelName": SwitchbotModel.LEAK,
+            "rawAdvData": b"&\x00d",
+        },
+        device=ble_device,
+        rssi=-73,
+        active=True,
+    )

pyswitchbot-0.55.0/tests/test_relay_switch.py

@@ -0,0 +1,60 @@
+from unittest.mock import AsyncMock
+
+import pytest
+from bleak.backends.device import BLEDevice
+
+from switchbot import SwitchBotAdvertisement, SwitchbotModel
+from switchbot.devices import relay_switch
+
+from .test_adv_parser import generate_ble_device
+
+
+def create_device_for_command_testing(calibration=True, reverse_mode=False):
+    ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
+    relay_switch_device = relay_switch.SwitchbotRelaySwitch(
+        ble_device, "ff", "ffffffffffffffffffffffffffffffff"
+    )
+    relay_switch_device.update_from_advertisement(make_advertisement_data(ble_device))
+    return relay_switch_device
+
+
+def make_advertisement_data(ble_device: BLEDevice):
+    """Set advertisement data with defaults."""
+
+    return SwitchBotAdvertisement(
+        address="aa:bb:cc:dd:ee:ff",
+        data={
+            "rawAdvData": b"$X|\x0866G\x81\x00\x00\x001\x00\x00\x00\x00",
+            "data": {
+                "switchMode": True,
+                "sequence_number": 71,
+                "isOn": True,
+                "power": 4.9,
+                "voltage": 0,
+                "current": 0,
+            },
+            "isEncrypted": False,
+            "model": "<",
+            "modelFriendlyName": "Relay Switch 1PM",
+            "modelName": SwitchbotModel.RELAY_SWITCH_1PM,
+        },
+        device=ble_device,
+        rssi=-80,
+        active=True,
+    )
+
+
+@pytest.mark.asyncio
+async def test_turn_on():
+    relay_switch_device = create_device_for_command_testing()
+    relay_switch_device._send_command = AsyncMock(return_value=b"\x01")
+    await relay_switch_device.turn_on()
+    assert relay_switch_device.is_on() is True
+
+
+@pytest.mark.asyncio
+async def test_trun_off():
+    relay_switch_device = create_device_for_command_testing()
+    relay_switch_device._send_command = AsyncMock(return_value=b"\x01")
+    await relay_switch_device.turn_off()
+    assert relay_switch_device.is_on() is False