Merge pull request #152 from fronzbot/dev

0.12.0

API.md

@@ -1,5 +1,5 @@
 # BlinkMonitorProtocol
-Unofficial documentation for the Client API of the Blink Wire-Free HD Home Monitoring and Alert System.
+Unofficial documentation for the Client API of the Blink Wire-Free HD Home Monitoring & Alert System.
 
 Copied from https://github.com/MattTW/BlinkMonitorProtocol
 
@@ -7,9 +7,6 @@ I am not affiliated with the company in any way - this documentation is strictly
 
 The Client API is a straightforward REST API using JSON and HTTPS.
 
-## This Document
-The purpose here is to describe what is going on behind the scenes, and what commands we know are available to communicate with Blink servers.  This is NOT a description of the blinkpy module, but a description of the commands blinkpy relies on to effectively communicate.
-
 ## Login
 
 Client login to the Blink Servers.
@@ -19,20 +16,25 @@ Client login to the Blink Servers.
 >  "password" : "*your blink password*",
 >  "client_specifier" : "iPhone 9.2 | 2.2 | 222",
 >  "email" : "*your blink login/email*"
->}' --compressed https://prod.immedia-semi.com/login
+>}' --compressed https://rest.prod.immedia-semi.com/login
 
 **Response:**
->{"authtoken":{"authtoken":"*an auth token*","message":"auth"}}
+>{"authtoken":{"authtoken":"*an auth token*","message":"auth"},"networks":{"*network id*":{"name":"*name*","onboarded":true}},"region":{"*regioncode for endpoint*":"*region name"}}
 
 **Notes:**
 The authtoken value is passed in a header in future calls.
+The region code for endpoint is required to form the URL of the REST endpoint for future calls.
+Depending on the region you are registered you will need to change the REST endpoints below:
+- from `https://rest.prod.immedia-semi.com`
+- to `https://rest.prde.immedia-semi.com` if e.g. your device is registered in Germany
+Please note that at this moment it seems that all regions are not implemented equally: not all endpoints are available in all regions
 
-##Networks
+## Networks
 
 Obtain information about the Blink networks defined for the logged in user.
 
 **Request:**
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/networks
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/networks
 
 **Response:**
 JSON response containing information including Network ID and Account ID.
@@ -46,7 +48,7 @@ Network ID is needed to issue arm/disarm calls
 Obtain information about the Blink Sync Modules on the given network.
 
 **Request:**
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/network/*network_id_from_networks_call*/syncmodules
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/network/*network_id_from_networks_call*/syncmodules
 
 **Response:**
 JSON response containing information about the known state of the Sync module, most notably if it is online
@@ -56,11 +58,11 @@ Probably not strictly needed but checking result can verify that the sync module
 
 
 ## Arm
-
+ 
 Arm the given network (start recording/reporting motion events)
 
 **Request:**
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://prod.immedia-semi.com/network/*network_id_from_networks_call*/arm
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://rest.prod.immedia-semi.com/network/*network_id_from_networks_call*/arm
 
 **Response:**
 JSON response containing information about the arm command request, including the command/request ID
@@ -73,7 +75,7 @@ When this call returns, it does not mean the arm request is complete,  the clien
 Disarm the given network (stop recording/reporting motion events)
 
 **Request:**
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://prod.immedia-semi.com/network/*network_id_from_networks_call*/disarm
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://rest.prod.immedia-semi.com/network/*network_id_from_networks_call*/disarm
 
 **Response:**
 JSON response containing information about the disarm command request, including the command/request ID
@@ -87,7 +89,7 @@ When this call returns, it does not mean the disarm request is complete,  the cl
 Get status info on the given command
 
 **Request:**
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/network/*network_id*/command/*command_id*
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/network/*network_id*/command/*command_id*
 
 **Response:**
 JSON response containing state information of the given command, most notably whether it has completed and was successful.
@@ -103,7 +105,7 @@ lv_relay, arm, disarm, thumbnail, clip
 Return information displayed on the home screen of the mobile client
 
 **Request:**
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/homescreen
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/homescreen
 
 **Response:**
 JSON response containing information that the mobile client displays on the home page, including:  status, armed state, links to thumbnails for each camera, etc.
@@ -111,12 +113,12 @@ JSON response containing information that the mobile client displays on the home
 **Notes:**
 Not necessary to as part of issuing arm/disarm commands, but contains good summary info.
 
-##Events, thumbnails & video captures
+## Events, thumbnails & video captures
 
 **Request**
 Get events for a given network (sync module) -- Need network ID from home 
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/events/network/*network__id*
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/events/network/*network__id*
 
 **Response**
 A json list of evets incluing URL's.   Replace the "mp4" with "jpg" extension to get the thumbnail of each clip
@@ -144,7 +146,7 @@ Note that you replace the 'mp4' with a 'jpg' to get the thumbnail
 **Request**
 Captures a new thumbnail for a camera
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/thumbnail
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://rest.prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/thumbnail
 
 **Response**
 Command information. 
@@ -152,17 +154,17 @@ Command information.
 **Request**
 Captures a new video for a camera
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/clip
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://rest.prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/clip
 
 **Response**
 Command information.
 
-##Video Information
+## Video Information
 
 **Request**
 Get the total number of videos in the system
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/api/v2/videos/count
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/api/v2/videos/count
 
 **Response**
 JSON response containing the total video count.
@@ -170,7 +172,7 @@ JSON response containing the total video count.
 **Request**
 Gets a paginated set of video information
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/api/v2/videos/page/0
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/api/v2/videos/page/0
 
 **Response**
 JSON response containing a set of video information, including: camera name, creation time, thumbnail URI, size, length
@@ -178,7 +180,7 @@ JSON response containing a set of video information, including: camera name, cre
 **Request**
 Gets information for a specific video by ID
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/api/v2/video/*video_id*
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/api/v2/video/*video_id*
 
 **Response**
 JSON response containing video information
@@ -186,7 +188,7 @@ JSON response containing video information
 **Request**
 Gets a list of unwatched videos
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/api/v2/videos/unwatched
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/api/v2/videos/unwatched
 
 **Response**
 JSON response containing unwatched video information
@@ -194,7 +196,7 @@ JSON response containing unwatched video information
 **Request**
 Deletes a video
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://prod.immedia-semi.com/api/v2/video/*video_id*/delete
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://rest.prod.immedia-semi.com/api/v2/video/*video_id*/delete
 
 **Response**
 Unknown - not tested
@@ -202,7 +204,7 @@ Unknown - not tested
 **Request**
 Deletes all videos
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://prod.immedia-semi.com/api/v2/videos/deleteall
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --data-binary --compressed https://rest.prod.immedia-semi.com/api/v2/videos/deleteall
 
 **Response**
 Unknown - not tested
@@ -212,7 +214,7 @@ Unknown - not tested
 **Request**
 Gets a list of cameras
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/network/*network_id*/cameras
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/network/*network_id*/cameras
 
 **Response**
 JSON response containing camera information
