wyzeapy 0.5.29__py3-none-any.whl → 0.5.31__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
@@ -442,6 +444,14 @@ class Wyzeapy:
             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:
         """Provides access to the Wyze Wall Switch service.

wyzeapy/payload_factory.py

@@ -52,6 +52,40 @@ 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_get_payload_irrigation_schedule_runs(
+    device_mac: str,
+) -> Dict[str, Any]:
+    nonce = int(time.time() * 1000)
+
+    return {"device_id": device_mac, "nonce": str(nonce)}
+
+
 def olive_create_post_payload(
     device_mac: str, device_model: str, prop_key: str, value: Any
 ) -> Dict[str, Any]:

wyzeapy/services/base_service.py

@@ -36,6 +36,10 @@ 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,
+    olive_create_get_payload_irrigation_schedule_runs,
 )
 from ..types import PropertyIDs, Device, DeviceMgmtToggleType
 from ..utils import (
@@ -896,3 +900,110 @@ 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
+
+    async def _get_schedule_runs(
+        self, url: str, device: Device, limit: int = 2
+    ) -> Dict[Any, Any]:
+        await self._auth_lib.refresh_if_should()
+
+        payload = olive_create_get_payload_irrigation_schedule_runs(device.mac)
+        payload["limit"] = limit
+        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

wyzeapy/services/bulb_service.py

@@ -15,7 +15,20 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class Bulb(Device):
-    """Bulb class for interacting with Wyze bulbs."""
+    """Bulb class for interacting with Wyze bulbs.
+
+    Note: When created via get_bulbs(), bulb properties (brightness, color,
+    color_temp, on) are initialized with default values. Call
+    BulbService.update(bulb) to fetch the actual current values from the
+    Wyze API.
+
+    Example:
+        bulb_service = await client.bulb_service
+        bulbs = await bulb_service.get_bulbs()
+        for bulb in bulbs:
+            bulb = await bulb_service.update(bulb)  # Fetches actual values
+            print(f"Brightness: {bulb.brightness}, Color: {bulb.color}")
+    """
 
     _brightness: int = 0
     _color_temp: int = 1800
@@ -90,10 +103,14 @@ class BulbService(BaseService):
     """Bulb service for interacting with Wyze bulbs."""
 
     async def update(self, bulb: Bulb) -> Bulb:
-        """Update the bulb object with the latest device parameters.
+        """Fetch and update the bulb's current state from the Wyze API.
+
+        This method retrieves the actual values for brightness, color,
+        color_temp, on/off state, and other properties from the Wyze API.
+        Must be called after get_bulbs() to get accurate property values.
 
         :param bulb: Bulb object to update
-        :return: Updated bulb object
+        :return: Updated bulb object with current property values
         """
         # Get updated device_params
         async with BaseService._update_lock:
@@ -131,7 +148,11 @@ class BulbService(BaseService):
     async def get_bulbs(self) -> List[Bulb]:
         """Get a list of all bulbs.
 
-        :return: List of Bulb objects
+        Note: Returned bulbs have default property values (brightness=0,
+        color="000000", etc.). Call update(bulb) on each bulb to fetch
+        the actual current values from the Wyze API.
+
+        :return: List of Bulb objects with default property values
         """
         if self._devices is None:
             self._devices = await self.get_object_list()

wyzeapy/services/irrigation_service.py

@@ -0,0 +1,246 @@
+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)
+
+    async def get_schedule_runs(self, device: Device) -> Dict[Any, Any]:
+        """Get schedule runs for an irrigation device.
+
+        Args:
+            device: The irrigation device
+
+        Returns:
+            Dict containing running status and zone information if running
+        """
+        url = (
+            "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/schedule_runs"
+        )
+        response = await self._get_schedule_runs(url, device, limit=2)
+
+        # Process the response and return simplified payload
+        result = {"running": False}
+
+        if "data" in response and "schedules" in response["data"]:
+            schedules = response["data"]["schedules"]
+            for schedule in schedules:
+                schedule_state = schedule.get("schedule_state")
+
+                if schedule_state == "running":
+                    result["running"] = True
+                    # Get zone information from zone_runs
+                    zone_runs = schedule.get("zone_runs")
+                    # Use the first zone run for zone info
+                    zone_run = zone_runs[0]
+                    result["zone_number"] = zone_run.get("zone_number")
+                    result["zone_name"] = zone_run.get("zone_name")
+                    break  # Found a running schedule, no need to check others
+        else:
+            _LOGGER.warning(
+                "No schedule data found in response for device %s", device.mac
+            )
+
+        return result

