Merge pull request #16 from ehendrix23/One-request-for-all

arraylabs · web-flow · commit 11098ee80748 · 2019-02-02T13:39:12.000-05:00
Retrieve all device states through 1 request
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,8 @@
 .mypy_cache
 Pipfile.lock
 pymyq.egg-info
+.DS_Store
+.idea/
+__pycache__/
+venv/
+
diff --git a/README.md b/README.md
@@ -64,9 +64,12 @@ asyncio.get_event_loop().run_until_complete(main())
 * `device_id`: the device's MyQ ID
 * `parent_id`: the device's parent device's MyQ ID
 * `name`: the name of the device
+* `available`: if device is online
 * `serial`: the serial number of the device
 * `state`: the device's current state
 * `type`: the type of MyQ device
+* `open_allowed`: if device can be opened unattended
+* `close_allowed`: if device can be closed unattended
 
 ## Methods
 
@@ -76,7 +79,8 @@ All of the routines on the `MyQDevice` class are coroutines and need to be
 * `close`: close the device
 * `open`: open the device
 * `update`: get the latest device state (which can then be accessed via the 
-`state` property)
+`state` property). Retrieval of state from cloud is will only be done if more then 5 seconds has elapsed since last 
+request. State for all devices is retrieved through (1) request.  
 
 # Disclaimer
 
diff --git a/example.py b/example.py
@@ -1,18 +1,47 @@
 """Run an example script to quickly test any MyQ account."""
 import asyncio
+import logging
+import json
 
 from aiohttp import ClientSession
 
 import pymyq
+from pymyq.device import STATE_CLOSED, STATE_OPEN
 from pymyq.errors import MyQError
 
+# Provide your email and password account details for MyQ.
+MYQ_ACCOUNT_EMAIL = '<EMAIL>'
+MYQ_ACCOUNT_PASSWORD = '<PASSWORD>'
+
+# BRAND can be one of the following:
+# liftmaster
+# chamberlain
+# craftsmaster
+# merlin
+MYQ_BRAND = '<BRAND>'
+LOGLEVEL = 'ERROR'
+
+# Set JSON_DUMP to True to dump all the device information retrieved,
+# this can be helpful to determine what else is available.
+# Set JSON_DUMP to False to open/close the doors instead. i.e.:
+# JSON_DUMP = False
+JSON_DUMP = True
+
 
 async def main() -> None:
     """Create the aiohttp session and run the example."""
+
+    loglevels = dict((logging.getLevelName(level), level)
+                     for level in [10, 20, 30, 40, 50])
+
+    logging.basicConfig(
+        level=loglevels[LOGLEVEL],
+        format='%(asctime)s:%(levelname)s:\t%(name)s\t%(message)s')
+
     async with ClientSession() as websession:
         try:
             myq = await pymyq.login(
-                '<EMAIL>', '<PASSWORD>', '<BRAND>', websession)
+                MYQ_ACCOUNT_EMAIL, MYQ_ACCOUNT_PASSWORD, MYQ_BRAND, websession)
 
             devices = await myq.get_devices()
             for idx, device in enumerate(devices):
@@ -23,15 +52,47 @@ async def main() -> None:
                 print('Serial: {0}'.format(device.serial))
                 print('Device ID: {0}'.format(device.device_id))
                 print('Parent ID: {0}'.format(device.parent_id))
-                print('Current State: {0}'.format(device.state))
+                print('Online: {0}'.format(device.available))
+                print('Unattended Open: {0}'.format(device.open_allowed))
+                print('Unattended Close: {0}'.format(device.close_allowed))
                 print()
-                print('Opening the device...')
-                await device.open()
-                print('Current State: {0}'.format(device.state))
-                await asyncio.sleep(15)
-                print('Closing the device...')
-                await device.close()
                 print('Current State: {0}'.format(device.state))
+                if JSON_DUMP:
+                    print(json.dumps(device._device, indent=4))
+                else:
+                    if device.state != STATE_OPEN:
+                        print('Opening the device...')
+                        await device.open()
+                        print('    0 Current State: {0}'.format(device.state))
+                        for waited in range(1, 30):
+                            if device.state == STATE_OPEN:
+                                break
+                            await asyncio.sleep(1)
+                            await device.update()
+                            print('    {} Current State: {}'.format(
+                                waited, device.state))
+
+                        await asyncio.sleep(10)
+                        await device.update()
+                        print()
+                        print('Current State: {0}'.format(device.state))
+
+                    if device.state != STATE_CLOSED:
+                        print('Closing the device...')
+                        await device.close()
+                        print('    0 Current State: {0}'.format(device.state))
+                        for waited in range(1, 30):
+                            if device.state == STATE_CLOSED:
+                                break
+                            await asyncio.sleep(1)
+                            await device.update()
+                            print('    {} Current State: {}'.format(
+                                waited, device.state))
+
+                        await asyncio.sleep(10)
+                        await device.update()
+                        print()
+                        print('Current State: {0}'.format(device.state))
         except MyQError as err:
             print(err)
 