@@ -220,7 +222,7 @@ JSON response containing camera information
 **Request**
 Gets information for one camera
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/network/*network_id*/camera/*camera_id*
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/network/*network_id*/camera/*camera_id*
 
 **Response**
 JSON response containing camera information
@@ -228,7 +230,7 @@ JSON response containing camera information
 **Request**
 Gets camera sensor information
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/signals
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/signals
 
 **Response**
 JSON response containing camera sensor information, such as wifi strength, temperature, and battery level
@@ -236,7 +238,7 @@ JSON response containing camera sensor information, such as wifi strength, tempe
 **Request**
 Enables motion detection for one camera
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: $auth_token" --data-binary --compressed https://prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/enable
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: $auth_token" --data-binary --compressed https://rest.prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/enable
 
 **Response**
 JSON response containing camera information
@@ -244,7 +246,7 @@ JSON response containing camera information
 **Request**
 Disables motion detection for one camera
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: $auth_token" --data-binary --compressed https://prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/disable
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: $auth_token" --data-binary --compressed https://rest.prod.immedia-semi.com/network/*network_id*/camera/*camera_id*/disable
 
 **Response**
 JSON response containing camera information
@@ -257,7 +259,7 @@ JSON response containing camera information
 **Request**
 Gets information about devices that have connected to the blink service
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/account/clients
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/account/clients
 
 **Response**
 JSON response containing client information, including: type, name, connection time, user ID
@@ -265,7 +267,7 @@ JSON response containing client information, including: type, name, connection t
 **Request**
 Gets information about supported regions
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/regions
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/regions
 
 **Response**
 JSON response containing region information
@@ -273,7 +275,7 @@ JSON response containing region information
 **Request**
 Gets information about system health
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/health
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/health
 
 **Response**
 "all ports tested are open"
@@ -281,7 +283,7 @@ Gets information about system health
 **Request**
 Gets information about programs
 
->curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://prod.immedia-semi.com/api/v1/networks/*network_id*/programs
+>curl -H "Host: prod.immedia-semi.com" -H "TOKEN_AUTH: *authtoken from login*" --compressed https://rest.prod.immedia-semi.com/api/v1/networks/*network_id*/programs
 
 **Response**
 Unknown.

CHANGES.rst

@@ -3,6 +3,21 @@ Changelog
 
 A list of changes between each release
 