wyzeapy/tests/test_irrigation_service.py

@@ -0,0 +1,732 @@
+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)
+
+    async def test_get_schedule_runs_running_schedule(self):
+        # Mock the _get_schedule_runs method
+        self.irrigation_service._get_schedule_runs = AsyncMock()
+        mock_response = {
+            "data": {
+                "schedules": [
+                    {
+                        "schedule_state": "running",
+                        "schedule_name": "Morning Watering",
+                        "zone_runs": [
+                            {
+                                "zone_number": 3,
+                                "zone_name": "Backyard S",
+                                "start_ts": 1746376809,
+                                "end_ts": 1746376869,
+                            }
+                        ],
+                    }
+                ]
+            }
+        }
+        self.irrigation_service._get_schedule_runs.return_value = mock_response
+
+        # Test get_schedule_runs with running schedule
+        result = await self.irrigation_service.get_schedule_runs(self.test_irrigation)
+
+        # Verify the call was made with correct parameters
+        self.irrigation_service._get_schedule_runs.assert_awaited_once_with(
+            "https://wyze-lockwood-service.wyzecam.com/plugin/irrigation/schedule_runs",
+            self.test_irrigation,
+            limit=2,
+        )
+
+        # Verify the result
+        expected_result = {"running": True, "zone_number": 3, "zone_name": "Backyard S"}
+        self.assertEqual(result, expected_result)
+
+    async def test_get_schedule_runs_past_schedule(self):
+        # Mock the _get_schedule_runs method
+        self.irrigation_service._get_schedule_runs = AsyncMock()
+        mock_response = {
+            "data": {
+                "schedules": [
+                    {
+                        "schedule_state": "past",
+                        "schedule_name": "Evening Watering",
+                        "zone_runs": [
+                            {
+                                "zone_number": 1,
+                                "zone_name": "Front Yard",
+                                "start_ts": 1746376809,
+                                "end_ts": 1746376869,
+                            }
+                        ],
+                    }
+                ]
+            }
+        }
+        self.irrigation_service._get_schedule_runs.return_value = mock_response
+
+        # Test get_schedule_runs with past schedule
+        result = await self.irrigation_service.get_schedule_runs(self.test_irrigation)
+
+        # Verify the result
+        expected_result = {"running": False}
+        self.assertEqual(result, expected_result)
+
+    async def test_get_schedule_runs_no_schedules(self):
+        # Mock the _get_schedule_runs method
+        self.irrigation_service._get_schedule_runs = AsyncMock()
+        mock_response = {"data": {"schedules": []}}
+        self.irrigation_service._get_schedule_runs.return_value = mock_response
+
+        # Test get_schedule_runs with no schedules
+        result = await self.irrigation_service.get_schedule_runs(self.test_irrigation)
+
+        # Verify the result
+        expected_result = {"running": False}
+        self.assertEqual(result, expected_result)
+
+    async def test_get_schedule_runs_no_data(self):
+        # Mock the _get_schedule_runs method
+        self.irrigation_service._get_schedule_runs = AsyncMock()
+        mock_response = {}  # No data field
+        self.irrigation_service._get_schedule_runs.return_value = mock_response
+
+        # Test get_schedule_runs with no data
+        with self.assertLogs(
+            "wyzeapy.services.irrigation_service", level="WARNING"
+        ) as log:
+            result = await self.irrigation_service.get_schedule_runs(
+                self.test_irrigation
+            )
+
+        # Verify the result
+        expected_result = {"running": False}
+        self.assertEqual(result, expected_result)
+
+        # Verify warning was logged
+        self.assertIn(
+            "No schedule data found in response for device IRRIG123", log.output[0]
+        )
+
+    async def test_get_schedule_runs_multiple_schedules_running_first(self):
+        # Mock the _get_schedule_runs method
+        self.irrigation_service._get_schedule_runs = AsyncMock()
+        mock_response = {
+            "data": {
+                "schedules": [
+                    {
+                        "schedule_state": "running",
+                        "schedule_name": "Morning Watering",
+                        "zone_runs": [
+                            {
+                                "zone_number": 2,
+                                "zone_name": "Side Yard",
+                                "start_ts": 1746376809,
+                                "end_ts": 1746376869,
+                            }
+                        ],
+                    },
+                    {
+                        "schedule_state": "past",
+                        "schedule_name": "Evening Watering",
+                        "zone_runs": [
+                            {
+                                "zone_number": 1,
+                                "zone_name": "Front Yard",
+                                "start_ts": 1746376809,
+                                "end_ts": 1746376869,
+                            }
+                        ],
+                    },
+                ]
+            }
+        }
+        self.irrigation_service._get_schedule_runs.return_value = mock_response
+
+        # Test get_schedule_runs with multiple schedules, first one running
+        result = await self.irrigation_service.get_schedule_runs(self.test_irrigation)
+
+        # Verify the result uses the first running schedule
+        expected_result = {"running": True, "zone_number": 2, "zone_name": "Side Yard"}
+        self.assertEqual(result, expected_result)
+
+    async def test_get_schedule_runs_multiple_schedules_running_second(self):
+        # Mock the _get_schedule_runs method
+        self.irrigation_service._get_schedule_runs = AsyncMock()
+        mock_response = {
+            "data": {
+                "schedules": [
+                    {
+                        "schedule_state": "past",
+                        "schedule_name": "Evening Watering",
+                        "zone_runs": [
+                            {
+                                "zone_number": 1,
+                                "zone_name": "Front Yard",
+                                "start_ts": 1746376809,
+                                "end_ts": 1746376869,
+                            }
+                        ],
+                    },
+                    {
+                        "schedule_state": "running",
+                        "schedule_name": "Morning Watering",
+                        "zone_runs": [
+                            {
+                                "zone_number": 4,
+                                "zone_name": "Garden Area",
+                                "start_ts": 1746376809,
+                                "end_ts": 1746376869,
+                            }
+                        ],
+                    },
+                ]
+            }
+        }
+        self.irrigation_service._get_schedule_runs.return_value = mock_response
+
+        # Test get_schedule_runs with multiple schedules, second one running
+        result = await self.irrigation_service.get_schedule_runs(self.test_irrigation)
+
+        # Verify the result uses the first running schedule found
+        expected_result = {
+            "running": True,
+            "zone_number": 4,
+            "zone_name": "Garden Area",
+        }
+        self.assertEqual(result, expected_result)
+
+
+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/utils.py

