Merge pull request #308 from fronzbot/fix-extra-reauth

Removed 'reauth' key from login payload

.pre-commit-config.yaml

@@ -8,10 +8,15 @@ repos:
           - --quiet
         files: ^((blinkpy|tests)/.+)?[^/]+\.py$
   - repo: https://gitlab.com/pycqa/flake8
-    rev: 3.8.1
+    rev: 3.8.2
     hooks:
       - id: flake8
         additional_dependencies:
           - flake8-docstrings==1.5.0
           - pydocstyle==5.0.2
-        files: ^(homeassistant|tests)/.+\.py$
+        files: ^(blinkpy|tests)/.+\.py$
+  - repo: https://github.com/Lucas-C/pre-commit-hooks-markup
+    rev: v1.0.0
+    hooks:
+      - id: rst-linter
+        files: /.+\.rst$

CHANGES.rst

@@ -1,10 +1,11 @@
+=========
 Changelog
------------
+=========
 
 A list of changes between each release
 
 0.15.0 (2020-05-08)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 **Breaking Changes:**
 
 - Removed support for Python 3.5 (3.6 is now the minimum supported version)
@@ -29,7 +30,7 @@ This can be used by instantiating the Blink class with the ``device_id`` paramet
 - Fix typos (`#244 <https://github.com/fronzbot/blinkpy/pull/244>`__)
 
 0.14.3 (2020-04-22)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Add time check on recorded videos before determining motion
 - Fix motion detection variable suck to ``True``
 - Add ability to load credentials from a json file
@@ -37,18 +38,18 @@ This can be used by instantiating the Blink class with the ``device_id`` paramet
 - Log response message from server if not attempting a re-authorization
 
 0.14.2 (2019-10-12)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Update dependencies
 - Dockerize `(@3ch01c <https://github.com/fronzbot/blinkpy/pull/198>__)`
 
 0.14.1 (2019-06-20)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Fix timeout problems blocking blinkpy startup
 - Updated login urls using ``rest-region`` subdomain
 - Removed deprecated thumbanil recovery from homescreen
 
 0.14.0 (2019-05-23)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 **Breaking Changes:**
 
 - ``BlinkCamera.battery`` no longer reports a percentage, instead it returns a string representing the state of the battery.
@@ -70,11 +71,11 @@ This can be used by instantiating the Blink class with the ``device_id`` paramet
 
 
 0.13.1 (2019-03-01)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Remove throttle decorator from network status request
 
 0.13.0 (2019-03-01)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 **Breaking change:**
 Wifi status reported in dBm again, instead of bars (which is great).  Also, the old ``get_camera_info`` method has changed and requires a ``camera_id`` parameter.
 
@@ -99,11 +100,11 @@ Wifi status reported in dBm again, instead of bars (which is great).  Also, the
 
 
 0.12.1 (2019-01-31)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Remove logging improvements since they were incompatible with home-assistant logging
 
 0.12.0 (2019-01-31)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Fix video api endpoint, re-enables motion detection
 - Add improved logging capability
 - Add download video method
@@ -111,22 +112,22 @@ Wifi status reported in dBm again, instead of bars (which is great).  Also, the
 
 
 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>`__)
 - Fix incorrect command status endpoint (`@md-reddevil <https://github.com/fronzbot/blinkpy/pull/118>`__)
 - Add extra debug logging
@@ -134,18 +135,18 @@ Wifi status reported in dBm again, instead of bars (which is great).  Also, the
 
 
 0.10.2 (2018-10-30)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Set minimum required version of the requests library to 2.20.0 due to vulnerability in earlier releases.
 - When multiple networks detected, changed log level to ``warning`` from ``error`` 
 
 
 0.10.1 (2018-10-18)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - 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>`__)
@@ -157,7 +158,7 @@ Wifi status reported in dBm again, instead of bars (which is great).  Also, the
 - Check if retrieved clip is "None" prior to storing in cache
 
 0.9.0 (2018-09-27)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Complete code refactoring to enable future multi-sync module support
 - Add image and video caching to the cameras
 - Add internal throttling of system refresh
@@ -168,7 +169,7 @@ Wifi status reported in dBm again, instead of bars (which is great).  Also, the
 
 
 0.8.1 (2018-09-24)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Update requirements_test.txt
 - Update linter versions
 - Fix pylint warnings
@@ -184,18 +185,18 @@ Wifi status reported in dBm again, instead of bars (which is great).  Also, the
   - Reset the value every system refresh
 
 0.8.0 (2018-05-21)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - 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>`__)
 
 0.7.1 (2018-05-09)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - 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>`__)
@@ -209,7 +210,7 @@ Wifi status reported in dBm again, instead of bars (which is great).  Also, the
 - Added ``attributes`` dictionary to camera object
 
 0.6.0 (2017-05-12)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - 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!)
@@ -217,44 +218,44 @@ Wifi status reported in dBm again, instead of bars (which is great).  Also, the
 - 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)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - Fixed packaging mishap, same as 0.5.0 otherwise
 
 0.5.0 (2017-03-12)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - Fixed region handling problem
 - Added rest.piri subdomain as a backup if region can't be found
 - Improved the file writing function
 - Large test coverage increase
 
 0.4.4 (2017-03-06)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - Fixed bug where region id was not being set in the header
 
 0.4.3 (2017-03-05)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - Changed to bdist_wheel release
 
 0.4.2 (2017-01-28)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - Fixed inability to retrieve motion data due to Key Error
 
 0.4.1 (2017-01-27)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - Fixed refresh bug (0.3.1 did not actually fix the problem)
 - Image refresh routine added (per camera)
 - Dictionary of thumbnails per camera added
 - Improved test coverage
 
 0.3.1 (2017-01-25)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - Fixed refresh bug (Key Error)
 
 0.3.0 (2017-01-25)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - Added device id to camera lookup table
 - Added image to file method
 
 0.2.0 (2017-01-21)
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 - Initial release of blinkpy

CONTRIBUTING.md

@@ -1,98 +0,0 @@
-# Contributing to blinkpy
-
-Everyone is welcome to contribute to blinkpy! The process to get started is described below.
-
-## Fork the Repository
-
-You can do this right in github: just click the 'fork' button at the top right.
-
-## Start Developing
-
-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
-   ```
-
-2. Create virtualenv and install dependencies
-   ```shell
-   $ python -m venv venv
-   $ source venv/bin/activate
-   $ pip install -r requirements.txt
-   $ pip install -r requirements_test.txt
-   $ pre-commit install
-   ```
-
-3. Create a Local Branch
-   
-   First, you will want to create a new branch to hold your changes:
-   ``git checkout -b <your-branch-name>``
-
-
-4. Make changes
-   
-   Now you can make changes to your code.  It is worthwhile to test your code as you progress (see the **Testing** section)
-
-5. 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
-   ```
-   
-6. 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/)
-   
-7. 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.
-
-
-## 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``
-
-```shell
-$ pip3 install tox
-```
-
-You can then run all of the tests with the following command:
-
-```shell
-$ tox
-```
-
-### Tips
-
-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 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
-
-If your code is taking a while to develop, you may be behind the ``dev`` branch, in which case you need to catch up before creating your pull-request.  To do this you can run ``git rebase`` as follows (running this on your local branch):
-
-```shell
-$ git fetch upstream dev
-$ git rebase upstream/dev
-```
-
-If rebase detects conflicts, repeat the following process until all changes have been resolved:
-
-1. ``git status`` shows you the filw with a conflict.  You will need to edit that file and resolve the lines between ``<<<< | >>>>`.
-2. Add the modified file: ``git add <file>`` or ``git add .``.
-3. Continue rebase: ``git rebase --continue``.
-4. Repeat until all conflicts resolved.

