Merge pull request #129 from fronzbot/dev

0.11.0

CHANGES.rst

@@ -3,6 +3,14 @@ Changelog
 
 A list of changes between each release
 
+0.10.3 (2018-11-18)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Use networks endpoint rather than homecreen to retrieve arm/disarm status (`@md-reddevil <https://github.com/fronzbot/blinkpy/pull/119>`__)
+- Fix incorrect command status endpoint (`@md-reddevil <https://github.com/fronzbot/blinkpy/pull/118>`__)
+- Add extra debug logging
+- Remove error prior to re-authorization (only log error when re-auth failed)
+
+
 0.10.2 (2018-10-30)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Set minimum required version of the requests library to 2.20.0 due to vulnerability in earlier releases.
@@ -11,19 +19,19 @@ A list of changes between each release
 
 0.10.1 (2018-10-18)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- Fix re-authorization bug (fixes `#101 <https://github.com/fronzbot/blinkpy/issues/#101>`_)
+- Fix re-authorization bug (fixes `#101 <https://github.com/fronzbot/blinkpy/issues/#101>`__)
 - Log an error if saving video that doesn't exist
 
 0.10.0 (2018-10-16)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Moved all API calls to own module for easier maintainability
 - Added network ids to sync module and cameras to allow for multi-network use
-- Removed dependency on video existance prior to camera setup (fixes `#93 <https://github.com/fronzbot/blinkpy/issues/#93>`_)
+- Removed dependency on video existance prior to camera setup (fixes `#93 <https://github.com/fronzbot/blinkpy/issues/#93>`__)
 - Camera wifi_strength now reported in wifi "bars" rather than dBm due to API endpoint change
 - Use homescreen thumbnail as fallback in case it's not in the camera endpoint
 - Removed "armed" and "status" attributes from camera (status of camera only reported by "motion_enabled" now)
 - Added serial number attributes to sync module and cameras
-- Check network_id from login response and verify that network is onboarded (fixes `#90 <https://github.com/fronzbot/#90>`_)
+- Check network_id from login response and verify that network is onboarded (fixes `#90 <https://github.com/fronzbot/#90>`__)
 - Check if retrieved clip is "None" prior to storing in cache
 
 0.9.0 (2018-09-27)
@@ -55,26 +63,26 @@ A list of changes between each release
 
 0.8.0 (2018-05-21)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- Added support for battery voltage level (fixes `#64 <https://github.com/fronzbot/blinkpy/issues/64>`_)
+- Added support for battery voltage level (fixes `#64 <https://github.com/fronzbot/blinkpy/issues/64>`__)
 - Added motion detection per camera
 - Added fully accessible camera configuration dict
-- Added celcius property to camera (fixes `#60 <https://github.com/fronzbot/blinkpy/issues/60>`_)
+- Added celcius property to camera (fixes `#60 <https://github.com/fronzbot/blinkpy/issues/60>`__)
 
 0.7.1 (2018-05-09)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- Fixed pip 10 import issue during setup (`@fronzbot <https://github.com/fronzbot/blinkpy/pull/61>`_)
+- Fixed pip 10 import issue during setup (`@fronzbot <https://github.com/fronzbot/blinkpy/pull/61>`__)
 
 0.7.0 (2018-02-08)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Fixed style errors for bumped pydocstring and pylint versions
-- Changed Blink.cameras dictionary to be case-insensitive (fixes `#35 <https://github.com/fronzbot/blinkpy/issues/35>`_)
-- Changed api endpoint for video extraction (fixes `#35 <https://github.com/fronzbot/blinkpy/issues/35>`_ and `#41 <https://github.com/fronzbot/blinkpy/issues/41>`_)
+- Changed Blink.cameras dictionary to be case-insensitive (fixes `#35 <https://github.com/fronzbot/blinkpy/issues/35>`__)
+- Changed api endpoint for video extraction (fixes `#35 <https://github.com/fronzbot/blinkpy/issues/35>`__ and `#41 <https://github.com/fronzbot/blinkpy/issues/41>`__)
 - Removed last_motion() function from Blink class
 - Refactored code for better organization
 - Moved some request calls out of @property methods (enables future CLI support)
 - Renamed get_summary() method to summary and changed to @property
 - Added ability to download most recent video clip
-- Improved camera arm/disarm handling (`@b10m <https://github.com/fronzbot/blinkpy/pull/50>`_)
+- Improved camera arm/disarm handling (`@b10m <https://github.com/fronzbot/blinkpy/pull/50>`__)
 - Added authentication to ``login()`` function and deprecated ``setup_system()`` in favor of ``start()``
 - Added ``attributes`` dictionary to camera object
 