@@ -81,8 +81,13 @@ def wyze_decrypt_cbc(key: str, enc_hex_str: str) -> str:
 
     Returns:
         The decrypted plaintext string.
+
+    Note:
+        MD5 is used here because it is required by Wyze's proprietary API protocol.
+        This is not a security vulnerability - it's mandatory for API compatibility.
     """
-    key_hash = hashlib.md5(key.encode("utf-8")).digest()
+    # MD5 is required by Wyze's API protocol - not a security choice but API compatibility
+    key_hash = hashlib.md5(key.encode("utf-8")).digest()  # nosec B324
 
     iv = b"0123456789ABCDEF"
     cipher = AES.new(key_hash, AES.MODE_CBC, iv)
@@ -104,10 +109,15 @@ def create_password(password: str) -> str:
 
     Returns:
         The hashed password as a hex string.
+
+    Note:
+        Triple MD5 is mandated by Wyze's authentication API. This cannot be changed
+        without breaking compatibility with Wyze's servers.
     """
-    hex1 = hashlib.md5(password.encode()).hexdigest()
-    hex2 = hashlib.md5(hex1.encode()).hexdigest()
-    return hashlib.md5(hex2.encode()).hexdigest()
+    # MD5 is required by Wyze's authentication protocol - not a security choice
+    hex1 = hashlib.md5(password.encode()).hexdigest()  # nosec B324
+    hex2 = hashlib.md5(hex1.encode()).hexdigest()  # nosec B324
+    return hashlib.md5(hex2.encode()).hexdigest()  # nosec B324
 
 
 def check_for_errors_standard(service, response_json: Dict[str, Any]) -> None:

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: wyzeapy
-Version: 0.5.29
+Version: 0.5.31
 Summary: A library for interacting with Wyze devices
 Author-email: Katie Mulliken <katie@mulliken.net>
 License: GPL-3.0-only
 Requires-Python: >=3.11.0