CONTRIBUTING.rst

@@ -0,0 +1,109 @@
+========================
+Contributing to blinkpy
+========================
+
+Everyone is welcome to contribute to blinkpy! The process to get started is described below.
+
+
+Fork the Repository
+-------------------
+
+You can do this right in github: just click the 'fork' button at the top right.
+
+Start Developing
+-----------------
+
+1. Setup Local Repository
+   .. code:: bash
+       
+       $ git clone https://github.com/<YOUR_GIT_USERNAME>/blinkpy.git
+       $ cd blinkpy
+       $ git remote add upstream https://github.com/fronzbot/blinkpy.git
+
+2. Create virtualenv and install dependencies
+   
+   .. code:: bash
+
+       $ python -m venv venv
+       $ source venv/bin/activate
+       $ pip install -r requirements.txt
+       $ pip install -r requirements_test.txt
+       $ pre-commit install
+
+3. Create a Local Branch
+   
+   First, you will want to create a new branch to hold your changes:
+   ``git checkout -b <your-branch-name>``
+
+
+4. Make changes
+   
+   Now you can make changes to your code.  It is worthwhile to test your code as you progress (see the **Testing** section)
+
+5. 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:
+
+   .. code:: bash
+   
+       $ git add .
+       $ git commit
+       $ git push origin HEAD
+   
+6. 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>`__
+   
+7. 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.
+
+
+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``
+
+.. code:: bash
+
+    $ pip install tox
+
+
+You can then run all of the tests with the following command:
+
+.. code:: bash
+    
+    $ tox
+
+**Tips**
+
+If you only want to see if you can pass the local tests, you can run ``tox -e py37`` (or whatever python version you have installed.  Only ``py36``, ``py37``, and ``py38`` 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 want to run a single test (perhaps you only changed a small thing in one file) you can run ``tox -e py37 -- 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
+-------------------------
+
+If your code is taking a while to develop, you may be behind the ``dev`` branch, in which case you need to catch up before creating your pull-request.  To do this you can run ``git rebase`` as follows (running this on your local branch):
+
+.. code:: bash
+
+    $ git fetch upstream dev
+    $ git rebase upstream/dev
+
+If rebase detects conflicts, repeat the following process until all changes have been resolved:
+
+1. ``git status`` shows you the filw with a conflict.  You will need to edit that file and resolve the lines between ``<<<< | >>>>``.
+2. Add the modified file: ``git add <file>`` or ``git add .``.
+3. Continue rebase: ``git rebase --continue``.
+4. Repeat until all conflicts resolved.

README.rst

@@ -4,10 +4,9 @@ A Python library for the Blink Camera system (Python 3.6+)
 
 Like the library? Consider buying me a cup of coffee!
 
-|Donate|
+`Buy me a Coffee! <https://buymeacoffee.com/kevinfronczak>`__
 
-Disclaimer:
-~~~~~~~~~~~~~~~
+**Disclaimer:**
 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.
@@ -18,11 +17,11 @@ Original protocol hacking by MattTW : https://github.com/MattTW/BlinkMonitorProt
 API calls faster than 60 seconds is not recommended as it can overwhelm Blink's servers.  Please use this module responsibly.
 
 Installation
-================
-``pip3 install blinkpy``
+-------------
+``pip install blinkpy``
 
 Installing Development Version
-==================================
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 To install the current development version, perform the following steps.  Note that the following will create a blinkpy directory in your home area:
 
 .. code:: bash
@@ -35,12 +34,12 @@ 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>`__.
+If you'd like to contribute to this library, please read the `contributing instructions <https://github.com/fronzbot/blinkpy/blob/dev/CONTRIBUTING.rst>`__.
 
 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 to support the `Blink component <https://home-assistant.io/components/blink>`__ in `homeassistant <https://home-assistant.io/>`__.
 
 Quick Start
