PySwitchbot 0.75.0__tar.gz → 1.0.0__tar.gz

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

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

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

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

{pyswitchbot-0.75.0 → pyswitchbot-1.0.0}/PySwitchbot.egg-info/SOURCES.txt

@@ -32,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
@@ -70,9 +71,11 @@ 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
+switchbot/devices/meter_pro.py
 switchbot/devices/motion.py
 switchbot/devices/plug.py
 switchbot/devices/relay_switch.py
@@ -89,13 +92,16 @@ tests/test_ceiling_light.py
 tests/test_colormode_imports.py
 tests/test_curtain.py
 tests/test_device.py
+tests/test_discovery_callback.py
 tests/test_encrypted_device.py
 tests/test_evaporative_humidifier.py
 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_meter_pro.py
 tests/test_relay_switch.py
 tests/test_roller_shade.py
 tests/test_smart_thermostat_radiator.py

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

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

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

@@ -45,12 +45,14 @@ 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,
     SwitchbotStripLight3,
 )
 from .devices.lock import SwitchbotLock
+from .devices.meter_pro import SwitchbotMeterProCO2
 from .devices.plug import SwitchbotPlugMini
 from .devices.relay_switch import (
     SwitchbotGarageDoorOpener,
@@ -97,8 +99,10 @@ __all__ = [
     "SwitchbotFan",
     "SwitchbotGarageDoorOpener",
     "SwitchbotHumidifier",
+    "SwitchbotKeypadVision",
     "SwitchbotLightStrip",
     "SwitchbotLock",
+    "SwitchbotMeterProCO2",
     "SwitchbotModel",
     "SwitchbotModel",
     "SwitchbotOperationError",

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

@@ -26,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 (
@@ -730,6 +731,30 @@ SUPPORTED_TYPES: dict[str | bytes, SwitchbotSupportedType] = {
         "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-1.0.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.75.0 → pyswitchbot-1.0.0}/switchbot/const/__init__.py

@@ -103,6 +103,8 @@ class SwitchbotModel(StrEnum):
     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.75.0 → pyswitchbot-1.0.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.75.0 → pyswitchbot-1.0.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.75.0 → pyswitchbot-1.0.0}/switchbot/devices/device.py

@@ -8,6 +8,7 @@ import logging
 import time
 from collections.abc import Callable
 from dataclasses import replace
+from enum import IntEnum
 from typing import Any, TypeVar, cast
 from uuid import UUID
 
@@ -142,6 +143,21 @@ class SwitchbotOperationError(Exception):
     """Raised when an operation fails."""
 
 
+class AESMode(IntEnum):
+    """Supported AES modes for encrypted devices."""
+
+    CTR = 0
+    GCM = 1
+
+
+def _normalize_encryption_mode(mode: int) -> AESMode:
+    """Normalize encryption mode to AESMode (only 0/1 allowed)."""
+    try:
+        return AESMode(mode)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"Unsupported encryption mode: {mode}") from exc
+
+
 def _sb_uuid(comms_type: str = "service") -> UUID | str:
     """Return Switchbot UUID."""
     _uuid = {"tx": "002", "rx": "003", "service": "d00"}
@@ -931,6 +947,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."""
@@ -956,7 +998,8 @@ class SwitchbotEncryptedDevice(SwitchbotDevice):
         self._key_id = key_id
         self._encryption_key = bytearray.fromhex(encryption_key)
         self._iv: bytes | None = None
-        self._cipher: bytes | None = None
+        self._cipher: Cipher | None = None
+        self._encryption_mode: AESMode | None = None
         super().__init__(device, None, interface, **kwargs)
         self._model = model
 
@@ -1055,9 +1098,8 @@ class SwitchbotEncryptedDevice(SwitchbotDevice):
                 _LOGGER.error("Failed to initialize encryption")
                 return None
 
-            encrypted = (
-                key[:2] + self._key_id + self._iv[0:2].hex() + self._encrypt(key[2:])
-            )
+            ciphertext_hex, header_hex = self._encrypt(key[2:])
+            encrypted = key[:2] + self._key_id + header_hex + ciphertext_hex
             command = bytearray.fromhex(self._commandkey(encrypted))
             _LOGGER.debug("%s: Scheduling command %s", self.name, command.hex())
             max_attempts = retry + 1
@@ -1067,7 +1109,10 @@ class SwitchbotEncryptedDevice(SwitchbotDevice):
             )
             if result is None:
                 return None
-            return result[:1] + self._decrypt(result[4:])
+            decrypted = self._decrypt(result[4:])
+            if self._encryption_mode == AESMode.GCM:
+                self._increment_gcm_iv()
+            return result[:1] + decrypted
 
     async def _ensure_encryption_initialized(self) -> bool:
         """Ensure encryption is initialized, must be called with operation lock held."""
@@ -1091,34 +1136,71 @@ class SwitchbotEncryptedDevice(SwitchbotDevice):
             return False
 
         if ok := self._check_command_result(result, 0, {1}):
-            self._iv = result[4:]
+            _LOGGER.debug("%s: Encryption init response: %s", self.name, result.hex())
+            mode_byte = result[2] if len(result) > 2 else None
+            self._resolve_encryption_mode(mode_byte)
+            if self._encryption_mode == AESMode.GCM:
+                iv = result[4:-4]
+                expected_iv_len = 12
+            else:
+                iv = result[4:]
+                expected_iv_len = 16
+            if len(iv) != expected_iv_len:
+                _LOGGER.error(
+                    "%s: Invalid IV length %d for mode %s (expected %d)",
+                    self.name,
+                    len(iv),
+                    self._encryption_mode.name,
+                    expected_iv_len,
+                )
+                return False
+            self._iv = iv
             self._cipher = None  # Reset cipher when IV changes
             _LOGGER.debug("%s: Encryption initialized successfully", self.name)
 
         return ok
 
     async def _execute_disconnect(self) -> None:
+        """
+        Reset encryption state and disconnect.
+
+        Clears IV, cipher, and encryption mode so they can be
+        re-detected on the next connection (e.g., after firmware update).
+        """
         async with self._connect_lock:
             self._iv = None
             self._cipher = None
+            self._encryption_mode = None
             await self._execute_disconnect_with_lock()
 
     def _get_cipher(self) -> Cipher:
         if self._cipher is None:
             if self._iv is None:
                 raise RuntimeError("Cannot create cipher: IV is None")
-            self._cipher = Cipher(
-                algorithms.AES128(self._encryption_key), modes.CTR(self._iv)
-            )
+            if self._encryption_mode == AESMode.GCM:
+                self._cipher = Cipher(
+                    algorithms.AES128(self._encryption_key), modes.GCM(self._iv)
+                )
+            else:
+                self._cipher = Cipher(
+                    algorithms.AES128(self._encryption_key), modes.CTR(self._iv)
+                )
         return self._cipher
 
-    def _encrypt(self, data: str) -> str:
+    def _encrypt(self, data: str) -> tuple[str, str]:
         if len(data) == 0:
-            return ""
+            return "", ""
         if self._iv is None:
             raise RuntimeError("Cannot encrypt: IV is None")
         encryptor = self._get_cipher().encryptor()
-        return (encryptor.update(bytearray.fromhex(data)) + encryptor.finalize()).hex()
+        ciphertext = encryptor.update(bytearray.fromhex(data)) + encryptor.finalize()
+        if self._encryption_mode == AESMode.GCM:
+            header_hex = encryptor.tag[:2].hex()
+            # GCM cipher is single-use; clear it so _get_cipher() creates a fresh one
+            self._cipher = None
+        else:
+            header_hex = self._iv[0:2].hex()
+        return ciphertext.hex(), header_hex
 
     def _decrypt(self, data: bytearray) -> bytes:
         if len(data) == 0:
@@ -1131,9 +1213,40 @@ class SwitchbotEncryptedDevice(SwitchbotDevice):
                 )
                 return b""
             raise RuntimeError("Cannot decrypt: IV is None")
+        if self._encryption_mode == AESMode.GCM:
+            # Firmware only returns a 2-byte partial tag which can't be used for
+            # verification. Use a dummy 16-byte tag and skip finalize() since
+            # authentication is handled by the firmware.
+            decryptor = Cipher(
+                algorithms.AES128(self._encryption_key),
+                modes.GCM(self._iv, b"\x00" * 16),
+            ).decryptor()
+            return decryptor.update(data)
         decryptor = self._get_cipher().decryptor()
         return decryptor.update(data) + decryptor.finalize()
 
+    def _increment_gcm_iv(self) -> None:
+        """Increment GCM IV by 1 (big-endian). Called after each encrypted command."""
+        if self._iv is None:
+            raise RuntimeError("Cannot increment GCM IV: IV is None")
+        if len(self._iv) != 12:
+            raise RuntimeError("Cannot increment GCM IV: IV length is not 12 bytes")
+        iv_int = int.from_bytes(self._iv, "big") + 1
+        self._iv = iv_int.to_bytes(12, "big")
+        self._cipher = None
+
+    def _resolve_encryption_mode(self, mode_byte: int | None) -> None:
+        """Resolve encryption mode from device response when available."""
+        if mode_byte is None:
+            raise ValueError("Encryption mode byte is missing")
+        detected_mode = _normalize_encryption_mode(mode_byte)
+        if self._encryption_mode is not None and self._encryption_mode != detected_mode:
+            raise ValueError(
+                f"Conflicting encryption modes detected: {self._encryption_mode.name} vs {detected_mode.name}"
+            )
+        self._encryption_mode = detected_mode
+        _LOGGER.debug("%s: Detected encryption mode: %s", self.name, detected_mode.name)
+
 
 class SwitchbotDeviceOverrideStateDuringConnection(SwitchbotBaseDevice):
     """

pyswitchbot-1.0.0/switchbot/devices/keypad_vision.py

@@ -0,0 +1,167 @@
+"""Keypad Vision (Pro) device handling."""
+
+import logging
+import re
+from typing import Any
+
+from bleak.backends.device import BLEDevice
+
+from ..const import SwitchbotModel
+from .device import SwitchbotEncryptedDevice, SwitchbotSequenceDevice
+
+PASSWORD_RE = re.compile(r"^\d{6,12}$")
+COMMAND_GET_PASSWORD_COUNT = "570F530100"
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SwitchbotKeypadVision(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
+    """Representation of a Switchbot Keypad Vision (Pro) device."""
+
+    def __init__(
+        self,
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        model: SwitchbotModel,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize Keypad Vision (Pro) device."""
+        super().__init__(device, key_id, encryption_key, model, **kwargs)
+
+    @classmethod
+    async def verify_encryption_key(
+        cls,
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        model: SwitchbotModel,
+        **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("Raw model %s basic info data: %s", self._model, _data.hex())
+
+        battery = _data[1] & 0x7F
+        firmware = _data[2] / 10.0
+        hardware = _data[3]
+        support_fingerprint = _data[4]
+        lock_button_enabled = bool(_data[5] != 1)
+        tamper_alarm_enabled = bool(_data[9])
+        backlight_enabled = bool(_data[10] != 1)
+        backlight_level = _data[11]
+        prompt_tone_enabled = bool(_data[12] != 1)
+
+        if self._model == SwitchbotModel.KEYPAD_VISION:
+            battery_charging = bool((_data[14] & 0x06) >> 1)
+        else:
+            battery_charging = bool((_data[14] & 0x0E) >> 1)
+
+        result = {
+            "battery": battery,
+            "firmware": firmware,
+            "hardware": hardware,
+            "support_fingerprint": support_fingerprint,
+            "lock_button_enabled": lock_button_enabled,
+            "tamper_alarm_enabled": tamper_alarm_enabled,
+            "backlight_enabled": backlight_enabled,
+            "backlight_level": backlight_level,
+            "prompt_tone_enabled": prompt_tone_enabled,
+            "battery_charging": battery_charging,
+        }
+
+        _LOGGER.debug("%s basic info: %s", self._model, result)
+        return result
+
+    def _check_password_rules(self, password: str) -> None:
+        """Check if the password compliant with the rules."""
+        if not PASSWORD_RE.fullmatch(password):
+            raise ValueError("Password must be 6-12 digits.")
+
+    def _build_password_payload(self, password: str) -> bytes:
+        """Build password payload."""
+        pwd_bytes = bytes(int(ch) for ch in password)
+        pwd_length = len(pwd_bytes)
+
+        payload = bytearray()
+        payload.append(0xFF)
+        payload.append(0x00)
+        payload.append(pwd_length)
+        payload.extend(pwd_bytes)
+
+        return bytes(payload)
+
+    def _build_add_password_cmd(self, password: str) -> list[str]:
+        """Build command to add a password."""
+        cmd_header = bytes.fromhex("570F520202")
+
+        payload = self._build_password_payload(password)
+
+        max_payload = 11
+
+        chunks = [
+            payload[i : i + max_payload] for i in range(0, len(payload), max_payload)
+        ]
+        total = len(chunks)
+        cmds: list[str] = []
+
+        for idx, chunk in enumerate(chunks):
+            packet_info = ((total & 0x0F) << 4) | (idx & 0x0F)
+
+            cmd = bytearray()
+            cmd.extend(cmd_header)
+            cmd.append(packet_info)
+            cmd.extend(chunk)
+
+            cmds.append(cmd.hex().upper())
+
+        _LOGGER.debug(
+            "device: %s add password commands: %s", self._device.address, cmds
+        )
+
+        return cmds
+
+    async def add_password(self, password: str) -> bool:
+        """Add a password to the Keypad Vision (Pro)."""
+        self._check_password_rules(password)
+        cmds = self._build_add_password_cmd(password)
+        return await self._send_command_sequence(cmds)
+
+    async def get_password_count(self) -> dict[str, int] | None:
+        """Get the number of passwords stored in the Keypad Vision (Pro)."""
+        if not (_data := await self._send_command(COMMAND_GET_PASSWORD_COUNT)):
+            return None
+        _LOGGER.debug("Raw model %s password count data: %s", self._model, _data.hex())
+
+        pin = _data[1]
+        nfc = _data[2]
+        fingerprint = _data[3]
+        duress_pin = _data[4]
+        duress_fingerprint = _data[5]
+
+        result = {
+            "pin": pin,
+            "nfc": nfc,
+            "fingerprint": fingerprint,
+            "duress_pin": duress_pin,
+            "duress_fingerprint": duress_fingerprint,
+        }
+
+        if self._model == SwitchbotModel.KEYPAD_VISION_PRO:
+            face = _data[6]
+            palm_vein = _data[7]
+            result.update(
+                {
+                    "face": face,
+                    "palm_vein": palm_vein,
+                }
+            )
+
+        _LOGGER.debug("%s password count: %s", self._model, result)
+        return result