From d890b0a3acd0948bb8c82a47b8a58e3dac92d5e5 Mon Sep 17 00:00:00 2001 From: "Steven B." <51370195+sdb9696@users.noreply.github.com> Date: Thu, 19 Dec 2024 23:22:08 +0000 Subject: [PATCH] Add smartcam detection modules (#1389) - Motion detection - Person detection - Tamper detection - Baby Cry Detection --- kasa/smartcam/modules/__init__.py | 8 ++++ kasa/smartcam/modules/babycrydetection.py | 47 +++++++++++++++++++ kasa/smartcam/modules/motiondetection.py | 47 +++++++++++++++++++ kasa/smartcam/modules/persondetection.py | 47 +++++++++++++++++++ kasa/smartcam/modules/tamperdetection.py | 47 +++++++++++++++++++ kasa/smartcam/smartcammodule.py | 12 +++++ .../smartcam/modules/test_babycrydetection.py | 45 ++++++++++++++++++ .../smartcam/modules/test_motiondetection.py | 43 +++++++++++++++++ .../smartcam/modules/test_persondetection.py | 45 ++++++++++++++++++ .../smartcam/modules/test_tamperdetection.py | 45 ++++++++++++++++++ 10 files changed, 386 insertions(+) create mode 100644 kasa/smartcam/modules/babycrydetection.py create mode 100644 kasa/smartcam/modules/motiondetection.py create mode 100644 kasa/smartcam/modules/persondetection.py create mode 100644 kasa/smartcam/modules/tamperdetection.py create mode 100644 tests/smartcam/modules/test_babycrydetection.py create mode 100644 tests/smartcam/modules/test_motiondetection.py create mode 100644 tests/smartcam/modules/test_persondetection.py create mode 100644 tests/smartcam/modules/test_tamperdetection.py diff --git a/kasa/smartcam/modules/__init__.py b/kasa/smartcam/modules/__init__.py index fae5923f..3ea4bb6a 100644 --- a/kasa/smartcam/modules/__init__.py +++ b/kasa/smartcam/modules/__init__.py @@ -1,6 +1,7 @@ """Modules for SMARTCAM devices.""" from .alarm import Alarm +from .babycrydetection import BabyCryDetection from .camera import Camera from .childdevice import ChildDevice from .device import DeviceModule @@ -8,18 +9,25 @@ from .homekit import HomeKit from .led import Led from .lensmask import LensMask from .matter import Matter +from .motiondetection import MotionDetection from .pantilt import PanTilt +from .persondetection import PersonDetection +from .tamperdetection import TamperDetection from .time import Time __all__ = [ "Alarm", + "BabyCryDetection", "Camera", "ChildDevice", "DeviceModule", "Led", "PanTilt", + "PersonDetection", "Time", "HomeKit", "Matter", + "MotionDetection", "LensMask", + "TamperDetection", ] diff --git a/kasa/smartcam/modules/babycrydetection.py b/kasa/smartcam/modules/babycrydetection.py new file mode 100644 index 00000000..e9e32371 --- /dev/null +++ b/kasa/smartcam/modules/babycrydetection.py @@ -0,0 +1,47 @@ +"""Implementation of baby cry detection module.""" + +from __future__ import annotations + +import logging + +from ...feature import Feature +from ..smartcammodule import SmartCamModule + +_LOGGER = logging.getLogger(__name__) + + +class BabyCryDetection(SmartCamModule): + """Implementation of baby cry detection module.""" + + REQUIRED_COMPONENT = "babyCryDetection" + + QUERY_GETTER_NAME = "getBCDConfig" + QUERY_MODULE_NAME = "sound_detection" + QUERY_SECTION_NAMES = "bcd" + + def _initialize_features(self) -> None: + """Initialize features after the initial update.""" + self._add_feature( + Feature( + self._device, + id="baby_cry_detection", + name="Baby cry detection", + container=self, + attribute_getter="enabled", + attribute_setter="set_enabled", + type=Feature.Type.Switch, + category=Feature.Category.Primary, + ) + ) + + @property + def enabled(self) -> bool: + """Return the baby cry detection enabled state.""" + return self.data["bcd"]["enabled"] == "on" + + async def set_enabled(self, enable: bool) -> dict: + """Set the baby cry detection enabled state.""" + params = {"enabled": "on" if enable else "off"} + return await self._device._query_setter_helper( + "setBCDConfig", self.QUERY_MODULE_NAME, "bcd", params + ) diff --git a/kasa/smartcam/modules/motiondetection.py b/kasa/smartcam/modules/motiondetection.py new file mode 100644 index 00000000..33067bdf --- /dev/null +++ b/kasa/smartcam/modules/motiondetection.py @@ -0,0 +1,47 @@ +"""Implementation of motion detection module.""" + +from __future__ import annotations + +import logging + +from ...feature import Feature +from ..smartcammodule import SmartCamModule + +_LOGGER = logging.getLogger(__name__) + + +class MotionDetection(SmartCamModule): + """Implementation of motion detection module.""" + + REQUIRED_COMPONENT = "detection" + + QUERY_GETTER_NAME = "getDetectionConfig" + QUERY_MODULE_NAME = "motion_detection" + QUERY_SECTION_NAMES = "motion_det" + + def _initialize_features(self) -> None: + """Initialize features after the initial update.""" + self._add_feature( + Feature( + self._device, + id="motion_detection", + name="Motion detection", + container=self, + attribute_getter="enabled", + attribute_setter="set_enabled", + type=Feature.Type.Switch, + category=Feature.Category.Primary, + ) + ) + + @property + def enabled(self) -> bool: + """Return the motion detection enabled state.""" + return self.data["motion_det"]["enabled"] == "on" + + async def set_enabled(self, enable: bool) -> dict: + """Set the motion detection enabled state.""" + params = {"enabled": "on" if enable else "off"} + return await self._device._query_setter_helper( + "setDetectionConfig", self.QUERY_MODULE_NAME, "motion_det", params + ) diff --git a/kasa/smartcam/modules/persondetection.py b/kasa/smartcam/modules/persondetection.py new file mode 100644 index 00000000..641609d5 --- /dev/null +++ b/kasa/smartcam/modules/persondetection.py @@ -0,0 +1,47 @@ +"""Implementation of person detection module.""" + +from __future__ import annotations + +import logging + +from ...feature import Feature +from ..smartcammodule import SmartCamModule + +_LOGGER = logging.getLogger(__name__) + + +class PersonDetection(SmartCamModule): + """Implementation of person detection module.""" + + REQUIRED_COMPONENT = "personDetection" + + QUERY_GETTER_NAME = "getPersonDetectionConfig" + QUERY_MODULE_NAME = "people_detection" + QUERY_SECTION_NAMES = "detection" + + def _initialize_features(self) -> None: + """Initialize features after the initial update.""" + self._add_feature( + Feature( + self._device, + id="person_detection", + name="Person detection", + container=self, + attribute_getter="enabled", + attribute_setter="set_enabled", + type=Feature.Type.Switch, + category=Feature.Category.Primary, + ) + ) + + @property + def enabled(self) -> bool: + """Return the person detection enabled state.""" + return self.data["detection"]["enabled"] == "on" + + async def set_enabled(self, enable: bool) -> dict: + """Set the person detection enabled state.""" + params = {"enabled": "on" if enable else "off"} + return await self._device._query_setter_helper( + "setPersonDetectionConfig", self.QUERY_MODULE_NAME, "detection", params + ) diff --git a/kasa/smartcam/modules/tamperdetection.py b/kasa/smartcam/modules/tamperdetection.py new file mode 100644 index 00000000..32b352f7 --- /dev/null +++ b/kasa/smartcam/modules/tamperdetection.py @@ -0,0 +1,47 @@ +"""Implementation of tamper detection module.""" + +from __future__ import annotations + +import logging + +from ...feature import Feature +from ..smartcammodule import SmartCamModule + +_LOGGER = logging.getLogger(__name__) + + +class TamperDetection(SmartCamModule): + """Implementation of tamper detection module.""" + + REQUIRED_COMPONENT = "tamperDetection" + + QUERY_GETTER_NAME = "getTamperDetectionConfig" + QUERY_MODULE_NAME = "tamper_detection" + QUERY_SECTION_NAMES = "tamper_det" + + def _initialize_features(self) -> None: + """Initialize features after the initial update.""" + self._add_feature( + Feature( + self._device, + id="tamper_detection", + name="Tamper detection", + container=self, + attribute_getter="enabled", + attribute_setter="set_enabled", + type=Feature.Type.Switch, + category=Feature.Category.Primary, + ) + ) + + @property + def enabled(self) -> bool: + """Return the tamper detection enabled state.""" + return self.data["tamper_det"]["enabled"] == "on" + + async def set_enabled(self, enable: bool) -> dict: + """Set the tamper detection enabled state.""" + params = {"enabled": "on" if enable else "off"} + return await self._device._query_setter_helper( + "setTamperDetectionConfig", self.QUERY_MODULE_NAME, "tamper_det", params + ) diff --git a/kasa/smartcam/smartcammodule.py b/kasa/smartcam/smartcammodule.py index 39033597..467d18c0 100644 --- a/kasa/smartcam/smartcammodule.py +++ b/kasa/smartcam/smartcammodule.py @@ -20,6 +20,18 @@ class SmartCamModule(SmartModule): """Base class for SMARTCAM modules.""" SmartCamAlarm: Final[ModuleName[modules.Alarm]] = ModuleName("SmartCamAlarm") + SmartCamMotionDetection: Final[ModuleName[modules.MotionDetection]] = ModuleName( + "MotionDetection" + ) + SmartCamPersonDetection: Final[ModuleName[modules.PersonDetection]] = ModuleName( + "PersonDetection" + ) + SmartCamTamperDetection: Final[ModuleName[modules.TamperDetection]] = ModuleName( + "TamperDetection" + ) + SmartCamBabyCryDetection: Final[ModuleName[modules.BabyCryDetection]] = ModuleName( + "BabyCryDetection" + ) #: Module name to be queried QUERY_MODULE_NAME: str diff --git a/tests/smartcam/modules/test_babycrydetection.py b/tests/smartcam/modules/test_babycrydetection.py new file mode 100644 index 00000000..89ff5ac4 --- /dev/null +++ b/tests/smartcam/modules/test_babycrydetection.py @@ -0,0 +1,45 @@ +"""Tests for smartcam baby cry detection module.""" + +from __future__ import annotations + +from kasa import Device +from kasa.smartcam.smartcammodule import SmartCamModule + +from ...device_fixtures import parametrize + +babycrydetection = parametrize( + "has babycry detection", + component_filter="babyCryDetection", + protocol_filter={"SMARTCAM"}, +) + + +@babycrydetection +async def test_babycrydetection(dev: Device): + """Test device babycry detection.""" + babycry = dev.modules.get(SmartCamModule.SmartCamBabyCryDetection) + assert babycry + + bcde_feat = dev.features.get("baby_cry_detection") + assert bcde_feat + + original_enabled = babycry.enabled + + try: + await babycry.set_enabled(not original_enabled) + await dev.update() + assert babycry.enabled is not original_enabled + assert bcde_feat.value is not original_enabled + + await babycry.set_enabled(original_enabled) + await dev.update() + assert babycry.enabled is original_enabled + assert bcde_feat.value is original_enabled + + await bcde_feat.set_value(not original_enabled) + await dev.update() + assert babycry.enabled is not original_enabled + assert bcde_feat.value is not original_enabled + + finally: + await babycry.set_enabled(original_enabled) diff --git a/tests/smartcam/modules/test_motiondetection.py b/tests/smartcam/modules/test_motiondetection.py new file mode 100644 index 00000000..c4ff9807 --- /dev/null +++ b/tests/smartcam/modules/test_motiondetection.py @@ -0,0 +1,43 @@ +"""Tests for smartcam motion detection module.""" + +from __future__ import annotations + +from kasa import Device +from kasa.smartcam.smartcammodule import SmartCamModule + +from ...device_fixtures import parametrize + +motiondetection = parametrize( + "has motion detection", component_filter="detection", protocol_filter={"SMARTCAM"} +) + + +@motiondetection +async def test_motiondetection(dev: Device): + """Test device motion detection.""" + motion = dev.modules.get(SmartCamModule.SmartCamMotionDetection) + assert motion + + mde_feat = dev.features.get("motion_detection") + assert mde_feat + + original_enabled = motion.enabled + + try: + await motion.set_enabled(not original_enabled) + await dev.update() + assert motion.enabled is not original_enabled + assert mde_feat.value is not original_enabled + + await motion.set_enabled(original_enabled) + await dev.update() + assert motion.enabled is original_enabled + assert mde_feat.value is original_enabled + + await mde_feat.set_value(not original_enabled) + await dev.update() + assert motion.enabled is not original_enabled + assert mde_feat.value is not original_enabled + + finally: + await motion.set_enabled(original_enabled) diff --git a/tests/smartcam/modules/test_persondetection.py b/tests/smartcam/modules/test_persondetection.py new file mode 100644 index 00000000..34137587 --- /dev/null +++ b/tests/smartcam/modules/test_persondetection.py @@ -0,0 +1,45 @@ +"""Tests for smartcam person detection module.""" + +from __future__ import annotations + +from kasa import Device +from kasa.smartcam.smartcammodule import SmartCamModule + +from ...device_fixtures import parametrize + +persondetection = parametrize( + "has person detection", + component_filter="personDetection", + protocol_filter={"SMARTCAM"}, +) + + +@persondetection +async def test_persondetection(dev: Device): + """Test device person detection.""" + person = dev.modules.get(SmartCamModule.SmartCamPersonDetection) + assert person + + pde_feat = dev.features.get("person_detection") + assert pde_feat + + original_enabled = person.enabled + + try: + await person.set_enabled(not original_enabled) + await dev.update() + assert person.enabled is not original_enabled + assert pde_feat.value is not original_enabled + + await person.set_enabled(original_enabled) + await dev.update() + assert person.enabled is original_enabled + assert pde_feat.value is original_enabled + + await pde_feat.set_value(not original_enabled) + await dev.update() + assert person.enabled is not original_enabled + assert pde_feat.value is not original_enabled + + finally: + await person.set_enabled(original_enabled) diff --git a/tests/smartcam/modules/test_tamperdetection.py b/tests/smartcam/modules/test_tamperdetection.py new file mode 100644 index 00000000..ab2f851d --- /dev/null +++ b/tests/smartcam/modules/test_tamperdetection.py @@ -0,0 +1,45 @@ +"""Tests for smartcam tamper detection module.""" + +from __future__ import annotations + +from kasa import Device +from kasa.smartcam.smartcammodule import SmartCamModule + +from ...device_fixtures import parametrize + +tamperdetection = parametrize( + "has tamper detection", + component_filter="tamperDetection", + protocol_filter={"SMARTCAM"}, +) + + +@tamperdetection +async def test_tamperdetection(dev: Device): + """Test device tamper detection.""" + tamper = dev.modules.get(SmartCamModule.SmartCamTamperDetection) + assert tamper + + tde_feat = dev.features.get("tamper_detection") + assert tde_feat + + original_enabled = tamper.enabled + + try: + await tamper.set_enabled(not original_enabled) + await dev.update() + assert tamper.enabled is not original_enabled + assert tde_feat.value is not original_enabled + + await tamper.set_enabled(original_enabled) + await dev.update() + assert tamper.enabled is original_enabled + assert tde_feat.value is original_enabled + + await tde_feat.set_value(not original_enabled) + await dev.update() + assert tamper.enabled is not original_enabled + assert tde_feat.value is not original_enabled + + finally: + await tamper.set_enabled(original_enabled)