wyzeapy 0.5.26__tar.gz → 0.5.27__tar.gz

{wyzeapy-0.5.26 → wyzeapy-0.5.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wyzeapy
-Version: 0.5.26
+Version: 0.5.27
 Summary: A library for interacting with Wyze devices
 License: GPL-3.0-only
 Author: Katie Mulliken
@@ -10,7 +10,6 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aiodns (>=3.2.0,<4.0.0)
-Requires-Dist: aiohttp (>=3.10.8,<4.0.0)
+Requires-Dist: aiohttp (>=3.11.12,<4.0.0)
 Requires-Dist: pycryptodome (>=3.21.0,<4.0.0)

{wyzeapy-0.5.26 → wyzeapy-0.5.27}/pyproject.toml

@@ -1,17 +1,17 @@
 [tool.poetry]
 name = "wyzeapy"
-version = "0.5.26"
+version = "0.5.27"
 description = "A library for interacting with Wyze devices"
 authors = ["Katie Mulliken <katie@mulliken.net>"]
 license = "GPL-3.0-only"
 
 [tool.poetry.dependencies]
 python = ">=3.11.0"
-aiohttp = "^3.10.8"
+aiohttp = "^3.11.12"
 aiodns = "^3.2.0"
 pycryptodome = "^3.21.0"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{wyzeapy-0.5.26 → wyzeapy-0.5.27}/src/wyzeapy/services/base_service.py

@@ -29,7 +29,7 @@ class BaseService:
     _devices: Optional[List[Device]] = None
     _last_updated_time: time = 0  # preload a value of 0 so that comparison will succeed on the first run
     _min_update_time = 1200  # lets let the device_params update every 20 minutes for now. This could probably reduced signicficantly.
-    _update_lock: asyncio.Lock() = asyncio.Lock()
+    _update_lock: asyncio.Lock = asyncio.Lock() # fmt: skip
     _update_manager: UpdateManager = UpdateManager()
     _update_loop = None
     _updater: DeviceUpdater = None
@@ -120,7 +120,6 @@ class BaseService:
                                                   json=payload)
 
         check_for_errors_standard(self, response_json)
-
         # Cache the devices so that update calls can pull more recent device_params
         BaseService._devices = [Device(device) for device in response_json['data']['device_list']]
 
@@ -166,7 +165,6 @@ class BaseService:
 
         check_for_errors_standard(self, response_json)
         properties = response_json['data']['property_list']
-
         property_list = []
         for prop in properties:
             try:

{wyzeapy-0.5.26 → wyzeapy-0.5.27}/src/wyzeapy/services/camera_service.py

@@ -32,6 +32,7 @@ class Camera(Device):
         self.on: bool = True
         self.siren: bool = False
         self.floodlight: bool = False
+        self.garage: bool = False
 
 
 class CameraService(BaseService):
@@ -76,8 +77,10 @@ class CameraService(BaseService):
                     camera.on = value == "1"
                 if property is PropertyIDs.CAMERA_SIREN:
                     camera.siren = value == "1"
-                if property is PropertyIDs.FLOOD_LIGHT:
+                if property is PropertyIDs.ACCESSORY:
                     camera.floodlight = value == "1"
+                    if camera.device_params["dongle_product_model"] == "HL_CGDC":
+                        camera.garage = value == "1" # 1 = open, 2 = closed by automation or smart platform (Alexa, Google Home, Rules), 0 = closed by app
                 if property is PropertyIDs.NOTIFICATION:
                     camera.notify = value == "1"
                 if property is PropertyIDs.MOTION_DETECTION:
@@ -139,14 +142,21 @@ class CameraService(BaseService):
     async def floodlight_on(self, camera: Camera):
         if (camera.product_model == "AN_RSCW"): await self._run_action_devicemgmt(camera, "spotlight", "1") # Battery cam pro integrated spotlight is controllable
         elif (camera.product_model in DEVICEMGMT_API_MODELS): await self._run_action_devicemgmt(camera, "floodlight", "1") # Some camera models use a diffrent api
-        else: await self._set_property(camera, PropertyIDs.FLOOD_LIGHT.value, "1")
+        else: await self._set_property(camera, PropertyIDs.ACCESSORY.value, "1")
 
     # Also controls lamp socket and BCP spotlight
     async def floodlight_off(self, camera: Camera):
         if (camera.product_model == "AN_RSCW"): await self._run_action_devicemgmt(camera, "spotlight", "0") # Battery cam pro integrated spotlight is controllable
         elif (camera.product_model in DEVICEMGMT_API_MODELS): await self._run_action_devicemgmt(camera, "floodlight", "0") # Some camera models use a diffrent api
-        else: await self._set_property(camera, PropertyIDs.FLOOD_LIGHT.value, "2")
-        
+        else: await self._set_property(camera, PropertyIDs.ACCESSORY.value, "2")
+
+    # Garage door trigger uses run action on all models
+    async def garage_door_open(self, camera: Camera):
+        await self._run_action(camera, "garage_door_trigger")
+    
+    async def garage_door_close(self, camera: Camera):
+        await self._run_action(camera, "garage_door_trigger")
+
     async def turn_on_notifications(self, camera: Camera):
         if (camera.product_model in DEVICEMGMT_API_MODELS): await self._set_toggle(camera, DeviceMgmtToggleProps.NOTIFICATION_TOGGLE.value, "1")
         else: await self._set_property(camera, PropertyIDs.NOTIFICATION.value, "1")

wyzeapy-0.5.27/src/wyzeapy/tests/test_bulb_service.py