diff --git a/pymyq/__version__.py b/pymyq/__version__.py
@@ -1,2 +1,2 @@
 """Define a version constant."""
-__version__ = '1.0.0'
+__version__ = '1.1.0'
diff --git a/pymyq/api.py b/pymyq/api.py
@@ -1,10 +1,12 @@
 """Define the MyQ API."""
+import asyncio
 import logging
+from datetime import datetime, timedelta
+from typing import Optional
 
-from aiohttp import BasicAuth, ClientSession
+from aiohttp import ClientSession
 from aiohttp.client_exceptions import ClientError
 
-from .device import MyQDevice
 from .errors import MyQError, RequestError, UnsupportedBrandError
 
 _LOGGER = logging.getLogger(__name__)
@@ -13,7 +15,11 @@
 LOGIN_ENDPOINT = "api/v4/User/Validate"
 DEVICE_LIST_ENDPOINT = "api/v4/UserDeviceDetails/Get"
 
-DEFAULT_TIMEOUT = 10
+DEFAULT_TIMEOUT = 1
+DEFAULT_REQUEST_RETRIES = 3
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=5)
+
 DEFAULT_USER_AGENT = "Chamberlain/3773 (iPhone; iOS 11.0.3; Scale/2.00)"
 
 BRAND_MAPPINGS = {
@@ -52,9 +58,17 @@ def __init__(self, brand: str, websession: ClientSession) -> None:
             raise UnsupportedBrandError('Unknown brand: {0}'.format(brand))
 
         self._brand = brand
-        self._security_token = None
         self._websession = websession
 
+        self._credentials = None
+        self._security_token = None
+        self._devices = []
+        self._last_update = None
+        self.online = False
+
+        self._update_lock = asyncio.Lock()
+        self._security_token_lock = asyncio.Lock()
+
     async def _request(
             self,
             method: str,
@@ -64,8 +78,16 @@ async def _request(
             params: dict = None,
             data: dict = None,
             json: dict = None,
-            **kwargs) -> dict:
-        """Make a request."""
+            login_request: bool = False,
+            **kwargs) -> Optional[dict]:
+
+        # Get a security token if we do not have one AND this request
+        # is not to get a security token.
+        if self._security_token is None and not login_request:
+            await self._get_security_token()
+            if self._security_token is None:
+                return None
+
         url = '{0}/{1}'.format(API_BASE, endpoint)
 
         if not headers:
@@ -77,39 +99,150 @@ async def _request(
             'User-Agent': DEFAULT_USER_AGENT,
         })
 
+        start_request_time = datetime.time(datetime.now())
+        _LOGGER.debug('%s Initiating request to %s', start_request_time, url)
+        timeout = DEFAULT_TIMEOUT
+        # Repeat twice amount of max requests retries for timeout errors.
+        for attempt in range(0, (DEFAULT_REQUEST_RETRIES * 2) - 1):
+            try:
+                async with self._websession.request(
+                        method, url, headers=headers, params=params,
+                        data=data, json=json, timeout=timeout,
+                        **kwargs) as resp:
+                    resp.raise_for_status()
+                    return await resp.json(content_type=None)
+            except asyncio.TimeoutError:
+                # Start increasing timeout if already tried twice..
+                if attempt > 1:
+                    timeout = timeout * 2
+                _LOGGER.debug('%s Timeout requesting from %s',
+                                start_request_time, endpoint)
+            except ClientError as err:
+                if attempt == DEFAULT_REQUEST_RETRIES - 1:
+                    raise RequestError('{} Client Error while requesting '
+                                       'data from {}: {}'.format(
+                                           start_request_time, endpoint,
+                                           err))
+
+                _LOGGER.warning('%s Error requesting from %s; retrying: '
+                                '%s', start_request_time, endpoint, err)
+                await asyncio.sleep(5)
+
+        raise RequestError('{} Constant timeouts while requesting data '
+                           'from {}'.format(start_request_time, endpoint))
+
+    async def _update_device_state(self) -> None:
+        async with self._update_lock:
+            if datetime.utcnow() - self._last_update >\
+                    MIN_TIME_BETWEEN_UPDATES:
+                self.online = await self._get_device_states()
+
+    async def _get_device_states(self) -> bool:
+        _LOGGER.debug('Retrieving new device states')
         try:
