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

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/services/lock_service.py

@@ -27,7 +27,9 @@ class LockService(BaseService):
             ble_token_info = await self._get_lock_ble_token(lock)
             lock.raw_dict["token"] = ble_token_info["token"]
             lock.ble_id = ble_token_info["token"]["id"]
-            lock.ble_token = wyze_decrypt_cbc(FORD_APP_SECRET[:16], ble_token_info["token"]["token"])
+            lock.ble_token = wyze_decrypt_cbc(
+                FORD_APP_SECRET[:16], ble_token_info["token"]["token"]
+            )
 
         lock.available = lock.raw_dict.get("onoff_line") == 1
         lock.door_open = lock.raw_dict.get("door_open_status") == 1
@@ -37,13 +39,13 @@ class LockService(BaseService):
         locker_status = lock.raw_dict.get("locker_status")
         # Check if the door is locked
         lock.unlocked = locker_status.get("hardlock") == 2
-        
+
         # Reset unlocking and locking if needed
         if lock.unlocked and lock.unlocking:
             lock.unlocking = False
         if not lock.unlocked and lock.locking:
             lock.locking = False
-        
+
         return lock
 
     async def get_locks(self):

wyzeapy/services/sensor_service.py

@@ -31,9 +31,9 @@ class SensorService(BaseService):
             sensor.device_params = await self.get_updated_params(sensor.mac)
         properties = await self._get_device_info(sensor)
 
-        for property in properties['data']['property_list']:
-            pid = property['pid']
-            value = property['value']
+        for property in properties["data"]["property_list"]:
+            pid = property["pid"]
+            value = property["value"]
 
             try:
                 if PropertyIDs(pid) == PropertyIDs.CONTACT_STATE:
@@ -45,26 +45,44 @@ class SensorService(BaseService):
 
         return sensor
 
-    async def register_for_updates(self, sensor: Sensor, callback: Callable[[Sensor], None]):
+    async def register_for_updates(
+        self, sensor: Sensor, callback: Callable[[Sensor], None]
+    ):
         _LOGGER.debug(f"Registering sensor: {sensor.nickname} for updates")
         loop = asyncio.get_event_loop()
         if not self._updater_thread:
-            self._updater_thread = Thread(target=self.update_worker, args=[loop, ], daemon=True)
+            self._updater_thread = Thread(
+                target=self.update_worker,
+                args=[
+                    loop,
+                ],
+                daemon=True,
+            )
             self._updater_thread.start()
 
         self._subscribers.append((sensor, callback))
 
     async def deregister_for_updates(self, sensor: Sensor):
-        self._subscribers = [(sense, callback) for sense, callback in self._subscribers if sense.mac != sensor.mac]
+        self._subscribers = [
+            (sense, callback)
+            for sense, callback in self._subscribers
+            if sense.mac != sensor.mac
+        ]
 
     def update_worker(self, loop):
         while True:
             for sensor, callback in self._subscribers:
                 _LOGGER.debug(f"Providing update for {sensor.nickname}")
                 try:
-                    callback(asyncio.run_coroutine_threadsafe(self.update(sensor), loop).result())
+                    callback(
+                        asyncio.run_coroutine_threadsafe(
+                            self.update(sensor), loop
+                        ).result()
+                    )
                 except UnknownApiError as e:
-                    _LOGGER.warning(f"The update method detected an UnknownApiError: {e}")
+                    _LOGGER.warning(
+                        f"The update method detected an UnknownApiError: {e}"
+                    )
                 except ClientOSError as e:
                     _LOGGER.error(f"A network error was detected: {e}")
                 except ContentTypeError as e:
@@ -74,7 +92,10 @@ class SensorService(BaseService):
         if self._devices is None:
             self._devices = await self.get_object_list()
 
-        sensors = [Sensor(device.raw_dict) for device in self._devices if
-                   device.type is DeviceTypes.MOTION_SENSOR or
-                   device.type is DeviceTypes.CONTACT_SENSOR]
+        sensors = [
+            Sensor(device.raw_dict)
+            for device in self._devices
+            if device.type is DeviceTypes.MOTION_SENSOR
+            or device.type is DeviceTypes.CONTACT_SENSOR
+        ]
         return [Sensor(sensor.raw_dict) for sensor in sensors]