@@ -0,0 +1,135 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+from wyzeapy.services.bulb_service import BulbService, Bulb
+from wyzeapy.types import DeviceTypes, PropertyIDs
+
+
+class TestBulbService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        mock_auth_lib = MagicMock()
+        self.bulb_service = BulbService(auth_lib=mock_auth_lib)
+        self.bulb_service._get_property_list = AsyncMock()
+        self.bulb_service.get_updated_params = AsyncMock()
+
+    async def test_update_bulb_basic_properties(self):
+        mock_bulb = Bulb({
+            "device_type": "Light",
+            "product_model": "WLPA19",
+            "mac": "TEST123",
+            "raw_dict": {},
+            "device_params": {"ip": "192.168.1.100"},
+            "prop_map": {},
+            'product_type': DeviceTypes.MESH_LIGHT.value
+        })
+
+        # Mock the property list response
+        self.bulb_service._get_property_list.return_value = [
+            (PropertyIDs.BRIGHTNESS, "75"),
+            (PropertyIDs.COLOR_TEMP, "4000"),
+            (PropertyIDs.ON, "1"),
+            (PropertyIDs.AVAILABLE, "1")
+        ]
+
+        updated_bulb = await self.bulb_service.update(mock_bulb)
+
+        self.assertEqual(updated_bulb.brightness, 75)
+        self.assertEqual(updated_bulb.color_temp, 4000)
+        self.assertTrue(updated_bulb.on)
+        self.assertTrue(updated_bulb.available)
+
+    async def test_update_bulb_lightstrip_properties(self):
+        mock_bulb = Bulb({
+            "device_type": "Light",
+            "product_model": "WLST19",
+            "mac": "TEST456",
+            "raw_dict": {},
+            "device_params": {"ip": "192.168.1.101"},
+            "prop_map": {},
+            'product_type': DeviceTypes.LIGHTSTRIP.value
+        })
+        mock_bulb.product_type = DeviceTypes.LIGHTSTRIP
+
+        # Mock the property list response with the corrected color format (no # symbol)
+        self.bulb_service._get_property_list.return_value = [
+            (PropertyIDs.COLOR, "FF0000"),  # Removed the # symbol
+            (PropertyIDs.COLOR_MODE, "1"),
+            (PropertyIDs.LIGHTSTRIP_EFFECTS, "rainbow"),
+            (PropertyIDs.LIGHTSTRIP_MUSIC_MODE, "1"),
+            (PropertyIDs.ON, "1"),
+            (PropertyIDs.AVAILABLE, "1")
+        ]
+
+        updated_bulb = await self.bulb_service.update(mock_bulb)
+
+        self.assertEqual(updated_bulb.color, "FF0000")
+        self.assertEqual(updated_bulb.color_mode, "1")
+        self.assertEqual(updated_bulb.effects, "rainbow")
+        self.assertTrue(updated_bulb.music_mode)
+        self.assertTrue(updated_bulb.on)
+        self.assertTrue(updated_bulb.available)
+
+    async def test_update_bulb_sun_match(self):
+        mock_bulb = Bulb({
+            "device_type": "Light",
+            "product_model": "WLPA19",
+            "mac": "TEST789",
+            "raw_dict": {},
+            "device_params": {"ip": "192.168.1.102"},
+            "prop_map": {},
+            'product_type': DeviceTypes.MESH_LIGHT.value
+        })
+
+        # Mock the property list response
+        self.bulb_service._get_property_list.return_value = [
+            (PropertyIDs.SUN_MATCH, "1"),
+            (PropertyIDs.ON, "1"),
+            (PropertyIDs.AVAILABLE, "1")
+        ]
+
+        updated_bulb = await self.bulb_service.update(mock_bulb)
+
+        self.assertTrue(updated_bulb.sun_match)
+        self.assertTrue(updated_bulb.on)
+        self.assertTrue(updated_bulb.available)
+
+    async def test_update_bulb_invalid_color_temp(self):
+        mock_bulb = Bulb({
+            "device_type": "Light",
+            "product_model": "WLPA19",
+            "mac": "TEST101",
+            "raw_dict": {},
+            "device_params": {"ip": "192.168.1.103"},
+            "prop_map": {},
+            'product_type': DeviceTypes.MESH_LIGHT.value
+        })
+
+        # Mock the property list response with invalid color temp
+        self.bulb_service._get_property_list.return_value = [
+            (PropertyIDs.COLOR_TEMP, "invalid"),
+            (PropertyIDs.ON, "1")
+        ]
+
+        updated_bulb = await self.bulb_service.update(mock_bulb)
+
+        # Should default to 2700K when invalid
+        self.assertEqual(updated_bulb.color_temp, 2700)
+        self.assertTrue(updated_bulb.on)
+
+    async def test_get_bulbs(self):
+        mock_device = MagicMock()
+        mock_device.type = DeviceTypes.LIGHT
+        mock_device.raw_dict = {
+            "device_type": "Light",
+            "product_model": "WLPA19",
+            "device_params": {"ip": "192.168.1.104"},
+            "prop_map": {},
+            'product_type': DeviceTypes.MESH_LIGHT.value
+        }
+
+        self.bulb_service.get_object_list = AsyncMock(return_value=[mock_device])
+
+        bulbs = await self.bulb_service.get_bulbs()
+
+        self.assertEqual(len(bulbs), 1)
+        self.assertIsInstance(bulbs[0], Bulb)
+        self.bulb_service.get_object_list.assert_awaited_once()

wyzeapy-0.5.27/src/wyzeapy/tests/test_camera_service.py