@@ -58,7 +57,7 @@ The simplest way to use this package from a terminal is to call ``Blink.start()`
 This flow will prompt you for your username and password.  Once entered, if you likely will need to send a 2FA key to the blink servers (this pin is sent to your email address).  When you receive this pin, enter at the prompt and the Blink library will proceed with setup.
 
 Starting blink without a prompt
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------------
 In some cases, having an interactive command-line session is not desired.  In this case, you will need to set the ``Blink.auth.no_prompt`` value to ``True``.  In addition, since you will not be prompted with a username and password, you must supply the login data to the blink authentication handler.  This is best done by instantiating your own auth handler with a dictionary containing at least your username and password.
 
 .. code:: python
@@ -82,7 +81,7 @@ Since you will not be prompted for any 2FA pin, you must call the ``blink.auth.s
 
 
 Supplying credentials from file
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------
 Other use cases may involved loading credentials from a file.  This file must be ``json`` formatted and contain a minimum of ``username`` and ``password``.  A built in function in the ``blinkpy.helpers.util`` module can aid in loading this file.  Note, if ``no_prompt`` is desired, a similar flow can be followed as above.
 
 .. code:: python
@@ -98,7 +97,7 @@ Other use cases may involved loading credentials from a file.  This file must be
 
 
 Saving credentials
-~~~~~~~~~~~~~~~~~~~
+-------------------
 This library also allows you to save your credentials to use in future sessions.  Saved information includes authentication tokens as well as unique ids which should allow for a more streamlined experience and limits the frequency of login requests.  This data can be saved as follows (it can then be loaded by following the instructions above for supplying credentials from a file):
 
 .. code:: python
@@ -107,7 +106,7 @@ This library also allows you to save your credentials to use in future sessions.
 
 
 Getting cameras
-~~~~~~~~~~~~~~~~
+----------------
 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:
@@ -138,8 +137,43 @@ The ``blinkpy`` api also allows for saving images and videos to a file and snapp
     camera.image_to_file('/local/path/for/image.jpg')
     camera.video_to_file('/local/path/for/video.mp4')
 
+
+Arming Blink
+-------------
+Methods exist to arm/disarm the sync module, as well as enable/disable motion detection for individual cameras.  This is done as follows:
+
+.. code:: python
+
+    # Arm a sync module
+    blink.sync["SYNC MODULE NAME"].arm = True
+
+    # Disarm a sync module
+    blink.sync["SYNC MODULE NAME"].disarm = False
+
+    # Print arm status of a sync module - a system refresh should be performed first
+    blink.refresh()
+    sync = blink.sync["SYNC MODULE NAME"]
+    print(f"{sync.name} status: {sync.arm}")
+
+Similar methods exist for individual cameras:
+
+.. code:: python
+
+   camera = blink.cameras["SOME CAMERA NAME"]
+
+   # Enable motion detection on a camera
+   camera.arm = True
+
+   # Disable motion detection on a camera
+   camera.arm = False
+
+   # Print arm status of a sync module - a system refresh should be performed first
+   blink.refresh()
+   print(f"{camera.name} status: {camera.arm}")
+
+
 Download videos
-~~~~~~~~~~~~~~~~
+----------------
 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:
@@ -157,7 +191,5 @@ Example usage, which downloads all videos recorded since July 4th, 2018 at 9:34a
     :target: https://pypi.python.org/pypi/blinkpy
 .. |Docs| image:: https://readthedocs.org/projects/blinkpy/badge/?version=latest
    :target: http://blinkpy.readthedocs.io/en/latest/?badge=latest   
-.. |Donate| image:: https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif
-   :target: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=UR6Z2B8GXYUCC
 .. |Codestyle| image:: https://img.shields.io/badge/code%20style-black-000000.svg
    :target: https://github.com/psf/black

app/app.py

@@ -1,11 +1,12 @@
 """Script to run blinkpy as an app."""
 from os import environ
 from datetime import datetime, timedelta
-from blinkpy import blinkpy
+from blinkpy.blinkpy import Blink
+from blinkpy.auth import Auth
+from blinkpy.helpers.util import json_load
 
 
-USERNAME = environ.get("USERNAME")
-PASSWORD = environ.get("PASSWORD")
+CREDFILE = environ.get("CREDFILE")
 TIMEDELTA = timedelta(environ.get("TIMEDELTA", 1))
 
 
@@ -21,11 +22,18 @@ def download_videos(blink, save_dir="/media"):
 
 def start():
     """Startup blink app."""
-    blink = blinkpy.Blink(username=USERNAME, password=PASSWORD)
+    blink = Blink()
+    blink.auth = Auth(json_load(CREDFILE))
     blink.start()
     return blink
 
 
+def main():
+    """Run the app."""
+    blink = start()
+    download_videos(blink)
+    blink.save(CREDFILE)
+
+
 if __name__ == "__main__":
-    BLINK = start()
-    download_videos(BLINK)
+    main()

blinkpy/api.py

@@ -32,7 +32,7 @@ def request_login(
             "client_name": "Computer",
             "client_type": "android",
             "os_version": "5.1.1",
-            "reauth": "true",
+            "reauth": "false",
         }
     )
     return auth.query(
@@ -60,6 +60,23 @@ def request_networks(blink):
     return http_get(blink, url)
 
 
+def request_network_update(blink, network):
+    """
+    Request network update.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
+    url = f"{blink.urls.base_url}/network/{network}/update"
+    return http_post(blink, url)
+
+
+def request_user(blink):
+    """Get user information from blink servers."""
+    url = f"{blink.urls.base_url}/user"
+    return http_get(blink, url)
+
+
 def request_network_status(blink, network):
     """
     Request network information.
@@ -90,7 +107,7 @@ def request_system_arm(blink, network):
     :param blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = f"{blink.urls.base_url}/network/{network}/arm"
+    url = f"{blink.urls.base_url}/api/v1/accounts/{blink.account_id}/networks/{network}/state/arm"
     return http_post(blink, url)
 
 
@@ -102,7 +119,7 @@ def request_system_disarm(blink, network):
     :param blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = f"{blink.urls.base_url}/network/{network}/disarm"
+    url = f"{blink.urls.base_url}/api/v1/accounts/{blink.account_id}/networks/{network}/state/disarm"
     return http_post(blink, url)
 
 
@@ -206,6 +223,30 @@ def request_camera_info(blink, network, camera_id):
     return http_get(blink, url)
 
 
+def request_camera_usage(blink):
+    """
+    Request camera status.
+
+    :param blink: Blink instance.
+    """
+    url = f"{blink.urls.base_url}/api/v1/camera/usage"
+    return http_get(blink, url)
+
+
+def request_camera_liveview(blink, network, camera_id):
+    """
+    Request camera liveview.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to request liveview from.
+    """
+    url = (
+        f"{blink.urls.base_url}/api/v3/networks/{network}/cameras/{camera_id}/liveview"
+    )
+    return http_post(blink, url)
+
+
 def request_camera_sensors(blink, network, camera_id):
     """
     Request camera sensor info for one camera.

blinkpy/blinkpy.py

@@ -23,7 +23,7 @@ from dateutil.parser import parse
 from slugify import slugify
 
 from blinkpy import api
-from blinkpy.sync_module import BlinkSyncModule
+from blinkpy.sync_module import BlinkSyncModule, BlinkOwl
 from blinkpy.helpers import util
 from blinkpy.helpers.constants import (
     DEFAULT_MOTION_INTERVAL,
@@ -33,7 +33,6 @@ from blinkpy.helpers.constants import (
 from blinkpy.helpers.constants import __version__
 from blinkpy.auth import Auth, TokenRefreshFailed, LoginError
 
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -41,7 +40,10 @@ class Blink:
     """Class to initialize communication."""
 
     def __init__(
-        self, refresh_rate=DEFAULT_REFRESH, motion_interval=DEFAULT_MOTION_INTERVAL,
+        self,
+        refresh_rate=DEFAULT_REFRESH,
+        motion_interval=DEFAULT_MOTION_INTERVAL,
+        no_owls=False,
     ):
         """
         Initialize Blink system.
@@ -52,6 +54,7 @@ class Blink:
                                 Defaults to last refresh time.
                                 Useful for preventing motion_detected property
                                 from de-asserting too quickly.
+        :param no_owls: Disable searching for owl entries (blink mini cameras only known entity).  Prevents an uneccessary API call if you don't have these in your network.
         """
         self.auth = Auth()
         self.account_id = None
@@ -68,6 +71,8 @@ class Blink:
         self.version = __version__
         self.available = False
         self.key_required = False
+        self.homescreen = {}
+        self.no_owls = no_owls
 
     @util.Throttle(seconds=MIN_THROTTLE_TIME)
     def refresh(self, force=False):
@@ -127,6 +132,7 @@ class Blink:
         for name, network_id in networks.items():
             sync_cameras = cameras.get(network_id, {})
             self.setup_sync_module(name, network_id, sync_cameras)
+
         self.cameras = self.merge_cameras()
 
         self.available = True
@@ -138,18 +144,52 @@ class Blink:
         self.sync[name] = BlinkSyncModule(self, name, network_id, cameras)
         self.sync[name].start()
 
+    def setup_owls(self):
+        """Check for mini cameras."""
+        if self.no_owls:
+            _LOGGER.debug("Skipping owl extraction.")
+            return []
+        response = api.request_homescreen(self)
+        self.homescreen = response
+        network_list = []
+        camera_list = []
+        try:
+            for owl in response["owls"]:
+                name = owl["name"]
+                network_id = str(owl["network_id"])
+                if network_id in self.network_ids:
+                    camera_list.append(
+                        {network_id: {"name": name, "id": network_id, "type": "mini"}}
+                    )
+                    continue
+                if owl["onboarded"]:
+                    network_list.append(str(network_id))
+                    self.sync[name] = BlinkOwl(self, name, network_id, owl)
+                    self.sync[name].start()
+        except KeyError:
+            # No sync-less devices found
+            pass
+
+        self.network_ids.extend(network_list)
+        return camera_list
+
     def setup_camera_list(self):
         """Create camera list for onboarded networks."""
         all_cameras = {}
-        response = api.request_homescreen(self)
+        response = api.request_camera_usage(self)
         try:
-            for camera in response["cameras"]:
-                camera_network = str(camera["network_id"])
+            for network in response["networks"]:
+                camera_network = str(network["network_id"])
                 if camera_network not in all_cameras:
                     all_cameras[camera_network] = []
+                for camera in network["cameras"]:
                     all_cameras[camera_network].append(
                         {"name": camera["name"], "id": camera["id"]}
                     )
+            mini_cameras = self.setup_owls()
+            for camera in mini_cameras:
+                for network, camera_info in camera.items():
+                    all_cameras[network].append(camera_info)
             return all_cameras
         except (KeyError, TypeError):
             _LOGGER.error("Unable to retrieve cameras from response %s", response)

blinkpy/camera.py

@@ -29,6 +29,7 @@ class BlinkCamera:
         self.last_record = None
         self._cached_image = None
         self._cached_video = None
+        self.camera_type = ""
 
     @property
     def attributes(self):
@@ -61,7 +62,10 @@ class BlinkCamera:
     @property
     def temperature_c(self):
         """Return temperature in celcius."""
+        try:
             return round((self.temperature - 32) / 9.0 * 5.0, 1)
+        except TypeError:
+            return None
 
     @property
     def image_from_cache(self):
@@ -112,18 +116,24 @@ class BlinkCamera:
 
     def update(self, config, force_cache=False, **kwargs):
         """Update camera info."""
-        # force = kwargs.pop('force', False)
-        self.name = config["name"]
-        self.camera_id = str(config["id"])
-        self.network_id = str(config["network_id"])
-        self.serial = config["serial"]
-        self.motion_enabled = config["enabled"]
-        self.battery_voltage = config["battery_voltage"]
-        self.battery_state = config["battery_state"]
-        self.temperature = config["temperature"]
-        self.wifi_strength = config["wifi_strength"]
+        self.extract_config_info(config)
+        self.get_sensor_info()
+        self.update_images(config, force_cache=force_cache)
 
-        # Retrieve calibrated temperature from special endpoint
+    def extract_config_info(self, config):
+        """Extract info from config."""
+        self.name = config.get("name", "unknown")
+        self.camera_id = str(config.get("id", "unknown"))
+        self.network_id = str(config.get("network_id", "unknown"))
+        self.serial = config.get("serial", None)
+        self.motion_enabled = config.get("enabled", "unknown")
+        self.battery_voltage = config.get("battery_voltage", None)
+        self.battery_state = config.get("battery_state", None)
+        self.temperature = config.get("temperature", None)
+        self.wifi_strength = config.get("wifi_strength", None)
+
+    def get_sensor_info(self):
+        """Retrieve calibrated temperatue from special endpoint."""
         resp = api.request_camera_sensors(
             self.sync.blink, self.network_id, self.camera_id
         )
@@ -133,12 +143,11 @@ class BlinkCamera:
             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 the sync module
-        # otherwise set it to None and log an error
+    def update_images(self, config, force_cache=False):
+        """Update images for camera."""
         new_thumbnail = None
         thumb_addr = None
-        if config["thumbnail"]:
+        if config.get("thumbnail", False):
             thumb_addr = config["thumbnail"]
         else:
             _LOGGER.warning(
@@ -154,10 +163,12 @@ class BlinkCamera:
             self.motion_detected = False
 
         clip_addr = None
-        if self.name in self.sync.last_record:
+        try:
             clip_addr = self.sync.last_record[self.name]["clip"]
             self.last_record = self.sync.last_record[self.name]["time"]
             self.clip = f"{self.sync.urls.base_url}{clip_addr}"
+        except KeyError:
+            pass
 
         # If the thumbnail or clip have changed, update the cache
         update_cached_image = False
@@ -178,6 +189,13 @@ class BlinkCamera:
                 self.sync.blink, url=self.clip, stream=True, json=False
             )
 
+    def get_liveview(self):
+        """Get livewview rtsps link."""
+        response = api.request_camera_liveview(
+            self.sync.blink, self.sync.network_id, self.camera_id
+        )
+        return response["server"]
+
     def image_to_file(self, path):
         """
         Write image to file.
@@ -195,7 +213,8 @@ class BlinkCamera:
             )
 
     def video_to_file(self, path):
-        """Write video to file.
+        """
+        Write video to file.
 
         :param path: Path to write file
         """
@@ -206,3 +225,42 @@ class BlinkCamera:
             return
         with open(path, "wb") as vidfile:
             copyfileobj(response.raw, vidfile)
+
+
+class BlinkCameraMini(BlinkCamera):
+    """Define a class for a Blink Mini camera."""
+
+    def __init__(self, sync):
+        """Initialize a Blink Mini cameras."""
+        super().__init__(sync)
+        self.camera_type = "mini"
+
+    @property
+    def arm(self):
+        """Return camera arm status."""
+        return self.sync.arm
+
+    @arm.setter
+    def arm(self, value):
+        """Set camera arm status."""
+        _LOGGER.warning(
+            "Individual camera motion detection enable/disable for Blink Mini cameras is unsupported at this time."
+        )
+
+    def snap_picture(self):
+        """Snap picture for a blink mini camera."""
+        url = f"{self.sync.urls.base_url}/api/v1/accounts/{self.sync.blink.account_id}/networks/{self.network_id}/owls/{self.camera_id}/thumbnail"
+        return api.http_post(self.sync.blink, url)
+
+    def get_sensor_info(self):
+        """Get sensor info for blink mini camera."""
+
+    def get_liveview(self):
+        """Get liveview link."""
+        url = f"{self.sync.urls.base_url}/api/v1/accounts/{self.sync.blink.account_id}/networks/{self.network_id}/owls/{self.camera_id}/liveview"
+        response = api.http_post(self.sync.blink, url)
+        server = response["server"]
+        server_split = server.split(":")
+        server_split[0] = "rtsps"
+        link = "".join(server_split)
+        return link

blinkpy/helpers/constants.py

@@ -4,7 +4,7 @@ import os
 
 MAJOR_VERSION = 0
 MINOR_VERSION = 16
-PATCH_VERSION = "0-rc2"
+PATCH_VERSION = "0-rc6"
 
 __version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}.{PATCH_VERSION}"
 

blinkpy/sync_module.py

@@ -4,7 +4,7 @@ import logging
 
 from requests.structures import CaseInsensitiveDict
 from blinkpy import api
-from blinkpy.camera import BlinkCamera
+from blinkpy.camera import BlinkCamera, BlinkCameraMini
 from blinkpy.helpers.util import time_to_seconds
 from blinkpy.helpers.constants import ONLINE
 
@@ -77,24 +77,15 @@ class BlinkSyncModule:
 
     @arm.setter
     def arm(self, value):
-        """Arm or disarm system."""
+        """Arm or disarm camera."""
         if value:
             return api.request_system_arm(self.blink, self.network_id)
-
         return api.request_system_disarm(self.blink, self.network_id)
 
     def start(self):
         """Initialize the system."""
-        response = api.request_syncmodule(self.blink, self.network_id)
-        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,
-            )
+        response = self.sync_initialize()
+        if not response:
             return False
 
         try:
@@ -108,26 +99,58 @@ class BlinkSyncModule:
 
         is_ok = self.get_network_info()
         self.check_new_videos()
+
+        if not is_ok or not self.update_cameras():
+            return False
+        self.available = True
+        return True
+
+    def sync_initialize(self):
+        """Initialize a sync module."""
+        response = api.request_syncmodule(self.blink, self.network_id)
+        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
+            )
+            return False
+        return response
+
+    def update_cameras(self, camera_type=BlinkCamera):
+        """Update cameras from server."""
         try:
             for camera_config in self.camera_list:
                 if "name" not in camera_config:
                     break
+                blink_camera_type = camera_config.get("type", "")
                 name = camera_config["name"]
-                self.cameras[name] = BlinkCamera(self)
                 self.motion[name] = False
-                camera_info = self.get_camera_info(camera_config["id"])
-                self.cameras[name].update(camera_info, force_cache=True, force=True)
-        except KeyError:
-            _LOGGER.error(
-                "Could not create cameras instances for %s", self.name, exc_info=True
+                owl_info = self.get_owl_info(name)
+                if blink_camera_type == "mini":
+                    camera_type = BlinkCameraMini
+                self.cameras[name] = camera_type(self)
+                camera_info = self.get_camera_info(
+                    camera_config["id"], owl_info=owl_info
                 )
-            return False
+                self.cameras[name].update(camera_info, force_cache=True, force=True)
 
-        if not is_ok:
+        except KeyError:
+            _LOGGER.error("Could not create camera instances for %s", self.name)
             return False
-        self.available = True
         return True
 
+    def get_owl_info(self, name):
+        """Extract owl information."""
+        try:
+            for owl in self.blink.homescreen["owls"]:
+                if owl["name"] == name:
+                    return owl
+        except KeyError:
+            pass
+        return None
+
     def get_events(self, **kwargs):
         """Retrieve events from server."""
         force = kwargs.pop("force", False)
@@ -138,8 +161,11 @@ class BlinkSyncModule:
             _LOGGER.error("Could not extract events: %s", response, exc_info=True)
             return False
 
-    def get_camera_info(self, camera_id):
+    def get_camera_info(self, camera_id, **kwargs):
         """Retrieve camera information."""
+        owl = kwargs.get("owl_info", None)
+        if owl is not None:
+            return owl
         response = api.request_camera_info(self.blink, self.network_id, camera_id)
         try:
             return response["camera"][0]
@@ -149,7 +175,7 @@ class BlinkSyncModule:
 
     def get_network_info(self):
         """Retrieve network status."""
-        self.network_info = api.request_network_status(self.blink, self.network_id)
+        self.network_info = api.request_network_update(self.blink, self.network_id)
         try:
             if self.network_info["network"]["sync_module_error"]:
                 raise KeyError
@@ -205,3 +231,66 @@ class BlinkSyncModule:
     def check_new_video_time(self, timestamp):
         """Check if video has timestamp since last refresh."""
         return time_to_seconds(timestamp) > self.blink.last_refresh
+
+
+class BlinkOwl(BlinkSyncModule):
+    """Representation of a sync-less device."""
+
+    def __init__(self, blink, name, network_id, response):
+        """Initialize a sync-less object."""
+        cameras = [{"name": name, "id": response["id"]}]
+        super().__init__(blink, name, network_id, cameras)
+        self.sync_id = response["id"]
+        self.serial = response["serial"]
+        self.status = response["enabled"]
+        if not self.serial:
+            self.serial = f"{network_id}-{self.sync_id}"
+
+    def sync_initialize(self):
+        """Initialize a sync-less module."""
+        self.summary = {
+            "id": self.sync_id,
+            "name": self.name,
+            "serial": self.serial,
+            "status": self.status,
+            "onboarded": True,
+            "account_id": self.blink.account_id,
+            "network_id": self.network_id,
+        }
+        return self.summary
+
+    def update_cameras(self, camera_type=BlinkCameraMini):
+        """Update sync-less cameras."""
+        return super().update_cameras(camera_type=BlinkCameraMini)
+
+    def get_camera_info(self, camera_id, **kwargs):
+        """Retrieve camera information."""
+        try:
+            for owl in self.blink.homescreen["owls"]:
+                if owl["name"] == self.name:
+                    self.status = owl["enabled"]
+                    return owl
+        except KeyError:
+            pass
+        return None
+
+    def get_network_info(self):
+        """Get network info for sync-less module."""
+        return True
+
+    @property
+    def network_info(self):
+        """Format owl response to resemble sync module."""
+        return {
+            "network": {
+                "id": self.network_id,
+                "name": self.name,
+                "armed": self.status,
+                "sync_module_error": False,
+                "account_id": self.blink.account_id,
+            }
+        }
+
+    @network_info.setter
+    def network_info(self, value):
+        """Set network_info property."""

codecov.yml

@@ -4,8 +4,12 @@ coverage:
   status:
     project:
       default:
-        target: 80
-        threshold: 0.02
+        target: 80%
+        threshold: 2%
+    patch:
+      default:
+        target: 60%
+        threshold: 5%
 
 comment: true
 require_ci_to_pass: yes

docs/CHANGES.rst

@@ -0,0 +1 @@
+../CHANGES.rst

docs/CONTRIBUTING.rst

@@ -0,0 +1 @@
+../CONTRIBUTING.rst

docs/advanced.rst

@@ -0,0 +1,81 @@
+=======================
+Advanced Library Usage
+=======================
+
+Usage of this library was designed with the `Home Assistant <https://home-assistant.io>`__ project in mind.  With that said, this library is flexible to be used in other scripts where advanced usage not covered in the Quick Start guide may be required.  This usage guide will attempt to cover as many use cases as possible.
+
+Throttling
+--------------
+In general, attempting too many requests to the Blink servers will result in your account being throttled.  Where possible, adding a delay between calls is ideal.  For use cases where this is not an acceptable solution, the ``blinkpy.helpers.util`` module contains a ``Throttle`` class that can be used as a decorator for calls.  There are many examples of usage within the ``blinkpy.api`` module.  A simple example of usage is covered below, where the decorated method is prevented from executing again until 10s has passed.  Note that if the method call is throttled by the decorator, the method will return `None`.
+
+.. code:: python
+   
+   from blinkpy.helpers.util import Throttle
+
+   @Throttle(seconds=10)
+   def my_method(*args):
+       """Some method to be throttled."""
+       return True
+
+Custom Sessions
+-----------------
+By default, the ``blink.auth.Auth`` class creates its own websession via its ``create_session`` method.  This is done when the class is initialized and is accessible via the ``Auth.session`` property. To override with a custom websession, the following code can accomplish that:
+
+.. code:: python
+
+    from blinkpy.blinkpy import Blink
+    from blinkpy.auth import Auth
+
+    blink = Blink()
+    blink.auth = Auth()
+    blink.auth.session = YourCustomSession
+
+Custom HTTP requests
+---------------------
+In addition to custom sessions, custom blink server requests can be performed.  This give you the ability to bypass the built-in ``Auth.query`` method.  It also allows flexibility by giving you the option to pass your own url, rather than be limited to what is currently implemented in the ``blinkpy.api`` module.
+
+**Send custom url**
+This prepares a standard "GET" request.
+
+.. code:: python
+
+    from blinkpy.blinkpy import Blink
+    from blinkpy.auth import Auth
+
+    blink = Blink()
+    blink.auth = Auth()
+    url = some_api_endpoint_string
+    request = blink.auth.prepare_request(url, blink.auth.header, None, "get")
+    response = blink.auth.session.send(request)
+
+**Overload query method**
+Another option is to create your own ``Auth`` class with a custom ``query`` method to avoid the built-in response checking. This allows you to use the built in ``blinkpy.api`` endpoints, but also gives you flexibility to send your own urls.
+
+.. code:: python
+    
+    from blinkpy.blinkpy import Blink
+    from blinkpy.auth import Auth
+    from blinkpy import api
+
+    class CustomAuth(Auth):
+        def query(
+            self,
+            url=None,
+            data=None,
+            headers=self.header,
+            reqtype="get",
+            stream=False,
+            json_resp=True,
+            **kwargs
+        ):
+            req = self.prepare_request(url, headers, data, reqtype)
+            return self.session.send(req, stream=stream)
+
+    blink = blink.Blink()
+    blink.auth = CustomAuth()
+
+    # Send custom GET query
+    response = blink.auth.query(url=some_custom_url)
+
+    # Call built-in networks api endpoint
+    response = api.request_networks(blink)

