PySwitchbot 0.74.0__tar.gz → 0.76.0__tar.gz

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/PKG-INFO

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

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/PySwitchbot.egg-info/PKG-INFO

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

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/PySwitchbot.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ switchbot/models.py
 switchbot/utils.py
 switchbot/adv_parsers/__init__.py
 switchbot/adv_parsers/air_purifier.py
+switchbot/adv_parsers/art_frame.py
 switchbot/adv_parsers/blind_tilt.py
 switchbot/adv_parsers/bot.py
 switchbot/adv_parsers/bulb.py
@@ -31,6 +32,7 @@ switchbot/adv_parsers/hub3.py
 switchbot/adv_parsers/hubmini_matter.py
 switchbot/adv_parsers/humidifier.py
 switchbot/adv_parsers/keypad.py
+switchbot/adv_parsers/keypad_vision.py
 switchbot/adv_parsers/leak.py
 switchbot/adv_parsers/light_strip.py
 switchbot/adv_parsers/lock.py
@@ -55,6 +57,7 @@ switchbot/const/lock.py
 switchbot/const/presence_sensor.py
 switchbot/devices/__init__.py
 switchbot/devices/air_purifier.py
+switchbot/devices/art_frame.py
 switchbot/devices/base_cover.py
 switchbot/devices/base_light.py
 switchbot/devices/blind_tilt.py
@@ -68,6 +71,7 @@ switchbot/devices/evaporative_humidifier.py
 switchbot/devices/fan.py
 switchbot/devices/humidifier.py
 switchbot/devices/keypad.py
+switchbot/devices/keypad_vision.py
 switchbot/devices/light_strip.py
 switchbot/devices/lock.py
 switchbot/devices/meter.py
@@ -79,6 +83,7 @@ switchbot/devices/smart_thermostat_radiator.py
 switchbot/devices/vacuum.py
 tests/test_adv_parser.py
 tests/test_air_purifier.py
+tests/test_art_frame.py
 tests/test_base_cover.py
 tests/test_blind_tilt.py
 tests/test_bulb.py
@@ -92,6 +97,7 @@ tests/test_fan.py
 tests/test_helpers.py
 tests/test_hub2.py
 tests/test_hub3.py
+tests/test_keypad_vision.py
 tests/test_lock.py
 tests/test_relay_switch.py
 tests/test_roller_shade.py

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/setup.py

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

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/switchbot/__init__.py

@@ -29,6 +29,7 @@ from .const import (
     SwitchbotModel,
 )
 from .devices.air_purifier import SwitchbotAirPurifier
+from .devices.art_frame import SwitchbotArtFrame
 from .devices.base_light import SwitchbotBaseLight
 from .devices.blind_tilt import SwitchbotBlindTilt
 from .devices.bot import Switchbot