@@ -0,0 +1,180 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+from wyzeapy.services.camera_service import CameraService, Camera, DEVICEMGMT_API_MODELS
+from wyzeapy.types import DeviceTypes, PropertyIDs, Event
+from wyzeapy.wyze_auth_lib import WyzeAuthLib
+
+
+class TestCameraService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
+        self.camera_service = CameraService(auth_lib=self.mock_auth_lib)
+        self.camera_service._get_property_list = AsyncMock()
+        self.camera_service._get_event_list = AsyncMock()
+        self.camera_service._run_action = AsyncMock()
+        self.camera_service._run_action_devicemgmt = AsyncMock()
+        self.camera_service._set_property = AsyncMock()
+        self.camera_service._set_property_list = AsyncMock()
+        self.camera_service._set_toggle = AsyncMock()
+        self.camera_service.get_updated_params = AsyncMock()
+
+        # Create a test camera
+        self.test_camera = Camera({
+            "device_type": DeviceTypes.CAMERA.value,
+            "product_model": "WYZEC1",
+            "mac": "TEST123",
+            "nickname": "Test Camera",
+            "device_params": {"ip": "192.168.1.100"},
+            "raw_dict": {}
+        })
+
+    async def test_update_legacy_camera(self):
+        # Mock responses
+        self.camera_service._get_event_list.return_value = {
+            'data': {
+                'event_list': [{
+                    'event_ts': 1234567890,
+                    'device_mac': 'TEST123',
+                    'event_type': 'motion'
+                }]
+            }
+        }
+        
+        self.camera_service._get_property_list.return_value = [
+            (PropertyIDs.AVAILABLE, "1"),
+            (PropertyIDs.ON, "1"),
+            (PropertyIDs.CAMERA_SIREN, "0"),
+            (PropertyIDs.ACCESSORY, "0"),
+            (PropertyIDs.NOTIFICATION, "1"),
+            (PropertyIDs.MOTION_DETECTION, "1")
+        ]
+
+        updated_camera = await self.camera_service.update(self.test_camera)
+
+        self.assertTrue(updated_camera.available)
+        self.assertTrue(updated_camera.on)
+        self.assertFalse(updated_camera.siren)
+        self.assertFalse(updated_camera.floodlight)
+        self.assertTrue(updated_camera.notify)
+        self.assertTrue(updated_camera.motion)
+        self.assertIsNotNone(updated_camera.last_event)
+        self.assertEqual(updated_camera.last_event_ts, 1234567890)
+
+    async def test_update_devicemgmt_camera(self):
+        # Create a test camera using new API model
+        devicemgmt_camera = Camera({
+            "device_type": DeviceTypes.CAMERA.value,
+            "product_model": "LD_CFP",  # Floodlight pro model
+            "mac": "TEST456",
+            "nickname": "Test DeviceMgmt Camera",
+            "device_params": {"ip": "192.168.1.101"},
+            "raw_dict": {}
+        })
+
+        self.camera_service._get_iot_prop_devicemgmt = AsyncMock(return_value={
+            'data': {
+                'capabilities': [
+                    {
+                        'name': 'camera',
+                        'properties': {'motion-detect-recording': True}
+                    },
+                    {
+                        'name': 'floodlight',
+                        'properties': {'on': True}
+                    },
+                    {
+                        'name': 'siren',
+                        'properties': {'state': True}
+                    },
+                    {
+                        'name': 'iot-device',
+                        'properties': {
+                            'push-switch': True,
+                            'iot-power': True,
+                            'iot-state': True
+                        }
+                    }
+                ]
+            }
+        })
+
+        updated_camera = await self.camera_service.update(devicemgmt_camera)
+
+        self.assertTrue(updated_camera.available)
+        self.assertTrue(updated_camera.on)
+        self.assertTrue(updated_camera.siren)
+        self.assertTrue(updated_camera.floodlight)
+        self.assertTrue(updated_camera.notify)
+        self.assertTrue(updated_camera.motion)
+
+    async def test_turn_on_off_legacy_camera(self):
+        await self.camera_service.turn_on(self.test_camera)
+        self.camera_service._run_action.assert_awaited_with(self.test_camera, "power_on")
+
+        await self.camera_service.turn_off(self.test_camera)
+        self.camera_service._run_action.assert_awaited_with(self.test_camera, "power_off")
+
+    async def test_siren_control_legacy_camera(self):
+        await self.camera_service.siren_on(self.test_camera)
+        self.camera_service._run_action.assert_awaited_with(self.test_camera, "siren_on")
+
+        await self.camera_service.siren_off(self.test_camera)
+        self.camera_service._run_action.assert_awaited_with(self.test_camera, "siren_off")
+
+    async def test_floodlight_control_legacy_camera(self):
+        await self.camera_service.floodlight_on(self.test_camera)
+        self.camera_service._set_property.assert_awaited_with(
+            self.test_camera, 
+            PropertyIDs.ACCESSORY.value, 
+            "1"
+        )
+
+        await self.camera_service.floodlight_off(self.test_camera)
+        self.camera_service._set_property.assert_awaited_with(
+            self.test_camera, 
+            PropertyIDs.ACCESSORY.value, 
+            "2"
+        )
+
+    async def test_notification_control_legacy_camera(self):
+        await self.camera_service.turn_on_notifications(self.test_camera)
+        self.camera_service._set_property.assert_awaited_with(
+            self.test_camera,
+            PropertyIDs.NOTIFICATION.value,
+            "1"
+        )
+
+        await self.camera_service.turn_off_notifications(self.test_camera)
+        self.camera_service._set_property.assert_awaited_with(
+            self.test_camera,
+            PropertyIDs.NOTIFICATION.value,
+            "0"
+        )
+
+    async def test_motion_detection_control_legacy_camera(self):
+        await self.camera_service.turn_on_motion_detection(self.test_camera)
+        self.camera_service._set_property.assert_any_await(
+            self.test_camera,
+            PropertyIDs.MOTION_DETECTION.value,
+            "1"
+        )
+        self.camera_service._set_property.assert_any_await(
+            self.test_camera,
+            PropertyIDs.MOTION_DETECTION_TOGGLE.value,
+            "1"
+        )
+
+        await self.camera_service.turn_off_motion_detection(self.test_camera)
+        self.camera_service._set_property.assert_any_await(
+            self.test_camera,
+            PropertyIDs.MOTION_DETECTION.value,
+            "0"
+        )
+        self.camera_service._set_property.assert_any_await(
+            self.test_camera,
+            PropertyIDs.MOTION_DETECTION_TOGGLE.value,
+            "0"
+        )
+
+if __name__ == '__main__':
+    unittest.main() 

wyzeapy-0.5.27/src/wyzeapy/tests/test_hms_service.py