@@ -83,7 +91,7 @@ A list of changes between each release
 - Removed redundent properties that only called hidden variables
 - Revised request wrapper function to be more intelligent
 - Added tests to ensure exceptions are caught and handled (100% coverage!)
-- Added auto-reauthorization (token refresh) when a request fails due to an expired token (`@tySwift93 <https://github.com/fronzbot/blinkpy/pull/24>`_)
+- Added auto-reauthorization (token refresh) when a request fails due to an expired token (`@tySwift93 <https://github.com/fronzbot/blinkpy/pull/24>`__)
 - Added battery level string to reduce confusion with the way Blink reports battery level as integer from 0 to 3
 
 0.5.2 (2017-03-12)

CONTRIBUTING.md

@@ -4,41 +4,55 @@ Everyone is welcome to contribute to blinkpy! The process to get started is desc
 
 ## Fork the Repository
 
-You can do this right in gituhb: just click the 'fork' button at the top right.
+You can do this right in github: just click the 'fork' button at the top right.
 
-## Setup Local Repository
+## Start Developing
 
-```shell
-$ git clone https://github.com/<YOUR_GIT_USERNAME>/blinkpy.git
-$ cd blinkpy
-$ git remote add upstream https://github.com/fronzbot/blinkpy.git
-```
+1. Setup Local Repository
+   ```shell
+   $ git clone https://github.com/<YOUR_GIT_USERNAME>/blinkpy.git
+   $ cd blinkpy
+   $ git remote add upstream https://github.com/fronzbot/blinkpy.git
+   ```
 
-## Create a Local Branch
+2. Create a Local Branch
+   
+   First, you will want to create a new branch to hold your changes:
+   ``git checkout -b <your-branch-name>``
 
-First, you will want to create a new branch to hold your changes:
-``git checkout -b <your-branch-name>``
-Next, you need to make sure you pull from the 'dev' branch:
-``git pull origin dev``
 
-## Make changes
+3. Make changes
+   
+   Now you can make changes to your code.  It is worthwhile to test your code as you progress (see the **Testing** section)
 