wyzeapy/services/switch_service.py

@@ -36,8 +36,12 @@ class SwitchService(BaseService):
         if self._devices is None:
             self._devices = await self.get_object_list()
 
-        devices = [device for device in self._devices if device.type is DeviceTypes.PLUG or
-                   device.type is DeviceTypes.OUTDOOR_PLUG]
+        devices = [
+            device
+            for device in self._devices
+            if device.type is DeviceTypes.PLUG
+            or device.type is DeviceTypes.OUTDOOR_PLUG
+        ]
         return [Switch(switch.raw_dict) for switch in devices]
 
     async def turn_on(self, switch: Switch):

wyzeapy/services/thermostat_service.py

@@ -37,9 +37,9 @@ class Preset(Enum):
 
 
 class HVACState(Enum):
-    COOLING = 'cooling'
-    HEATING = 'heating'
-    IDLE = 'idle'
+    COOLING = "cooling"
+    HEATING = "heating"
+    IDLE = "idle"
 
 
 class Thermostat(Device):
@@ -60,7 +60,7 @@ class Thermostat(Device):
 
 class ThermostatService(BaseService):
     async def update(self, thermostat: Thermostat) -> Thermostat:
-        properties = (await self._thermostat_get_iot_prop(thermostat))['data']['props']
+        properties = (await self._thermostat_get_iot_prop(thermostat))["data"]["props"]
 
         device_props = []
         for property in properties:
@@ -87,7 +87,7 @@ class ThermostatService(BaseService):
             elif prop == ThermostatProps.TEMPERATURE:
                 thermostat.temperature = float(value)
             elif prop == ThermostatProps.IOT_STATE:
-                thermostat.available = value == 'connected'
+                thermostat.available = value == "connected"
             elif prop == ThermostatProps.HUMIDITY:
                 thermostat.humidity = int(value)
             elif prop == ThermostatProps.WORKING_STATE:
@@ -99,7 +99,9 @@ class ThermostatService(BaseService):
         if self._devices is None:
             self._devices = await self.get_object_list()
 
-        thermostats = [device for device in self._devices if device.type is DeviceTypes.THERMOSTAT]
+        thermostats = [
+            device for device in self._devices if device.type is DeviceTypes.THERMOSTAT
+        ]
 
         return [Thermostat(thermostat.raw_dict) for thermostat in thermostats]
 
@@ -110,22 +112,34 @@ class ThermostatService(BaseService):
         await self._thermostat_set_iot_prop(thermostat, ThermostatProps.HEAT_SP, temp)
 
     async def set_hvac_mode(self, thermostat: Device, hvac_mode: HVACMode):
-        await self._thermostat_set_iot_prop(thermostat, ThermostatProps.MODE_SYS, hvac_mode.value)
+        await self._thermostat_set_iot_prop(
+            thermostat, ThermostatProps.MODE_SYS, hvac_mode.value
+        )
 
     async def set_fan_mode(self, thermostat: Device, fan_mode: FanMode):
-        await self._thermostat_set_iot_prop(thermostat, ThermostatProps.FAN_MODE, fan_mode.value)
+        await self._thermostat_set_iot_prop(
+            thermostat, ThermostatProps.FAN_MODE, fan_mode.value
+        )
 
     async def set_preset(self, thermostat: Thermostat, preset: Preset):
-        await self._thermostat_set_iot_prop(thermostat, ThermostatProps.CURRENT_SCENARIO, preset.value)
+        await self._thermostat_set_iot_prop(
+            thermostat, ThermostatProps.CURRENT_SCENARIO, preset.value
+        )
 
     async def _thermostat_get_iot_prop(self, device: Device) -> Dict[Any, Any]:
         url = "https://wyze-earth-service.wyzecam.com/plugin/earth/get_iot_prop"