@@ -0,0 +1,90 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+from wyzeapy.services.hms_service import HMSService, HMSMode
+from wyzeapy.wyze_auth_lib import WyzeAuthLib
+
+class TestHMSService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
+        self.hms_service = await HMSService.create(self.mock_auth_lib)
+        self.hms_service._get_plan_binding_list_by_user = AsyncMock()
+        self.hms_service._monitoring_profile_state_status = AsyncMock()
+        self.hms_service._monitoring_profile_active = AsyncMock()
+        self.hms_service._disable_reme_alarm = AsyncMock()
+
+    async def test_update_changing_mode(self):
+        self.hms_service._monitoring_profile_state_status.return_value = {'message': 'changing'}
+
+        mode = await self.hms_service.update('test_hms_id')
+        self.assertEqual(mode, HMSMode.CHANGING)
+
+    async def test_update_disarmed_mode(self):
+        self.hms_service._monitoring_profile_state_status.return_value = {'message': 'disarm'}
+
+        mode = await self.hms_service.update('test_hms_id')
+        self.assertEqual(mode, HMSMode.DISARMED)
+
+    async def test_update_away_mode(self):
+        self.hms_service._monitoring_profile_state_status.return_value = {'message': 'away'}
+
+        mode = await self.hms_service.update('test_hms_id')
+        self.assertEqual(mode, HMSMode.AWAY)
+
+    async def test_update_home_mode(self):
+        self.hms_service._monitoring_profile_state_status.return_value = {'message': 'home'}
+
+        mode = await self.hms_service.update('test_hms_id')
+        self.assertEqual(mode, HMSMode.HOME)
+
+    async def test_set_mode_disarmed(self):
+        self.hms_service._hms_id = 'test_hms_id'
+
+        await self.hms_service.set_mode(HMSMode.DISARMED)
+
+        self.hms_service._disable_reme_alarm.assert_awaited_with('test_hms_id')
+        self.hms_service._monitoring_profile_active.assert_awaited_with('test_hms_id', 0, 0)
+
+    async def test_set_mode_away(self):
+        self.hms_service._hms_id = 'test_hms_id'
+
+        await self.hms_service.set_mode(HMSMode.AWAY)
+
+        self.hms_service._monitoring_profile_active.assert_awaited_with('test_hms_id', 0, 1)
+
+    async def test_set_mode_home(self):
+        self.hms_service._hms_id = 'test_hms_id'
+
+        await self.hms_service.set_mode(HMSMode.HOME)
+
+        self.hms_service._monitoring_profile_active.assert_awaited_with('test_hms_id', 1, 0)
+
+    async def test_get_hms_id_with_existing_id(self):
+        self.hms_service._hms_id = 'existing_hms_id'
+        hms_id = await self.hms_service._get_hms_id()
+        self.assertEqual(hms_id, 'existing_hms_id')
+
+    async def test_get_hms_id_with_no_hms(self):
+        self.hms_service._hms_id = None
+        self.hms_service._get_plan_binding_list_by_user.return_value = {'data': []}
+
+        hms_id = await self.hms_service._get_hms_id()
+        self.assertIsNone(hms_id)
+
+    async def test_get_hms_id_finds_id(self):
+        self.hms_service._hms_id = None
+        self.hms_service._get_plan_binding_list_by_user.return_value = {
+            'data': [
+                {
+                    'deviceList': [
+                        {'device_id': 'found_hms_id'}
+                    ]
+                }
+            ]
+        }
+
+        hms_id = await self.hms_service._get_hms_id()
+        self.assertEqual(hms_id, 'found_hms_id')
+        self.assertEqual(self.hms_service._hms_id, 'found_hms_id')
+
+if __name__ == '__main__':
+    unittest.main() 

wyzeapy-0.5.27/src/wyzeapy/tests/test_lock_service.py

@@ -0,0 +1,114 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+from wyzeapy.services.lock_service import LockService, Lock
+from wyzeapy.types import DeviceTypes
+from wyzeapy.exceptions import UnknownApiError
+
+class TestLockService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        mock_auth_lib = MagicMock()
+        self.lock_service = LockService(auth_lib=mock_auth_lib)
+        self.lock_service._get_lock_info = AsyncMock()
+        self.lock_service._lock_control = AsyncMock()
+
+    async def test_update_lock_online(self):
+        mock_lock = Lock({
+            "device_type": "Lock",
+            "onoff_line": 1,
+            "door_open_status": 0,
+            "trash_mode": 0,
+            "locker_status": {"hardlock": 2},
+            "raw_dict": {}
+        })
+        self.lock_service._get_lock_info.return_value = {
+            "device": {
+                "onoff_line": 1,
+                "door_open_status": 0,
+                "trash_mode": 0,
+                "locker_status": {"hardlock": 2},
+            }
+        }
+
+        updated_lock = await self.lock_service.update(mock_lock)
+
+        self.assertTrue(updated_lock.available)
+        self.assertFalse(updated_lock.door_open)
+        self.assertFalse(updated_lock.trash_mode)
+        self.assertTrue(updated_lock.unlocked)
+        self.assertFalse(updated_lock.unlocking)
+        self.assertFalse(updated_lock.locking)
+        self.lock_service._get_lock_info.assert_awaited_once_with(mock_lock)
+
+    async def test_update_lock_offline(self):
+        mock_lock = Lock({
+            "device_type": "Lock",
+            "onoff_line": 0,
+            "door_open_status": 1,
+            "trash_mode": 1,
+            "locker_status": {"hardlock": 1},
+            "raw_dict": {}
+        })
+        self.lock_service._get_lock_info.return_value = {
+            "device": {
+                "onoff_line": 0,
+                "door_open_status": 1,
+                "trash_mode": 1,
+                "locker_status": {"hardlock": 1},
+            }
+        }
+
+        updated_lock = await self.lock_service.update(mock_lock)
+
+        self.assertFalse(updated_lock.available)
+        self.assertTrue(updated_lock.door_open)
+        self.assertTrue(updated_lock.trash_mode)
+        self.assertFalse(updated_lock.unlocked)
+        self.assertFalse(updated_lock.unlocking)
+        self.assertFalse(updated_lock.locking)
+        self.lock_service._get_lock_info.assert_awaited_once_with(mock_lock)
+
+    async def test_get_locks(self):
+        mock_device = AsyncMock()
+        mock_device.type = DeviceTypes.LOCK
+        mock_device.raw_dict = {"device_type": "Lock"}
+
+        self.lock_service.get_object_list = AsyncMock(return_value=[mock_device])
+
+        locks = await self.lock_service.get_locks()
+
+        self.assertEqual(len(locks), 1)
+        self.assertIsInstance(locks[0], Lock)
+        self.lock_service.get_object_list.assert_awaited_once()
+
+    async def test_lock(self):
+        mock_lock = Lock({
+            "device_type": "Lock",
+            "raw_dict": {}
+        })
+
+        await self.lock_service.lock(mock_lock)
+        self.lock_service._lock_control.assert_awaited_with(mock_lock, "remoteLock")
+
+    async def test_unlock(self):
+        mock_lock = Lock({
+            "device_type": "Lock",
+            "raw_dict": {}
+        })
+
+        await self.lock_service.unlock(mock_lock)
+        self.lock_service._lock_control.assert_awaited_with(mock_lock, "remoteUnlock")
+
+    async def test_lock_control_error_handling(self):
+        mock_lock = Lock({
+            "device_type": "Lock",
+            "raw_dict": {}
+        })
+        self.lock_service._lock_control.side_effect = UnknownApiError("Failed to lock/unlock")
+
+        with self.assertRaises(UnknownApiError):
+            await self.lock_service.lock(mock_lock)
+
+        with self.assertRaises(UnknownApiError):
+            await self.lock_service.unlock(mock_lock)
+
+# ... other test cases ... 