@@ -44,6 +45,7 @@ from .devices.device import (
 from .devices.evaporative_humidifier import SwitchbotEvaporativeHumidifier
 from .devices.fan import SwitchbotFan
 from .devices.humidifier import SwitchbotHumidifier
+from .devices.keypad_vision import SwitchbotKeypadVision
 from .devices.light_strip import (
     SwitchbotLightStrip,
     SwitchbotRgbicLight,
@@ -83,6 +85,7 @@ __all__ = [
     "SwitchbotAccountConnectionError",
     "SwitchbotAirPurifier",
     "SwitchbotApiError",
+    "SwitchbotArtFrame",
     "SwitchbotAuthenticationError",
     "SwitchbotBaseLight",
     "SwitchbotBlindTilt",
@@ -95,6 +98,7 @@ __all__ = [
     "SwitchbotFan",
     "SwitchbotGarageDoorOpener",
     "SwitchbotHumidifier",
+    "SwitchbotKeypadVision",
     "SwitchbotLightStrip",
     "SwitchbotLock",
     "SwitchbotModel",

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/switchbot/adv_parser.py

@@ -12,6 +12,7 @@ from bleak.backends.device import BLEDevice
 from bleak.backends.scanner import AdvertisementData
 
 from .adv_parsers.air_purifier import process_air_purifier
+from .adv_parsers.art_frame import process_art_frame
 from .adv_parsers.blind_tilt import process_woblindtilt
 from .adv_parsers.bot import process_wohand
 from .adv_parsers.bulb import process_color_bulb
@@ -25,6 +26,7 @@ from .adv_parsers.hub3 import process_hub3
 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.keypad_vision import process_keypad_vision, process_keypad_vision_pro
 from .adv_parsers.leak import process_leak
 from .adv_parsers.light_strip import process_light, process_rgbic_light, process_wostrip
 from .adv_parsers.lock import (
@@ -717,6 +719,42 @@ SUPPORTED_TYPES: dict[str | bytes, SwitchbotSupportedType] = {
         "func": process_presence_sensor,
         "manufacturer_id": 2409,
     },
+    b"\x00\x11>\x10": {
+        "modelName": SwitchbotModel.ART_FRAME,
+        "modelFriendlyName": "Art Frame",
+        "func": process_art_frame,
+        "manufacturer_id": 2409,
+    },
+    b"\x01\x11>\x10": {
+        "modelName": SwitchbotModel.ART_FRAME,
+        "modelFriendlyName": "Art Frame",
+        "func": process_art_frame,
+        "manufacturer_id": 2409,
+    },
+    b"\x00\x11\x03x": {
+        "modelName": SwitchbotModel.KEYPAD_VISION,
+        "modelFriendlyName": "Keypad Vision",
+        "func": process_keypad_vision,
+        "manufacturer_id": 2409,
+    },
+    b"\x01\x11\x03x": {
+        "modelName": SwitchbotModel.KEYPAD_VISION,
+        "modelFriendlyName": "Keypad Vision",
+        "func": process_keypad_vision,
+        "manufacturer_id": 2409,
+    },
+    b"\x00\x11Q\x98": {
+        "modelName": SwitchbotModel.KEYPAD_VISION_PRO,
+        "modelFriendlyName": "Keypad Vision Pro",
+        "func": process_keypad_vision_pro,
+        "manufacturer_id": 2409,
+    },
+    b"\x01\x11Q\x98": {
+        "modelName": SwitchbotModel.KEYPAD_VISION_PRO,
+        "modelFriendlyName": "Keypad Vision Pro",
+        "func": process_keypad_vision_pro,
+        "manufacturer_id": 2409,
+    },
 }
 
 _SWITCHBOT_MODEL_TO_CHAR: defaultdict[SwitchbotModel, list[str | bytes]] = defaultdict(

pyswitchbot-0.76.0/switchbot/adv_parsers/art_frame.py

@@ -0,0 +1,35 @@
+"""Art Frame advertisement data parser."""
+
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def process_art_frame(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, bool | int | str]:
+    """Process Art Frame data."""
+    if mfr_data is None:
+        return {}
+
+    _seq_num = mfr_data[6]
+    battery_charging = bool(mfr_data[7] & 0x80)
+    battery = mfr_data[7] & 0x7F
+    image_index = mfr_data[8]
+    display_size = (mfr_data[9] >> 4) & 0x0F
+    display_mode = (mfr_data[9] >> 3) & 0x01
+    last_network_status = (mfr_data[9] >> 2) & 0x01
+
+    result = {
+        "sequence_number": _seq_num,
+        "battery_charging": battery_charging,
+        "battery": battery,
+        "image_index": image_index,
+        "display_size": display_size,
+        "display_mode": display_mode,
+        "last_network_status": last_network_status,
+    }
+
+    _LOGGER.debug("Art Frame mfr data: %s, result: %s", mfr_data.hex(), result)
+
+    return result

pyswitchbot-0.76.0/switchbot/adv_parsers/keypad_vision.py

@@ -0,0 +1,79 @@
+"""Keypad Vision (Pro) device data parsers."""
+
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def process_common_mfr_data(mfr_data: bytes | None) -> dict[str, bool | int]:
+    """Process common Keypad Vision (Pro) manufacturer data."""
+    if mfr_data is None:
+        return {}
+
+    sequence_number = mfr_data[6]
+    battery_charging = bool(mfr_data[7] & 0b10000000)
+    battery = mfr_data[7] & 0b01111111
+    lockout_alarm = bool(mfr_data[8] & 0b00000001)
+    tamper_alarm = bool(mfr_data[8] & 0b00000010)
+    duress_alarm = bool(mfr_data[8] & 0b00000100)
+    low_temperature = bool(mfr_data[8] & 0b10000000)
+    high_temperature = bool(mfr_data[8] & 0b01000000)
+    doorbell = bool(mfr_data[12] & 0b00001000)
+
+    return {
+        "sequence_number": sequence_number,
+        "battery_charging": battery_charging,
+        "battery": battery,
+        "lockout_alarm": lockout_alarm,
+        "tamper_alarm": tamper_alarm,
+        "duress_alarm": duress_alarm,
+        "low_temperature": low_temperature,
+        "high_temperature": high_temperature,
+        "doorbell": doorbell,
+    }
+
+
+def process_keypad_vision(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, bool | int | str]:
+    """Process Keypad Vision data."""
+    result = process_common_mfr_data(mfr_data)
+
+    if not result:
+        return {}
+
+    pir_triggered_level = mfr_data[13] & 0x03
+
+    result.update(
+        {
+            "pir_triggered_level": pir_triggered_level,
+        }
+    )
+
+    _LOGGER.debug("Keypad Vision mfr data: %s, result: %s", mfr_data.hex(), result)
+
+    return result
+
+
+def process_keypad_vision_pro(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, bool | int | str]:
+    """Process Keypad Vision Pro data."""
+    result = process_common_mfr_data(mfr_data)
+
+    if not result:
+        return {}
+
+    radar_triggered_level = mfr_data[13] & 0x03
+    radar_triggered_distance = (mfr_data[13] >> 2) & 0x03
+
+    result.update(
+        {
+            "radar_triggered_level": radar_triggered_level,
+            "radar_triggered_distance": radar_triggered_distance,
+        }
+    )
+
+    _LOGGER.debug("Keypad Vision Pro mfr data: %s, result: %s", mfr_data.hex(), result)
+
+    return result

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/switchbot/adv_parsers/presence_sensor.py

@@ -21,15 +21,17 @@ def process_presence_sensor(
     motion_detected = bool(mfr_data[7] & 0x40)
     battery_bits = (mfr_data[7] >> 2) & 0x03
     battery_range = BATTERY_LEVEL_MAP.get(battery_bits, "Unknown")
+    duration = (mfr_data[8] << 8) + mfr_data[9]
     trigger_flag = mfr_data[10]
     led_state = bool(mfr_data[11] & 0x80)
-    light_level = mfr_data[11] & 0x0F
+    light_level = mfr_data[11] & 0x1F
 
     result = {
         "sequence_number": seq_number,
         "adaptive_state": adaptive_state,
         "motion_detected": motion_detected,
         "battery_range": battery_range,
+        "duration": duration,
         "trigger_flag": trigger_flag,
         "led_state": led_state,
         "lightLevel": light_level,

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/switchbot/const/__init__.py

@@ -102,6 +102,9 @@ class SwitchbotModel(StrEnum):
     SMART_THERMOSTAT_RADIATOR = "Smart Thermostat Radiator"
     S20_VACUUM = "S20 Vacuum"
     PRESENCE_SENSOR = "Presence Sensor"
+    ART_FRAME = "Art Frame"
+    KEYPAD_VISION = "Keypad Vision"
+    KEYPAD_VISION_PRO = "Keypad Vision Pro"
 
 
 __all__ = [

pyswitchbot-0.76.0/switchbot/devices/art_frame.py

@@ -0,0 +1,140 @@
+"""Device handler for the Art Frame."""
+
+import logging
+from typing import Any
+
+from bleak.backends.device import BLEDevice
+
+from ..const import SwitchbotModel
+from .device import (
+    SwitchbotEncryptedDevice,
+    SwitchbotSequenceDevice,
+    update_after_operation,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+COMMAND_SET_IMAGE = "570F7A02{}"
+
+
+class SwitchbotArtFrame(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
+    """Representation of a Switchbot Art Frame."""
+
+    def __init__(
+        self,
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        interface: int = 0,
+        model: SwitchbotModel = SwitchbotModel.ART_FRAME,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(device, key_id, encryption_key, model, interface, **kwargs)
+        self.response_flag = True
+
+    @classmethod
+    async def verify_encryption_key(
+        cls,
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        model: SwitchbotModel = SwitchbotModel.ART_FRAME,
+        **kwargs: Any,
+    ) -> bool:
+        return await super().verify_encryption_key(
+            device, key_id, encryption_key, model, **kwargs
+        )
+
+    async def get_basic_info(self) -> dict[str, Any] | None:
+        """Get device basic settings."""
+        if not (_data := await self._get_basic_info()):
+            return None
+        _LOGGER.debug("basic info data: %s", _data.hex())
+
+        battery_charging = bool(_data[1] & 0x80)
+        battery = _data[1] & 0x7F
+        firmware = _data[2] / 10.0
+        hardware = _data[3]
+        display_size = (_data[4] >> 4) & 0x0F
+        display_mode = (_data[4] >> 3) & 0x01
+        last_network_status = (_data[4] >> 2) & 0x01
+        current_image_index = _data[5]
+        total_num_of_images = _data[6]
+        all_images_index = [_data[x] for x in range(7, 7 + total_num_of_images)]
+
+        basic_info = {
+            "battery_charging": battery_charging,
+            "battery": battery,
+            "firmware": firmware,
+            "hardware": hardware,
+            "display_size": display_size,
+            "display_mode": display_mode,
+            "last_network_status": last_network_status,
+            "current_image_index": current_image_index,
+            "total_num_of_images": total_num_of_images,
+            "all_images_index": all_images_index,
+        }
+        _LOGGER.debug("Art Frame %s basic info: %s", self._device.address, basic_info)
+        return basic_info
+
+    def _select_image_index(self, offset: int) -> int:
+        """Select the image index based on the current index and offset."""
+        current_index = self.get_current_image_index()
+        all_images_index = self.get_all_images_index()
+
+        if not all_images_index or len(all_images_index) <= 1:
+            raise RuntimeError("No images available to select from.")
+
+        new_position = (all_images_index.index(current_index) + offset) % len(
+            all_images_index
+        )
+        return all_images_index[new_position]
+
+    async def _get_current_image_index(self) -> None:
+        """Validate the current image index."""
+        if not await self.get_basic_info():
+            raise RuntimeError("Failed to retrieve basic info for current image index.")
+
+    @update_after_operation
+    async def next_image(self) -> bool:
+        """Display the next image."""
+        await self._get_current_image_index()
+        idx = self._select_image_index(1)
+        result = await self._send_command(COMMAND_SET_IMAGE.format(f"{idx:02X}"))
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def prev_image(self) -> bool:
+        """Display the previous image."""
+        await self._get_current_image_index()
+        idx = self._select_image_index(-1)
+        result = await self._send_command(COMMAND_SET_IMAGE.format(f"{idx:02X}"))
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def set_image(self, index: int) -> bool:
+        """Set the image by index."""
+        await self._get_current_image_index()
+        total_images = self.get_total_images()
+
+        if index < 0 or index >= total_images:
+            raise ValueError(
+                f"Image index {index} is out of range. Total images: {total_images}."
+            )
+
+        all_images_index = self.get_all_images_index()
+        img_index = all_images_index[index]
+        result = await self._send_command(COMMAND_SET_IMAGE.format(f"{img_index:02X}"))
+        return self._check_command_result(result, 0, {1})
+
+    def get_all_images_index(self) -> list[int] | None:
+        """Return cached list of all image indexes."""
+        return self._get_adv_value("all_images_index")
+
+    def get_current_image_index(self) -> int | None:
+        """Return cached current image index."""
+        return self._get_adv_value("current_image_index")
+
+    def get_total_images(self) -> int | None:
+        """Return cached total number of images."""
+        return self._get_adv_value("total_num_of_images")

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/switchbot/devices/base_cover.py

@@ -43,19 +43,6 @@ class SwitchbotBaseCover(SwitchbotDevice):
         self._is_opening: bool = False
         self._is_closing: bool = False
 
-    async def _send_multiple_commands(self, keys: list[str]) -> bool:
-        """
-        Send multiple commands to device.
-
-        Since we current have no way to tell which command the device
-        needs we send both.
-        """
-        final_result = False
-        for key in keys:
-            result = await self._send_command(key)
-            final_result |= self._check_command_result(result, 0, {1})
-        return final_result
-
     @update_after_operation
     async def stop(self) -> bool:
         """Send stop command to device."""

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/switchbot/devices/base_light.py

@@ -119,19 +119,6 @@ class SwitchbotBaseLight(SwitchbotDevice):
             self._override_state({"effect": effect})
         return result
 
-    async def _send_multiple_commands(self, keys: list[str]) -> bool:
-        """
-        Send multiple commands to device.
-
-        Since we current have no way to tell which command the device
-        needs we send both.
-        """
-        final_result = False
-        for key in keys:
-            result = await self._send_command(key)
-            final_result |= self._check_command_result(result, 0, {1})
-        return final_result
-
     async def _get_multi_commands_results(
         self, commands: list[str]
     ) -> tuple[bytes, bytes] | None:

{pyswitchbot-0.74.0 → pyswitchbot-0.76.0}/switchbot/devices/device.py

@@ -104,6 +104,7 @@ API_MODEL_TO_ENUM: dict[str, SwitchbotModel] = {
     "W1104000": SwitchbotModel.PLUG_MINI_EU,
     "W1128000": SwitchbotModel.SMART_THERMOSTAT_RADIATOR,
     "W1111000": SwitchbotModel.CLIMATE_PANEL,
+    "W1130000": SwitchbotModel.ART_FRAME,
 }
 
 REQ_HEADER = "570f"
@@ -224,7 +225,6 @@ class SwitchbotBaseDevice:
         self._write_char: BleakGATTCharacteristic | None = None
         self._disconnect_timer: asyncio.TimerHandle | None = None
         self._expected_disconnect = False
-        self.loop = asyncio.get_event_loop()
         self._callbacks: list[Callable[[], None]] = []
         self._notify_future: asyncio.Future[bytearray] | None = None
         self._last_full_update: float = -PASSIVE_POLL_INTERVAL
@@ -546,7 +546,7 @@ class SwitchbotBaseDevice:
         """Reset disconnect timer."""
         self._cancel_disconnect_timer()
         self._expected_disconnect = False
-        self._disconnect_timer = self.loop.call_later(
+        self._disconnect_timer = asyncio.get_running_loop().call_later(
             DISCONNECT_DELAY, self._disconnect_from_timer
         )
 
@@ -679,15 +679,16 @@ class SwitchbotBaseDevice:
         assert self._client is not None
         assert self._read_char is not None
         assert self._write_char is not None
-        self._notify_future = self.loop.create_future()
+        loop = asyncio.get_running_loop()
+        self._notify_future = loop.create_future()
         client = self._client
 
         _LOGGER.debug("%s: Sending command: %s", self.name, key)
         await client.write_gatt_char(self._write_char, command, False)
 
         timeout = 5
-        timeout_handle = self.loop.call_at(
-            self.loop.time() + timeout, _handle_timeout, self._notify_future
+        timeout_handle = loop.call_at(
+            loop.time() + timeout, _handle_timeout, self._notify_future
         )
         timeout_expired = False
         try:
@@ -930,6 +931,32 @@ class SwitchbotDevice(SwitchbotBaseDevice):
         super().update_from_advertisement(advertisement)
         self._set_advertisement_data(advertisement)
 
+    async def _send_multiple_commands(self, keys: list[str]) -> bool:
+        """
+        Send multiple commands to device.
+
+        Returns True if any command succeeds. Used when we don't know
+        which command the device needs, so we send multiple and consider
+        it successful if any one works.
+        """
+        final_result = False
+        for key in keys:
+            result = await self._send_command(key)
+            final_result |= self._check_command_result(result, 0, {1})
+        return final_result
+
+    async def _send_command_sequence(self, keys: list[str]) -> bool:
+        """
+        Send a sequence of commands to device where all must succeed.
+
+        Returns True only if all commands succeed.
+        """
+        for key in keys:
+            result = await self._send_command(key)
+            if not self._check_command_result(result, 0, {1}):
+                return False
+        return True
+
 
 class SwitchbotEncryptedDevice(SwitchbotDevice):
     """A Switchbot device that uses encryption."""