wyzeapy

  1#  Copyright (c) 2021. Mulliken, LLC - All Rights Reserved
  2#  You may use, distribute and modify this code under the terms
  3#  of the attached license. You should have received a copy of
  4#  the license with this file. If not, please write to:
  5#  katie@mulliken.net to receive a copy
  6import logging
  7from inspect import iscoroutinefunction
  8from typing import List, Optional, Set, Callable
  9
 10from .const import PHONE_SYSTEM_TYPE, APP_VERSION, SC, APP_VER, SV, PHONE_ID, APP_NAME, OLIVE_APP_ID, APP_INFO
 11from .crypto import olive_create_signature
 12from .exceptions import TwoFactorAuthenticationEnabled
 13from .payload_factory import olive_create_user_info_payload
 14from .services.base_service import BaseService
 15from .services.bulb_service import BulbService
 16from .services.camera_service import CameraService
 17from .services.hms_service import HMSService
 18from .services.lock_service import LockService
 19from .services.sensor_service import SensorService
 20from .services.switch_service import SwitchService, SwitchUsageService
 21from .services.thermostat_service import ThermostatService
 22from .services.wall_switch_service import WallSwitchService
 23from .wyze_auth_lib import WyzeAuthLib, Token
 24
 25_LOGGER = logging.getLogger(__name__)
 26
 27
 28class Wyzeapy:
 29    """A Python module to assist developers in interacting with the Wyze service API.
 30    
 31    This class provides methods for authentication, device management, and accessing
 32    various Wyze device services including:
 33    
 34    * **Bulbs** - Control brightness, color, and power state
 35    * **Switches** - Toggle power and monitor usage
 36    * **Cameras** - Access video streams and control settings
 37    * **Thermostats** - Manage temperature settings and modes
 38    * **Locks** - Control and monitor door locks
 39    * **Sensors** - Monitor motion, contact, and environmental sensors
 40    * **HMS** - Manage home monitoring system
 41    
 42    Most interactions with Wyze devices should go through this class.
 43    """
 44    # _client: Client
 45    _auth_lib: WyzeAuthLib
 46
 47    def __init__(self):
 48        self._bulb_service = None
 49        self._switch_service = None
 50        self._camera_service = None
 51        self._thermostat_service = None
 52        self._hms_service = None
 53        self._lock_service = None
 54        self._sensor_service = None
 55        self._wall_switch_service = None
 56        self._switch_usage_service = None
 57        self._email = None
 58        self._password = None
 59        self._key_id = None
 60        self._api_key = None
 61        self._service: Optional[BaseService] = None
 62        self._token_callbacks: List[Callable] = []
 63
 64    @classmethod
 65    async def create(cls):
 66        """
 67        Creates and initializes the Wyzeapy class asynchronously.
 68        
 69        This factory method provides a way to instantiate the class using async/await syntax,
 70        though it's currently a simple implementation that may be expanded in the future.
 71        
 72        **Returns:**
 73            `Wyzeapy`: A new instance of the Wyzeapy class ready for authentication.
 74        """
 75        self = cls()
 76        return self
 77
 78    async def login(
 79        self, email, password, key_id, api_key, token: Optional[Token] = None
 80    ):
 81        """
 82        Authenticates with the Wyze API and retrieves the user's access token.
 83        
 84        This method handles the authentication process, including token management
 85        and service initialization. If two-factor authentication is enabled on the account,
 86        it will raise an exception requiring the use of `login_with_2fa()` instead.
 87        
 88        **Args:**
 89        * `email` (str): User's email address for Wyze account
 90        * `password` (str): User's password for Wyze account
 91        * `key_id` (str): Key ID for third-party API access
 92        * `api_key` (str): API Key for third-party API access
 93        * `token` (Optional[Token], optional): Existing token from a previous session. Defaults to None.
 94        
 95        **Raises:**
 96        * `TwoFactorAuthenticationEnabled`: When the account has 2FA enabled and requires verification
 97        """
 98
 99        self._email = email