wyzeapy-0.5.27/src/wyzeapy/tests/test_sensor_service.py

@@ -0,0 +1,159 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+from wyzeapy.services.sensor_service import SensorService, Sensor
+from wyzeapy.types import DeviceTypes, PropertyIDs
+from wyzeapy.wyze_auth_lib import WyzeAuthLib
+
+
+class TestSensorService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
+        self.sensor_service = SensorService(auth_lib=self.mock_auth_lib)
+        self.sensor_service._get_device_info = AsyncMock()
+        self.sensor_service.get_updated_params = AsyncMock()
+        self.sensor_service.get_object_list = AsyncMock()
+        
+        # Reset the class-level subscribers list
+        self.sensor_service._subscribers = []
+
+        # Create test sensors
+        self.motion_sensor = Sensor({
+            "device_type": DeviceTypes.MOTION_SENSOR.value,
+            "product_model": "PIR3U",
+            "mac": "MOTION123",
+            "nickname": "Test Motion Sensor",
+            "device_params": {"ip": "192.168.1.100"},
+            "raw_dict": {}
+        })
+
+        self.contact_sensor = Sensor({
+            "device_type": DeviceTypes.CONTACT_SENSOR.value,
+            "product_model": "DWS3U",
+            "mac": "CONTACT456",
+            "nickname": "Test Contact Sensor",
+            "device_params": {"ip": "192.168.1.101"},
+            "raw_dict": {}
+        })
+
+    async def test_update_motion_sensor_detected(self):
+        self.sensor_service._get_device_info.return_value = {
+            'data': {
+                'property_list': [
+                    {
+                        'pid': PropertyIDs.MOTION_STATE.value,
+                        'value': '1'
+                    }
+                ]
+            }
+        }
+
+        updated_sensor = await self.sensor_service.update(self.motion_sensor)
+        self.assertTrue(updated_sensor.detected)
+
+    async def test_update_motion_sensor_not_detected(self):
+        self.sensor_service._get_device_info.return_value = {
+            'data': {
+                'property_list': [
+                    {
+                        'pid': PropertyIDs.MOTION_STATE.value,
+                        'value': '0'
+                    }
+                ]
+            }
+        }
+
+        updated_sensor = await self.sensor_service.update(self.motion_sensor)
+        self.assertFalse(updated_sensor.detected)
+
+    async def test_update_contact_sensor_detected(self):
+        self.sensor_service._get_device_info.return_value = {
+            'data': {
+                'property_list': [
+                    {
+                        'pid': PropertyIDs.CONTACT_STATE.value,
+                        'value': '1'
+                    }
+                ]
+            }
+        }
+
+        updated_sensor = await self.sensor_service.update(self.contact_sensor)
+        self.assertTrue(updated_sensor.detected)
+
+    async def test_update_contact_sensor_not_detected(self):
+        self.sensor_service._get_device_info.return_value = {
+            'data': {
+                'property_list': [
+                    {
+                        'pid': PropertyIDs.CONTACT_STATE.value,
+                        'value': '0'
+                    }
+                ]
+            }
+        }
+
+        updated_sensor = await self.sensor_service.update(self.contact_sensor)
+        self.assertFalse(updated_sensor.detected)
+
+    async def test_get_sensors(self):
+        mock_motion_device = MagicMock()
+        mock_motion_device.type = DeviceTypes.MOTION_SENSOR
+        mock_motion_device.raw_dict = {
+            "device_type": DeviceTypes.MOTION_SENSOR.value,
+            "product_model": "PIR3U",
+            "mac": "MOTION123"
+        }
+
+        mock_contact_device = MagicMock()
+        mock_contact_device.type = DeviceTypes.CONTACT_SENSOR
+        mock_contact_device.raw_dict = {
+            "device_type": DeviceTypes.CONTACT_SENSOR.value,
+            "product_model": "DWS3U",
+            "mac": "CONTACT456"
+        }
+
+        self.sensor_service.get_object_list.return_value = [
+            mock_motion_device,
+            mock_contact_device
+        ]
+
+        sensors = await self.sensor_service.get_sensors()
+        
+        self.assertEqual(len(sensors), 2)
+        self.assertIsInstance(sensors[0], Sensor)
+        self.assertIsInstance(sensors[1], Sensor)
+        self.sensor_service.get_object_list.assert_awaited_once()
+
+    async def test_register_for_updates(self):
+        mock_callback = MagicMock()
+        await self.sensor_service.register_for_updates(self.motion_sensor, mock_callback)
+        
+        self.assertEqual(len(self.sensor_service._subscribers), 1)
+        self.assertEqual(self.sensor_service._subscribers[0][0], self.motion_sensor)
+        self.assertEqual(self.sensor_service._subscribers[0][1], mock_callback)
+
+    async def test_deregister_for_updates(self):
+        mock_callback = MagicMock()
+        await self.sensor_service.register_for_updates(self.motion_sensor, mock_callback)
+        await self.sensor_service.deregister_for_updates(self.motion_sensor)
+        
+        self.assertEqual(len(self.sensor_service._subscribers), 0)
+
+    async def test_update_with_unknown_property(self):
+        self.sensor_service._get_device_info.return_value = {
+            'data': {
+                'property_list': [
+                    {
+                        'pid': 'unknown_property',
+                        'value': '1'
+                    }
+                ]
+            }
+        }
+
+        updated_sensor = await self.sensor_service.update(self.motion_sensor)
+        self.assertFalse(updated_sensor.detected)  # Should maintain default value
+
+
+if __name__ == '__main__':
+    unittest.main()

