wyzeapy 0.5.26__py3-none-any.whl → 0.5.28__py3-none-any.whl

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/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/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/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/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

wyzeapy/utils.py

@@ -4,6 +4,7 @@
 #  the license with this file. If not, please write to:
 #  katie@mulliken.net to receive a copy
 import base64
+import binascii
 import hashlib
 from typing import Dict, Any, List, Optional
 
@@ -66,6 +67,20 @@ def wyze_decrypt(key, enc):
     return decrypt_txt
 
 
+def wyze_decrypt_cbc(key: str, enc_hex_str: str) -> str:
+    key_hash = hashlib.md5(key.encode("utf-8")).digest()
+    
+    iv = b"0123456789ABCDEF"
+    cipher = AES.new(key_hash, AES.MODE_CBC, iv)
+    
+    encrypted_bytes = binascii.unhexlify(enc_hex_str)
+    decrypted_bytes = cipher.decrypt(encrypted_bytes)
+    
+    # PKCS5Padding
+    padding_length = decrypted_bytes[-1]
+    return decrypted_bytes[:-padding_length].decode()
+
+
 def create_password(password: str) -> str:
     hex1 = hashlib.md5(password.encode()).hexdigest()
     hex2 = hashlib.md5(hex1.encode()).hexdigest()

{wyzeapy-0.5.26.dist-info → wyzeapy-0.5.28.dist-info}/METADATA

@@ -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)