-        keys = 'trigger_off_val,emheat,temperature,humidity,time2temp_val,protect_time,mode_sys,heat_sp,cool_sp,' \
-                'current_scenario,config_scenario,temp_unit,fan_mode,iot_state,w_city_id,w_lat,w_lon,working_state,' \
-                'dev_hold,dev_holdtime,asw_hold,app_version,setup_state,wiring_logic_id,save_comfort_balance,' \
-                'kid_lock,calibrate_humidity,calibrate_temperature,fancirc_time,query_schedule'
+        keys = (
+            "trigger_off_val,emheat,temperature,humidity,time2temp_val,protect_time,mode_sys,heat_sp,cool_sp,"
+            "current_scenario,config_scenario,temp_unit,fan_mode,iot_state,w_city_id,w_lat,w_lon,working_state,"
+            "dev_hold,dev_holdtime,asw_hold,app_version,setup_state,wiring_logic_id,save_comfort_balance,"
+            "kid_lock,calibrate_humidity,calibrate_temperature,fancirc_time,query_schedule"
+        )
         return await self._get_iot_prop(url, device, keys)
 
-    async def _thermostat_set_iot_prop(self, device: Device, prop: ThermostatProps, value: Any) -> None:
-        url = "https://wyze-earth-service.wyzecam.com/plugin/earth/set_iot_prop_by_topic"
+    async def _thermostat_set_iot_prop(
+        self, device: Device, prop: ThermostatProps, value: Any
+    ) -> None:
+        url = (
+            "https://wyze-earth-service.wyzecam.com/plugin/earth/set_iot_prop_by_topic"
+        )
         return await self._set_iot_prop(url, device, prop.value, value)

wyzeapy/services/update_manager.py

@@ -7,17 +7,34 @@ from ..types import Device
 import logging
 import threading
 
+"""
+Asynchronous device update scheduling and management.
+
+This module provides classes to schedule and execute periodic updates of
+Wyze devices, ensuring rate limits and fair distribution of update calls.
+"""
+
 _LOGGER = logging.getLogger(__name__)
 
 INTERVAL = 300
 MAX_SLOTS = 225
 
+
 @dataclass(order=True)
 class DeviceUpdater(object):