-Requires-Dist: aiodns<4.0.0,>=3.2.0
+Requires-Dist: aiodns<5.0.0,>=3.2.0
 Requires-Dist: aiohttp<4.0.0,>=3.11.12
 Requires-Dist: pycryptodome<4.0.0,>=3.21.0
 Provides-Extra: dev
-Requires-Dist: pdoc<16.0.0,>=15.0.3; extra == 'dev'
-Requires-Dist: pytest<9.0.0,>=7.0.0; extra == 'dev'
+Requires-Dist: pdoc<17.0.0,>=15.0.3; extra == 'dev'
+Requires-Dist: pytest<10.0.0,>=7.0.0; extra == 'dev'

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

@@ -1,22 +1,24 @@
-wyzeapy/__init__.py,sha256=PeZ7J6Q9P8CsNrtpoUU7j8_OHMzupjn9pAKV7ba4ECQ,16850
+wyzeapy/__init__.py,sha256=4peDFw5zdEc9T6iR2NxZ1mwhcG3ShW91gceBJqcWZy8,17244
 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/utils.py,sha256=EXnsZFBxgI3LsIh9Ttg4gq3Aq1VMLOxBUPCspWJX9IQ,7407
+wyzeapy/payload_factory.py,sha256=1QUEgqSSDwEjKv1ew-jQYoXcFk0uf5B4gODw83ep2zg,20638
+wyzeapy/types.py,sha256=LPLc86FkEy8rUoPMwG8xB73NCTVRkJ1O5w7uSfDydLQ,6785
+wyzeapy/utils.py,sha256=_aoP9H7RXuND3nCMP3gJRLBxX6Dsxag81RLm83G5Pu4,7969
 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/bulb_service.py,sha256=DNuT9PBmFhXpaD9rcjoYZMt-TLWWEAC3o0Yyvw_itHA,7825
+wyzeapy/services/base_service.py,sha256=3FsbZHm6ndc6pSGCwrwh6SRgGb7HDK_L5lzuSjaLgO0,35547
+wyzeapy/services/bulb_service.py,sha256=4Z_rX40OGqzRuKz_fgyWGb4di7jtyJSB_ZvFFCDlcCo,8821
 wyzeapy/services/camera_service.py,sha256=vaJIChKDMg3zWcoC_JqITDBjw4sgFdyUEkl3_w2ML8I,11170
 wyzeapy/services/hms_service.py,sha256=lQojRASz9AlwqkRfj7W7gOKXpLHrHHVwBGMw5WJ23Nc,2450
+wyzeapy/services/irrigation_service.py,sha256=6HzwFRTjZcM4-Y9exSn5EmS2DZbl1gF_uaiMpK2Kd6c,8670
 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=ui3ZlqLUkoLb-uebK8Q1A83d9lAV9WIuHGbIrqPLyqg,28926
+wyzeapy-0.5.31.dist-info/METADATA,sha256=ps5g5kCz_rY2XLNeVS31nSuX4ZXp1xVQmNJTrCLsTOw,446
+wyzeapy-0.5.31.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wyzeapy-0.5.31.dist-info/RECORD,,

{wyzeapy-0.5.29.dist-info → wyzeapy-0.5.31.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any