-Now you can make changes to your code.  It is worthwhile to test your code as you progress (see the **Testing** section)
+4. Commit Your Changes
+   
+   To commit changes to your branch, simply add the files you want and the commit them to the branch.  After that, you can push to your fork on GitHub:
+   ```shell
+   $ git add .
+   $ git commit -m "Put your commit text here.  Please be concise, but descriptive."
+   $ git push origin HEAD
+   ```
+   
+5. Submit your pull request on GitHub
+   
+   - On GitHub, navigate to the [blinkpy](https://github.com/fronzbot/blinkpy) repository.
+   - In the "Branch" menu, choose the branch that contains your commits (from your fork).
+   - To the right of the Branch menu, click New pull request.
+   - The base branch dropdown menu should read `dev`. Use the compare branch drop-down menu to choose the branch you made your changes        in.
+   - Type a title and complete the provided description for your pull request.
+   - Click Create pull request.
+   - More detailed instructions can be found here: [Creating a Pull Request](https://help.github.com/articles/creating-a-pull-request/)
+   
+6. Prior to merge approval
+   
+   Finally, the `blinkpy` repository uses continuous integration tools to run tests prior to merging. If there are any problems, you      will see a red 'X' next to your pull request. To see what's wrong, you can find your pull request [here](https://travis-       ci.org/fronzbot/blinkpy/pull_requests) and click on the failing test to see the logs.  Those logs will indicate, as best as they can, what is causing that test to fail.
 
-## Commit Your Changes
-
-To commit changes to your branch, simply add the files you want and the commit them to the branch.  After that, you can push to your fork on GitHub:
-
-```shell
-$ git add .
-$ git commit -m "Put your commit text here.  Please be concise, but descriptive."
-$ git push origin HEAD
-```
 
 ## Testing
 
 It is important to test the code to make sure your changes don't break anything major and that they pass PEP8 style conventions.
-FIrst, you need to locally install ``tox``
+First, you need to locally install ``tox``
 
 ```shell
 $ pip3 install tox
@@ -52,11 +66,11 @@ $ tox
 
 ### Tips
 
-If you only want to see if you can pass the local tests, you can run ``tox -e py34``.  If you just want to check for style violations, you can run ``tox -e lint``.  Regardless, when you submit a pull request, your code MUST pass both the unit tests, and the linters.
+If you only want to see if you can pass the local tests, you can run `tox -e py35` (or whatever python version you have installed.  Only `py35`, `py36`, and `py37` will be accepted).  If you just want to check for style violations, you can run `tox -e lint`.  Regardless, when you submit a pull request, your code MUST pass both the unit tests, and the linters.
 
-If you need to change anything in ``requirements.txt`` for any reason, you'll want to regenerate the virtual envrionments used by ``tox`` by running with the ``-r`` flag: ``tox -r``
+If you need to change anything in `requirements.txt` for any reason, you'll want to regenerate the virtual envrionments used by `tox` by running with the `-r` flag: `tox -r`
 
-Please do not locally disable any linter warnings within the ``blinkpy.py`` module itself (it's ok to do this in any of the ``test_*.py`` files)
+If you want to run a single test (perhaps you only changed a small thing in one file) you can run `tox -e py35 -- tests/<testname>.py -x`.  This will run the test `<testname>.py` and stop testing upon the first failure, making it easier to figure out why a particular test might be failing.  The test structure mimics the library structure, so if you changed something in `sync_module.py`, the associated test file would be in `test_sync_module.py` (ie. the filename is prepended with `test_`.
 
 # Catching Up With Reality
 
@@ -73,11 +87,3 @@ If rebase detects conflicts, repeat the following process until all changes have
 2. Add the modified file: ``git add <file>`` or ``git add .``.
 3. Continue rebase: ``git rebase --continue``.
 4. Repeat until all conflicts resolved.
-
-# Creating a Pull Request
-
-Please follow these steps to create a pull request against the ``dev`` branch: [Creating a Pull Request](https://help.github.com/articles/creating-a-pull-request/)
-
-# Monitor Build Status
-
-Once you create your PR, you can monitor the status of your build [here](https://travis-ci.org/fronzbot/blinkpy),  Your code will be tested to ensure it passes and won't cause any problems after merging.

README.rst

@@ -1,7 +1,6 @@
 blinkpy |Build Status| |Coverage Status| |Docs| |PyPi Version| |Python Version|
 ================================================================================
 A Python library for the Blink Camera system
-Only compatible with Python 3+
 
 Disclaimer:
 ~~~~~~~~~~~~~~~
@@ -32,12 +31,16 @@ To install the current development version, perform the following steps.  Note t
     $ pip3 install --upgrade dist/*.whl
 
 
+If you'd like to contribute to this library, please read the `contributing instructions <https://github.com/fronzbot/blinkpy/blob/dev/CONTRIBUTING.md>`__.
+
+For more information on how to use this library, please `read the docs <https://blinkpy.readthedocs.io/en/latest/>`__.
+
 Purpose
 ===========
-This library was built with the intention of allowing easy communication with Blink camera systems, specifically so I can add a module into homeassistant https://home-assistant.io
+This library was built with the intention of allowing easy communication with Blink camera systems, specifically to support the `Blink component <https://home-assistant.io/components/blink>`__ in `homeassistant <https://home-assistant.io/>`__.
 
-Usage
-=========
+Quick Start
+=============
 The simplest way to use this package from a terminal is to call ``Blink.start()`` which will prompt for your Blink username and password and then log you in.  Alternatively, you can instantiate the Blink class with a username and password, and call ``Blink.start()`` to login and setup without prompt, as shown below.  In addition, http requests are throttled internally via use of the ``Blink.refresh_rate`` variable, which can be set at initialization and defaults to 30 seconds.
 
 .. code:: python
@@ -48,7 +51,7 @@ The simplest way to use this package from a terminal is to call ``Blink.start()`
 
 If you would like to log in without setting up the cameras or system, you can simply call the ``Blink.login()`` function which will prompt for a username and password and then authenticate with the server.  This is useful if you want to avoid use of the ``start()`` function which simply acts as a wrapper for more targeted API methods.
 
-Cameras are instantiated as individual ``BlinkCamera`` classes within a ``BlinkSyncModule`` instance.  Note: currently the API only supports one sync module, but multiple sync modules are planned to be supported in the future.
+Cameras are instantiated as individual ``BlinkCamera`` classes within a ``BlinkSyncModule`` instance.  All of your sync modules are stored within the ``Blink.sync`` dictionary and can be accessed using the name of the sync module as the key (this is the name of your sync module in the Blink App).
 
 The below code will display cameras and their available attributes:
 
@@ -59,15 +62,15 @@ The below code will display cameras and their available attributes:
     blink = blinkpy.Blink(username='YOUR USER NAME', password='YOUR PASSWORD')
     blink.start()
 
-    for name, camera in blink.sync.cameras.items():
-        print(name)                   # Name of the camera
-        print(camera.attributes)      # Print available attributes of camera
+    for name, camera in blink.cameras.items():
+      print(name)                   # Name of the camera
+      print(camera.attributes)      # Print available attributes of camera
 
 The most recent images and videos can be accessed as a bytes-object via internal variables.  These can be updated with calls to ``Blink.refresh()`` but will only make a request if motion has been detected or other changes have been found.  This can be overridden with the ``force_cache`` flag, but this should be used for debugging only since it overrides the internal request throttling.
 
 .. code:: python
     
-    camera = blink.sync.camera['SOME CAMERA NAME']
+    camera = blink.cameras['SOME CAMERA NAME']
     blink.refresh(force_cache=True)  # force a cache update USE WITH CAUTION
     camera.image_from_cache.raw  # bytes-like image object (jpg)
     camera.video_from_cache.raw  # bytes-like video object (mp4)
@@ -76,7 +79,7 @@ The ``blinkpy`` api also allows for saving images and videos to a file and snapp
 
 .. code:: python
 
-    camera = blink.sync.camera['SOME CAMERA NAME']
+    camera = blink.cameras['SOME CAMERA NAME']
     camera.snap_picture()       # Take a new picture with the camera
     blink.refresh()             # Get new information from server
     camera.image_to_file('/local/path/for/image.jpg')

blinkpy/api.py

@@ -25,11 +25,17 @@ def request_login(blink, url, username, password):
 
 
 def request_networks(blink):
-    """Request network information."""
+    """Request all networks information."""
     url = "{}/networks".format(blink.urls.base_url)
     return http_get(blink, url)
 
 
+def request_network_status(blink, network):
+    """Request network information."""
+    url = "{}/network/{}".format(blink.urls.base_url, network)
+    return http_get(blink, url)
+
+
 def request_syncmodule(blink, network):
     """Request sync module info."""
     url = "{}/network/{}/syncmodules".format(blink.urls.base_url, network)
@@ -50,9 +56,9 @@ def request_system_disarm(blink, network):
 
 def request_command_status(blink, network, command_id):
     """Request command status."""
-    url = "{}/network/{}/command_id/{}".format(blink.urls.base_url,
-                                               network,
-                                               command_id)
+    url = "{}/network/{}/command/{}".format(blink.urls.base_url,
+                                            network,
+                                            command_id)
     return http_get(blink, url)
 
 
@@ -144,6 +150,7 @@ def http_get(blink, url, stream=False, json=True):
     """
     if blink.auth_header is None:
         raise BlinkException(ERROR.AUTH_TOKEN)
+    _LOGGER.debug("Making GET request to %s", url)
     return http_req(blink, url=url, headers=blink.auth_header,
                     reqtype='get', stream=stream, json_resp=json)
 
@@ -156,4 +163,5 @@ def http_post(blink, url):
     """
     if blink.auth_header is None:
         raise BlinkException(ERROR.AUTH_TOKEN)
+    _LOGGER.debug("Making POST request to %s", url)
     return http_req(blink, url=url, headers=blink.auth_header, reqtype='post')

blinkpy/blinkpy.py

@@ -14,14 +14,15 @@ I am in no way affiliated with Blink, nor Immedia Inc.
 import time
 import getpass
 import logging
+from requests.structures import CaseInsensitiveDict
 import blinkpy.helpers.errors as ERROR
 from blinkpy import api
 from blinkpy.sync_module import BlinkSyncModule
 from blinkpy.helpers.util import (
-    create_session, BlinkURLHandler,
+    create_session, merge_dicts, BlinkURLHandler,
     BlinkAuthenticationException)
 from blinkpy.helpers.constants import (
-    BLINK_URL, LOGIN_URL, LOGIN_BACKUP_URL, PROJECT_URL)
+    BLINK_URL, LOGIN_URL, LOGIN_BACKUP_URL)
 
 REFRESH_RATE = 30
 
@@ -46,16 +47,17 @@ class Blink():
         self._token = None
         self._auth_header = None
         self._host = None
-        self.network_id = None
         self.account_id = None
+        self.network_ids = []
         self.urls = None
-        self.sync = None
+        self.sync = CaseInsensitiveDict({})
         self.region = None
         self.region_id = None
         self.last_refresh = None
         self.refresh_rate = refresh_rate
         self.session = None
         self.networks = []
+        self.cameras = CaseInsensitiveDict({})
         self._login_url = LOGIN_URL
 
     @property
@@ -75,9 +77,12 @@ class Blink():
         else:
             self.get_auth_token()
 
-        self.get_ids()
-        self.sync = BlinkSyncModule(self)
-        self.sync.start()
+        networks = self.get_ids()
+        for network_name, network_id in networks.items():
+            sync_module = BlinkSyncModule(self, network_name, network_id)
+            sync_module.start()
+            self.sync[network_name] = sync_module
+        self.cameras = self.merge_cameras()
 
     def login(self):
         """Prompt user for username and password."""
@@ -136,18 +141,20 @@ class Blink():
         # Look for only onboarded network, flag warning if multiple
         # since it's unexpected
         all_networks = []
+        network_dict = {}
         for network, status in self.networks.items():
             if status['onboarded']:
-                all_networks.append(network)
-        self.network_id = all_networks.pop(0)
+                all_networks.append('{}'.format(network))
+                network_dict[status['name']] = network
+
+        # For the first onboarded network we find, grab the account id
         for resp in response['networks']:
-            if str(resp['id']) == self.network_id:
+            if str(resp['id']) in all_networks:
                 self.account_id = resp['account_id']
-        if all_networks:
-            _LOGGER.warning(("More than one onboarded network. "
-                             "Platform may not work as intended. "
-                             "If you experience problems, please "
-                             "open an issue on %s"), PROJECT_URL)
+                break
+
+        self.network_ids = all_networks
+        return network_dict
 
     def refresh(self, force_cache=False):
         """
@@ -156,8 +163,9 @@ class Blink():
         :param force_cache: Force an update of the camera cache
         """
         if self.check_if_ok_to_update() or force_cache:
-            _LOGGER.debug("Attempting refresh of cameras.")
-            self.sync.refresh(force_cache=force_cache)
+            for sync_name, sync_module in self.sync.items():
+                _LOGGER.debug("Attempting refresh of sync %s", sync_name)
+                sync_module.refresh(force_cache=force_cache)
 
     def check_if_ok_to_update(self):
         """Check if it is ok to perform an http request."""
@@ -169,3 +177,10 @@ class Blink():
             self.last_refresh = current_time
             return True
         return False
+
+    def merge_cameras(self):
+        """Merge all sync camera dicts into one."""
+        combined = CaseInsensitiveDict({})
+        for sync in self.sync:
+            combined = merge_dicts(combined, self.sync[sync].cameras)
+        return combined

blinkpy/camera.py

@@ -47,6 +47,7 @@ class BlinkCamera():
             'motion_detected': self.motion_detected,
             'wifi_strength': self.wifi_strength,
             'network_id': self.sync.network_id,
+            'sync_module': self.sync.name,
             'last_record': self.last_record
         }
         return attributes

blinkpy/helpers/constants.py

@@ -3,8 +3,8 @@
 import os
 
 MAJOR_VERSION = 0
-MINOR_VERSION = 10
-PATCH_VERSION = 2
+MINOR_VERSION = 11
+PATCH_VERSION = 0
 
 __version__ = '{}.{}.{}'.format(MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION)
 

blinkpy/helpers/util.py

@@ -2,13 +2,22 @@
 
 import logging
 from requests import Request, Session, exceptions
-from blinkpy.helpers.constants import BLINK_URL, PROJECT_URL
+from blinkpy.helpers.constants import BLINK_URL
 import blinkpy.helpers.errors as ERROR
 
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def merge_dicts(dict_a, dict_b):
+    """Merge two dictionaries into one."""
+    duplicates = [val for val in dict_a if val in dict_b]
+    if duplicates:
+        _LOGGER.warning(("Duplicates found during merge: %s. "
+                         "Renaming is recommended."), duplicates)
+    return {**dict_a, **dict_b}
+
+
 def create_session():
     """Create a session for blink communication."""
     sess = Session()
@@ -50,8 +59,7 @@ def http_req(blink, url='http://example.com', data=None, headers=None,
         response = blink.session.send(prepped, stream=stream)
         if json_resp and 'code' in response.json():
             if is_retry:
-                _LOGGER.error(("Cannot obtain new token for server auth. "
-                               "Please report this issue on %s"), PROJECT_URL)
+                _LOGGER.error("Cannot obtain new token for server auth.")
                 return None
             else:
                 headers = attempt_reauthorization(blink)
@@ -59,13 +67,14 @@ def http_req(blink, url='http://example.com', data=None, headers=None,
                                 reqtype=reqtype, stream=stream,
                                 json_resp=json_resp, is_retry=True)
     except (exceptions.ConnectionError, exceptions.Timeout):
-        _LOGGER.error("Cannot connect to server with url %s.", url)
+        _LOGGER.info("Cannot connect to server with url %s.", url)
         if not is_retry:
             headers = attempt_reauthorization(blink)
             return http_req(blink, url=url, data=data, headers=headers,
                             reqtype=reqtype, stream=stream,
                             json_resp=json_resp, is_retry=True)
-        _LOGGER.error("Possible issue with Blink servers.")
+        _LOGGER.error("Endpoint %s failed. Possible issue with Blink servers.",
+                      url)
         return None
 
     if json_resp:

blinkpy/sync_module.py

@@ -13,7 +13,7 @@ _LOGGER = logging.getLogger(__name__)
 class BlinkSyncModule():
     """Class to initialize sync module."""
 
-    def __init__(self, blink):
+    def __init__(self, blink, network_name, network_id):
         """
         Initialize Blink sync module.
 
@@ -21,16 +21,17 @@ class BlinkSyncModule():
         """
         self.blink = blink
         self._auth_header = blink.auth_header
-        self.network_id = blink.network_id
+        self.network_id = network_id
         self.region = blink.region
         self.region_id = blink.region_id
-        self.name = 'sync'
+        self.name = network_name
         self.serial = None
         self.status = None
         self.sync_id = None
         self.host = None
         self.summary = None
         self.homescreen = None
+        self.network_info = None
         self.record_dates = {}
         self.videos = {}
         self.events = []
@@ -64,7 +65,7 @@ class BlinkSyncModule():
     @property
     def arm(self):
         """Return status of sync module: armed/disarmed."""
-        return self.homescreen['network']['armed']
+        return self.network_info['network']['armed']
 
     @arm.setter
     def arm(self, value):
@@ -78,7 +79,6 @@ class BlinkSyncModule():
         """Initialize the system."""
         response = api.request_syncmodule(self.blink, self.network_id)
         self.summary = response['syncmodule']
-        self.name = self.summary['name']
         self.sync_id = self.summary['id']
         self.network_id = self.summary['network_id']
         self.serial = self.summary['serial']
@@ -88,6 +88,9 @@ class BlinkSyncModule():
 
         self.homescreen = api.request_homescreen(self.blink)
 
+        self.network_info = api.request_network_status(self.blink,
+                                                       self.network_id)
+
         camera_info = self.get_camera_info()
         for camera_config in camera_info:
             name = camera_config['name']
@@ -114,6 +117,8 @@ class BlinkSyncModule():
         self.events = self.get_events()
         self.videos = self.get_videos()
         self.homescreen = api.request_homescreen(self.blink)
+        self.network_info = api.request_network_status(self.blink,
+                                                       self.network_id)
         camera_info = self.get_camera_info()
         for camera_config in camera_info:
             name = camera_config['name']
@@ -135,9 +140,10 @@ class BlinkSyncModule():
             if not this_page:
                 break
             videos.append(this_page)
-
+        _LOGGER.debug("Getting videos from page %s through %s",
+                      start_page,
+                      end_page)
         for page in videos:
-            _LOGGER.debug("Retrieved video page %s", page)
             for entry in page:
                 camera_name = entry['camera_name']
                 clip_addr = entry['address']
@@ -168,5 +174,5 @@ class BlinkSyncModule():
                         }
                     ]
         self.record_dates = all_dates
-
+        _LOGGER.debug("Retrieved a total of %s records", len(all_dates))
         return self.videos

docs/api/blinkpy.rst

@@ -1,30 +1,17 @@
 .. _core_module:
 
-:mod:`blinkpy`
+Blinkpy
 ----------------------
 
 .. automodule:: blinkpy.blinkpy
+    :members:
 
 .. automodule:: blinkpy.sync_module
+    :members:
 
 .. automodule:: blinkpy.camera
+    :members:
 
 .. automodule:: blinkpy.helpers.util
-
-.. autoclass:: blinkpy.blinkpy.Blink
     :members:
 
-.. autoclass:: blinkpy.sync_module.BlinkSyncModule
-    :members:
-
-.. autoclass:: blinkpy.camera.BlinkCamera
-    :members:
-
-.. autoclass:: blinkpy.helpers.util.BlinkURLHandler
-    :members:
-
-.. autofunction:: blinkpy.helpers.util.create_session
-
-.. autofunction:: blinkpy.helpers.util.http_req
-
-.. autofunction:: blinkpy.helpers.util.attempt_reauthorization

docs/api/implemented.rst

@@ -0,0 +1,6 @@
+API Reference
+----------------------
+
+.. automodule:: blinkpy.api
+    :members:
+

tests/test_api.py

@@ -25,13 +25,14 @@ class TestBlinkAPI(unittest.TestCase):
     def test_http_req_connect_error(self, mock_auth):
         """Test http_get error condition."""
         mock_auth.return_value = {'foo': 'bar'}
-        firstlog = ("ERROR:blinkpy.helpers.util:"
-                    "Cannot connect to server with url {}").format(
-                        'http://notreal.fake.')
+        firstlog = ("INFO:blinkpy.helpers.util:"
+                    "Cannot connect to server with url {}.").format(
+                        'http://notreal.fake')
         nextlog = ("INFO:blinkpy.helpers.util:"
                    "Auth token expired, attempting reauthorization.")
         lastlog = ("ERROR:blinkpy.helpers.util:"
-                   "Possible issue with Blink servers.")
+                   "Endpoint {} failed. Possible issue with "
+                   "Blink servers.").format('http://notreal.fake')
         expected = [firstlog, nextlog, firstlog, lastlog]
         with self.assertLogs() as getlog:
             api.http_get(self.blink, 'http://notreal.fake')

tests/test_blink_functions.py

@@ -70,3 +70,15 @@ class TestBlinkFunctions(unittest.TestCase):
         self.assertEqual(self.blink.region, 'UNKNOWN')
         # pylint: disable=protected-access
         self.assertEqual(self.blink._token, 'foobar123')
+
+    def test_merge_cameras(self, mock_sess):
+        """Test merge camera functionality."""
+        first_dict = {'foo': 'bar', 'test': 123}
+        next_dict = {'foobar': 456, 'bar': 'foo'}
+        self.blink.sync['foo'] = BlinkSyncModule(self.blink, 'foo', 1)
+        self.blink.sync['bar'] = BlinkSyncModule(self.blink, 'bar', 2)
+        self.blink.sync['foo'].cameras = first_dict
+        self.blink.sync['bar'].cameras = next_dict
+        result = self.blink.merge_cameras()
+        expected = {'foo': 'bar', 'test': 123, 'foobar': 456, 'bar': 'foo'}
+        self.assertEqual(expected, result)

tests/test_blinkpy.py

@@ -14,7 +14,6 @@ from blinkpy.sync_module import BlinkSyncModule
 from blinkpy.helpers.util import (
     http_req, create_session, BlinkAuthenticationException,
     BlinkException, BlinkURLHandler)
-from blinkpy.helpers.constants import PROJECT_URL
 import tests.mock_responses as mresp
 
 USERNAME = 'foobar'
@@ -31,7 +30,7 @@ class TestBlinkSetup(unittest.TestCase):
         self.blink_no_cred = Blink()
         self.blink = Blink(username=USERNAME,
                            password=PASSWORD)
-        self.blink.sync = BlinkSyncModule(self.blink)
+        self.blink.sync['test'] = BlinkSyncModule(self.blink, 'test', '1234')
         self.blink.urls = BlinkURLHandler('test')
         self.blink.session = create_session()
 
@@ -79,8 +78,7 @@ class TestBlinkSetup(unittest.TestCase):
         """Check that we raise an Exception with a bad request."""
         self.blink.session = create_session()
         explog = ("ERROR:blinkpy.helpers.util:"
-                  "Cannot obtain new token for server auth. "
-                  "Please report this issue on {}").format(PROJECT_URL)
+                  "Cannot obtain new token for server auth.")
         with self.assertRaises(BlinkException):
             http_req(self.blink, reqtype='bad')
 
@@ -112,13 +110,28 @@ class TestBlinkSetup(unittest.TestCase):
             'networks': [{'id': 1234, 'account_id': 1111},
                          {'id': 5678, 'account_id': 2222}]
         }
-        self.blink.networks = {'0000': {'onboarded': False},
-                               '5678': {'onboarded': True},
-                               '1234': {'onboarded': False}}
+        self.blink.networks = {'0000': {'onboarded': False, 'name': 'foo'},
+                               '5678': {'onboarded': True, 'name': 'bar'},
+                               '1234': {'onboarded': False, 'name': 'test'}}
         self.blink.get_ids()
-        self.assertEqual(self.blink.network_id, '5678')
+        self.assertTrue('5678' in self.blink.network_ids)
         self.assertEqual(self.blink.account_id, 2222)
 
+    @mock.patch('blinkpy.api.request_networks')
+    def test_multiple_onboarded_networks(self, mock_net, mock_sess):
+        """Check that we handle multiple networks appropriately."""
+        mock_net.return_value = {
+            'networks': [{'id': 0000, 'account_id': 2222},
+                         {'id': 5678, 'account_id': 1111}]
+        }
+        self.blink.networks = {'0000': {'onboarded': False, 'name': 'foo'},
+                               '5678': {'onboarded': True, 'name': 'bar'},
+                               '1234': {'onboarded': True, 'name': 'test'}}
+        self.blink.get_ids()
+        self.assertTrue('5678' in self.blink.network_ids)
+        self.assertTrue('1234' in self.blink.network_ids)
+        self.assertEqual(self.blink.account_id, 1111)
+
     @mock.patch('blinkpy.blinkpy.time.time')
     def test_throttle(self, mock_time, mock_sess):
         """Check throttling functionality."""
@@ -130,3 +143,8 @@ class TestBlinkSetup(unittest.TestCase):
         self.assertEqual(result, True)
         self.assertEqual(self.blink.check_if_ok_to_update(), False)
         self.assertEqual(self.blink.last_refresh, now)
+
+    def test_sync_case_insensitive_dict(self, mock_sess):
+        """Check that we can access sync modules ignoring case."""
+        self.assertEqual(self.blink.sync['test'].name, 'test')
+        self.assertEqual(self.blink.sync['TEST'].name, 'test')

tests/test_cameras.py

@@ -46,10 +46,10 @@ class TestBlinkCameraSetup(unittest.TestCase):
         self.blink._auth_header = header
         self.blink.session = create_session()
         self.blink.urls = BlinkURLHandler('test')
-        self.blink.sync = BlinkSyncModule(self.blink)
-        self.camera = BlinkCamera(self.blink.sync)
+        self.blink.sync['test'] = BlinkSyncModule(self.blink, 'test', 1234)
+        self.camera = BlinkCamera(self.blink.sync['test'])
         self.camera.name = 'foobar'
-        self.blink.sync.cameras['foobar'] = self.camera
+        self.blink.sync['test'].cameras['foobar'] = self.camera
 
     def tearDown(self):
         """Clean up after test."""

tests/test_sync_module.py

@@ -24,7 +24,7 @@ class TestBlinkSyncModule(unittest.TestCase):
             'TOKEN_AUTH': 'foobar123'
         }
         self.blink.urls = blinkpy.BlinkURLHandler('test')
-        self.blink.sync = BlinkSyncModule(self.blink)
+        self.blink.sync['test'] = BlinkSyncModule(self.blink, 'test', '1234')
         self.camera = BlinkCamera(self.blink.sync)
 
     def tearDown(self):
@@ -35,12 +35,12 @@ class TestBlinkSyncModule(unittest.TestCase):
     def test_get_events(self, mock_resp):
         """Test get events function."""
         mock_resp.return_value = {'event': True}
-        self.assertEqual(self.blink.sync.get_events(), True)
+        self.assertEqual(self.blink.sync['test'].get_events(), True)
 
     def test_get_camera_info(self, mock_resp):
         """Test get camera info function."""
         mock_resp.return_value = {'devicestatus': True}
-        self.assertEqual(self.blink.sync.get_camera_info(), True)
+        self.assertEqual(self.blink.sync['test'].get_camera_info(), True)
 
     def test_get_videos_one_page(self, mock_resp):
         """Test video access."""
@@ -54,13 +54,13 @@ class TestBlinkSyncModule(unittest.TestCase):
         expected_videos = {'foobar': [
             {'clip': '/test/clip_1900_01_01_12_00_00AM.mp4',
              'thumb': '/test/thumb'}]}
-        expected_records = {'foobar': ['1900_01_01_12_00_00AM']}
+        expected_recs = {'foobar': ['1900_01_01_12_00_00AM']}
         expected_clips = {'foobar': {
             '1900_01_01_12_00_00AM': '/test/clip_1900_01_01_12_00_00AM.mp4'}}
-        self.blink.sync.get_videos(start_page=0, end_page=0)
-        self.assertEqual(self.blink.sync.videos, expected_videos)
-        self.assertEqual(self.blink.sync.record_dates, expected_records)
-        self.assertEqual(self.blink.sync.all_clips, expected_clips)
+        self.blink.sync['test'].get_videos(start_page=0, end_page=0)
+        self.assertEqual(self.blink.sync['test'].videos, expected_videos)
+        self.assertEqual(self.blink.sync['test'].record_dates, expected_recs)
+        self.assertEqual(self.blink.sync['test'].all_clips, expected_clips)
 
     def test_get_videos_multi_page(self, mock_resp):
         """Test video access with multiple pages."""
@@ -71,30 +71,30 @@ class TestBlinkSyncModule(unittest.TestCase):
                 'thumbnail': '/foobar'
             }
         ]
-        self.blink.sync.get_videos()
+        self.blink.sync['test'].get_videos()
         self.assertEqual(mock_resp.call_count, 2)
         mock_resp.reset_mock()
-        self.blink.sync.get_videos(start_page=0, end_page=9)
+        self.blink.sync['test'].get_videos(start_page=0, end_page=9)
         self.assertEqual(mock_resp.call_count, 10)
 
     def test_sync_start(self, mock_resp):
         """Test sync start function."""
         mock_resp.side_effect = [
             {'syncmodule': {
-                'name': 'test',
                 'id': 1234,
                 'network_id': 5678,
                 'serial': '12345678',
                 'status': 'foobar'}},
             {'event': True},
             {},
+            {},
             {'devicestatus': {}},
             None,
             None
         ]
-        self.blink.sync.start()
-        self.assertEqual(self.blink.sync.name, 'test')
-        self.assertEqual(self.blink.sync.sync_id, 1234)
-        self.assertEqual(self.blink.sync.network_id, 5678)
-        self.assertEqual(self.blink.sync.serial, '12345678')
-        self.assertEqual(self.blink.sync.status, 'foobar')
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].name, 'test')
+        self.assertEqual(self.blink.sync['test'].sync_id, 1234)
+        self.assertEqual(self.blink.sync['test'].network_id, 5678)
+        self.assertEqual(self.blink.sync['test'].serial, '12345678')
+        self.assertEqual(self.blink.sync['test'].status, 'foobar')