wyzeapy-0.5.27/src/wyzeapy/tests/test_switch_service.py

@@ -0,0 +1,138 @@
+import unittest
+from datetime import datetime, timedelta
+from unittest.mock import AsyncMock, MagicMock
+from wyzeapy.services.switch_service import SwitchService, SwitchUsageService, Switch
+from wyzeapy.types import DeviceTypes, PropertyIDs
+from wyzeapy.wyze_auth_lib import WyzeAuthLib
+
+
+class TestSwitchService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
+        self.switch_service = SwitchService(auth_lib=self.mock_auth_lib)
+        self.switch_service._get_property_list = AsyncMock()
+        self.switch_service.get_updated_params = AsyncMock()
+        self.switch_service.get_object_list = AsyncMock()
+        self.switch_service._set_property = AsyncMock()
+
+        # Create test switch
+        self.test_switch = Switch({
+            "device_type": DeviceTypes.PLUG.value,
+            "product_model": "WLPP1",
+            "mac": "SWITCH123",
+            "nickname": "Test Switch",
+            "device_params": {"ip": "192.168.1.100"},
+            "raw_dict": {}
+        })
+
+    async def test_update_switch_on(self):
+        self.switch_service._get_property_list.return_value = [
+            (PropertyIDs.ON, "1"),
+            (PropertyIDs.AVAILABLE, "1")
+        ]
+
+        updated_switch = await self.switch_service.update(self.test_switch)
+        
+        self.assertTrue(updated_switch.on)
+        self.assertTrue(updated_switch.available)
+
+    async def test_update_switch_off(self):
+        self.switch_service._get_property_list.return_value = [
+            (PropertyIDs.ON, "0"),
+            (PropertyIDs.AVAILABLE, "1")
+        ]
+
+        updated_switch = await self.switch_service.update(self.test_switch)
+        
+        self.assertFalse(updated_switch.on)
+        self.assertTrue(updated_switch.available)
+
+    async def test_get_switches(self):
+        mock_plug = MagicMock()
+        mock_plug.type = DeviceTypes.PLUG
+        mock_plug.raw_dict = {
+            "device_type": DeviceTypes.PLUG.value,
+            "product_model": "WLPP1",
+            "mac": "PLUG123"
+        }
+
+        mock_outdoor_plug = MagicMock()
+        mock_outdoor_plug.type = DeviceTypes.OUTDOOR_PLUG
+        mock_outdoor_plug.raw_dict = {
+            "device_type": DeviceTypes.OUTDOOR_PLUG.value,
+            "product_model": "WLPPO",
+            "mac": "OUTPLUG456"
+        }
+
+        self.switch_service.get_object_list.return_value = [
+            mock_plug,
+            mock_outdoor_plug
+        ]
+
+        switches = await self.switch_service.get_switches()
+        
+        self.assertEqual(len(switches), 2)
+        self.assertIsInstance(switches[0], Switch)
+        self.assertIsInstance(switches[1], Switch)
+        self.switch_service.get_object_list.assert_awaited_once()
+
+    async def test_turn_on(self):
+        await self.switch_service.turn_on(self.test_switch)
+        self.switch_service._set_property.assert_awaited_with(
+            self.test_switch,
+            PropertyIDs.ON.value,
+            "1"
+        )
+
+    async def test_turn_off(self):
+        await self.switch_service.turn_off(self.test_switch)
+        self.switch_service._set_property.assert_awaited_with(
+            self.test_switch,
+            PropertyIDs.ON.value,
+            "0"
+        )
+
+
+class TestSwitchUsageService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
+        self.usage_service = SwitchUsageService(auth_lib=self.mock_auth_lib)
+        self.usage_service._get_plug_history = AsyncMock()
+
+        # Create test switch
+        self.test_switch = Switch({
+            "device_type": DeviceTypes.PLUG.value,
+            "product_model": "WLPP1",
+            "mac": "SWITCH123",
+            "nickname": "Test Switch",
+            "device_params": {"ip": "192.168.1.100"},
+            "raw_dict": {}
+        })
+
+    async def test_update_usage_history(self):
+        mock_usage_data = {
+            "total_power": 100,
+            "time_series": [
+                {"power": 10, "timestamp": 1234567890},
+                {"power": 20, "timestamp": 1234567891}
+            ]
+        }
+        self.usage_service._get_plug_history.return_value = mock_usage_data
+
+        # Calculate expected timestamps
+        now = datetime.now()
+        expected_end_time = int(datetime.timestamp(now) * 1000)
+        expected_start_time = int(datetime.timestamp(now - timedelta(hours=25)) * 1000)
+
+        updated_switch = await self.usage_service.update(self.test_switch)
+
+        self.assertEqual(updated_switch.usage_history, mock_usage_data)
+        self.usage_service._get_plug_history.assert_awaited_with(
+            self.test_switch,
+            expected_start_time,
+            expected_end_time
+        )
+
+
+if __name__ == '__main__':
+    unittest.main() 

wyzeapy-0.5.27/src/wyzeapy/tests/test_thermostat_service.py