+0.11.2 (2019-01-23)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Hotfix to prevent platform from stalling due to API change
+- Motion detection and video recovery broken until new API endpoint discovered
+
+0.11.1 (2019-01-02)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Fixed incorrect backup login url
+- Added calibrated temperature property for cameras
+
+
+0.11.0 (2018-11-23)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Added support for multiple sync modules
+
 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>`__)

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,24 @@ 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.
+At initialization, you may also set the logging level of the ``blinkpy`` library like so (default is ``INFO``:
+
+.. code:: python
+
+    import logging
+    from blinkpy import blinkpy
+    blink = blinkpy.Blink(..., loglevel=logging.<LEVEL>)
+    blink.start()
+    
+You can also disable logging of duplicate entries via the ``allow_duplicate_logs`` flag (default is ``True``):
+
+.. code:: python
+
+    from blinkpy import blinkpy
+    blink = blinkpy.Blink(..., allow_duplicate_logs=False)
+    blink.start()
+    
+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 +79,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,11 +96,22 @@ 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')
     camera.video_to_file('/local/path/for/video.mp4')
+    
+You can also use this library to download all videos from the server.  In order to do this, you must specify a ``path``.  You may also specifiy a how far back in time to go to retrieve videos via the ``since=`` variable (a simple string such as ``"2017/09/21"`` is sufficient), as well as how many pages to traverse via the ``page=`` variable.  Note that by default, the library will search the first ten pages which is sufficient in most use cases.  Additionally, you can specidy one or more cameras via the ``camera=`` property.  This can be a single string indicating the name of the camera, or a list of camera names.  By default, it is set to the string ``'all'`` to grab videos from all cameras.
+
+Example usage, which downloads all videos recorded since July 4th, 2018 at 9:34am to the ``/home/blink`` directory:
+
+.. code:: python
+
+    blink = blinkpy.Blink(username="YOUR USER NAME", password="YOUR PASSWORD")
+    blink.start()
+    blink.download_videos('/home/blink', since='2018/07/04 09:34')
+
 
 .. |Build Status| image:: https://travis-ci.org/fronzbot/blinkpy.svg?branch=dev
    :target: https://travis-ci.org/fronzbot/blinkpy

blinkpy/api.py

@@ -3,14 +3,22 @@
 import logging
 from json import dumps
 import blinkpy.helpers.errors as ERROR
-from blinkpy.helpers.util import http_req, BlinkException
+from blinkpy.helpers.util import http_req, get_time, BlinkException
 from blinkpy.helpers.constants import DEFAULT_URL
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def request_login(blink, url, username, password):
-    """Login request."""
+def request_login(blink, url, username, password, is_retry=False):
+    """
+    Login request.
+
+    :param blink: Blink instance.
+    :param url: Login url.
+    :param username: Blink username.
+    :param password: Blink password.
+    :param is_retry: Is this part of a re-authorization attempt?
+    """
     headers = {
         'Host': DEFAULT_URL,
         'Content-Type': 'application/json'
@@ -21,7 +29,7 @@ def request_login(blink, url, username, password):
         'client_specifier': 'iPhone 9.2 | 2.2 | 222'
     })
     return http_req(blink, url=url, headers=headers, data=data,
-                    json_resp=False, reqtype='post')
+                    json_resp=False, reqtype='post', is_retry=is_retry)
 
 
 def request_networks(blink):
@@ -31,31 +39,57 @@ def request_networks(blink):
 
 
 def request_network_status(blink, network):
-    """Request network information."""
+    """
+    Request network information.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}".format(blink.urls.base_url, network)
     return http_get(blink, url)
 
 
 def request_syncmodule(blink, network):
-    """Request sync module info."""
+    """
+    Request sync module info.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}/syncmodules".format(blink.urls.base_url, network)
     return http_get(blink, url)
 
 
 def request_system_arm(blink, network):
-    """Arm system."""
+    """
+    Arm system.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}/arm".format(blink.urls.base_url, network)
     return http_post(blink, url)
 
 
 def request_system_disarm(blink, network):
-    """Disarm system."""
+    """
+    Disarm system.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}/disarm".format(blink.urls.base_url, network)
     return http_post(blink, url)
 
 
 def request_command_status(blink, network, command_id):
-    """Request command status."""
+    """
+    Request command status.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param command_id: Command id to check.
+    """
     url = "{}/network/{}/command/{}".format(blink.urls.base_url,
                                             network,
                                             command_id)
@@ -69,13 +103,24 @@ def request_homescreen(blink):
 
 
 def request_sync_events(blink, network):
-    """Request events from sync module."""
+    """
+    Request events from sync module.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/events/network/{}".format(blink.urls.base_url, network)
     return http_get(blink, url)
 
 
 def request_new_image(blink, network, camera_id):
-    """Request to capture new thumbnail for camera."""
+    """
+    Request to capture new thumbnail for camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to request new image from.
+    """
     url = "{}/network/{}/camera/{}/thumbnail".format(blink.urls.base_url,
                                                      network,
                                                      camera_id)
@@ -83,33 +128,58 @@ def request_new_image(blink, network, camera_id):
 
 
 def request_new_video(blink, network, camera_id):
-    """Request to capture new video clip."""
+    """
+    Request to capture new video clip.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to request new video from.
+    """
     url = "{}/network/{}/camera/{}/clip".format(blink.urls.base_url,
                                                 network,
                                                 camera_id)
     return http_post(blink, url)
 
 
-def request_video_count(blink, headers):
+def request_video_count(blink):
     """Request total video count."""
     url = "{}/api/v2/videos/count".format(blink.urls.base_url)
     return http_get(blink, url)
 
 
-def request_videos(blink, page=0):
-    """Perform a request for videos."""
-    url = "{}/api/v2/videos/page/{}".format(blink.urls.base_url, page)
+def request_videos(blink, time=None, page=0):
+    """
+    Perform a request for videos.
+
+    :param blink: Blink instance.
+    :param time: Get videos since this time.  In epoch seconds.
+    :param page: Page number to get videos from.
+    """
+    timestamp = get_time(time)
+    url = "{}/api/v2/videos/changed?since={}&page={}".format(
+        blink.urls.base_url, timestamp, page)
     return http_get(blink, url)
 
 
 def request_cameras(blink, network):
-    """Request all camera information."""
+    """
+    Request all camera information.
+
+    :param Blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}/cameras".format(blink.urls.base_url, network)
     return http_get(blink, url)
 
 
 def request_camera_info(blink, network, camera_id):
-    """Request camera info for one camera."""
+    """
+    Request camera info for one camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to request info from.
+    """
     url = "{}/network/{}/camera/{}".format(blink.urls.base_url,
                                            network,
                                            camera_id)
@@ -117,7 +187,13 @@ def request_camera_info(blink, network, camera_id):
 
 
 def request_camera_sensors(blink, network, camera_id):
-    """Request camera sensor info for one camera."""
+    """
+    Request camera sensor info for one camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to request sesnor info from.
+    """
     url = "{}/network/{}/camera/{}/signals".format(blink.urls.base_url,
                                                    network,
                                                    camera_id)
@@ -125,7 +201,13 @@ def request_camera_sensors(blink, network, camera_id):
 
 
 def request_motion_detection_enable(blink, network, camera_id):
-    """Enable motion detection for a camera."""
+    """
+    Enable motion detection for a camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to enable.
+    """
     url = "{}/network/{}/camera/{}/enable".format(blink.urls.base_url,
                                                   network,
                                                   camera_id)
@@ -133,35 +215,44 @@ def request_motion_detection_enable(blink, network, camera_id):
 
 
 def request_motion_detection_disable(blink, network, camera_id):
-    """Disable motion detection for a camera."""
+    """Disable motion detection for a camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to disable.
+    """
     url = "{}/network/{}/camera/{}/disable".format(blink.urls.base_url,
                                                    network,
                                                    camera_id)
     return http_post(blink, url)
 
 
-def http_get(blink, url, stream=False, json=True):
+def http_get(blink, url, stream=False, json=True, is_retry=False):
     """
     Perform an http get request.
 
     :param url: URL to perform get request.
     :param stream: Stream response? True/FALSE
     :param json: Return json response? TRUE/False
+    :param is_retry: Is this part of a re-auth attempt?
     """
     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)
+                    reqtype='get', stream=stream, json_resp=json,
+                    is_retry=is_retry)
 
 
-def http_post(blink, url):
+def http_post(blink, url, is_retry=False):
     """
     Perform an http post request.
 
     :param url: URL to perfom post request.
+    :param is_retry: Is this part of a re-auth attempt?
     """
     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')
+    return http_req(blink, url=url, headers=blink.auth_header,
+                    reqtype='post', is_retry=is_retry)

blinkpy/blinkpy.py

@@ -1,38 +1,49 @@
 # -*- coding: utf-8 -*-
 """
-blinkpy by Kevin Fronczak - A Blink camera Python library.
+blinkpy is an unofficial api for the Blink security camera system.
+
+repo url: https://github.com/fronzbot/blinkpy
 
-https://github.com/fronzbot/blinkpy
 Original protocol hacking by MattTW :
 https://github.com/MattTW/BlinkMonitorProtocol
+
 Published under the MIT license - See LICENSE file for more details.
 "Blink Wire-Free HS Home Monitoring & Alert Systems" is a trademark
 owned by Immedia Inc., see www.blinkforhome.com for more information.
-I am in no way affiliated with Blink, nor Immedia Inc.
+blinkpy is in no way affiliated with Blink, nor Immedia Inc.
 """
 
+import os.path
 import time
 import getpass
 import logging
-import blinkpy.helpers.errors as ERROR
+from shutil import copyfileobj
+
+from requests.structures import CaseInsensitiveDict
+from dateutil.parser import parse
+
 from blinkpy import api
 from blinkpy.sync_module import BlinkSyncModule
+from blinkpy.helpers import errors as ERROR
+from blinkpy.helpers import log
 from blinkpy.helpers.util import (
-    create_session, BlinkURLHandler,
+    create_session, merge_dicts, get_time, BlinkURLHandler,
     BlinkAuthenticationException)
 from blinkpy.helpers.constants import (
-    BLINK_URL, LOGIN_URL, LOGIN_BACKUP_URL, PROJECT_URL)
+    BLINK_URL, LOGIN_URL, LOGIN_BACKUP_URL)
+from blinkpy.helpers.constants import __version__
 
 REFRESH_RATE = 30
 
-_LOGGER = logging.getLogger('blinkpy')
+_LOGGER = log.create_logger('blinkpy')
 
 
 class Blink():
     """Class to initialize communication."""
 
     def __init__(self, username=None, password=None,
-                 refresh_rate=REFRESH_RATE):
+                 refresh_rate=REFRESH_RATE, loglevel=logging.INFO,
+                 allow_duplicate_logs=True):
         """
         Initialize Blink system.
 
@@ -40,23 +51,33 @@ class Blink():
         :param password: Blink password
         :param refresh_rate: Refresh rate of blink information.
                              Defaults to 15 (seconds)
+        :param loglevel: Sets the log level for the logger.
+        :param allow_duplicate_logs: Set to 'False' to only allow a log
+                                     message to be logged once.
         """
         self._username = username
         self._password = password
         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.session = create_session()
         self.networks = []
+        self.cameras = CaseInsensitiveDict({})
+        self.video_list = CaseInsensitiveDict({})
         self._login_url = LOGIN_URL
+        self.version = __version__
+        self.allow_duplicate_logs = allow_duplicate_logs
+
+        self.loglevel = loglevel
+        self._reset_logger()
 
     @property
     def auth_header(self):
@@ -70,14 +91,20 @@ class Blink():
         Method logs in and sets auth token, urls, and ids for future requests.
         Essentially this is just a wrapper function for ease of use.
         """
-        if self._username is None or self._password is None:
-            self.login()
-        else:
-            self.get_auth_token()
+        self._reset_logger()
 
-        self.get_ids()
-        self.sync = BlinkSyncModule(self)
-        self.sync.start()
+        if self._username is None or self._password is None:
+            if not self.login():
+                return
+        elif not self.get_auth_token():
+            return
+
+        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."""
@@ -89,7 +116,7 @@ class Blink():
         _LOGGER.warning("Unable to login with %s.", self._username)
         return False
 
-    def get_auth_token(self):
+    def get_auth_token(self, is_retry=False):
         """Retrieve the authentication token from Blink."""
         if not isinstance(self._username, str):
             raise BlinkAuthenticationException(ERROR.USERNAME)
@@ -97,34 +124,39 @@ class Blink():
             raise BlinkAuthenticationException(ERROR.PASSWORD)
 
         login_url = LOGIN_URL
-        self.session = create_session()
         response = api.request_login(self,
                                      login_url,
                                      self._username,
-                                     self._password)
-
-        if response.status_code == 200:
+                                     self._password,
+                                     is_retry=is_retry)
+        try:
+            if response.status_code != 200:
+                _LOGGER.debug("Received response code %s during login.",
+                              response.status_code)
+                login_url = LOGIN_BACKUP_URL
+                response = api.request_login(self,
+                                             login_url,
+                                             self._username,
+                                             self._password,
+                                             is_retry=is_retry)
             response = response.json()
             (self.region_id, self.region), = response['region'].items()
-        else:
-            _LOGGER.debug(
-                ("Received response code %s "
-                 "when authenticating, "
-                 "trying new url"), response.status_code
-            )
-            login_url = LOGIN_BACKUP_URL
-            response = api.request_login(self,
-                                         login_url,
-                                         self._username,
-                                         self._password)
+        except AttributeError:
+            _LOGGER.error("Login API endpoint failed with response %s",
+                          response,
+                          exc_info=True)
+            return False
+        except KeyError:
+            _LOGGER.warning("Could not extract region info.")
             self.region_id = 'piri'
-            self.region = "UNKNOWN"
+            self.region = 'UNKNOWN'
 
         self._host = "{}.{}".format(self.region_id, BLINK_URL)
         self._token = response['authtoken']['authtoken']
+        self.networks = response['networks']
+
         self._auth_header = {'Host': self._host,
                              'TOKEN_AUTH': self._token}
-        self.networks = response['networks']
         self.urls = BlinkURLHandler(self.region_id)
         self._login_url = login_url
 
@@ -133,21 +165,21 @@ class Blink():
     def get_ids(self):
         """Set the network ID and Account ID."""
         response = api.request_networks(self)
-        # 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 +188,12 @@ 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)
+            if not force_cache:
+                # Prevents rapid clearing of motion detect property
+                self.last_refresh = int(time.time())
 
     def check_if_ok_to_update(self):
         """Check if it is ok to perform an http request."""
@@ -166,6 +202,102 @@ class Blink():
         if last_refresh is None:
             last_refresh = 0
         if current_time >= (last_refresh + self.refresh_rate):
-            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
+
+    def download_videos(self, path, since=None, camera='all', stop=10):
+        """
+        Download all videos from server since specified time.
+
+        :param path: Path to write files.  /path/<cameraname>_<recorddate>.mp4
+        :param since: Date and time to get videos from.
+                      Ex: "2018/07/28 12:33:00" to retrieve videos since
+                           July 28th 2018 at 12:33:00
+        :param camera: Camera name to retrieve.  Defaults to "all".
+                       Use a list for multiple cameras.
+        :param stop: Page to stop on (~25 items per page. Default page 10).
+        """
+        if since is None:
+            since_epochs = self.last_refresh
+        else:
+            parsed_datetime = parse(since, fuzzy=True)
+            since_epochs = parsed_datetime.timestamp()
+
+        formatted_date = get_time(time_to_convert=since_epochs)
+        _LOGGER.info("Retrieving videos since %s", formatted_date)
+
+        if not isinstance(camera, list):
+            camera = [camera]
+
+        for page in range(1, stop):
+            response = api.request_videos(self, time=since_epochs, page=page)
+            _LOGGER.debug("Processing page %s", page)
+            try:
+                result = response['videos']
+                if not result:
+                    raise IndexError
+            except (KeyError, IndexError):
+                _LOGGER.info("No videos found on page %s. Exiting.", page)
+                break
+
+            self._parse_downloaded_items(result, camera, path)
+
+    def _parse_downloaded_items(self, result, camera, path):
+        """Parse downloaded videos."""
+        for item in result:
+            try:
+                created_at = item['created_at']
+                camera_name = item['camera_name']
+                is_deleted = item['deleted']
+                address = item['address']
+            except KeyError:
+                _LOGGER.info("Missing clip information, skipping...")
+                continue
+
+            if camera_name not in camera and 'all' not in camera:
+                _LOGGER.debug("Skipping videos for %s.", camera_name)
+                continue
+
+            if is_deleted:
+                _LOGGER.debug("%s: %s is marked as deleted.",
+                              camera_name,
+                              address)
+                continue
+
+            clip_address = "{}{}".format(self.urls.base_url, address)
+            filename = "{}_{}.mp4".format(camera_name, created_at)
+            filename = os.path.join(path, filename)
+
+            if os.path.isfile(filename):
+                _LOGGER.info("%s already exists, skipping...", filename)
+                continue
+
+            response = api.http_get(self, url=clip_address,
+                                    stream=True, json=False)
+            with open(filename, 'wb') as vidfile:
+                copyfileobj(response.raw, vidfile)
+
+            _LOGGER.info("Downloaded video to %s", filename)
+
+    # pylint: disable=no-self-use
+    def _reset_logger(self):
+        """Reset the log handler."""
+        for handler in _LOGGER.handlers:
+            _LOGGER.removeHandler(handler)
+            handler.close()
+        _LOGGER.setLevel(self.loglevel)
+        if self.allow_duplicate_logs:
+            handler = logging.StreamHandler()
+            handler.setFormatter(log.log_formatter())
+        else:
+            handler = log.RepeatLogHandler()
+            handler.setFormatter(log.log_formatter())
+
+        _LOGGER.addHandler(handler)

blinkpy/camera.py

@@ -6,8 +6,6 @@ from blinkpy import api
 
 _LOGGER = logging.getLogger(__name__)
 
-MAX_CLIPS = 5
-
 
 class BlinkCamera():
     """Class to initialize individual camera."""
@@ -24,10 +22,11 @@ class BlinkCamera():
         self.battery_voltage = None
         self.clip = None
         self.temperature = None
+        self.temperature_calibrated = None
         self.battery_state = None
         self.motion_detected = None
         self.wifi_strength = None
-        self.last_record = []
+        self.last_record = None
         self._cached_image = None
         self._cached_video = None
 
@@ -40,6 +39,7 @@ class BlinkCamera():
             'serial': self.serial,
             'temperature': self.temperature,
             'temperature_c': self.temperature_c,
+            'temperature_calibrated': self.temperature_calibrated,
             'battery': self.battery,
             'thumbnail': self.thumbnail,
             'video': self.clip,
@@ -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
@@ -103,6 +104,16 @@ class BlinkCamera():
         self.temperature = config['temperature']
         self.wifi_strength = config['wifi_strength']
 
+        # Retrieve calibrated temperature from special endpoint
+        resp = api.request_camera_sensors(self.sync.blink,
+                                          self.network_id,
+                                          self.camera_id)
+        try:
+            self.temperature_calibrated = resp['temp']
+        except KeyError:
+            self.temperature_calibrated = self.temperature
+            _LOGGER.warning("Could not retrieve calibrated temperature.")
+
         # Check if thumbnail exists in config, if not try to
         # get it from the homescreen info in teh sync module
         # otherwise set it to None and log an error
@@ -116,12 +127,15 @@ class BlinkCamera():
             new_thumbnail = "{}{}.jpg".format(self.sync.urls.base_url,
                                               thumb_addr)
 
-        # Check if a new motion clip has been recorded
-        # check_for_motion_method sets motion_detected variable
-        self.check_for_motion()
+        try:
+            self.motion_detected = self.sync.motion[self.name]
+        except KeyError:
+            self.motion_detected = False
+
         clip_addr = None
-        if self.last_record:
-            clip_addr = self.sync.all_clips[self.name][self.last_record[0]]
+        if self.name in self.sync.last_record:
+            clip_addr = self.sync.last_record[self.name]['clip']
+            self.last_record = self.sync.last_record[self.name]['time']
             self.clip = "{}{}".format(self.sync.urls.base_url,
                                       clip_addr)
 
@@ -146,25 +160,6 @@ class BlinkCamera():
                                               stream=True,
                                               json=False)
 
-    def check_for_motion(self):
-        """Check if motion detected.."""
-        try:
-            records = sorted(self.sync.record_dates[self.name])
-            new_clip = records.pop()
-            if new_clip not in self.last_record and self.last_record:
-                self.motion_detected = True
-                self.last_record.insert(0, new_clip)
-                if len(self.last_record) > MAX_CLIPS:
-                    self.last_record.pop()
-            elif not self.last_record:
-                self.last_record.insert(0, new_clip)
-                self.motion_detected = False
-            else:
-                self.motion_detected = False
-        except KeyError:
-            _LOGGER.info("Could not extract clip info from camera %s",
-                         self.name)
-
     def image_to_file(self, path):
         """
         Write image to file.
@@ -178,7 +173,8 @@ class BlinkCamera():
                 copyfileobj(response.raw, imgfile)
         else:
             _LOGGER.error("Cannot write image to file, response %s",
-                          response.status_code)
+                          response.status_code,
+                          exc_info=True)
 
     def video_to_file(self, path):
         """Write video to file.
@@ -188,7 +184,9 @@ class BlinkCamera():
         _LOGGER.debug("Writing video from %s to %s", self.name, path)
         response = self._cached_video
         if response is None:
-            _LOGGER.error("No saved video exist for %s.", self.name)
+            _LOGGER.error("No saved video exist for %s.",
+                          self.name,
+                          exc_info=True)
             return
         with open(path, 'wb') as vidfile:
             copyfileobj(response.raw, vidfile)
@@ -204,5 +202,7 @@ class BlinkCamera():
                     return device_thumb
             except KeyError:
                 pass
-        _LOGGER.error("Could not find thumbnail for camera %s", self.name)
+        _LOGGER.error("Could not find thumbnail for camera %s",
+                      self.name,
+                      exc_info=True)
         return None

blinkpy/helpers/constants.py

@@ -3,8 +3,8 @@
 import os
 
 MAJOR_VERSION = 0
-MINOR_VERSION = 10
-PATCH_VERSION = 3
+MINOR_VERSION = 12
+PATCH_VERSION = 0
 
 __version__ = '{}.{}.{}'.format(MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION)
 
@@ -45,12 +45,17 @@ PYPI_URL = 'https://pypi.python.org/pypi/{}'.format(PROJECT_PACKAGE_NAME)
 URLS
 '''
 BLINK_URL = 'immedia-semi.com'
-LOGIN_URL = 'https://prod.' + BLINK_URL + '/login'
-LOGIN_BACKUP_URL = 'https://rest.piri/' + BLINK_URL + '/login'
-BASE_URL = 'https://prod.' + BLINK_URL
-DEFAULT_URL = 'prod.' + BLINK_URL
+DEFAULT_URL = "{}.{}".format('prod', BLINK_URL)
+BASE_URL = "https://{}".format(DEFAULT_URL)
+LOGIN_URL = "{}/login".format(BASE_URL)
+LOGIN_BACKUP_URL = "https://{}.{}/login".format('rest.piri', BLINK_URL)
 
 '''
 Dictionaries
 '''
 ONLINE = {'online': True, 'offline': False}
+
+'''
+OTHER
+'''
+TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%S%Z'

blinkpy/helpers/log.py

@@ -0,0 +1,33 @@
+"""Module for blinkpy logging."""
+import logging
+
+
+def create_logger(name):
+    """Create a logger instance."""
+    handler = RepeatLogHandler()
+    handler.setFormatter(log_formatter())
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.DEBUG)
+    logger.addHandler(handler)
+    return logger
+
+
+def log_formatter():
+    """Create log formatter."""
+    fmt = "%(asctime)s %(levelname)s [%(name)s] %(message)s"
+    return logging.Formatter(fmt)
+
+
+class RepeatLogHandler(logging.StreamHandler):
+    """Log handler for repeat entries."""
+
+    def __init__(self):
+        """Initialize repeat log handler."""
+        super().__init__()
+        self.log_record = set()
+
+    def emit(self, record):
+        """Ensure we only log a message once."""
+        if record.msg not in self.log_record:
+            self.log_record.add(record.msg)
+            super().emit(record)

blinkpy/helpers/util.py

@@ -1,14 +1,31 @@
 """Useful functions for blinkpy."""
 
 import logging
+import time
 from requests import Request, Session, exceptions
-from blinkpy.helpers.constants import BLINK_URL
+from blinkpy.helpers.constants import BLINK_URL, TIMESTAMP_FORMAT
 import blinkpy.helpers.errors as ERROR
 
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def get_time(time_to_convert=None):
+    """Create blink-compatible timestamp."""
+    if time_to_convert is None:
+        time_to_convert = time.time()
+    return time.strftime(TIMESTAMP_FORMAT, time.localtime(time_to_convert))
+
+
+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()
@@ -18,7 +35,7 @@ def create_session():
 def attempt_reauthorization(blink):
     """Attempt to refresh auth token and links."""
     _LOGGER.info("Auth token expired, attempting reauthorization.")
-    headers = blink.get_auth_token()
+    headers = blink.get_auth_token(is_retry=True)
     return headers
 
 
@@ -47,13 +64,15 @@ def http_req(blink, url='http://example.com', data=None, headers=None,
     prepped = req.prepare()
 
     try:
-        response = blink.session.send(prepped, stream=stream)
+        response = blink.session.send(prepped, stream=stream, timeout=10)
         if json_resp and 'code' in response.json():
             if is_retry:
                 _LOGGER.error("Cannot obtain new token for server auth.")
                 return None
             else:
                 headers = attempt_reauthorization(blink)
+                if not headers:
+                    raise exceptions.ConnectionError
                 return http_req(blink, url=url, data=data, headers=headers,
                                 reqtype=reqtype, stream=stream,
                                 json_resp=json_resp, is_retry=True)

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,10 +21,10 @@ 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
@@ -32,11 +32,10 @@ class BlinkSyncModule():
         self.summary = None
         self.homescreen = None
         self.network_info = None
-        self.record_dates = {}
-        self.videos = {}
         self.events = []
         self.cameras = CaseInsensitiveDict({})
-        self.all_clips = {}
+        self.motion = {}
+        self.last_record = {}
 
     @property
     def attributes(self):
@@ -78,102 +77,95 @@ class BlinkSyncModule():
     def start(self):
         """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']
-        self.status = self.summary['status']
+        try:
+            self.summary = response['syncmodule']
+            self.network_id = self.summary['network_id']
+        except (TypeError, KeyError):
+            _LOGGER.error(("Could not retrieve sync module information "
+                           "with response: %s"), response, exc_info=True)
+            return False
+
+        try:
+            self.sync_id = self.summary['id']
+            self.serial = self.summary['serial']
+            self.status = self.summary['status']
+        except KeyError:
+            _LOGGER.error("Could not extract some sync module info: %s",
+                          response,
+                          exc_info=True)
 
         self.events = self.get_events()
-
         self.homescreen = api.request_homescreen(self.blink)
-
         self.network_info = api.request_network_status(self.blink,
                                                        self.network_id)
 
+        self.check_new_videos()
         camera_info = self.get_camera_info()
         for camera_config in camera_info:
             name = camera_config['name']
             self.cameras[name] = BlinkCamera(self)
+            self.motion[name] = False
+            self.cameras[name].update(camera_config, force_cache=True)
 
-        self.videos = self.get_videos()
-        for camera_config in camera_info:
-            name = camera_config['name']
-            if name in self.cameras:
-                self.cameras[name].update(camera_config, force_cache=True)
+        return True
 
     def get_events(self):
         """Retrieve events from server."""
         response = api.request_sync_events(self.blink, self.network_id)
-        return response['event']
+        try:
+            return response['event']
+        except (TypeError, KeyError):
+            _LOGGER.error("Could not extract events: %s",
+                          response,
+                          exc_info=True)
+            return False
 
     def get_camera_info(self):
         """Retrieve camera information."""
         response = api.request_cameras(self.blink, self.network_id)
-        return response['devicestatus']
+        try:
+            return response['devicestatus']
+        except (TypeError, KeyError):
+            _LOGGER.error("Could not extract camera info: %s",
+                          response,
+                          exc_info=True)
+            return []
 
     def refresh(self, force_cache=False):
         """Get all blink cameras and pulls their most recent status."""
         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()
+        self.check_new_videos()
         for camera_config in camera_info:
             name = camera_config['name']
             self.cameras[name].update(camera_config, force_cache=force_cache)
 
-    def get_videos(self, start_page=0, end_page=1):
-        """
-        Retrieve last recorded videos per camera.
+    def check_new_videos(self):
+        """Check if new videos since last refresh."""
+        resp = api.request_videos(self.blink,
+                                  time=self.blink.last_refresh,
+                                  page=0)
 
-        :param start_page: Page to start reading from on blink servers
-                           (defaults to 0)
-        :param end_page: Page to stop reading from (defaults to 1)
-        """
-        videos = list()
-        all_dates = dict()
+        for camera in self.cameras.keys():
+            self.motion[camera] = False
 
-        for page_num in range(start_page, end_page + 1):
-            this_page = api.request_videos(self.blink, page=page_num)
-            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:
-            for entry in page:
-                camera_name = entry['camera_name']
-                clip_addr = entry['address']
-                thumb_addr = entry['thumbnail']
-                clip_date = clip_addr.split('_')[-6:]
-                clip_date = '_'.join(clip_date)
-                clip_date = clip_date.split('.')[0]
-                try:
-                    self.all_clips[camera_name][clip_date] = clip_addr
-                except KeyError:
-                    self.all_clips[camera_name] = {clip_date: clip_addr}
+        try:
+            info = resp['videos']
+        except (KeyError, TypeError):
+            _LOGGER.warning("Could not check for motion. Response: %s", resp)
+            return False
 
-                if camera_name not in all_dates:
-                    all_dates[camera_name] = list()
-                all_dates[camera_name].append(clip_date)
-                try:
-                    self.videos[camera_name].append(
-                        {
-                            'clip': clip_addr,
-                            'thumb': thumb_addr,
-                        }
-                    )
-                except KeyError:
-                    self.videos[camera_name] = [
-                        {
-                            'clip': clip_addr,
-                            'thumb': thumb_addr,
-                        }
-                    ]
-        self.record_dates = all_dates
-        _LOGGER.debug("Retrieved a total of %s records", len(all_dates))
-        return self.videos
+        for entry in info:
+            try:
+                name = entry['camera_name']
+                clip = entry['address']
+                timestamp = entry['created_at']
+                self.motion[name] = True
+                self.last_record[name] = {'clip': clip, 'time': timestamp}
+            except KeyError:
+                _LOGGER.debug("No new videos since last refresh.")
+
+        return True

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:
+

requirements.txt

@@ -1,2 +1,3 @@
+python-dateutil==2.7.5
 requests>=2.20.0
 testtools==2.3.0

tests/test_blink_functions.py

@@ -1,12 +1,12 @@
 """Tests camera and system functions."""
 import unittest
 from unittest import mock
-
+import logging
 from requests import Request
 
 from blinkpy import blinkpy
 from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.helpers.util import create_session
+from blinkpy.helpers.util import create_session, get_time
 import tests.mock_responses as mresp
 
 USERNAME = 'foobar'
@@ -60,13 +60,91 @@ class TestBlinkFunctions(unittest.TestCase):
     def test_backup_url(self, req, mock_sess):
         """Test backup login method."""
         fake_req = Request('POST', 'http://wrong.url').prepare()
+        json_resp = {
+            'authtoken': {'authtoken': 'foobar123'},
+            'networks': {'1234': {'name': 'foobar', 'onboarded': True}}
+        }
+        new_req = mresp.MockResponse(json_resp, 200)
         req.side_effect = [
             mresp.mocked_session_send(fake_req),
-            {'authtoken': {'authtoken': 'foobar123'},
-             'networks': {'1234': {'name': 'foobar', 'onboarded': True}}}
+            new_req
         ]
         self.blink.get_auth_token()
         self.assertEqual(self.blink.region_id, 'piri')
         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)
+
+    @mock.patch('blinkpy.blinkpy.api.request_videos')
+    def test_download_video_exit(self, mock_req, mock_sess):
+        """Test we exit method when provided bad response."""
+        blink = blinkpy.Blink(loglevel=logging.DEBUG)
+        blink.last_refresh = 0
+        mock_req.return_value = {}
+        formatted_date = get_time(blink.last_refresh)
+        expected_log = [
+            "INFO:blinkpy:Retrieving videos since {}".format(formatted_date),
+            "DEBUG:blinkpy:Processing page 1",
+            "INFO:blinkpy:No videos found on page 1. Exiting."
+        ]
+        with self.assertLogs() as dl_log:
+            blink.download_videos('/tmp')
+        self.assertEqual(dl_log.output, expected_log)
+
+    @mock.patch('blinkpy.blinkpy.api.request_videos')
+    def test_parse_downloaded_items(self, mock_req, mock_sess):
+        """Test ability to parse downloaded items list."""
+        blink = blinkpy.Blink(loglevel=logging.DEBUG)
+        generic_entry = {
+            'created_at': '1970',
+            'camera_name': 'foo',
+            'deleted': True,
+            'address': '/bar.mp4'
+        }
+        result = [generic_entry]
+        mock_req.return_value = {'videos': result}
+        blink.last_refresh = 0
+        formatted_date = get_time(blink.last_refresh)
+        expected_log = [
+            "INFO:blinkpy:Retrieving videos since {}".format(formatted_date),
+            "DEBUG:blinkpy:Processing page 1",
+            "DEBUG:blinkpy:foo: /bar.mp4 is marked as deleted."
+        ]
+        with self.assertLogs() as dl_log:
+            blink.download_videos('/tmp', stop=2)
+        self.assertEqual(dl_log.output, expected_log)
+
+    @mock.patch('blinkpy.blinkpy.api.request_videos')
+    def test_parse_camera_not_in_list(self, mock_req, mock_sess):
+        """Test ability to parse downloaded items list."""
+        blink = blinkpy.Blink(loglevel=logging.DEBUG)
+        generic_entry = {
+            'created_at': '1970',
+            'camera_name': 'foo',
+            'deleted': True,
+            'address': '/bar.mp4'
+        }
+        result = [generic_entry]
+        mock_req.return_value = {'videos': result}
+        blink.last_refresh = 0
+        formatted_date = get_time(blink.last_refresh)
+        expected_log = [
+            "INFO:blinkpy:Retrieving videos since {}".format(formatted_date),
+            "DEBUG:blinkpy:Processing page 1",
+            "DEBUG:blinkpy:Skipping videos for foo."
+        ]
+        with self.assertLogs() as dl_log:
+            blink.download_videos('/tmp', camera='bar', stop=2)
+        self.assertEqual(dl_log.output, expected_log)

tests/test_blinkpy.py

@@ -14,6 +14,7 @@ from blinkpy.sync_module import BlinkSyncModule
 from blinkpy.helpers.util import (
     http_req, create_session, BlinkAuthenticationException,
     BlinkException, BlinkURLHandler)
+from blinkpy.helpers.constants import __version__
 import tests.mock_responses as mresp
 
 USERNAME = 'foobar'
@@ -30,7 +31,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()
 
@@ -41,6 +42,7 @@ class TestBlinkSetup(unittest.TestCase):
 
     def test_initialization(self, mock_sess):
         """Verify we can initialize blink."""
+        self.assertEqual(self.blink.version, __version__)
         # pylint: disable=protected-access
         self.assertEqual(self.blink._username, USERNAME)
         # pylint: disable=protected-access
@@ -110,21 +112,51 @@ 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."""
         now = self.blink.refresh_rate + 1
         mock_time.return_value = now
         self.assertEqual(self.blink.last_refresh, None)
-        result = self.blink.check_if_ok_to_update()
+        self.assertEqual(self.blink.check_if_ok_to_update(), True)
+        self.assertEqual(self.blink.last_refresh, None)
+        with mock.patch('blinkpy.sync_module.BlinkSyncModule.refresh',
+                        return_value=True):
+            self.blink.refresh()
+
         self.assertEqual(self.blink.last_refresh, now)
-        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')
+
+    @mock.patch('blinkpy.api.request_login')
+    def test_unexpected_login(self, mock_login, mock_sess):
+        """Check that we appropriately handle unexpected login info."""
+        mock_login.return_value = None
+        self.assertFalse(self.blink.get_auth_token())

tests/test_cameras.py

@@ -11,7 +11,7 @@ from unittest import mock
 from blinkpy import blinkpy
 from blinkpy.helpers.util import create_session, BlinkURLHandler
 from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.camera import BlinkCamera, MAX_CLIPS
+from blinkpy.camera import BlinkCamera
 import tests.mock_responses as mresp
 
 USERNAME = 'foobar'
@@ -46,41 +46,15 @@ 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."""
         self.blink = None
 
-    def test_check_for_motion(self, mock_sess):
-        """Test check for motion function."""
-        self.assertEqual(self.camera.last_record, [])
-        self.assertEqual(self.camera.motion_detected, None)
-        self.camera.sync.record_dates = {'foobar': [1, 3, 2, 4]}
-        self.camera.check_for_motion()
-        self.assertEqual(self.camera.last_record, [4])
-        self.assertEqual(self.camera.motion_detected, False)
-        self.camera.sync.record_dates = {'foobar': [7, 1, 3, 4]}
-        self.camera.check_for_motion()
-        self.assertEqual(self.camera.last_record, [7, 4])
-        self.assertEqual(self.camera.motion_detected, True)
-        self.camera.check_for_motion()
-        self.assertEqual(self.camera.last_record, [7, 4])
-        self.assertEqual(self.camera.motion_detected, False)
-
-    def test_max_motion_clips(self, mock_sess):
-        """Test that we only maintain certain number of records."""
-        for i in range(0, MAX_CLIPS):
-            self.camera.last_record.append(i)
-        self.camera.sync.record_dates['foobar'] = [MAX_CLIPS+2]
-        self.assertEqual(len(self.camera.last_record), MAX_CLIPS)
-        self.camera.check_for_motion()
-        self.assertEqual(self.camera.motion_detected, True)
-        self.assertEqual(len(self.camera.last_record), MAX_CLIPS)
-
     def test_camera_update(self, mock_sess):
         """Test that we can properly update camera properties."""
         config = {
@@ -96,8 +70,14 @@ class TestBlinkCameraSetup(unittest.TestCase):
             'thumbnail': '/thumb',
         }
         self.camera.last_record = ['1']
-        self.camera.sync.all_clips = {'new': {'1': '/test.mp4'}}
+        self.camera.sync.last_record = {
+            'new': {
+                'clip': '/test.mp4',
+                'time': '1970-01-01T00:00:00'
+            }
+        }
         mock_sess.side_effect = [
+            mresp.MockResponse({'temp': 71}, 200),
             'test',
             'foobar'
         ]
@@ -110,6 +90,7 @@ class TestBlinkCameraSetup(unittest.TestCase):
         self.assertEqual(self.camera.battery, 50)
         self.assertEqual(self.camera.temperature, 68)
         self.assertEqual(self.camera.temperature_c, 20)
+        self.assertEqual(self.camera.temperature_calibrated, 71)
         self.assertEqual(self.camera.wifi_strength, 4)
         self.assertEqual(self.camera.thumbnail,
                          'https://rest.test.immedia-semi.com/thumb.jpg')
@@ -120,10 +101,18 @@ class TestBlinkCameraSetup(unittest.TestCase):
 
     def test_thumbnail_not_in_info(self, mock_sess):
         """Test that we grab thumbanil if not in camera_info."""
-        mock_sess.side_effect = ['foobar', 'barfoo']
+        mock_sess.side_effect = [
+            mresp.MockResponse({'temp': 71}, 200),
+            'foobar',
+            'barfoo'
+        ]
         self.camera.last_record = ['1']
-        self.camera.sync.record_dates['new'] = ['1']
-        self.camera.sync.all_clips = {'new': {'1': '/test.mp4'}}
+        self.camera.sync.last_record = {
+            'new': {
+                'clip': '/test.mp4',
+                'time': '1970-01-01T00:00:00'
+            }
+        }
         config = {
             'name': 'new',
             'camera_id': 1234,
@@ -153,8 +142,6 @@ class TestBlinkCameraSetup(unittest.TestCase):
         """Tests that thumbnail is 'None' if none found."""
         mock_sess.return_value = 'foobar'
         self.camera.last_record = ['1']
-        self.camera.sync.record_dates['new'] = ['1']
-        self.camera.sync.all_clips = {'new': {'1': '/test.mp4'}}
         config = {
             'name': 'new',
             'camera_id': 1234,
@@ -170,12 +157,18 @@ class TestBlinkCameraSetup(unittest.TestCase):
         self.camera.sync.homescreen = {
             'devices': []
         }
+        self.assertEqual(self.camera.temperature_calibrated, None)
         with self.assertLogs() as logrecord:
             self.camera.update(config)
         self.assertEqual(self.camera.thumbnail, None)
+        self.assertEqual(self.camera.last_record, ['1'])
+        self.assertEqual(self.camera.temperature_calibrated, 68)
         self.assertEqual(
             logrecord.output,
-            ["ERROR:blinkpy.camera:Could not find thumbnail for camera new"]
+            [("WARNING:blinkpy.camera:Could not retrieve calibrated "
+              "temperature."),
+             ("ERROR:blinkpy.camera:Could not find thumbnail for camera new"
+              "\nNoneType: None")]
         )
 
     def test_no_video_clips(self, mock_sess):

tests/test_sync_module.py

@@ -24,64 +24,10 @@ 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):
-        """Clean up after test."""
-        self.blink = None
-        self.camera = None
-
-    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)
-
-    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)
-
-    def test_get_videos_one_page(self, mock_resp):
-        """Test video access."""
-        mock_resp.return_value = [
-            {
-                'camera_name': 'foobar',
-                'address': '/test/clip_1900_01_01_12_00_00AM.mp4',
-                'thumbnail': '/test/thumb'
-            }
-        ]
-        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_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)
-
-    def test_get_videos_multi_page(self, mock_resp):
-        """Test video access with multiple pages."""
-        mock_resp.return_value = [
-            {
-                'camera_name': 'test',
-                'address': '/foo/bar_1900_01_01_12_00_00AM.mp4',
-                'thumbnail': '/foobar'
-            }
-        ]
-        self.blink.sync.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.assertEqual(mock_resp.call_count, 10)
-
-    def test_sync_start(self, mock_resp):
-        """Test sync start function."""
-        mock_resp.side_effect = [
+        self.mock_start = [
             {'syncmodule': {
-                'name': 'test',
                 'id': 1234,
                 'network_id': 5678,
                 'serial': '12345678',
@@ -89,13 +35,122 @@ class TestBlinkSyncModule(unittest.TestCase):
             {'event': True},
             {},
             {},
-            {'devicestatus': {}},
             None,
-            None
+            {'devicestatus': {}},
         ]
-        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')
+
+    def tearDown(self):
+        """Clean up after test."""
+        self.blink = None
+        self.camera = None
+        self.mock_start = None
+
+    def test_get_events(self, mock_resp):
+        """Test get events function."""
+        mock_resp.return_value = {'event': 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['test'].get_camera_info(), True)
+
+    def test_check_new_videos(self, mock_resp):
+        """Test recent video response."""
+        mock_resp.return_value = {
+            'videos': [{
+                'camera_name': 'foo',
+                'address': '/foo/bar.mp4',
+                'created_at': '1970-01-01T00:00:00+0:00'
+            }]
+        }
+        sync_module = self.blink.sync['test']
+        sync_module.cameras = {'foo': None}
+        self.assertEqual(sync_module.motion, {})
+        self.assertTrue(sync_module.check_new_videos())
+        self.assertEqual(sync_module.last_record['foo'],
+                         {'clip': '/foo/bar.mp4',
+                          'time': '1970-01-01T00:00:00+0:00'})
+        self.assertEqual(sync_module.motion, {'foo': True})
+        mock_resp.return_value = {'videos': []}
+        self.assertTrue(sync_module.check_new_videos())
+        self.assertEqual(sync_module.motion, {'foo': False})
+        self.assertEqual(sync_module.last_record['foo'],
+                         {'clip': '/foo/bar.mp4',
+                          'time': '1970-01-01T00:00:00+0:00'})
+
+    def test_check_new_videos_failed(self, mock_resp):
+        """Test method when response is unexpected."""
+        mock_resp.side_effect = [None, 'just a string', {}]
+        sync_module = self.blink.sync['test']
+        sync_module.cameras = {'foo': None}
+
+        sync_module.motion['foo'] = True
+        self.assertFalse(sync_module.check_new_videos())
+        self.assertFalse(sync_module.motion['foo'])
+
+        sync_module.motion['foo'] = True
+        self.assertFalse(sync_module.check_new_videos())
+        self.assertFalse(sync_module.motion['foo'])
+
+        sync_module.motion['foo'] = True
+        self.assertFalse(sync_module.check_new_videos())
+        self.assertFalse(sync_module.motion['foo'])
+
+    def test_sync_start(self, mock_resp):
+        """Test sync start function."""
+        mock_resp.side_effect = self.mock_start
+        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')
+
+    def test_unexpected_summary(self, mock_resp):
+        """Test unexpected summary response."""
+        self.mock_start[0] = None
+        mock_resp.side_effect = self.mock_start
+        self.assertFalse(self.blink.sync['test'].start())
+
+    def test_summary_with_no_network_id(self, mock_resp):
+        """Test handling of bad summary."""
+        self.mock_start[0]['syncmodule'] = None
+        mock_resp.side_effect = self.mock_start
+        self.assertFalse(self.blink.sync['test'].start())
+
+    def test_summary_with_only_network_id(self, mock_resp):
+        """Test handling of sparse summary."""
+        self.mock_start[0]['syncmodule'] = {'network_id': 8675309}
+        mock_resp.side_effect = self.mock_start
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].network_id, 8675309)
+
+    def test_unexpected_events(self, mock_resp):
+        """Test unexpected events response."""
+        self.mock_start[1] = None
+        mock_resp.side_effect = self.mock_start
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].events, False)
+
+    def test_missing_events(self, mock_resp):
+        """Test missing events key from response."""
+        self.mock_start[1] = {}
+        mock_resp.side_effect = self.mock_start
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].events, False)
+
+    def test_unexpected_camera_info(self, mock_resp):
+        """Test unexpected camera info response."""
+        self.blink.sync['test'].cameras['foo'] = None
+        self.mock_start[5] = None
+        mock_resp.side_effect = self.mock_start
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].cameras, {'foo': None})
+
+    def test_missing_camera_info(self, mock_resp):
+        """Test missing key from camera info response."""
+        self.blink.sync['test'].cameras['foo'] = None
+        self.mock_start[5] = {}
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].cameras, {'foo': None})