wyzeapy 0.5.29__py3-none-any.whl → 0.5.30__py3-none-any.whl

wyzeapy/__init__.py

@@ -16,6 +16,7 @@ from .services.lock_service import LockService
 from .services.sensor_service import SensorService
 from .services.switch_service import SwitchService, SwitchUsageService
 from .services.thermostat_service import ThermostatService
+from .services.irrigation_service import IrrigationService
 from .services.wall_switch_service import WallSwitchService
 from .wyze_auth_lib import WyzeAuthLib, Token
 
@@ -50,6 +51,7 @@ class Wyzeapy:
         self._hms_service = None
         self._lock_service = None
         self._sensor_service = None
+        self._irrigation_service = None
         self._wall_switch_service = None
         self._switch_usage_service = None
         self._email = None
@@ -441,6 +443,14 @@ class Wyzeapy:
         if self._sensor_service is None:
             self._sensor_service = SensorService(self._auth_lib)
         return self._sensor_service
+    
+    @property
+    async def irrigation_service(self) -> IrrigationService:
+        """Returns an instance of the irrigation service"""
+
+        if self._irrigation_service is None:
+            self._irrigation_service = IrrigationService(self._auth_lib)
+        return self._irrigation_service
 
     @property
     async def wall_switch_service(self) -> WallSwitchService:

wyzeapy/payload_factory.py

@@ -51,6 +51,36 @@ def olive_create_get_payload(device_mac: str, keys: str) -> Dict[str, Any]:
 
     return {"keys": keys, "did": device_mac, "nonce": nonce}
 