@@ -0,0 +1,136 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+from wyzeapy.services.thermostat_service import (
+    ThermostatService, Thermostat, HVACMode, FanMode,
+    TemperatureUnit, Preset, HVACState, ThermostatProps
+)
+from wyzeapy.types import DeviceTypes
+from wyzeapy.wyze_auth_lib import WyzeAuthLib
+
+
+class TestThermostatService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
+        self.thermostat_service = ThermostatService(auth_lib=self.mock_auth_lib)
+        self.thermostat_service._thermostat_get_iot_prop = AsyncMock()
+        self.thermostat_service._thermostat_set_iot_prop = AsyncMock()
+        self.thermostat_service.get_object_list = AsyncMock()
+
+        # Create test thermostat
+        self.test_thermostat = Thermostat({
+            "device_type": DeviceTypes.THERMOSTAT.value,
+            "product_model": "WLPTH1",
+            "mac": "THERM123",
+            "nickname": "Test Thermostat",
+            "device_params": {"ip": "192.168.1.100"},
+            "raw_dict": {}
+        })
+
+    async def test_update_thermostat(self):
+        self.thermostat_service._thermostat_get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'temp_unit': 'F',
+                    'cool_sp': '74',
+                    'heat_sp': '64',
+                    'fan_mode': 'auto',
+                    'mode_sys': 'auto',
+                    'current_scenario': 'home',
+                    'temperature': '71.5',
+                    'iot_state': 'connected',
+                    'humidity': '50',
+                    'working_state': 'idle'
+                }
+            }
+        }
+
+        updated_thermostat = await self.thermostat_service.update(self.test_thermostat)
+
+        self.assertEqual(updated_thermostat.temp_unit, TemperatureUnit.FAHRENHEIT)
+        self.assertEqual(updated_thermostat.cool_set_point, 74)
+        self.assertEqual(updated_thermostat.heat_set_point, 64)
+        self.assertEqual(updated_thermostat.fan_mode, FanMode.AUTO)
+        self.assertEqual(updated_thermostat.hvac_mode, HVACMode.AUTO)
+        self.assertEqual(updated_thermostat.preset, Preset.HOME)
+        self.assertEqual(updated_thermostat.temperature, 71.5)
+        self.assertTrue(updated_thermostat.available)
+        self.assertEqual(updated_thermostat.humidity, 50)
+        self.assertEqual(updated_thermostat.hvac_state, HVACState.IDLE)
+
+    async def test_get_thermostats(self):
+        mock_thermostat = MagicMock()
+        mock_thermostat.type = DeviceTypes.THERMOSTAT
+        mock_thermostat.raw_dict = {
+            "device_type": DeviceTypes.THERMOSTAT.value,
+            "product_model": "WLPTH1",
+            "mac": "THERM123"
+        }
+
+        self.thermostat_service.get_object_list.return_value = [mock_thermostat]
+
+        thermostats = await self.thermostat_service.get_thermostats()
+        
+        self.assertEqual(len(thermostats), 1)
+        self.assertIsInstance(thermostats[0], Thermostat)
+        self.thermostat_service.get_object_list.assert_awaited_once()
+
+    async def test_set_cool_point(self):
+        await self.thermostat_service.set_cool_point(self.test_thermostat, 75)
+        self.thermostat_service._thermostat_set_iot_prop.assert_awaited_with(
+            self.test_thermostat,
+            ThermostatProps.COOL_SP,
+            75
+        )
+
+    async def test_set_heat_point(self):
+        await self.thermostat_service.set_heat_point(self.test_thermostat, 68)
+        self.thermostat_service._thermostat_set_iot_prop.assert_awaited_with(
+            self.test_thermostat,
+            ThermostatProps.HEAT_SP,
+            68
+        )
+
+    async def test_set_hvac_mode(self):
+        await self.thermostat_service.set_hvac_mode(self.test_thermostat, HVACMode.COOL)
+        self.thermostat_service._thermostat_set_iot_prop.assert_awaited_with(
+            self.test_thermostat,
+            ThermostatProps.MODE_SYS,
+            HVACMode.COOL.value
+        )
+
+    async def test_set_fan_mode(self):
+        await self.thermostat_service.set_fan_mode(self.test_thermostat, FanMode.ON)
+        self.thermostat_service._thermostat_set_iot_prop.assert_awaited_with(
+            self.test_thermostat,
+            ThermostatProps.FAN_MODE,
+            FanMode.ON.value
+        )
+
+    async def test_set_preset(self):
+        await self.thermostat_service.set_preset(self.test_thermostat, Preset.AWAY)
+        self.thermostat_service._thermostat_set_iot_prop.assert_awaited_with(
+            self.test_thermostat,
+            ThermostatProps.CURRENT_SCENARIO,
+            Preset.AWAY.value
+        )
+
+    async def test_update_with_invalid_property(self):
+        self.thermostat_service._thermostat_get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'invalid_property': 'some_value',
+                    'temperature': '71.5'
+                }
+            }
+        }
+
+        updated_thermostat = await self.thermostat_service.update(self.test_thermostat)
+        self.assertEqual(updated_thermostat.temperature, 71.5)
+        # Other properties should maintain their default values
+        self.assertEqual(updated_thermostat.temp_unit, TemperatureUnit.FAHRENHEIT)
+        self.assertEqual(updated_thermostat.cool_set_point, 74)
+        self.assertEqual(updated_thermostat.heat_set_point, 64)
+
+
+if __name__ == '__main__':
+    unittest.main() 

wyzeapy-0.5.27/src/wyzeapy/tests/test_wall_switch_service.py

