Change sensitivity_level to int

as the Scan will be sent a number for the level

Author: bouwew

plugwise_usb/nodes/scan.py

@@ -11,7 +11,6 @@
 
 from ..api import (
     MotionConfig,
-    MotionSensitivity,
     MotionState,
     NodeEvent,
     NodeFeature,
@@ -43,27 +42,32 @@
 
 # region Defaults for Scan Devices
 
+# Sensitivity values for motion sensor configuration
+HIGH: Final[str] = "HIGH"
+MEDIUM: Final[str] = "MEDIUM"
+OFF: Final[str] = "OFF"
+MOTION_SENSITIVITY: Final[dict] = {
+    HIGH: 20,  # 0x14
+    MEDIUM: 30,  # 0x1E
+    OFF: 255,  # 0xFF
+}
+
 DEFAULT_MOTION_STATE: Final = False
 
 # Time in minutes the motion sensor should not sense motion to
 # report "no motion" state [Source: 1min - 4uur]
 DEFAULT_RESET_TIMER: Final = 10
 
 # Default sensitivity of the motion sensors
-DEFAULT_SENSITIVITY: Final = MotionSensitivity.MEDIUM
+DEFAULT_SENSITIVITY = MOTION_SENSITIVITY(MEDIUM)
 
 # Light override
 DEFAULT_DAYLIGHT_MODE: Final = False
 
 # Default firmware if not known
 DEFAULT_FIRMWARE: Final = datetime(2010, 11, 4, 16, 58, 46, tzinfo=UTC)
 
-# Sensitivity values for motion sensor configuration
-SENSITIVITY_MAP: Final = {
-    MotionSensitivity.HIGH: 20,  # 0x14
-    MotionSensitivity.MEDIUM: 30,  # 0x1E
-    MotionSensitivity.OFF: 255,  # 0xFF
-}
+
 
 # Scan Features
 SCAN_FEATURES: Final = (
@@ -204,12 +208,12 @@ def _reset_timer_from_cache(self) -> int | None:
             return int(reset_timer)
         return None
 
-    def _sensitivity_level_from_cache(self) -> MotionSensitivity | None:
+    def _sensitivity_level_from_cache(self) -> str | None:
         """Load sensitivity level from cache."""
         if (
             sensitivity_level := self._get_cache(CACHE_SCAN_CONFIG_SENSITIVITY)
         ) is not None:
-            return MotionSensitivity[sensitivity_level]
+            return MOTION_SENSITIVITY(sensitivity_level)
         return None
 
     def _motion_config_dirty_from_cache(self) -> bool:
@@ -278,7 +282,7 @@ def reset_timer(self) -> int:
         return DEFAULT_RESET_TIMER
 
     @property
-    def sensitivity_level(self) -> MotionSensitivity:
+    def sensitivity_level(self) -> int:
         """Sensitivity level of motion sensor."""
         if self._motion_config.sensitivity_level is not None:
             return self._motion_config.sensitivity_level
@@ -330,7 +334,7 @@ async def set_motion_reset_timer(self, minutes: int) -> bool:
         await self._scan_configure_update()
         return True
 
-    async def set_motion_sensitivity_level(self, level: MotionSensitivity) -> bool:
+    async def set_motion_sensitivity_level(self, level: int) -> bool:
         """Configure the motion sensitivity level."""
         _LOGGER.debug(
             "set_motion_sensitivity_level | Device %s | %s -> %s",
@@ -445,14 +449,11 @@ async def _configure_scan_task(self) -> bool:
     async def scan_configure(self) -> bool:
         """Configure Scan device settings. Returns True if successful."""
         # Default to medium
-        sensitivity_value = SENSITIVITY_MAP.get(
-            self._motion_config.sensitivity_level, MotionSensitivity.MEDIUM
-        )
         request = ScanConfigureRequest(
             self._send,
             self._mac_in_bytes,
             self._motion_config.reset_timer,
-            sensitivity_value,
+            self._motion_config.sensitivity_value,
             self._motion_config.daylight_mode,
         )
         if (response := await request.send()) is None:
@@ -482,7 +483,7 @@ async def _scan_configure_update(self) -> None:
             CACHE_SCAN_CONFIG_RESET_TIMER, str(self._motion_config.reset_timer)
         )
         self._set_cache(
-            CACHE_SCAN_CONFIG_SENSITIVITY, self._motion_config.sensitivity_level.name
+            CACHE_SCAN_CONFIG_SENSITIVITY, self._motion_config.sensitivity_level
         )
         self._set_cache(
             CACHE_SCAN_CONFIG_DAYLIGHT_MODE, str(self._motion_config.daylight_mode)

tests/test_usb.py

@@ -1827,10 +1827,7 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
 
         with pytest.raises(pw_exceptions.NodeError):
             assert (
-                await test_node.set_motion_sensitivity_level(
-                    pw_api.MotionSensitivity.HIGH
-                )
-                is not None
+                await test_node.set_motion_sensitivity_level(20) is not None
             )
 
         with pytest.raises(pw_exceptions.NodeError):
@@ -1863,10 +1860,7 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
 
         with pytest.raises(pw_exceptions.FeatureError):
             assert (
-                await test_node.set_motion_sensitivity_level(
-                    pw_api.MotionSensitivity.HIGH
-                )
-                is not None
+                await test_node.set_motion_sensitivity_level(20) is not None
             )
 
         with pytest.raises(pw_exceptions.FeatureError):
@@ -1895,10 +1889,7 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
             assert await test_node.set_motion_daylight_mode(True) is not None
         with pytest.raises(NotImplementedError):
             assert (
-                await test_node.set_motion_sensitivity_level(
-                    pw_api.MotionSensitivity.HIGH
-                )
-                is not None
+                await test_node.set_motion_sensitivity_level(20) is not None
             )
         with pytest.raises(NotImplementedError):
             assert await test_node.set_motion_reset_timer(5) is not None
@@ -2117,25 +2108,25 @@ def fake_cache(dummy: object, setting: str) -> str | bool | None:  # noqa: PLR09
             if setting == pw_node.CACHE_NODE_INFO_TIMESTAMP:
                 return "2024-12-7-1-0-0"
             if setting == pw_sed.CACHE_SED_AWAKE_DURATION:
-                return "20"
+                return 20
             if setting == pw_sed.CACHE_SED_CLOCK_INTERVAL:
-                return "12600"
+                return 12600
             if setting == pw_sed.CACHE_SED_CLOCK_SYNC:
                 return True
             if setting == pw_sed.CACHE_SED_DIRTY:
                 return False
             if setting == pw_sed.CACHE_SED_MAINTENANCE_INTERVAL:
-                return "60"
+                return 60
             if setting == pw_sed.CACHE_SED_SLEEP_DURATION:
-                return "60"
+                return 60
             if setting == pw_scan.CACHE_SCAN_MOTION_STATE:
                 return False
             if setting == pw_scan.CACHE_SCAN_MOTION_TIMESTAMP:
                 return "2024-12-6-1-0-0"
             if setting == pw_scan.CACHE_SCAN_CONFIG_RESET_TIMER:
-                return "10"
+                return 10
             if setting == pw_scan.CACHE_SCAN_CONFIG_SENSITIVITY:
-                return "MEDIUM"
+                return 30
             if setting == pw_scan.CACHE_SCAN_CONFIG_DAYLIGHT_MODE:
                 return False
             if setting == pw_scan.CACHE_SCAN_CONFIG_DIRTY:
@@ -2237,17 +2228,14 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
         assert test_scan.motion_config.daylight_mode
 
         # test motion sensitivity level
-        assert test_scan.sensitivity_level == pw_api.MotionSensitivity.MEDIUM
+        assert test_scan.sensitivity_level == 30
         assert (
-            test_scan.motion_config.sensitivity_level == pw_api.MotionSensitivity.MEDIUM
+            test_scan.motion_config.sensitivity_level == 30
         )
-        assert not await test_scan.set_motion_sensitivity_level(
-            pw_api.MotionSensitivity.MEDIUM
+        assert not await test_scan.set_motion_sensitivity_level(30)
         )
         assert not test_scan.motion_config.dirty
-        assert await test_scan.set_motion_sensitivity_level(
-            pw_api.MotionSensitivity.HIGH
-        )
+        assert await test_scan.set_motion_sensitivity_level(20)
         assert test_scan.motion_config.dirty
         awake_response4 = pw_responses.NodeAwakeResponse()
         awake_response4.deserialize(
@@ -2259,10 +2247,8 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
         await test_scan._awake_response(awake_response4)  # pylint: disable=protected-access
         await asyncio.sleep(0.001)  # Ensure time for task to be executed
         assert not test_scan.motion_config.dirty
-        assert test_scan.sensitivity_level == pw_api.MotionSensitivity.HIGH
-        assert (
-            test_scan.motion_config.sensitivity_level == pw_api.MotionSensitivity.HIGH
-        )
+        assert test_scan.sensitivity_level == 20
+        assert test_scan.motion_config.sensitivity_level == 20
 
         # scan with cache enabled
         mock_stick_controller.send_response = None