-            async with self._websession.request(
-                    method, url, headers=headers, params=params, data=data,
-                    json=json, timeout=DEFAULT_TIMEOUT, **kwargs) as resp:
-                resp.raise_for_status()
-                return await resp.json(content_type=None)
-        except ClientError as err:
-            raise RequestError(
-                'Error requesting data from {0}: {1}'.format(endpoint, err))
+            devices_resp = await self._request('get', DEVICE_LIST_ENDPOINT)
+        except RequestError as err:
+            _LOGGER.error('Getting device states failed: %s', err)
+            return False
+
+        if devices_resp is None:
+            return False
+
+        return_code = int(devices_resp.get('ReturnCode', 1))
+
+        if return_code != 0:
+            if return_code == -3333:
+                # Login error, need to retrieve a new token next time.
+                self._security_token = None
+                _LOGGER.debug('Security token expired')
+            else:
+                _LOGGER.error(
+                    'Error %s while retrieving states: %s',
+                    devices_resp.get('ReturnCode'),
+                    devices_resp.get('ErrorMessage', 'Unknown Error'))
+            return False
+
+        self._store_device_states(devices_resp.get('Devices', []))
+        _LOGGER.debug('New device states retrieved')
+        return True
+
+    def _store_device_states(self, devices: dict) -> None:
+        for device in self._devices:
+            myq_device = next(
+                (element for element in devices
+                 if element.get('MyQDeviceId') == device['device_id']), None)
+
+            if myq_device is not None:
+                device['device_info'] = myq_device
+                continue
+
+        self._last_update = datetime.utcnow()
 
     async def authenticate(self, username: str, password: str) -> None:
         """Authenticate against the API."""
-        login_resp = await self._request(
-            'post',
-            LOGIN_ENDPOINT,
-            json={
-                'username': username,
-                'password': password
-            })
-
-        if int(login_resp['ReturnCode']) != 0:
-            raise MyQError(login_resp['ErrorMessage'])
-
-        self._security_token = login_resp['SecurityToken']
+        self._credentials = {
+            'username': username,
+            'password': password,
+        }
+
+        await self._get_security_token()
+
+    async def _get_security_token(self) -> None:
+        """Request a security token."""
+        _LOGGER.debug('Requesting security token.')
+        if self._credentials is None:
+            return
+
+        # Make sure only 1 request can be sent at a time.
+        async with self._security_token_lock:
+            # Confirm there is still no security token.
+            if self._security_token is None:
+                login_resp = await self._request(
+                    'post',
+                    LOGIN_ENDPOINT,
+                    json=self._credentials,
+                    login_request=True,
+                )
+
+                return_code = int(login_resp.get('ReturnCode', 1))
+                if return_code != 0:
+                    if return_code == 203:
+                        # Invalid username or password.
+                        _LOGGER.debug('Invalid username or password')
+                        self._credentials = None
+                    raise MyQError(login_resp['ErrorMessage'])
+
+                self._security_token = login_resp['SecurityToken']
 
     async def get_devices(self, covers_only: bool = True) -> list:
         """Get a list of all devices associated with the account."""
+        from .device import MyQDevice
+
+        _LOGGER.debug('Retrieving list of devices')
         devices_resp = await self._request('get', DEVICE_LIST_ENDPOINT)
-        return [
-            MyQDevice(device, self._brand, self._request)
-            for device in devices_resp['Devices'] if not covers_only
-            or device['MyQDeviceTypeName'] in SUPPORTED_DEVICE_TYPE_NAMES
-        ]
+        # print(json.dumps(devices_resp, indent=4))
+
+        device_list = []
+        if devices_resp is None:
+            return device_list
+
+        for device in devices_resp['Devices']:
+            if not covers_only or \
+               device['MyQDeviceTypeName'] in SUPPORTED_DEVICE_TYPE_NAMES:
+
+                self._devices.append({
+                    'device_id': device['MyQDeviceId'],
+                    'device_info': device
+                })
+                myq_device = MyQDevice(
+                    self._devices[-1], self._brand, self)
+                device_list.append(myq_device)
+
+        # Store current device states.
+        self._store_device_states(devices_resp.get('Devices', []))
+
+        _LOGGER.debug('List of devices retrieved')
+        return device_list
 
 
 async def login(
diff --git a/pymyq/device.py b/pymyq/device.py
diff --git a/requirements.txt b/requirements.txt

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`"""Define a version constant."""`
`2`		`-__version__ = '1.0.0'`
	`2`	`+__version__ = '1.1.0'`