-    device: Device=field(compare=False)  # The device that will be updated
-    service: Any=field(compare=False)
-    update_in: int # A countdown to zero that will tell the priority queue that it is time to update this device
-    updates_per_interval: int=field(compare=False) # The number of updates that should happen every 5 minutes
+    """Represents a scheduled update task for a single device.
+
+    Attributes:
+        service: The service instance responsible for updating the device.
+        device: The Device object to be updated.
+        update_in: Countdown ticks until the next update is due.
+        updates_per_interval: Number of updates allowed per INTERVAL.
+    """
+
+    device: Device = field(compare=False)
+    service: Any = field(compare=False)
+    update_in: int  # Countdown ticks until this device should be updated
+    updates_per_interval: int = field(compare=False)
 
     def __init__(self, service, device: Device, update_interval: int):
         """
@@ -42,7 +59,7 @@ class DeviceUpdater(object):
                 self.device = await self.service.update(self.device)
                 # Callback to provide the updated info to the subscriber
                 self.device.callback_function(self.device)
-            except:
+            except Exception:
                 _LOGGER.exception("Unknown error happened during updating device info")
             finally:
                 # Release the mutex after the async call
@@ -63,11 +80,17 @@ class DeviceUpdater(object):
         if self.updates_per_interval > 1:
             self.updates_per_interval -= 1
 
+
 class UpdateManager:
-    # Holds all the logic for when to update the devices
+    """Manager for scheduling and executing periodic device updates.
+
+    Maintains a priority queue of DeviceUpdater instances and enforces rate
+    limits and fair distribution of update calls across devices.
+    """
+
     updaters = []
     removed_updaters = []
-    mutex = threading.Lock()  # Create a lock object as a class variable
+    mutex = threading.Lock()
 
     def check_if_removed(self, updater: DeviceUpdater):
         for item in self.removed_updaters:
@@ -78,7 +101,7 @@ class UpdateManager:
     # This function should be called once every second
     async def update_next(self):
         # If there are no updaters in the queue we don't need to do anything
-        if (len(self.updaters) == 0):
+        if len(self.updaters) == 0:
             _LOGGER.debug("No devices to update in queue")
             return
         while True:
@@ -92,12 +115,13 @@ class UpdateManager:
             # We then reduce the counter for all the other updaters
             self.tick_tock()
             # Then we update the target device
-            await updater.update(self.mutex) # It will only update if it is time for it to update. Otherwise it just reduces its update_in counter.
+            await updater.update(
+                self.mutex
+            )  # It will only update if it is time for it to update. Otherwise it just reduces its update_in counter.
             # Then we put it back at the end of the queue. Or the front again if it wasn't ready to update
             heappush(self.updaters, updater)
             await sleep(1)
 
-
     def filled_slots(self):
         # This just returns the number of available slots
         current_slots = 0
@@ -123,7 +147,10 @@ class UpdateManager:
 
         # When we add a new updater it has to fit within the max slots or we will not add it
         while (self.filled_slots() + updater.updates_per_interval) > MAX_SLOTS:
-            _LOGGER.debug("Reducing updates per interval to fit new device as slots are full: %s", self.filled_slots())
+            _LOGGER.debug(
+                "Reducing updates per interval to fit new device as slots are full: %s",
+                self.filled_slots(),
+            )
             # If we are overflowing the available slots we will reduce the frequency of updates evenly for all devices until we can fit in one more.
             self.decrease_updates_per_interval()
             updater.delay()

wyzeapy/services/wall_switch_service.py

@@ -41,7 +41,7 @@ class WallSwitch(Device):
 
 class WallSwitchService(BaseService):
     async def update(self, switch: WallSwitch) -> WallSwitch:
-        properties = (await self._wall_switch_get_iot_prop(switch))['data']['props']
+        properties = (await self._wall_switch_get_iot_prop(switch))["data"]["props"]
 
         device_props = []
         for prop_key, prop_value in properties.items():
@@ -67,9 +67,11 @@ class WallSwitchService(BaseService):
         if self._devices is None:
             self._devices = await self.get_object_list()
 
-        switches = [device for device in self._devices
-                    if device.type is DeviceTypes.COMMON 
-                    and device.product_model == "LD_SS1"]
+        switches = [
+            device
+            for device in self._devices
+            if device.type is DeviceTypes.COMMON and device.product_model == "LD_SS1"
+        ]
 
         return [WallSwitch(switch.raw_dict) for switch in switches]
 
@@ -89,7 +91,9 @@ class WallSwitchService(BaseService):
         await self._wall_switch_set_iot_prop(switch, WallSwitchProps.SWITCH_POWER, True)
 
     async def power_off(self, switch: WallSwitch):
-        await self._wall_switch_set_iot_prop(switch, WallSwitchProps.SWITCH_POWER, False)
+        await self._wall_switch_set_iot_prop(
+            switch, WallSwitchProps.SWITCH_POWER, False
+        )
 
     async def iot_on(self, switch: WallSwitch):
         await self._wall_switch_set_iot_prop(switch, WallSwitchProps.SWITCH_IOT, True)
@@ -97,14 +101,20 @@ class WallSwitchService(BaseService):
     async def iot_off(self, switch: WallSwitch):
         await self._wall_switch_set_iot_prop(switch, WallSwitchProps.SWITCH_IOT, False)
 
-    async def set_single_press_type(self, switch: WallSwitch, single_press_type: SinglePressType):
-        await self._wall_switch_set_iot_prop(switch, WallSwitchProps.SINGLE_PRESS_TYPE, single_press_type.value)
+    async def set_single_press_type(
+        self, switch: WallSwitch, single_press_type: SinglePressType
+    ):
+        await self._wall_switch_set_iot_prop(
+            switch, WallSwitchProps.SINGLE_PRESS_TYPE, single_press_type.value
+        )
 
     async def _wall_switch_get_iot_prop(self, device: Device) -> Dict[Any, Any]:
         url = "https://wyze-sirius-service.wyzecam.com//plugin/sirius/get_iot_prop"
         keys = "iot_state,switch-power,switch-iot,single_press_type"
         return await self._get_iot_prop(url, device, keys)
 
-    async def _wall_switch_set_iot_prop(self, device: Device, prop: WallSwitchProps, value: Any) -> None:
+    async def _wall_switch_set_iot_prop(
+        self, device: Device, prop: WallSwitchProps, value: Any
+    ) -> None:
         url = "https://wyze-sirius-service.wyzecam.com//plugin/sirius/set_iot_prop_by_topic"
         return await self._set_iot_prop(url, device, prop.value, value)