+def olive_create_get_payload_irrigation(device_mac: str) -> Dict[str, Any]:
+    nonce = int(time.time() * 1000)
+
+    return {
+        'device_id': device_mac,
+        'nonce': str(nonce)
+    }
+
+def olive_create_post_payload_irrigation_stop(device_mac: str, action: str) -> Dict[str, Any]:
+    nonce = int(time.time() * 1000)
+
+    return {
+        'device_id': device_mac,
+        'nonce': str(nonce),
+        "action": action
+    }
+
+def olive_create_post_payload_irrigation_quickrun(device_mac: str, zone_number: int, duration: int) -> Dict[str, Any]:
+    nonce = int(time.time() * 1000)
+
+    return {
+        'device_id': device_mac,
+        'nonce': str(nonce),
+        "zone_runs": [
+            {
+                "zone_number": zone_number,
+                "duration": duration
+            }
+        ]
+    }
 
 def olive_create_post_payload(
     device_mac: str, device_model: str, prop_key: str, value: Any

wyzeapy/services/base_service.py

@@ -36,6 +36,9 @@ from ..payload_factory import (
     olive_create_user_info_payload,
     devicemgmt_create_capabilities_payload,
     devicemgmt_get_iot_props_list,
+    olive_create_get_payload_irrigation,
+    olive_create_post_payload_irrigation_stop,
+    olive_create_post_payload_irrigation_quickrun,
 )
 from ..types import PropertyIDs, Device, DeviceMgmtToggleType
 from ..utils import (
@@ -896,3 +899,73 @@ class BaseService:
         check_for_errors_standard(self, response_json)
 
         return response_json["data"]["usage_record_list"]
+
+    async def _get_zone_by_device(self, url: str, device: Device) -> Dict[Any, Any]:
+        await self._auth_lib.refresh_if_should()
+
+        payload = olive_create_get_payload_irrigation(device.mac)
+        signature = olive_create_signature(payload, self._auth_lib.token.access_token)
+        headers = {
+            'Accept-Encoding': 'gzip',
+            'User-Agent': 'myapp',
+            'appid': OLIVE_APP_ID,
+            'appinfo': APP_INFO,
+            'phoneid': PHONE_ID,
+            'access_token': self._auth_lib.token.access_token,
+            'signature2': signature
+        }
+
+        response_json = await self._auth_lib.get(url, headers=headers, params=payload)
+
+        check_for_errors_iot(self, response_json)
+
+        return response_json
+
+
+    async def _stop_running_schedule(self, url: str, device: Device, action: str) -> Dict[Any, Any]:
+        await self._auth_lib.refresh_if_should()
+
+        payload = olive_create_post_payload_irrigation_stop(device.mac, action)
+        signature = olive_create_signature(json.dumps(payload, separators=(',', ':')),
+                                           self._auth_lib.token.access_token)
+        headers = {
+            'Accept-Encoding': 'gzip',
+            'Content-Type': 'application/json',
+            'User-Agent': 'myapp',
+            'appid': OLIVE_APP_ID,
+            'appinfo': APP_INFO,
+            'phoneid': PHONE_ID,
+            'access_token': self._auth_lib.token.access_token,
+            'signature2': signature
+        }
+
+        payload_str = json.dumps(payload, separators=(',', ':'))
+        response_json = await self._auth_lib.post(url, headers=headers, data=payload_str)
+
+        check_for_errors_iot(self, response_json)
+
+        return response_json
+
+    async def _start_zone(self, url: str, device: Device, zone_number: int, duration: int) -> Dict[Any, Any]:
+        await self._auth_lib.refresh_if_should()
+
+        payload = olive_create_post_payload_irrigation_quickrun(device.mac, zone_number, duration)
+        signature = olive_create_signature(json.dumps(payload, separators=(',', ':')),
+                                           self._auth_lib.token.access_token)
+        headers = {
+            'Accept-Encoding': 'gzip',
+            'Content-Type': 'application/json',
+            'User-Agent': 'myapp',
+            'appid': OLIVE_APP_ID,
+            'appinfo': APP_INFO,
+            'phoneid': PHONE_ID,
+            'access_token': self._auth_lib.token.access_token,
+            'signature2': signature
+        }
+
+        payload_str = json.dumps(payload, separators=(',', ':'))
+        response_json = await self._auth_lib.post(url, headers=headers, data=payload_str)
+
+        check_for_errors_iot(self, response_json)
+
+        return response_json

wyzeapy/services/irrigation_service.py

@@ -0,0 +1,189 @@
+import logging
+from enum import Enum
+from typing import Any, Dict, List
+
+from .base_service import BaseService
+from ..types import Device, IrrigationProps, DeviceTypes
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CropType(Enum):
+    COOL_SEASON_GRASS = "cool_season_grass"
+    WARM_SEASON_GRASS = "warm_season_grass"
+    SHRUBS = "shrubs"
+    TREES = "trees"
+    ANNUALS = "annuals"
+    PERENNIALS = "perennials"
+    XERISCAPE = "xeriscape"
+    GARDEN = "garden"
+
+
+class ExposureType(Enum):
+    LOTS_OF_SUN = "lots_of_sun"
+    SOME_SHADE = "some_shade"
+
+
+class NozzleType(Enum):
+    FIXED_SPRAY_HEAD = "fixed_spray_head"
+    ROTOR_HEAD = "rotor_head"
+    ROTARY_NOZZLE = "rotary_nozzle"
+    MISTER = "mister"
+    BUBBLER = "bubbler"
+    EMITTER = "emitter"
+    DRIP_LINE = "drip_line"
+
+
+class SlopeType(Enum):
+    FLAT = "flat"
+    SLIGHT = "slight"
+    MODERATE = "moderate"
+    STEEP = "steep"
+
+
+class SoilType(Enum):
+    CLAY_LOAM = 'clay_loam'
+    CLAY = 'clay'
+    SILTY_CLAY = 'silty_clay'
+    LOAM = 'loam'
+    SANDY_LOAM = 'sandy_loam'
+    LOAMY_SAND = 'loamy_sand'
+    SAND = 'sand'
+
+
+class Zone:
+    """Represents a single irrigation zone."""
+    def __init__(self, dictionary: Dict[Any, Any]):
+        self.zone_number: int = dictionary.get('zone_number', 1)
+        self.name: str = dictionary.get('name', 'Zone 1')
+        self.enabled: bool = dictionary.get('enabled', True)
+        self.zone_id: str = dictionary.get('zone_id', 'zone_id')
+        self.smart_duration: int = dictionary.get('smart_duration', 600)
+        
+        # this quickrun duration is used only for running a zone manually
+        # the wyze api has no such value, but takes a duration as part of the api call
+        # the default value grabs the wyze smart_duration but all further updates
+        # are managed through the home assistant state
+        self.quickrun_duration: int = dictionary.get('smart_duration', 600)
+
+class Irrigation(Device):
+    def __init__(self, dictionary: Dict[Any, Any]):
+        super().__init__(dictionary)
+
+        # the below comes from the get_iot_prop call
+        self.RSSI: int = 0
+        self.IP: str = "192.168.1.100"
+        self.sn: str = "SN123456789"
+        self.available: bool = False
+        self.ssid: str = "ssid"
+        # the below comes from the device_info call
+        self.zones: List[Zone] = []
+
+
+class IrrigationService(BaseService):
+    async def update(self, irrigation: Irrigation) -> Irrigation:
+        """Update the irrigation device with latest data from Wyze API."""
+        # Get IoT properties
+        properties = (await self.get_iot_prop(irrigation))['data']['props']
+        
+        # Update device properties
+        irrigation.RSSI = properties.get('RSSI', -65)
+        irrigation.IP = properties.get('IP', '192.168.1.100')
+        irrigation.sn = properties.get('sn', 'SN123456789')
+        irrigation.ssid = properties.get('ssid', 'ssid')
+        irrigation.available = (properties.get(IrrigationProps.IOT_STATE.value) == "connected")
+
+        # Get zones
+        zones = (await self.get_zone_by_device(irrigation))['data']['zones']
+        
+        # Update zones
+        irrigation.zones = []
+        for zone in zones:
+            irrigation.zones.append(Zone(zone))
+        
+        return irrigation
+    
+    async def update_device_props(self, irrigation: Irrigation) -> Irrigation:
+        """Update the irrigation device with latest data from Wyze API."""
+        # Get IoT properties
+        properties = (await self.get_iot_prop(irrigation))['data']['props']
+        
+        # Update device properties
+        irrigation.RSSI = properties.get('RSSI')
+        irrigation.IP = properties.get('IP')
+        irrigation.sn = properties.get('sn')
+        irrigation.ssid = properties.get('ssid')
+        irrigation.available = (properties.get(IrrigationProps.IOT_STATE.value) == 'connected')
+
+        return irrigation
+
+    async def get_irrigations(self) -> List[Irrigation]:
+        if self._devices is None:
+            self._devices = await self.get_object_list()
+
+        irrigations = [device for device in self._devices if device.type == DeviceTypes.IRRIGATION and "BS_WK1" in device.product_model]
+
+        return [Irrigation(irrigation.raw_dict) for irrigation in irrigations]
+
+    async def start_zone(self, irrigation: Device, zone_number: int, quickrun_duration: int) -> Dict[Any, Any]:
+        """Start a zone with the specified duration.
+        
+        Args:
+            irrigation: The irrigation device
+            zone_number: The zone number to start
+            quickrun_duration: Duration in seconds to run the zone
+            
+        Returns:
+            Dict containing the API response
+        """
+        url = "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/quickrun"
+        return await self._start_zone(url, irrigation, zone_number, quickrun_duration)
+
+    async def stop_running_schedule(self, device: Device) -> Dict[Any, Any]:
+        """Stop any currently running irrigation schedule.
+        
+        Args:
+            device: The irrigation device
+            
+        Returns:
+            Dict containing the API response
+        """
+        url = "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/runningschedule"
+        action = "STOP"    
+        return await self._stop_running_schedule(url, device, action)
+
+    async def set_zone_quickrun_duration(self, irrigation: Irrigation, zone_number: int, duration: int) -> Irrigation:
+        """Set the quickrun duration for a specific zone.
+        
+        Args:
+            irrigation: The irrigation device
+            zone_number: The zone number to configure
+            duration: Duration in seconds for quickrun
+        """
+        for zone in irrigation.zones:
+            if zone.zone_number == zone_number:
+                zone.quickrun_duration = duration
+                break
+        
+        return irrigation
+
+    # Private implementation methods
+    async def get_iot_prop(self, device: Device) -> Dict[Any, Any]:
+        """Get IoT properties for a device."""
+        url = "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/get_iot_prop"
+        keys = 'zone_state,iot_state,iot_state_update_time,app_version,RSSI,' \
+            'wifi_mac,sn,device_model,ssid,IP'
+        return await self._get_iot_prop(url, device, keys)
+
+    async def get_device_info(self, device: Device) -> Dict[Any, Any]:
+        """Get device info from Wyze API."""
+        url = "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/device_info"
+        keys = 'wiring,sensor,enable_schedules,notification_enable,notification_watering_begins,' \
+            'notification_watering_ends,notification_watering_is_skipped,skip_low_temp,skip_wind,' \
+            'skip_rain,skip_saturation'
+        return await self._irrigation_device_info(url, device, keys)
+
+    async def get_zone_by_device(self, device: Device) -> List[Dict[Any, Any]]:
+        """Get zones for a device."""
+        url = "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/zone"
+        return await self._get_zone_by_device(url, device)

wyzeapy/tests/test_irrigation_service.py

@@ -0,0 +1,536 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+from wyzeapy.services.irrigation_service import (
+    IrrigationService, Irrigation, Zone
+)
+from wyzeapy.types import DeviceTypes, Device
+from wyzeapy.wyze_auth_lib import WyzeAuthLib
+
+# todo: add tests for irrigation service
+
+class TestIrrigationService(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
+        self.irrigation_service = IrrigationService(auth_lib=self.mock_auth_lib)
+        self.irrigation_service.get_iot_prop = AsyncMock()
+        self.irrigation_service.get_zone_by_device = AsyncMock()
+        self.irrigation_service.get_object_list = AsyncMock()
+        self.irrigation_service._get_iot_prop = AsyncMock()
+        self.irrigation_service._get_zone_by_device = AsyncMock()
+        self.irrigation_service._irrigation_device_info = AsyncMock()
+
+        # Create test irrigation
+        self.test_irrigation = Irrigation({
+            "device_type": DeviceTypes.IRRIGATION.value,
+            "product_model": "BS_WK1",
+            "mac": "IRRIG123",
+            "nickname": "Test Irrigation",
+            "device_params": {"ip": "192.168.1.100"},
+            "raw_dict": {}
+        })
+
+    async def test_update_irrigation(self):
+        # Mock IoT properties response
+        self.irrigation_service.get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'RSSI': '-65',
+                    'IP': '192.168.1.100',
+                    'sn': 'SN123456789',
+                    'ssid': 'TestSSID',
+                    'iot_state': 'connected'
+                }
+            }
+        }
+
+        # Mock zones response
+        self.irrigation_service.get_zone_by_device.return_value = {
+            'data': {
+                'zones': [
+                    {
+                        'zone_number': 1,
+                        'name': 'Zone 1',
+                        'enabled': True,
+                        'zone_id': 'zone1',
+                        'smart_duration': 600
+                    },
+                    {
+                        'zone_number': 2,
+                        'name': 'Zone 2',
+                        'enabled': True,
+                        'zone_id': 'zone2',
+                        'smart_duration': 900
+                    }
+                ]
+            }
+        }
+
+        updated_irrigation = await self.irrigation_service.update(self.test_irrigation)
+
+        # Test IoT properties
+        self.assertEqual(updated_irrigation.RSSI, '-65')
+        self.assertEqual(updated_irrigation.IP, '192.168.1.100')
+        self.assertEqual(updated_irrigation.sn, 'SN123456789')
+        self.assertEqual(updated_irrigation.ssid, 'TestSSID')
+        self.assertTrue(updated_irrigation.available)
+
+        # Test zones
+        self.assertEqual(len(updated_irrigation.zones), 2)
+        self.assertEqual(updated_irrigation.zones[0].zone_number, 1)
+        self.assertEqual(updated_irrigation.zones[0].name, 'Zone 1')
+        self.assertTrue(updated_irrigation.zones[0].enabled)
+        self.assertEqual(updated_irrigation.zones[0].quickrun_duration, 600)
+        self.assertEqual(updated_irrigation.zones[1].zone_number, 2)
+        self.assertEqual(updated_irrigation.zones[1].name, 'Zone 2')
+        self.assertTrue(updated_irrigation.zones[1].enabled)
+        self.assertEqual(updated_irrigation.zones[1].quickrun_duration, 900)
+
+    async def test_get_irrigations(self):
+        # Create a mock irrigation device with all required attributes
+        mock_irrigation = MagicMock()
+        mock_irrigation.type = DeviceTypes.IRRIGATION
+        mock_irrigation.product_model = "BS_WK1"
+        mock_irrigation.raw_dict = {
+            "device_type": DeviceTypes.IRRIGATION.value,
+            "product_model": "BS_WK1",
+            "mac": "IRRIG123",
+            "nickname": "Test Irrigation",
+            "device_params": {"ip": "192.168.1.100"},
+            "raw_dict": {}
+        }
+
+        # Mock the get_object_list to return our mock irrigation device
+        self.irrigation_service.get_object_list.return_value = [mock_irrigation]
+
+        # Get the irrigations
+        irrigations = await self.irrigation_service.get_irrigations()
+        
+        # Verify the results
+        self.assertEqual(len(irrigations), 1)
+        self.assertIsInstance(irrigations[0], Irrigation)
+        self.assertEqual(irrigations[0].product_model, "BS_WK1")
+        self.assertEqual(irrigations[0].mac, "IRRIG123")
+        self.irrigation_service.get_object_list.assert_awaited_once()
+
+    async def test_set_zone_quickrun_duration(self):
+        # Setup test irrigation with zones
+        self.test_irrigation.zones = [
+            Zone({
+                'zone_number': 1,
+                'name': 'Zone 1',
+                'enabled': True,
+                'zone_id': 'zone1',
+                'smart_duration': 400
+            }),
+            Zone({
+                'zone_number': 2,
+                'name': 'Zone 2',
+                'enabled': True,
+                'zone_id': 'zone2',
+                'smart_duration': 900
+            })
+        ]
+
+        # Test setting quickrun duration
+        await self.irrigation_service.set_zone_quickrun_duration(
+            self.test_irrigation,
+            1,
+            300
+        )
+        self.assertEqual(self.test_irrigation.zones[0].quickrun_duration, 300)
+
+        # Test setting quickrun duration for non-existent zone
+        await self.irrigation_service.set_zone_quickrun_duration(
+            self.test_irrigation,
+            999,
+            300
+        )
+        # Verify that no zones were modified
+        self.assertEqual(len(self.test_irrigation.zones), 2)
+        self.assertEqual(self.test_irrigation.zones[0].quickrun_duration, 300)  # First zone changed to 300
+        self.assertEqual(self.test_irrigation.zones[1].quickrun_duration, 900)  # Second zone should be unchanged at 900
+
+    async def test_update_with_invalid_property(self):
+        self.irrigation_service.get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'invalid_property': 'some_value',
+                    'RSSI': '-65'
+                }
+            }
+        }
+
+        self.irrigation_service.get_zone_by_device.return_value = {
+            'data': {
+                'zones': []
+            }
+        }
+
+        updated_irrigation = await self.irrigation_service.update(self.test_irrigation)
+        self.assertEqual(updated_irrigation.RSSI, '-65')
+        # Other properties should maintain their default values
+        self.assertEqual(updated_irrigation.IP, "192.168.1.100")
+        self.assertEqual(updated_irrigation.sn, "SN123456789")
+        self.assertEqual(updated_irrigation.ssid, "ssid")
+
+    async def test_start_zone(self):
+        # Mock the _start_zone method
+        self.irrigation_service._start_zone = AsyncMock()
+        expected_response = {'data': {'result': 'success'}}
+        self.irrigation_service._start_zone.return_value = expected_response
+
+        # Test starting a zone
+        result = await self.irrigation_service.start_zone(
+            self.test_irrigation,
+            zone_number=1,
+            quickrun_duration=300
+        )
+
+        # Verify the call was made with correct parameters
+        self.irrigation_service._start_zone.assert_awaited_once_with(
+            "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/quickrun",
+            self.test_irrigation,
+            1,
+            300
+        )
+        self.assertEqual(result, expected_response)
+
+    async def test_stop_running_schedule(self):
+        # Mock the _stop_running_schedule method
+        self.irrigation_service._stop_running_schedule = AsyncMock()
+        expected_response = {'data': {'result': 'stopped'}}
+        self.irrigation_service._stop_running_schedule.return_value = expected_response
+
+        # Test stopping running schedule
+        result = await self.irrigation_service.stop_running_schedule(self.test_irrigation)
+
+        # Verify the call was made with correct parameters
+        self.irrigation_service._stop_running_schedule.assert_awaited_once_with(
+            "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/runningschedule",
+            self.test_irrigation,
+            "STOP"
+        )
+        self.assertEqual(result, expected_response)
+
+    async def test_update_device_props(self):
+        # Mock IoT properties response
+        self.irrigation_service.get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'RSSI': '-70',
+                    'IP': '192.168.1.101',
+                    'sn': 'SN987654321',
+                    'ssid': 'NewSSID',
+                    'iot_state': 'connected'
+                }
+            }
+        }
+
+        updated_irrigation = await self.irrigation_service.update_device_props(self.test_irrigation)
+
+        # Test that properties were updated correctly
+        self.assertEqual(updated_irrigation.RSSI, '-70')
+        self.assertEqual(updated_irrigation.IP, '192.168.1.101')
+        self.assertEqual(updated_irrigation.sn, 'SN987654321')
+        self.assertEqual(updated_irrigation.ssid, 'NewSSID')
+        self.assertTrue(updated_irrigation.available)
+
+    async def test_update_device_props_disconnected(self):
+        # Mock IoT properties response with disconnected state
+        self.irrigation_service.get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'RSSI': '-80',
+                    'IP': '192.168.1.102',
+                    'sn': 'SN555666777',
+                    'ssid': 'TestSSID2',
+                    'iot_state': 'disconnected'
+                }
+            }
+        }
+
+        updated_irrigation = await self.irrigation_service.update_device_props(self.test_irrigation)
+
+        # Test that device is marked as unavailable
+        self.assertFalse(updated_irrigation.available)
+        self.assertEqual(updated_irrigation.RSSI, '-80')
+        self.assertEqual(updated_irrigation.IP, '192.168.1.102')
+
+    async def test_get_iot_prop(self):
+        # Mock the get_iot_prop method directly to test the public interface
+        expected_response = {'data': {'props': {'RSSI': '-65'}}}
+        self.irrigation_service.get_iot_prop.return_value = expected_response
+
+        # Test get_iot_prop
+        result = await self.irrigation_service.get_iot_prop(self.test_irrigation)
+
+        # Verify the call was made and returned expected result
+        self.irrigation_service.get_iot_prop.assert_awaited_once_with(self.test_irrigation)
+        self.assertEqual(result, expected_response)
+
+    async def test_get_device_info(self):
+        # Mock the _irrigation_device_info method
+        self.irrigation_service._irrigation_device_info = AsyncMock()
+        expected_response = {'data': {'props': {'enable_schedules': True}}}
+        self.irrigation_service._irrigation_device_info.return_value = expected_response
+
+        # Test get_device_info
+        result = await self.irrigation_service.get_device_info(self.test_irrigation)
+
+        # Verify the call was made with correct parameters
+        expected_keys = 'wiring,sensor,enable_schedules,notification_enable,notification_watering_begins,notification_watering_ends,notification_watering_is_skipped,skip_low_temp,skip_wind,skip_rain,skip_saturation'
+        self.irrigation_service._irrigation_device_info.assert_awaited_once_with(
+            "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/device_info",
+            self.test_irrigation,
+            expected_keys
+        )
+        self.assertEqual(result, expected_response)
+
+    async def test_get_zone_by_device_method(self):
+        # Mock the get_zone_by_device method directly to test the public interface
+        expected_response = {'data': {'zones': [{'zone_number': 1, 'name': 'Zone 1'}]}}
+        self.irrigation_service.get_zone_by_device.return_value = expected_response
+
+        # Test get_zone_by_device
+        result = await self.irrigation_service.get_zone_by_device(self.test_irrigation)
+
+        # Verify the call was made and returned expected result
+        self.irrigation_service.get_zone_by_device.assert_awaited_once_with(self.test_irrigation)
+        self.assertEqual(result, expected_response)
+
+
+class TestZone(unittest.TestCase):
+    def test_zone_initialization_with_defaults(self):
+        # Test zone initialization with minimal data
+        zone_data = {'zone_number': 3, 'name': 'Test Zone'}
+        zone = Zone(zone_data)
+        
+        self.assertEqual(zone.zone_number, 3)
+        self.assertEqual(zone.name, 'Test Zone')
+        self.assertTrue(zone.enabled)  # Default value
+        self.assertEqual(zone.zone_id, 'zone_id')  # Default value
+        self.assertEqual(zone.smart_duration, 600)  # Default value
+        self.assertEqual(zone.quickrun_duration, 600)  # Default value from smart_duration
+
+    def test_zone_initialization_with_all_data(self):
+        # Test zone initialization with all data
+        zone_data = {
+            'zone_number': 2,
+            'name': 'Garden Zone',
+            'enabled': False,
+            'zone_id': 'zone_garden',
+            'smart_duration': 1200
+        }
+        zone = Zone(zone_data)
+        
+        self.assertEqual(zone.zone_number, 2)
+        self.assertEqual(zone.name, 'Garden Zone')
+        self.assertFalse(zone.enabled)
+        self.assertEqual(zone.zone_id, 'zone_garden')
+        self.assertEqual(zone.smart_duration, 1200)
+        self.assertEqual(zone.quickrun_duration, 1200)  # Should use smart_duration
+
+    def test_zone_initialization_empty_dict(self):
+        # Test zone initialization with empty dict
+        zone = Zone({})
+        
+        self.assertEqual(zone.zone_number, 1)  # Default value
+        self.assertEqual(zone.name, 'Zone 1')  # Default value
+        self.assertTrue(zone.enabled)  # Default value
+        self.assertEqual(zone.zone_id, 'zone_id')  # Default value
+        self.assertEqual(zone.smart_duration, 600)  # Default value
+        self.assertEqual(zone.quickrun_duration, 600)  # Default value
+
+
+class TestIrrigation(unittest.TestCase):
+    def test_irrigation_initialization(self):
+        # Test irrigation device initialization
+        irrigation_data = {
+            "device_type": DeviceTypes.IRRIGATION.value,
+            "product_model": "BS_WK1",
+            "mac": "IRRIG456",
+            "nickname": "Backyard Sprinkler",
+            "device_params": {"ip": "192.168.1.200"}
+        }
+        irrigation = Irrigation(irrigation_data)
+        
+        self.assertEqual(irrigation.product_model, "BS_WK1")
+        self.assertEqual(irrigation.mac, "IRRIG456")
+        self.assertEqual(irrigation.nickname, "Backyard Sprinkler")
+        
+        # Test default values
+        self.assertEqual(irrigation.RSSI, 0)
+        self.assertEqual(irrigation.IP, "192.168.1.100")
+        self.assertEqual(irrigation.sn, "SN123456789")
+        self.assertFalse(irrigation.available)
+        self.assertEqual(irrigation.ssid, "ssid")
+        self.assertEqual(len(irrigation.zones), 0)
+
+    def test_irrigation_inheritance(self):
+        # Test that Irrigation inherits from Device
+        irrigation_data = {
+            "product_type": DeviceTypes.IRRIGATION.value,
+            "product_model": "BS_WK1",
+            "mac": "IRRIG789",
+            "nickname": "Front Yard Sprinkler"
+        }
+        irrigation = Irrigation(irrigation_data)
+        
+        # Test inherited Device properties
+        self.assertIsInstance(irrigation, Device)
+        self.assertEqual(irrigation.type, DeviceTypes.IRRIGATION)
+
+
+class TestIrrigationServiceEdgeCases(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
+        self.irrigation_service = IrrigationService(auth_lib=self.mock_auth_lib)
+        self.irrigation_service.get_iot_prop = AsyncMock()
+        self.irrigation_service.get_zone_by_device = AsyncMock()
+        self.irrigation_service.get_object_list = AsyncMock()
+
+        # Create test irrigation
+        self.test_irrigation = Irrigation({
+            "device_type": DeviceTypes.IRRIGATION.value,
+            "product_model": "BS_WK1",
+            "mac": "IRRIG123",
+            "nickname": "Test Irrigation",
+            "device_params": {"ip": "192.168.1.100"},
+            "raw_dict": {}
+        })
+
+    async def test_update_with_empty_zones(self):
+        # Mock IoT properties response
+        self.irrigation_service.get_iot_prop.return_value = {
+            'data': {
+                'props': {
+                    'RSSI': '-65',
+                    'IP': '192.168.1.100',
+                    'sn': 'SN123456789',
+                    'ssid': 'TestSSID',
+                    'iot_state': 'connected'
+                }
+            }
+        }
+
+        # Mock empty zones response
+        self.irrigation_service.get_zone_by_device.return_value = {
+            'data': {
+                'zones': []
+            }
+        }
+
+        updated_irrigation = await self.irrigation_service.update(self.test_irrigation)
+
+        # Verify empty zones list
+        self.assertEqual(len(updated_irrigation.zones), 0)
+        self.assertTrue(updated_irrigation.available)
+
+    async def test_update_with_missing_iot_props(self):
+        # Mock IoT properties response with missing props
+        self.irrigation_service.get_iot_prop.return_value = {
+            'data': {
+                'props': {}
+            }
+        }
+
+        self.irrigation_service.get_zone_by_device.return_value = {
+            'data': {
+                'zones': []
+            }
+        }
+
+        updated_irrigation = await self.irrigation_service.update(self.test_irrigation)
+
+        # Verify default values are used
+        self.assertEqual(updated_irrigation.RSSI, -65)
+        self.assertEqual(updated_irrigation.IP, '192.168.1.100')
+        self.assertEqual(updated_irrigation.sn, 'SN123456789')
+        self.assertEqual(updated_irrigation.ssid, 'ssid')
+        self.assertFalse(updated_irrigation.available)  # iot_state missing, so not connected
+
+    async def test_get_irrigations_empty_device_list(self):
+        # Mock empty device list
+        self.irrigation_service.get_object_list.return_value = []
+
+        irrigations = await self.irrigation_service.get_irrigations()
+        
+        # Verify empty list returned
+        self.assertEqual(len(irrigations), 0)
+        self.irrigation_service.get_object_list.assert_awaited_once()
+
+    async def test_get_irrigations_no_irrigation_devices(self):
+        # Mock device list with non-irrigation devices
+        mock_camera = MagicMock()
+        mock_camera.type = DeviceTypes.CAMERA
+        mock_camera.product_model = "CAM_V1"
+        
+        mock_bulb = MagicMock()
+        mock_bulb.type = DeviceTypes.LIGHT
+        mock_bulb.product_model = "LIGHT_V1"
+
+        self.irrigation_service.get_object_list.return_value = [mock_camera, mock_bulb]
+
+        irrigations = await self.irrigation_service.get_irrigations()
+        
+        # Verify no irrigation devices returned
+        self.assertEqual(len(irrigations), 0)
+
+    async def test_get_irrigations_wrong_product_model(self):
+        # Mock device list with irrigation type but wrong product model
+        mock_irrigation = MagicMock()
+        mock_irrigation.type = DeviceTypes.IRRIGATION
+        mock_irrigation.product_model = "WRONG_MODEL"
+        mock_irrigation.raw_dict = {
+            "device_type": DeviceTypes.IRRIGATION.value,
+            "product_model": "WRONG_MODEL",
+            "mac": "IRRIG123",
+            "nickname": "Test Irrigation"
+        }
+
+        self.irrigation_service.get_object_list.return_value = [mock_irrigation]
+
+        irrigations = await self.irrigation_service.get_irrigations()
+        
+        # Verify no irrigation devices returned due to wrong product model
+        self.assertEqual(len(irrigations), 0)
+
+    async def test_set_zone_quickrun_duration_zone_not_found(self):
+        # Setup test irrigation with zones
+        self.test_irrigation.zones = [
+            Zone({
+                'zone_number': 1,
+                'name': 'Zone 1',
+                'enabled': True,
+                'zone_id': 'zone1',
+                'smart_duration': 600
+            })
+        ]
+
+        # Try to set duration for non-existent zone
+        result = await self.irrigation_service.set_zone_quickrun_duration(
+            self.test_irrigation,
+            99,  # Non-existent zone
+            300
+        )
+
+        # Verify existing zone unchanged
+        self.assertEqual(self.test_irrigation.zones[0].quickrun_duration, 600)
+        self.assertEqual(result, self.test_irrigation)
+
+    async def test_set_zone_quickrun_duration_no_zones(self):
+        # Test with irrigation that has no zones
+        self.test_irrigation.zones = []
+
+        result = await self.irrigation_service.set_zone_quickrun_duration(
+            self.test_irrigation,
+            1,
+            300
+        )
+
+        # Verify no error and empty zones list
+        self.assertEqual(len(self.test_irrigation.zones), 0)
+        self.assertEqual(result, self.test_irrigation)
+
+if __name__ == '__main__':
+    unittest.main() 

wyzeapy/types.py

@@ -48,6 +48,7 @@ class DeviceTypes(Enum):
     SENSE_V2_GATEWAY = "S1Gateway"
     KEYPAD = "Keypad"
     LIGHTSTRIP = "LightStrip"
+    IRRIGATION = "Common"
 
 
 class Device:
@@ -156,6 +157,14 @@ class ThermostatProps(Enum):
     ASW_HOLD = "asw_hold"
 
 
+class IrrigationProps(Enum):
+    IOT_STATE = "iot_state"  # Connection state: connected, disconnected
+    RSSI = "RSSI"
+    IP = "IP"
+    SN = "sn"
+    SSID = "ssid"
+
+
 class ResponseCodes(Enum):
     SUCCESS = "1"
     PARAMETER_ERROR = "1001"

{wyzeapy-0.5.29.dist-info → wyzeapy-0.5.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wyzeapy
-Version: 0.5.29
+Version: 0.5.30
 Summary: A library for interacting with Wyze devices
 Author-email: Katie Mulliken <katie@mulliken.net>
 License: GPL-3.0-only

{wyzeapy-0.5.29.dist-info → wyzeapy-0.5.30.dist-info}/RECORD

@@ -1,22 +1,24 @@
-wyzeapy/__init__.py,sha256=PeZ7J6Q9P8CsNrtpoUU7j8_OHMzupjn9pAKV7ba4ECQ,16850
+wyzeapy/__init__.py,sha256=QckgsDmJxrQFPdVT4rheUqi3cCBSN-jkEWD-6hHmrqk,17248
 wyzeapy/const.py,sha256=3PV2Uq7wDD1X0ZmJBg8GWXYGHrpJvszyr9FuvwjHyus,1249
 wyzeapy/crypto.py,sha256=ApzPL0hrrd0D4k2jB5psNatJvUSzx1Kxui6_l4NJGO8,2057
 wyzeapy/exceptions.py,sha256=uKVWooofK22DZ3o9kwxnlJXnhk0VMJXnp-26pNavAis,1136
-wyzeapy/payload_factory.py,sha256=HbkVMUsJgFiRnoOh2ppmTAQobRMgFX8DcEuGg9AMQ2k,19735
-wyzeapy/types.py,sha256=5VP2ltvYsGZQCovYWmEefTNopz3lHxsbeFiOUtRDYfM,6591
+wyzeapy/payload_factory.py,sha256=D37H0rTFakqnhmYrYjBAhFvRSquujINA7b8UyhRUjl0,20547
+wyzeapy/types.py,sha256=LPLc86FkEy8rUoPMwG8xB73NCTVRkJ1O5w7uSfDydLQ,6785
 wyzeapy/utils.py,sha256=EXnsZFBxgI3LsIh9Ttg4gq3Aq1VMLOxBUPCspWJX9IQ,7407
 wyzeapy/wyze_auth_lib.py,sha256=CiWdl_UAzYxKLS8yCfjXxEI87gStJede2eS4g7KlnjE,18273
 wyzeapy/services/__init__.py,sha256=hbdyglbWQjM4XlNqPIACOEbspdsEEm4k5VXZ1hI0gc8,77
-wyzeapy/services/base_service.py,sha256=wMxWIlQyW_Kmsu_U7TvIZR0ax-k22zwZywCKOG8xcPM,31671
+wyzeapy/services/base_service.py,sha256=HUIU2uugHhY0KiGvc5ALYQn4NnsFMNZzECLJgqPHR9Q,34573
 wyzeapy/services/bulb_service.py,sha256=DNuT9PBmFhXpaD9rcjoYZMt-TLWWEAC3o0Yyvw_itHA,7825
 wyzeapy/services/camera_service.py,sha256=vaJIChKDMg3zWcoC_JqITDBjw4sgFdyUEkl3_w2ML8I,11170
 wyzeapy/services/hms_service.py,sha256=lQojRASz9AlwqkRfj7W7gOKXpLHrHHVwBGMw5WJ23Nc,2450
+wyzeapy/services/irrigation_service.py,sha256=lzQoUT2COlIMF1oTTDsvb-7H7zkra96i_Cxr4zkfYzs,7110
 wyzeapy/services/lock_service.py,sha256=NBjlr7pL5zJqdJaH33v1i6BbLHb7TXCkoCql4hCr8J8,2234
 wyzeapy/services/sensor_service.py,sha256=WSNz0OOLoZKru4d1ZwZ80-pdJ321HssUnwEgVfwX2zM,3578
 wyzeapy/services/switch_service.py,sha256=2O3J8-hP3vOgGVi0cKiKG_3j71zI6rHiqQd3u7CEKcE,2244
 wyzeapy/services/thermostat_service.py,sha256=_d-UbD65JArhwsslawvwpTmfVC4tMksY-L1Uu7HW0m4,5360
 wyzeapy/services/update_manager.py,sha256=5pZJmnyN4rlYJwMtEY13NlPBssnRLhtlLLmXr9t990Q,6770
 wyzeapy/services/wall_switch_service.py,sha256=cBKmnB2InHKIuoPwQ47t1rDtDplyOyGQYvnfX4fXFcc,4339
-wyzeapy-0.5.29.dist-info/METADATA,sha256=xYN-zwQtZz2SYcJ0f9HetzIj7VShIyrDZzHtPQiCCyQ,445
-wyzeapy-0.5.29.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wyzeapy-0.5.29.dist-info/RECORD,,
+wyzeapy/tests/test_irrigation_service.py,sha256=6rknfL0FzkptHs4CcYBamBTMD4pHcG0RyYNe3OgYBI8,21270
+wyzeapy-0.5.30.dist-info/METADATA,sha256=7OVSrLycTNIfh3zcmTI-38EZ0xt4NZExNKamzuTT61I,445
+wyzeapy-0.5.30.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wyzeapy-0.5.30.dist-info/RECORD,,