PySwitchbot 1.0.0__tar.gz → 2.0.0__tar.gz

{pyswitchbot-1.0.0 → pyswitchbot-2.0.0}/PKG-INFO

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

{pyswitchbot-1.0.0 → pyswitchbot-2.0.0}/PySwitchbot.egg-info/PKG-INFO

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

{pyswitchbot-1.0.0 → pyswitchbot-2.0.0}/pyproject.toml

@@ -25,7 +25,6 @@ ignore = [
     "S110", # `try`-`except`-`pass` detected, consider logging the exception
     "D106", # Missing docstring in public nested class
     "UP007", # typer needs Optional syntax
-    "UP038", # Use `X | Y` in `isinstance` is slower
     "S603", #  check for execution of untrusted input
     "S105", # possible hard coded creds
     "TID252", # not for this lib

{pyswitchbot-1.0.0 → pyswitchbot-2.0.0}/setup.py

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

{pyswitchbot-1.0.0 → pyswitchbot-2.0.0}/switchbot/__init__.py

@@ -11,6 +11,7 @@ from bleak_retry_connector import (
 from .adv_parser import SwitchbotSupportedType, parse_advertisement_data
 from .const import (
     AirPurifierMode,
+    AirQualityLevel,
     BulbColorMode,
     CeilingLightColorMode,
     ClimateAction,
@@ -67,6 +68,7 @@ from .models import SwitchBotAdvertisement
 
 __all__ = [
     "AirPurifierMode",
+    "AirQualityLevel",
     "BulbColorMode",
     "CeilingLightColorMode",
     "ClimateAction",

{pyswitchbot-1.0.0 → pyswitchbot-2.0.0}/switchbot/adv_parser.py

@@ -492,50 +492,50 @@ SUPPORTED_TYPES: dict[str | bytes, SwitchbotSupportedType] = {
         "manufacturer_id": 2409,
     },
     "*": {
-        "modelName": SwitchbotModel.AIR_PURIFIER,
-        "modelFriendlyName": "Air Purifier",
+        "modelName": SwitchbotModel.AIR_PURIFIER_US,
+        "modelFriendlyName": "Air Purifier US",
         "func": process_air_purifier,
         "manufacturer_id": 2409,
     },
     b"\x0a": {
-        "modelName": SwitchbotModel.AIR_PURIFIER,
-        "modelFriendlyName": "Air Purifier",
+        "modelName": SwitchbotModel.AIR_PURIFIER_US,
+        "modelFriendlyName": "Air Purifier US",
         "func": process_air_purifier,
         "manufacturer_id": 2409,
     },
     "+": {
-        "modelName": SwitchbotModel.AIR_PURIFIER,
-        "modelFriendlyName": "Air Purifier",
+        "modelName": SwitchbotModel.AIR_PURIFIER_JP,
+        "modelFriendlyName": "Air Purifier JP",
         "func": process_air_purifier,
         "manufacturer_id": 2409,
     },
     b"\x0b": {
-        "modelName": SwitchbotModel.AIR_PURIFIER,
-        "modelFriendlyName": "Air Purifier",
+        "modelName": SwitchbotModel.AIR_PURIFIER_JP,
+        "modelFriendlyName": "Air Purifier JP",
         "func": process_air_purifier,
         "manufacturer_id": 2409,
     },
     "7": {
-        "modelName": SwitchbotModel.AIR_PURIFIER_TABLE,
-        "modelFriendlyName": "Air Purifier Table",
+        "modelName": SwitchbotModel.AIR_PURIFIER_TABLE_US,
+        "modelFriendlyName": "Air Purifier Table US",
         "func": process_air_purifier,
         "manufacturer_id": 2409,
     },
     b"\x17": {
-        "modelName": SwitchbotModel.AIR_PURIFIER_TABLE,
-        "modelFriendlyName": "Air Purifier Table",
+        "modelName": SwitchbotModel.AIR_PURIFIER_TABLE_US,
+        "modelFriendlyName": "Air Purifier Table US",
         "func": process_air_purifier,
         "manufacturer_id": 2409,
     },
     "8": {
-        "modelName": SwitchbotModel.AIR_PURIFIER_TABLE,
-        "modelFriendlyName": "Air Purifier Table",
+        "modelName": SwitchbotModel.AIR_PURIFIER_TABLE_JP,
+        "modelFriendlyName": "Air Purifier Table JP",
         "func": process_air_purifier,
         "manufacturer_id": 2409,
     },
     b"\x18": {
-        "modelName": SwitchbotModel.AIR_PURIFIER_TABLE,
-        "modelFriendlyName": "Air Purifier Table",
+        "modelName": SwitchbotModel.AIR_PURIFIER_TABLE_JP,
+        "modelFriendlyName": "Air Purifier Table JP",
         "func": process_air_purifier,
         "manufacturer_id": 2409,
     },
@@ -755,6 +755,42 @@ SUPPORTED_TYPES: dict[str | bytes, SwitchbotSupportedType] = {
         "func": process_keypad_vision_pro,
         "manufacturer_id": 2409,
     },
+    b"\x00\x11\x69\x09": {
+        "modelName": SwitchbotModel.LOCK_VISION_PRO,
+        "modelFriendlyName": "Lock Vision Pro",
+        "func": process_lock2,
+        "manufacturer_id": 2409,
+    },
+    b"\x01\x11\x69\x09": {
+        "modelName": SwitchbotModel.LOCK_VISION_PRO,
+        "modelFriendlyName": "Lock Vision Pro",
+        "func": process_lock2,
+        "manufacturer_id": 2409,
+    },
+    b"\x00\x11\x69\x08": {
+        "modelName": SwitchbotModel.LOCK_VISION,
+        "modelFriendlyName": "Lock Vision",
+        "func": process_locklite,
+        "manufacturer_id": 2409,
+    },
+    b"\x01\x11\x69\x08": {
+        "modelName": SwitchbotModel.LOCK_VISION,
+        "modelFriendlyName": "Lock Vision",
+        "func": process_locklite,
+        "manufacturer_id": 2409,
+    },
+    b"\x00\x10\xff\x90": {
+        "modelName": SwitchbotModel.LOCK_PRO_WIFI,
+        "modelFriendlyName": "Lock Pro Wifi",
+        "func": process_wolock_pro,
+        "manufacturer_id": 2409,
+    },
+    b"\x01\x10\xff\x90": {
+        "modelName": SwitchbotModel.LOCK_PRO_WIFI,
+        "modelFriendlyName": "Lock Pro Wifi",
+        "func": process_wolock_pro,
+        "manufacturer_id": 2409,
+    },
 }
 
 _SWITCHBOT_MODEL_TO_CHAR: defaultdict[SwitchbotModel, list[str | bytes]] = defaultdict(

{pyswitchbot-1.0.0 → pyswitchbot-2.0.0}/switchbot/const/__init__.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from ..enum import StrEnum
-from .air_purifier import AirPurifierMode
+from .air_purifier import AirPurifierMode, AirQualityLevel
 from .climate import ClimateAction, ClimateMode, SmartThermostatRadiatorMode
 from .evaporative_humidifier import (
     HumidifierAction,
@@ -85,8 +85,10 @@ class SwitchbotModel(StrEnum):
     K10_VACUUM = "K10+ Vacuum"
     K10_PRO_VACUUM = "K10+ Pro Vacuum"
     K10_PRO_COMBO_VACUUM = "K10+ Pro Combo Vacuum"
-    AIR_PURIFIER = "Air Purifier"
-    AIR_PURIFIER_TABLE = "Air Purifier Table"
+    AIR_PURIFIER_US = "Air Purifier US"
+    AIR_PURIFIER_JP = "Air Purifier JP"
+    AIR_PURIFIER_TABLE_US = "Air Purifier Table US"
+    AIR_PURIFIER_TABLE_JP = "Air Purifier Table JP"
     HUB3 = "Hub3"
     LOCK_ULTRA = "Lock Ultra"
     LOCK_LITE = "Lock Lite"
@@ -105,6 +107,9 @@ class SwitchbotModel(StrEnum):
     ART_FRAME = "Art Frame"
     KEYPAD_VISION = "Keypad Vision"
     KEYPAD_VISION_PRO = "Keypad Vision Pro"
+    LOCK_VISION_PRO = "Lock Vision Pro"
+    LOCK_VISION = "Lock Vision"
+    LOCK_PRO_WIFI = "Lock Pro Wifi"
 
 
 __all__ = [
@@ -112,6 +117,7 @@ __all__ = [
     "DEFAULT_RETRY_TIMEOUT",
     "DEFAULT_SCAN_TIMEOUT",
     "AirPurifierMode",
+    "AirQualityLevel",
     "BulbColorMode",
     "CeilingLightColorMode",
     "ClimateAction",

pyswitchbot-2.0.0/switchbot/devices/air_purifier.py

@@ -0,0 +1,311 @@
+"""Library to handle connection with Switchbot."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, ClassVar
+
+from bleak.backends.device import BLEDevice
+
+from ..adv_parsers.air_purifier import get_air_purifier_mode
+from ..const import SwitchbotModel
+from ..const.air_purifier import AirPurifierMode, AirQualityLevel
+from ..const.light import ColorMode
+from ..helpers import _UNPACK_UINT16_BE
+from .base_light import SwitchbotSequenceBaseLight
+from .device import (
+    SwitchbotEncryptedDevice,
+    SwitchbotOperationError,
+    update_after_operation,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+COMMAND_HEAD = "570f4c"
+COMMAND_SET_MODE = {
+    AirPurifierMode.LEVEL_1.name.lower(): f"{COMMAND_HEAD}01010100",
+    AirPurifierMode.LEVEL_2.name.lower(): f"{COMMAND_HEAD}01010132",
+    AirPurifierMode.LEVEL_3.name.lower(): f"{COMMAND_HEAD}01010164",
+    AirPurifierMode.AUTO.name.lower(): f"{COMMAND_HEAD}01010200",
+    AirPurifierMode.SLEEP.name.lower(): f"{COMMAND_HEAD}01010300",
+    AirPurifierMode.PET.name.lower(): f"{COMMAND_HEAD}01010400",
+}
+DEVICE_GET_BASIC_SETTINGS_KEY = "570f4d81"
+COMMAND_SET_PERCENTAGE = f"{COMMAND_HEAD}02{{percentage:02x}}"
+READ_LED_SETTINGS_COMMAND = "570f4d05"
+READ_LED_STATUS_COMMAND = "570f4d07"
+
+
+class SwitchbotAirPurifier(SwitchbotSequenceBaseLight, SwitchbotEncryptedDevice):
+    """Representation of a Switchbot Air Purifier."""
+
+    _turn_on_command = f"{COMMAND_HEAD}010100"
+    _turn_off_command = f"{COMMAND_HEAD}010000"
+    _open_child_lock_command = f"{COMMAND_HEAD}0301"
+    _close_child_lock_command = f"{COMMAND_HEAD}0300"
+    _open_wireless_charging_command = f"{COMMAND_HEAD}0d01"
+    _close_wireless_charging_command = f"{COMMAND_HEAD}0d00"
+    _open_light_sensitive_switch_command = f"{COMMAND_HEAD}0702"
+    _turn_led_on_command = f"{COMMAND_HEAD}0701"
+    _turn_led_off_command = f"{COMMAND_HEAD}0700"
+    _set_rgb_command = _set_brightness_command = f"{COMMAND_HEAD}0501{{}}"
+    _get_basic_info_command = [
+        DEVICE_GET_BASIC_SETTINGS_KEY,
+        READ_LED_SETTINGS_COMMAND,
+        READ_LED_STATUS_COMMAND,
+    ]
+
+    _PM25_MODELS: ClassVar[frozenset[SwitchbotModel]] = frozenset(
+        {
+            SwitchbotModel.AIR_PURIFIER_US,
+            SwitchbotModel.AIR_PURIFIER_TABLE_US,
+        }
+    )
+
+    _LEVEL_MODES: ClassVar[frozenset[str]] = frozenset(
+        {
+            AirPurifierMode.LEVEL_1.name.lower(),
+            AirPurifierMode.LEVEL_2.name.lower(),
+            AirPurifierMode.LEVEL_3.name.lower(),
+        }
+    )
+
+    _WIRELESS_MODELS: ClassVar[frozenset[SwitchbotModel]] = frozenset(
+        {
+            SwitchbotModel.AIR_PURIFIER_TABLE_US,
+            SwitchbotModel.AIR_PURIFIER_TABLE_JP,
+        }
+    )
+
+    def __init__(
+        self,
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        interface: int = 0,
+        model: SwitchbotModel = SwitchbotModel.AIR_PURIFIER_US,
+        **kwargs: Any,
+    ) -> None:
+        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.AIR_PURIFIER_US,
+        **kwargs: Any,
+    ) -> bool:
+        return await super().verify_encryption_key(
+            device, key_id, encryption_key, model, **kwargs
+        )
+
+    @property
+    def color_modes(self) -> set[ColorMode]:
+        """Return the supported color modes."""
+        return {ColorMode.RGB}
+
+    @property
+    def color_mode(self) -> ColorMode:
+        """Return the current color mode."""
+        return ColorMode.RGB
+
+    async def get_basic_info(self) -> dict[str, Any] | None:
+        """Get device basic settings."""
+        if not (
+            res := await self._get_basic_info_by_multi_commands(
+                self._get_basic_info_command
+            )
+        ):
+            return None
+
+        _data, led_settings, led_status = res[0], res[1], res[2]
+
+        _LOGGER.debug(
+            "%s %s basic info %s", self._model, self._device.address, _data.hex()
+        )
+        _LOGGER.debug(
+            "%s %s led settings %s",
+            self._model,
+            self._device.address,
+            led_settings.hex(),
+        )
+        _LOGGER.debug(
+            "%s %s led_status %s", self._model, self._device.address, led_status.hex()
+        )
+        isOn = bool(_data[2] & 0b10000000)
+        wireless_charging = bool(_data[2] & 0b01000000)
+        version_info = (_data[2] & 0b00110000) >> 4
+        _mode = _data[2] & 0b00000111
+        isAqiValid = bool(_data[3] & 0b00000100)
+        child_lock = bool(_data[3] & 0b00000010)
+        _aqi_level = (_data[4] & 0b00000110) >> 1
+        aqi_level = AirQualityLevel(_aqi_level).name.lower()
+        speed = _data[6] & 0b01111111
+        pm25 = _UNPACK_UINT16_BE(_data, 12)[0] & 0xFFF
+        firmware = _data[15] / 10.0
+        mode = get_air_purifier_mode(_mode, speed)
+        self._state["r"] = led_settings[2]
+        self._state["g"] = led_settings[3]
+        self._state["b"] = led_settings[4]
+        brightness = led_settings[5]
+        light_sensitive = bool(led_status[1] & 0x02)
+
+        data = {
+            "isOn": isOn,
+            "version_info": version_info,
+            "mode": mode,
+            "isAqiValid": isAqiValid,
+            "child_lock": child_lock,
+            "aqi_level": aqi_level,
+            "speed": speed,
+            "firmware": firmware,
+            "brightness": brightness,
+            "light_sensitive": light_sensitive,
+        }
+        if self._model in self._WIRELESS_MODELS:
+            data["wireless_charging"] = wireless_charging
+
+        if self._model in self._PM25_MODELS:
+            return data | {"pm25": pm25}
+        return data
+
+    @update_after_operation
+    async def set_preset_mode(self, preset_mode: str) -> bool:
+        """Send command to set air purifier preset_mode."""
+        result = await self._send_command(COMMAND_SET_MODE[preset_mode])
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def set_percentage(self, percentage: int) -> bool:
+        """Set percentage."""
+        if not 0 <= percentage <= 100:
+            raise ValueError("Percentage must be between 0 and 100")
+        self._validate_current_mode()
+
+        result = await self._send_command(
+            COMMAND_SET_PERCENTAGE.format(percentage=percentage)
+        )
+        return self._check_command_result(result, 0, {1})
+
+    def _validate_current_mode(self) -> None:
+        """Validate current mode for setting percentage."""
+        current_mode = self.get_current_mode()
+        if current_mode not in self._LEVEL_MODES:
+            raise ValueError("Percentage can only be set in LEVEL modes.")
+
+    @update_after_operation
+    async def set_brightness(self, brightness: int) -> bool:
+        """Set brightness."""
+        self._validate_brightness(brightness)
+        r, g, b = (
+            self._state.get("r", 0),
+            self._state.get("g", 0),
+            self._state.get("b", 0),
+        )
+        hex_data = f"{r:02X}{g:02X}{b:02X}{brightness:02X}"
+        result = await self._send_command(self._set_brightness_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.
+
+        Note: byte order is reversed from base class (RGB+brightness
+        instead of brightness+RGB).
+        """
+        self._validate_brightness(brightness)
+        self._validate_rgb(r, g, b)
+        hex_data = f"{r:02X}{g:02X}{b:02X}{brightness: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 turn_led_on(self) -> bool:
+        """Turn on LED."""
+        result = await self._send_command(self._turn_led_on_command)
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def turn_led_off(self) -> bool:
+        """Turn off LED."""
+        result = await self._send_command(self._turn_led_off_command)
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def open_light_sensitive_switch(self) -> bool:
+        """
+        Open the light sensitive switch.
+
+        This will allow the LED to automatically adjust brightness based on ambient light.
+        The LED will turn on in dark environments and turn off in bright environments.
+        """
+        result = await self._send_command(self._open_light_sensitive_switch_command)
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def close_light_sensitive_switch(self) -> bool:
+        """
+        Close the light sensitive switch.
+
+        Since the current protocol does not support obtaining the LED status,
+        sending an on or off command will turn off the light sensitive switch.
+        """
+        result = await self._send_command(self._turn_led_on_command)
+        return self._check_command_result(result, 0, {1})
+
+    def _check_wireless_charging_supported(self) -> None:
+        if self._model not in self._WIRELESS_MODELS:
+            raise SwitchbotOperationError(
+                "Wireless charging is only available on table versions"
+                f" (current model={self._model})"
+            )
+
+    @update_after_operation
+    async def open_wireless_charging(self) -> bool:
+        """Enable the wireless charging pad (table models only)."""
+        self._check_wireless_charging_supported()
+        result = await self._send_command(self._open_wireless_charging_command)
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def close_wireless_charging(self) -> bool:
+        """Disable the wireless charging pad (table models only)."""
+        self._check_wireless_charging_supported()
+        result = await self._send_command(self._close_wireless_charging_command)
+        return self._check_command_result(result, 0, {1})
+
+    def is_on(self) -> bool | None:
+        """Return air purifier state from cache."""
+        return self._get_adv_value("isOn")
+
+    def get_current_aqi_level(self) -> Any:
+        """Return cached aqi level."""
+        return self._get_adv_value("aqi_level")
+
+    def get_current_pm25(self) -> Any:
+        """Return cached pm25."""
+        return self._get_adv_value("pm25")
+
+    def get_current_mode(self) -> Any:
+        """Return cached mode."""
+        return self._get_adv_value("mode")
+
+    def is_child_lock_on(self) -> bool | None:
+        """Return child lock state from cache."""
+        return self._get_adv_value("child_lock")
+
+    def is_wireless_charging_on(self) -> bool | None:
+        """Return wireless charging state from cache."""
+        return self._get_adv_value("wireless_charging")
+
+    def get_current_percentage(self) -> int | None:
+        """Return cached percentage."""
+        return self._get_adv_value("speed")
+
+    def is_light_sensitive_on(self) -> bool | None:
+        """Return light sensitive state from cache."""
+        return self._get_adv_value("light_sensitive")

{pyswitchbot-1.0.0 → pyswitchbot-2.0.0}/switchbot/devices/base_light.py

@@ -75,10 +75,29 @@ class SwitchbotBaseLight(SwitchbotDevice):
         """Return the current effect."""
         return self._get_adv_value("effect")
 
+    @staticmethod
+    def _validate_brightness(brightness: int) -> None:
+        if not 0 <= brightness <= 100:
+            raise ValueError("Brightness must be between 0 and 100")
+
+    @staticmethod
+    def _validate_rgb(r: int, g: int, b: int) -> None:
+        if not 0 <= r <= 255:
+            raise ValueError("r must be between 0 and 255")
+        if not 0 <= g <= 255:
+            raise ValueError("g must be between 0 and 255")
+        if not 0 <= b <= 255:
+            raise ValueError("b must be between 0 and 255")
+
+    @staticmethod
+    def _validate_color_temp(color_temp: int) -> None:
+        if not 2700 <= color_temp <= 6500:
+            raise ValueError("Color Temp must be between 2700 and 6500")
+
     @update_after_operation
     async def set_brightness(self, brightness: int) -> bool:
         """Set brightness."""
-        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        self._validate_brightness(brightness)
         hex_brightness = f"{brightness:02X}"
         self._check_function_support(self._set_brightness_command)
         result = await self._send_command(
@@ -89,8 +108,8 @@ class SwitchbotBaseLight(SwitchbotDevice):
     @update_after_operation
     async def set_color_temp(self, brightness: int, color_temp: int) -> bool:
         """Set color temp."""
-        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
-        assert 2700 <= color_temp <= 6500, "Color Temp must be between 2700 and 6500"
+        self._validate_brightness(brightness)
+        self._validate_color_temp(color_temp)
         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))
@@ -99,10 +118,8 @@ class SwitchbotBaseLight(SwitchbotDevice):
     @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._validate_brightness(brightness)
+        self._validate_rgb(r, g, b)
         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))
@@ -141,7 +158,8 @@ class SwitchbotBaseLight(SwitchbotDevice):
         """Get device basic settings by sending multiple commands."""
         results = []
         for command in commands:
-            if not (result := await self._get_basic_info(command)):
+            result = await self._send_command(command)
+            if not self._check_command_result(result, 0, {1}):
                 return None
             results.append(result)
         return results

{pyswitchbot-1.0.0 → pyswitchbot-2.0.0}/switchbot/devices/device.py

@@ -78,10 +78,10 @@ API_MODEL_TO_ENUM: dict[str, SwitchbotModel] = {
     "WoFan2": SwitchbotModel.CIRCULATOR_FAN,
     "WoHub2": SwitchbotModel.HUB2,
     "WoRollerShade": SwitchbotModel.ROLLER_SHADE,
-    "WoAirPurifierJP": SwitchbotModel.AIR_PURIFIER,
-    "WoAirPurifierUS": SwitchbotModel.AIR_PURIFIER,
-    "WoAirPurifierJPPro": SwitchbotModel.AIR_PURIFIER_TABLE,
-    "WoAirPurifierUSPro": SwitchbotModel.AIR_PURIFIER_TABLE,
+    "WoAirPurifierJP": SwitchbotModel.AIR_PURIFIER_JP,
+    "WoAirPurifierUS": SwitchbotModel.AIR_PURIFIER_US,
+    "WoAirPurifierJPPro": SwitchbotModel.AIR_PURIFIER_TABLE_JP,
+    "WoAirPurifierUSPro": SwitchbotModel.AIR_PURIFIER_TABLE_US,
     "WoSweeperMini": SwitchbotModel.K10_VACUUM,
     "WoSweeperMiniPro": SwitchbotModel.K10_PRO_VACUUM,
     "91AgWZ1n": SwitchbotModel.K10_PRO_COMBO_VACUUM,
@@ -106,6 +106,9 @@ API_MODEL_TO_ENUM: dict[str, SwitchbotModel] = {
     "W1128000": SwitchbotModel.SMART_THERMOSTAT_RADIATOR,
     "W1111000": SwitchbotModel.CLIMATE_PANEL,
     "W1130000": SwitchbotModel.ART_FRAME,
+    "W1141001": SwitchbotModel.LOCK_VISION_PRO,
+    "W1141000": SwitchbotModel.LOCK_VISION,
+    "W1114000": SwitchbotModel.LOCK_PRO_WIFI,
 }
 
 REQ_HEADER = "570f"
@@ -213,6 +216,8 @@ class SwitchbotBaseDevice:
     _open_command: str | None = None
     _close_command: str | None = None
     _press_command: str | None = None
+    _open_child_lock_command: str | None = None
+    _close_child_lock_command: str | None = None
 
     def __init__(
         self,
@@ -932,6 +937,20 @@ class SwitchbotBaseDevice:
         result = await self._send_command(self._press_command)
         return self._check_command_result(result, 0, {1})
 
+    @update_after_operation
+    async def open_child_lock(self) -> bool:
+        """Open the child lock."""
+        self._check_function_support(self._open_child_lock_command)
+        result = await self._send_command(self._open_child_lock_command)
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def close_child_lock(self) -> bool:
+        """Close the child lock."""
+        self._check_function_support(self._close_child_lock_command)
+        result = await self._send_command(self._close_child_lock_command)
+        return self._check_command_result(result, 0, {1})
+
 
 class SwitchbotDevice(SwitchbotBaseDevice):
     """