docs/api/blinkpy.rst

@@ -1,17 +0,0 @@
-.. _core_module:
-
-Blinkpy
-----------------------
-
-.. automodule:: blinkpy.blinkpy
-    :members:
-
-.. automodule:: blinkpy.sync_module
-    :members:
-
-.. automodule:: blinkpy.camera
-    :members:
-
-.. automodule:: blinkpy.helpers.util
-    :members:
-

docs/api/implemented.rst

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

docs/index.rst

@@ -7,12 +7,16 @@ Welcome to blinkpy's documentation!
 ===================================
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 1
    :caption: Contents:
    :glob:
    
    README
-   api/*
+   advanced
+   CONTRIBUTING
+   modules/*
+   CHANGES
+
 
 Indices and tables
 ==================

docs/modules/blinkpy.rst

@@ -0,0 +1,41 @@
+.. _core_module:
+
+===========================
+Blinkpy Library Reference
+===========================
+
+blinkpy.py
+-----------
+.. automodule:: blinkpy.blinkpy
+    :members:
+
+auth.py
+--------
+
+.. automodule:: blinkpy.auth
+   :members:
+
+sync_module.py
+----------------
+
+.. automodule:: blinkpy.sync_module
+   :members:
+
+camera.py
+-----------
+
+.. automodule:: blinkpy.camera
+   :members:
+
+api.py
+---------
+
+.. automodule:: blinkpy.api
+   :members:
+
+helpers/util.py
+----------------
+
+.. automodule:: blinkpy.helpers.util
+    :members:
+

requirements_test.txt

@@ -1,13 +1,13 @@
 black==19.10b0
 coverage==5.1
-flake8==3.8.2
+flake8==3.8.3
 flake8-docstrings==1.5.0
-pre-commit==2.4.0
-pylint==2.5.2
+pre-commit==2.5.1
+pylint==2.5.3
 pydocstyle==5.0.2
-pytest==5.4.2
+pytest==5.4.3
 pytest-cov==2.9.0
 pytest-sugar==0.9.3
 pytest-timeout==1.3.4
-restructuredtext-lint==1.3.0
+restructuredtext-lint==1.3.1
 pygments==2.6.1

tests/test_blinkpy.py

@@ -9,6 +9,7 @@ any communication related errors at startup.
 import unittest
 from unittest import mock
 from blinkpy.blinkpy import Blink, BlinkSetupError
+from blinkpy.sync_module import BlinkOwl
 from blinkpy.helpers.constants import __version__
 
 
@@ -81,14 +82,21 @@ class TestBlinkSetup(unittest.TestCase):
         self.assertEqual(self.blink.sync["TEST"], 1234)
         self.assertEqual(self.blink.sync["tEsT"], 1234)
 
+    @mock.patch("blinkpy.api.request_camera_usage")
     @mock.patch("blinkpy.api.request_homescreen")
-    def test_setup_cameras(self, mock_home):
+    def test_setup_cameras(self, mock_home, mock_req):
         """Check retrieval of camera information."""
-        mock_home.return_value = {
+        mock_home.return_value = {}
+        mock_req.return_value = {
+            "networks": [
+                {
+                    "network_id": 1234,
                     "cameras": [
-                {"name": "foo", "network_id": 1234, "id": 5678},
-                {"name": "bar", "network_id": 1234, "id": 5679},
-                {"name": "test", "network_id": 4321, "id": 0000},
+                        {"id": 5678, "name": "foo"},
+                        {"id": 5679, "name": "bar"},
+                    ],
+                },
+                {"network_id": 4321, "cameras": [{"id": 0000, "name": "test"}]},
             ]
         }
         result = self.blink.setup_camera_list()
@@ -100,7 +108,7 @@ class TestBlinkSetup(unittest.TestCase):
             },
         )
 
-    @mock.patch("blinkpy.api.request_homescreen")
+    @mock.patch("blinkpy.api.request_camera_usage")
     def test_setup_cameras_failure(self, mock_home):
         """Check that on failure we raise a setup error."""
         mock_home.return_value = {}
@@ -155,10 +163,12 @@ class TestBlinkSetup(unittest.TestCase):
 
     @mock.patch("blinkpy.blinkpy.Blink.setup_camera_list")
     @mock.patch("blinkpy.api.request_networks")
-    def test_setup_post_verify(self, mock_networks, mock_camera):
+    @mock.patch("blinkpy.blinkpy.Blink.setup_owls")
+    def test_setup_post_verify(self, mock_owl, mock_networks, mock_camera):
         """Test setup after verification."""
         self.blink.available = False
         self.blink.key_required = True
+        mock_owl.return_value = True
         mock_networks.return_value = {
             "summary": {"foo": {"onboarded": False, "name": "bar"}}
         }
@@ -187,6 +197,99 @@ class TestBlinkSetup(unittest.TestCase):
         self.assertEqual(combined["fizz"], "buzz")
         self.assertEqual(combined["bar"], "foo")
 
+    @mock.patch("blinkpy.api.request_homescreen")
+    @mock.patch("blinkpy.blinkpy.BlinkOwl.start")
+    def test_initialize_blink_minis(self, mock_start, mock_home):
+        """Test blink mini initialization."""
+        mock_start.return_value = True
+        mock_home.return_value = {
+            "owls": [
+                {
+                    "enabled": False,
+                    "id": 1,
+                    "name": "foo",
+                    "network_id": 2,
+                    "onboarded": True,
+                    "status": "online",
+                    "thumbnail": "/foo/bar",
+                    "serial": "1234",
+                },
+                {
+                    "enabled": True,
+                    "id": 3,
+                    "name": "bar",
+                    "network_id": 4,
+                    "onboarded": True,
+                    "status": "online",
+                    "thumbnail": "/foo/bar",
+                    "serial": "abcd",
+                },
+            ]
+        }
+        self.blink.sync = {}
+        self.blink.setup_owls()
+        self.assertEqual(self.blink.sync["foo"].__class__, BlinkOwl)
+        self.assertEqual(self.blink.sync["bar"].__class__, BlinkOwl)
+        self.assertEqual(self.blink.sync["foo"].arm, False)
+        self.assertEqual(self.blink.sync["bar"].arm, True)
+        self.assertEqual(self.blink.sync["foo"].name, "foo")
+        self.assertEqual(self.blink.sync["bar"].name, "bar")
+
+    @mock.patch("blinkpy.api.request_homescreen")
+    def test_blink_mini_cameras_returned(self, mock_home):
+        """Test that blink mini cameras are found if attached to sync module."""
+        self.blink.network_ids = ["1234"]
+        mock_home.return_value = {
+            "owls": [
+                {
+                    "id": 1,
+                    "name": "foo",
+                    "network_id": 1234,
+                    "onboarded": True,
+                    "enabled": True,
+                    "status": "online",
+                    "thumbnail": "/foo/bar",
+                    "serial": "abc123",
+                }
+            ]
+        }
+        result = self.blink.setup_owls()
+        self.assertEqual(self.blink.network_ids, ["1234"])
+        self.assertEqual(
+            result, [{"1234": {"name": "foo", "id": "1234", "type": "mini"}}]
+        )
+
+        self.blink.no_owls = True
+        self.blink.network_ids = []
+        result = self.blink.setup_owls()
+        self.assertEqual(self.blink.network_ids, [])
+        self.assertEqual(result, [])
+
+    @mock.patch("blinkpy.api.request_homescreen")
+    @mock.patch("blinkpy.api.request_camera_usage")
+    def test_blink_mini_attached_to_sync(self, mock_usage, mock_home):
+        """Test that blink mini cameras are properly attached to sync module."""
+        self.blink.network_ids = ["1234"]
+        mock_home.return_value = {
+            "owls": [
+                {
+                    "id": 1,
+                    "name": "foo",
+                    "network_id": 1234,
+                    "onboarded": True,
+                    "enabled": True,
+                    "status": "online",
+                    "thumbnail": "/foo/bar",
+                    "serial": "abc123",
+                }
+            ]
+        }
+        mock_usage.return_value = {"networks": [{"cameras": [], "network_id": 1234}]}
+        result = self.blink.setup_camera_list()
+        self.assertEqual(
+            result, {"1234": [{"name": "foo", "id": "1234", "type": "mini"}]}
+        )
+
 
 class MockSync:
     """Mock sync module class."""

tests/test_cameras.py

@@ -11,7 +11,7 @@ from unittest import mock
 from blinkpy.blinkpy import Blink
 from blinkpy.helpers.util import BlinkURLHandler
 from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.camera import BlinkCamera
+from blinkpy.camera import BlinkCamera, BlinkCameraMini
 
 
 CAMERA_CFG = {
@@ -161,3 +161,21 @@ class TestBlinkCameraSetup(unittest.TestCase):
         mock_en.return_value = "enable"
         self.assertEqual(self.camera.set_motion_detect(True), "enable")
         self.assertEqual(self.camera.set_motion_detect(False), "disable")
+
+    def test_missing_attributes(self, mock_resp):
+        """Test that attributes return None if missing."""
+        self.camera.temperature = None
+        self.camera.serial = None
+        attr = self.camera.attributes
+        self.assertEqual(attr["serial"], None)
+        self.assertEqual(attr["temperature"], None)
+        self.assertEqual(attr["temperature_c"], None)
+
+    def test_mini_missing_attributes(self, mock_resp):
+        """Test that attributes return None if missing."""
+        camera = BlinkCameraMini(self.blink.sync)
+        self.blink.sync.network_id = None
+        self.blink.sync.name = None
+        attr = camera.attributes
+        for key in attr:
+            self.assertEqual(attr[key], None)

tests/test_sync_module.py

@@ -4,8 +4,8 @@ from unittest import mock
 
 from blinkpy.blinkpy import Blink
 from blinkpy.helpers.util import BlinkURLHandler
-from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.camera import BlinkCamera
+from blinkpy.sync_module import BlinkSyncModule, BlinkOwl
+from blinkpy.camera import BlinkCamera, BlinkCameraMini
 
 
 @mock.patch("blinkpy.auth.Auth.query")
@@ -275,3 +275,20 @@ class TestBlinkSyncModule(unittest.TestCase):
         """Test sync attributes."""
         self.assertEqual(self.blink.sync["test"].attributes["name"], "test")
         self.assertEqual(self.blink.sync["test"].attributes["network_id"], "1234")
+
+    def test_owl_start(self, mock_resp):
+        """Test owl camera instantiation."""
+        response = {
+            "name": "foo",
+            "id": 2,
+            "serial": "foobar123",
+            "enabled": True,
+            "network_id": 1,
+            "thumbnail": "/foo/bar",
+        }
+        self.blink.last_refresh = None
+        self.blink.homescreen = {"owls": [response]}
+        owl = BlinkOwl(self.blink, "foo", 1234, response)
+        self.assertTrue(owl.start())
+        self.assertTrue("foo" in owl.cameras)
+        self.assertEqual(owl.cameras["foo"].__class__, BlinkCameraMini)

tox.ini

@@ -41,8 +41,7 @@ commands =
     flake8 blinkpy tests app
     pydocstyle blinkpy tests app
     black --check --diff blinkpy tests app
-    rst-lint README.rst
-    rst-lint CHANGES.rst
+    rst-lint README.rst CHANGES.rst CONTRIBUTING.rst
 
 [testenv:build]
 recreate = True