@@ -0,0 +1,161 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+from wyzeapy.services.wall_switch_service import (
+    WallSwitchService, WallSwitch, SinglePressType, WallSwitchProps
+)
+from wyzeapy.types import DeviceTypes
+from wyzeapy.wyze_auth_lib import WyzeAuthLib
+
+
+class TestWallSwitchService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
+        self.wall_switch_service = WallSwitchService(auth_lib=self.mock_auth_lib)
+        self.wall_switch_service._wall_switch_get_iot_prop = AsyncMock()
+        self.wall_switch_service._wall_switch_set_iot_prop = AsyncMock()
+        self.wall_switch_service.get_object_list = AsyncMock()
+
+        # Create test wall switch
+        self.test_switch = WallSwitch({
+            "device_type": DeviceTypes.COMMON.value,
+            "product_model": "LD_SS1",
+            "mac": "SWITCH123",
+            "nickname": "Test Wall Switch",
+            "device_params": {"ip": "192.168.1.100"},
+            "raw_dict": {}
+        })
+
+    async def test_update_wall_switch(self):
+        self.wall_switch_service._wall_switch_get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'iot_state': 'connected',
+                    'switch-power': True,
+                    'switch-iot': False,
+                    'single_press_type': 1
+                }
+            }
+        }
+
+        updated_switch = await self.wall_switch_service.update(self.test_switch)
+
+        self.assertTrue(updated_switch.available)
+        self.assertTrue(updated_switch.switch_power)
+        self.assertFalse(updated_switch.switch_iot)
+        self.assertEqual(updated_switch.single_press_type, SinglePressType.CLASSIC)
+        # Test the property that depends on single_press_type
+        self.assertTrue(updated_switch.on)  # Should be True because switch_power is True and type is CLASSIC
+
+    async def test_update_wall_switch_iot_mode(self):
+        self.wall_switch_service._wall_switch_get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'iot_state': 'connected',
+                    'switch-power': False,
+                    'switch-iot': True,
+                    'single_press_type': 2
+                }
+            }
+        }
+
+        updated_switch = await self.wall_switch_service.update(self.test_switch)
+
+        self.assertTrue(updated_switch.available)
+        self.assertFalse(updated_switch.switch_power)
+        self.assertTrue(updated_switch.switch_iot)
+        self.assertEqual(updated_switch.single_press_type, SinglePressType.IOT)
+        # Test the property that depends on single_press_type
+        self.assertTrue(updated_switch.on)  # Should be True because switch_iot is True and type is IOT
+
+    async def test_get_switches(self):
+        mock_switch = MagicMock()
+        mock_switch.type = DeviceTypes.COMMON
+        mock_switch.product_model = "LD_SS1"
+        mock_switch.raw_dict = {
+            "device_type": DeviceTypes.COMMON.value,
+            "product_model": "LD_SS1",
+            "mac": "SWITCH123"
+        }
+
+        # Add a non-wall switch device to test filtering
+        mock_other_device = MagicMock()
+        mock_other_device.type = DeviceTypes.COMMON
+        mock_other_device.product_model = "OTHER_MODEL"
+
+        self.wall_switch_service.get_object_list.return_value = [
+            mock_switch,
+            mock_other_device
+        ]
+
+        switches = await self.wall_switch_service.get_switches()
+        
+        self.assertEqual(len(switches), 1)
+        self.assertIsInstance(switches[0], WallSwitch)
+        self.wall_switch_service.get_object_list.assert_awaited_once()
+
+    async def test_turn_on_classic_mode(self):
+        self.test_switch.single_press_type = SinglePressType.CLASSIC
+        await self.wall_switch_service.turn_on(self.test_switch)
+        self.wall_switch_service._wall_switch_set_iot_prop.assert_awaited_with(
+            self.test_switch,
+            WallSwitchProps.SWITCH_POWER,
+            True
+        )
+
+    async def test_turn_off_classic_mode(self):
+        self.test_switch.single_press_type = SinglePressType.CLASSIC
+        await self.wall_switch_service.turn_off(self.test_switch)
+        self.wall_switch_service._wall_switch_set_iot_prop.assert_awaited_with(
+            self.test_switch,
+            WallSwitchProps.SWITCH_POWER,
+            False
+        )
+
+    async def test_turn_on_iot_mode(self):
+        self.test_switch.single_press_type = SinglePressType.IOT
+        await self.wall_switch_service.turn_on(self.test_switch)
+        self.wall_switch_service._wall_switch_set_iot_prop.assert_awaited_with(
+            self.test_switch,
+            WallSwitchProps.SWITCH_IOT,
+            True
+        )
+
+    async def test_turn_off_iot_mode(self):
+        self.test_switch.single_press_type = SinglePressType.IOT
+        await self.wall_switch_service.turn_off(self.test_switch)
+        self.wall_switch_service._wall_switch_set_iot_prop.assert_awaited_with(
+            self.test_switch,
+            WallSwitchProps.SWITCH_IOT,
+            False
+        )
+
+    async def test_set_single_press_type(self):
+        await self.wall_switch_service.set_single_press_type(
+            self.test_switch,
+            SinglePressType.IOT
+        )
+        self.wall_switch_service._wall_switch_set_iot_prop.assert_awaited_with(
+            self.test_switch,
+            WallSwitchProps.SINGLE_PRESS_TYPE,
+            SinglePressType.IOT.value
+        )
+
+    async def test_update_with_invalid_property(self):
+        self.wall_switch_service._wall_switch_get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'invalid_property': 'some_value',
+                    'switch-power': True
+                }
+            }
+        }
+
+        updated_switch = await self.wall_switch_service.update(self.test_switch)
+        self.assertTrue(updated_switch.switch_power)
+        # Other properties should maintain their default values
+        self.assertEqual(updated_switch.single_press_type, SinglePressType.CLASSIC)
+        self.assertFalse(updated_switch.switch_iot)
+
+
+if __name__ == '__main__':
+    unittest.main() 

{wyzeapy-0.5.26 → wyzeapy-0.5.27}/src/wyzeapy/types.py

@@ -28,6 +28,7 @@ class DeviceTypes(Enum):
     CHIME_SENSOR = "ChimeSensor"
     CONTACT_SENSOR = "ContactSensor"
     MOTION_SENSOR = "MotionSensor"
+    LEAK_SENSOR = "LeakSensor"
     WRIST = "Wrist"
     BASE_STATION = "BaseStation"
     SCALE = "WyzeScale"
@@ -43,6 +44,7 @@ class DeviceTypes(Enum):
     KEYPAD = "Keypad"
     LIGHTSTRIP = "LightStrip"
 
+
 class Device:
     product_type: str
     product_model: str
@@ -102,7 +104,7 @@ class PropertyIDs(Enum):
     CONTACT_STATE = "P1301"
     MOTION_STATE = "P1302"
     CAMERA_SIREN = "P1049"
-    FLOOD_LIGHT = "P1056" # Also lamp socket on v3/v4 with lamp socket accessory
+    ACCESSORY = "P1056" # Is state for camera accessories, like garage doors, light sockets, and floodlights.
     SUN_MATCH = "P1528"
     MOTION_DETECTION = "P1047"  # Current Motion Detection State of the Camera
     MOTION_DETECTION_TOGGLE = "P1001"  # This toggles Camera Motion Detection On/Off