100        self._password = password
101        self._key_id = key_id
102        self._api_key = api_key
103
104        try:
105            self._auth_lib = await WyzeAuthLib.create(
106                email, password, key_id, api_key, token, self.execute_token_callbacks
107            )
108            if token:
109                # User token supplied, refresh on startup
110                await self._auth_lib.refresh()
111            else:
112                await self._auth_lib.get_token_with_username_password(
113                    email, password, key_id, api_key
114                )
115            self._service = BaseService(self._auth_lib)
116        except TwoFactorAuthenticationEnabled as error:
117            raise error
118
119    async def login_with_2fa(self, verification_code) -> Token:
120        """
121        Completes the login process for accounts with two-factor authentication enabled.
122        
123        This method should be called after receiving a `TwoFactorAuthenticationEnabled`
124        exception from the `login()` method. It completes the authentication process
125        using the verification code sent to the user.
126        
127        **Args:**
128        * `verification_code` (str): The 2FA verification code received by the user
129            
130        **Returns:**
131        * `Token`: The authenticated user token object
132        """
133
134        _LOGGER.debug(f"Verification Code: {verification_code}")
135
136        await self._auth_lib.get_token_with_2fa(verification_code)
137        self._service = BaseService(self._auth_lib)
138        return self._auth_lib.token
139
140    async def execute_token_callbacks(self, token: Token):
141        """
142        Sends the token to all registered callback functions.
143        
144        This method is called internally whenever the token is refreshed or updated,
145        allowing external components to stay in sync with token changes.
146        
147        **Args:**
148        * `token` (Token): The current user token object
149        """
150        for callback in self._token_callbacks:
151            if iscoroutinefunction(callback):
152                await callback(token)
153            else:
154                callback(token)
155
156    def register_for_token_callback(self, callback_function):
157        """
158        Registers a callback function to be called whenever the user's token is modified.
159        
160        This allows external components to be notified of token changes for persistence
161        or other token-dependent operations.
162        
163        **Args:**
164        * `callback_function`: A function that accepts a Token object as its parameter
165        
166        **Example:**
167        ```python
168        def token_updated(token):
169            print(f"Token refreshed: {token.access_token[:10]}...")
170            
171        wyze = Wyzeapy()
172        wyze.register_for_token_callback(token_updated)
173        ```
174        """
175        self._token_callbacks.append(callback_function)
176
177    def unregister_for_token_callback(self, callback_function):
178        """
179        Removes a previously registered token callback function.
180        
181        This stops the specified callback from receiving token updates.
182        
183        **Args:**
184        * `callback_function`: The callback function to remove from the notification list
185        """
186        self._token_callbacks.remove(callback_function)
187
188    @property
189    async def unique_device_ids(self) -> Set[str]:
190        """
191        Retrieves a set of all unique device IDs known to the Wyze server.
192        
193        This property fetches all devices associated with the account and
194        extracts their MAC addresses as unique identifiers.
195        
196        **Returns:**
197        * `Set[str]`: A set containing all unique device IDs (MAC addresses)
198        
199        **Example:**
200        ```python
201        device_ids = await wyze.unique_device_ids
202        print(f"Found {len(device_ids)} devices")
203        ```
204        """
205
206        devices = await self._service.get_object_list()
207        device_ids = set()
208        for device in devices:
209            device_ids.add(device.mac)
210
211        return device_ids
212
213    @property
214    async def notifications_are_on(self) -> bool:
215        """
216        Checks if push notifications are enabled for the account.
217        
218        This property queries the user profile to determine the current
219        notification settings status.
220        
221        **Returns:**
222        * `bool`: True if notifications are enabled, False otherwise
223        """
224
225        response_json = await self._service.get_user_profile()
226        return response_json['data']['notification']
227
228    async def enable_notifications(self):
229        """Enables push notifications for the Wyze account.
230        
231        This method updates the user's profile to turn on push notifications
232        for all supported devices and events.
233        
234        **Example:**
235        ```python
236        # Turn on notifications
237        await wyze.enable_notifications()
238        ```
239        """
240
241        await self._service.set_push_info(True)
242
243    async def disable_notifications(self):
244        """Disables push notifications for the Wyze account.
245        
246        This method updates the user's profile to turn off push notifications
247        for all devices and events.
248        
249        **Example:**
250        ```python
251        # Turn off notifications
252        await wyze.disable_notifications()
253        ```
254        """
255
256        await self._service.set_push_info(False)
257
258    @classmethod
259    async def valid_login(
260        cls, email: str, password: str, key_id: str, api_key: str
261    ) -> bool:
262        """
263        Validates if the provided credentials can successfully authenticate with the Wyze API.
264        
265        This method attempts to log in with the provided credentials and returns whether
266        the authentication was successful. It's useful for validating credentials without
267        needing to handle the full login process.
268        
269        **Args:**
270        * `email` (str): The user's email address
271        * `password` (str): The user's password
272        * `key_id` (str): Key ID for third-party API access
273        * `api_key` (str): API Key for third-party API access
274            
275        **Returns:**
276        * `bool`: True if the credentials are valid and authentication succeeded
277        
278        **Example:**
279        ```python
280        is_valid = await Wyzeapy.valid_login("user@example.com", "password123", "key_id", "api_key")
281        if is_valid:
282            print("Credentials are valid")
283        else:
284            print("Invalid credentials")
285        ```
286        """
287
288        self = cls()
289        await self.login(email, password, key_id, api_key)
290
291        return not self._auth_lib.should_refresh
292
293    @property
294    async def bulb_service(self) -> BulbService:
295        """Provides access to the Wyze Bulb service.
296        
297        This property lazily initializes and returns a BulbService instance
298        for controlling and monitoring Wyze bulbs.
299        
300        **Returns:**
301        * `BulbService`: An instance of the bulb service for interacting with Wyze bulbs
302        
303        **Example:**
304        ```python
305        # Get all bulbs
306        bulb_service = await wyze.bulb_service
307        bulbs = await bulb_service.get_bulbs()
308        ```
309        """
310
311        if self._bulb_service is None:
312            self._bulb_service = BulbService(self._auth_lib)
313        return self._bulb_service
314
315    @property
316    async def switch_service(self) -> SwitchService:
317        """Provides access to the Wyze Switch service.
318        
319        This property lazily initializes and returns a SwitchService instance
320        for controlling and monitoring Wyze plugs and switches.
321        
322        **Returns:**
323        * `SwitchService`: An instance of the switch service for interacting with Wyze switches
324        
325        **Example:**
326        ```python
327        # Get all switches
328        switch_service = await wyze.switch_service
329        switches = await switch_service.get_switches()
330        ```
331        """
332
333        if self._switch_service is None:
334            self._switch_service = SwitchService(self._auth_lib)
335        return self._switch_service
336
337    @property
338    async def camera_service(self) -> CameraService:
339        """Provides access to the Wyze Camera service.
340        
341        This property lazily initializes and returns a CameraService instance
342        for controlling and monitoring Wyze cameras.
343        
344        **Returns:**
345        * `CameraService`: An instance of the camera service for interacting with Wyze cameras
346        
347        **Example:**
348        ```python
349        # Get all cameras
350        camera_service = await wyze.camera_service
351        cameras = await camera_service.get_cameras()
352        ```
353        """
354
355        if self._camera_service is None:
356            self._camera_service = CameraService(self._auth_lib)
357        return self._camera_service
358
359    @property
360    async def thermostat_service(self) -> ThermostatService:
361        """Provides access to the Wyze Thermostat service.
362        
363        This property lazily initializes and returns a ThermostatService instance
364        for controlling and monitoring Wyze thermostats.
365        
366        **Returns:**
367        * `ThermostatService`: An instance of the thermostat service for interacting with Wyze thermostats
368        
369        **Example:**
370        ```python
371        # Get all thermostats
372        thermostat_service = await wyze.thermostat_service
373        thermostats = await thermostat_service.get_thermostats()
374        ```
375        """
376
377        if self._thermostat_service is None:
378            self._thermostat_service = ThermostatService(self._auth_lib)
379        return self._thermostat_service
380
381    @property
382    async def hms_service(self) -> HMSService:
383        """Provides access to the Wyze Home Monitoring Service (HMS).
384        
385        This property lazily initializes and returns an HMSService instance
386        for controlling and monitoring the Wyze home security system.
387        
388        **Returns:**
389        * `HMSService`: An instance of the HMS service for interacting with Wyze home monitoring
390        
391        **Example:**
392        ```python
393        # Get HMS status
394        hms_service = await wyze.hms_service
395        status = await hms_service.get_hms_status()
396        ```
397        """
398
399        if self._hms_service is None:
400            self._hms_service = await HMSService.create(self._auth_lib)
401        return self._hms_service
402
403    @property
404    async def lock_service(self) -> LockService:
405        """Provides access to the Wyze Lock service.
406        
407        This property lazily initializes and returns a LockService instance
408        for controlling and monitoring Wyze locks.
409        
410        **Returns:**
411        * `LockService`: An instance of the lock service for interacting with Wyze locks
412        
413        **Example:**
414        ```python
415        # Get all locks
416        lock_service = await wyze.lock_service
417        locks = await lock_service.get_locks()
418        ```
419        """
420
421        if self._lock_service is None:
422            self._lock_service = LockService(self._auth_lib)
423        return self._lock_service
424
425    @property
426    async def sensor_service(self) -> SensorService:
427        """Provides access to the Wyze Sensor service.
428        
429        This property lazily initializes and returns a SensorService instance
430        for monitoring Wyze sensors such as contact sensors, motion sensors, etc.
431        
432        **Returns:**
433        * `SensorService`: An instance of the sensor service for interacting with Wyze sensors
434        
435        **Example:**
436        ```python
437        # Get all sensors
438        sensor_service = await wyze.sensor_service
439        sensors = await sensor_service.get_sensors()
440        ```
441        """
442
443        if self._sensor_service is None:
444            self._sensor_service = SensorService(self._auth_lib)
445        return self._sensor_service
446
447    @property
448    async def wall_switch_service(self) -> WallSwitchService:
449        """Provides access to the Wyze Wall Switch service.
450        
451        This property lazily initializes and returns a WallSwitchService instance
452        for controlling and monitoring Wyze wall switches.
453        
454        **Returns:**
455        * `WallSwitchService`: An instance of the wall switch service for interacting with Wyze wall switches
456        
457        **Example:**
458        ```python
459        # Get all wall switches
460        wall_switch_service = await wyze.wall_switch_service
461        switches = await wall_switch_service.get_wall_switches()
462        ```
463        """
464
465        if self._wall_switch_service is None:
466            self._wall_switch_service = WallSwitchService(self._auth_lib)
467        return self._wall_switch_service
468
469    @property
470    async def switch_usage_service(self) -> SwitchUsageService:
471        """Provides access to the Wyze Switch Usage service.
472        
473        This property lazily initializes and returns a SwitchUsageService instance
474        for retrieving usage statistics from Wyze switches and plugs.
475        
476        **Returns:**
477        * `SwitchUsageService`: An instance of the switch usage service for accessing Wyze switch usage data
478        
479        **Example:**
480        ```python
481        # Get usage data for a switch
482        usage_service = await wyze.switch_usage_service
483        usage = await usage_service.get_usage_records(switch_mac)
484        ```
485        """
486        if self._switch_usage_service is None:
487            self._switch_usage_service = SwitchUsageService(self._auth_lib)
488        return self._switch_usage_service