wyzeapy 0.5.26__tar.gz → 0.5.28__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: wyzeapy
-Version: 0.5.26
+Version: 0.5.28
 Summary: A library for interacting with Wyze devices
 License: GPL-3.0-only
 Author: Katie Mulliken
@@ -12,5 +12,5 @@ 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.28}/pyproject.toml

@@ -1,17 +1,17 @@
 [tool.poetry]
 name = "wyzeapy"
-version = "0.5.26"
+version = "0.5.28"
 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.28}/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:
@@ -628,6 +626,25 @@ class BaseService:
 
         return response_json
 
+    async def _get_lock_ble_token(self, device: Device) -> Dict[str, Optional[Any]]:
+        await self._auth_lib.refresh_if_should()
+
+        url_path = "/openapi/lock/v1/ble/token"
+
+        payload = {
+            "uuid": device.mac
+        }
+
+        payload = ford_create_payload(self._auth_lib.token.access_token, payload, url_path, "get")
+
+        url = f"https://yd-saas-toc.wyzecam.com{url_path}"
+
+        response_json = await self._auth_lib.get(url, params=payload)
+
+        check_for_errors_lock(self, response_json)
+
+        return response_json
+
     async def _get_device_info(self, device: Device) -> Dict[Any, Any]:
         await self._auth_lib.refresh_if_should()
 

{wyzeapy-0.5.26 → wyzeapy-0.5.28}/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.26 → wyzeapy-0.5.28}/src/wyzeapy/services/lock_service.py

@@ -4,7 +4,9 @@
 #  the license with this file. If not, please write to:
 #  katie@mulliken.net to receive a copy
 from .base_service import BaseService
+from ..const import FORD_APP_SECRET
 from ..types import Device, DeviceTypes
+from ..utils import wyze_decrypt_cbc
 
 
 class Lock(Device):
@@ -13,12 +15,19 @@ class Lock(Device):
     unlocking = False
     door_open = False
     trash_mode = False
+    ble_id = None
+    ble_token = None
 
 
 class LockService(BaseService):
     async def update(self, lock: Lock):
         device_info = await self._get_lock_info(lock)
         lock.raw_dict = device_info["device"]
+        if lock.product_model == "YD_BT1":
+            ble_token_info = await self._get_lock_ble_token(lock)
+            lock.raw_dict["token"] = ble_token_info["token"]
+            lock.ble_id = ble_token_info["token"]["id"]
+            lock.ble_token = wyze_decrypt_cbc(FORD_APP_SECRET[:16], ble_token_info["token"]["token"])
 
         lock.available = lock.raw_dict.get("onoff_line") == 1
         lock.door_open = lock.raw_dict.get("door_open_status") == 1

wyzeapy-0.5.28/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.28/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.28/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.28/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 ...