Merge pull request #401 from fronzbot/fix-exception-on-refresh

Added test to catch NoneType error on refresh, fixed offending code

.coveragerc

@@ -1,5 +1,5 @@
 [run]
-omit = 
-    helpers/*
+parallel = true
+omit =
     tests/*
-    setup.py
+    setup.py

.github/stale.yml

@@ -0,0 +1,30 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - Priority
+  - bug
+  - Help Wanted
+
+# Set to true to ignore issues in a project (defaults to false)
+exemptProjects: true
+
+# Set to true to ignore issues in a milestone (defaults to false)
+exemptMilestones: true
+
+# Label to use when marking an issue as stale
+staleLabel: stale
+
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs within seven days. Thank you
+  for your contributions.
+  
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: >
+  This issue is now being closed due to inactivity.

.github/workflows/coverage.yml

@@ -0,0 +1,42 @@
+name: coverage
+
+on:
+  push:
+    branches: [ master, dev ]
+  pull_request:
+    branches: [ master, dev ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.platform }}
+    strategy:
+      max-parallel: 4
+      matrix:
+        platform:
+          - ubuntu-latest
+        python-version: [3.8]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install -r requirements_test.txt
+        pip install tox
+        pip install codecov
+    - name: Test
+      run: |
+        tox -r -e cov
+    - name: Codecov
+      uses: codecov/codecov-action@v1
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        flags: unittests
+        file: ./coverage.xml
+        name: blinkpy
+        fail_ci_if_error: true

.github/workflows/lint.yml

@@ -0,0 +1,34 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Lint
+
+on:
+  push:
+    branches: [ master, dev ]
+  pull_request:
+    branches: [ master, dev ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.8]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install -r requirements_test.txt
+        pip install tox
+    - name: Lint
+      run: |
+        tox -r -e lint

.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+# This workflows will upload a Python Package using Twine when a release is created
+# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v1
+      with:
+        python-version: '3.7'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
+        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+      run: |
+        python setup.py bdist_wheel
+        twine upload dist/*

.github/workflows/tests.yml

@@ -0,0 +1,33 @@
+name: build
+
+on:
+  push:
+    branches: [ master, dev ]
+  pull_request:
+    branches: [ master, dev ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.platform }}
+    strategy:
+      max-parallel: 3
+      matrix:
+        platform:
+          - ubuntu-latest
+        python-version: [3.6, 3.7, 3.8]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install -r requirements_test.txt
+        pip install tox
+    - name: Test
+      run: |
+        tox -r

.gitignore

@@ -4,6 +4,8 @@
 __pycache__/*
 htmlcov/*
 .coverage
+.coverage.*
+coverage.xml
 *.pyc
 *.egg*/*
 dist/*
@@ -11,3 +13,4 @@ dist/*
 build/*
 docs/_build
 *.log
+venv

.hound.yml

@@ -1,7 +0,0 @@
-python:
-  enabled: true
-  ignore_file: setup.py
-  ignored_directories:
-  - docs
-
-fail_on_violations: true

.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 19.10b0
+    hooks:
+      - id: black
+        args:
+          - --safe
+          - --quiet
+        files: ^((blinkpy|tests)/.+)?[^/]+\.py$
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.8.3
+    hooks:
+      - id: flake8
+        additional_dependencies:
+          - flake8-docstrings==1.5.0
+          - pydocstyle==5.1.1
+        files: ^(blinkpy|tests)/.+\.py$
+  - repo: https://github.com/Lucas-C/pre-commit-hooks-markup
+    rev: v1.0.0
+    hooks:
+      - id: rst-linter
+        files: /.+\.rst$

.travis.yml

@@ -1,23 +0,0 @@
-sudo: required
-matrix:
-  fast_finish: true
-  include:
-    - python: "3.5.3"
-      env: TOXENV=lint
-    - python: "3.5.3"
-      env: TOXENV=py35
-    - python: "3.6"
-      env: TOXENV=py36
-    - python: "3.6"
-      env: TOXENV=build
-    - python: "3.7"
-      env: TOXENV=py37
-      dist: xenial
-    - python: "3.8-dev"
-      env: TOXENV=py38
-      dist: xenial
-
-install: pip install -U tox coveralls
-language: python
-script: tox
-after_success: coveralls

CHANGES.rst

@@ -1,15 +1,136 @@
+=========
 Changelog
------------
+=========
 
 A list of changes between each release
 
+0.16.3 (2020-08-02)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Add user-agent to all headers
+
+0.16.2 (2020-08-01)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Add user-agent to header at login
+- Remove extra data parameters at login (not-needed)
+- Bump pytest to 6.0.1
+
+
+0.16.1 (2020-07-29)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Unpin requirements, set minimum version instead
+- Bump coverage to 5.2.1
+- Bump pytest to 6.0.0
+
+
+0.16.0 (2020-07-20)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+**Breaking Changes:**
+
+- Add arm property to camera, deprecate motion enable method (`#273 <https://github.com/fronzbot/blinkpy/pull/273>`__)
+- Complete refactoring of auth logic (breaks all pre-0.16.0 setups!) (`#261 <https://github.com/fronzbot/blinkpy/pull/261>`__)
+
+**New Features:**
+
+- Add is_errored property to Auth class (`#275 <https://github.com/fronzbot/blinkpy/pull/275>`__)
+- Add new endpoint to get user infor (`#280 <https://github.com/fronzbot/blinkpy/pull/280>`__)
+- Add get_liveview command to camera module (`#289 <https://github.com/fronzbot/blinkpy/pull/289>`__)
+- Add blink Mini Camera support (`#290 <https://github.com/fronzbot/blinkpy/pull/290>`__)
+- Add option to skip homescreen check (`#305 <https://github.com/fronzbot/blinkpy/pull/305>`__)
+- Add different timeout for video and image retrieval (`#323 <https://github.com/fronzbot/blinkpy/pull/323>`__)
+- Modifiy session to use HTTPAdapter and handle retries (`#324 <https://github.com/fronzbot/blinkpy/pull/324>`__)
+- Add retry option overrides (`#339 <https://github.com/fronzbot/blinkpy/pull/339>`__)
+
+**All changes:**
+
+Please see the change list in the (`Release Notes <https://github.com/fronzbot/releases/tag/v0.16.0>`__)
+
+
+0.15.1 (2020-07-11)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+- Bugfix: remove "Host" from auth header (`#330 <https://github.com/fronzbot/blinkpy/pull/330>`__)
+
+
+0.15.0 (2020-05-08)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+**Breaking Changes:**
+
+- Removed support for Python 3.5 (3.6 is now the minimum supported version)
+- Deprecated ``Blink.login()`` method.  Please only use the ``Blink.start()`` method for logging in.
+
+**New Functions**
+
+- Add ``device_id`` override when logging in (for debug and to differentiate applications) (`#245 <https://github.com/fronzbot/blinkpy/pull/245>`__)
+
+This can be used by instantiating the Blink class with the ``device_id`` parameter. 
+
+**All Changes:**
+
+- Fix setup.py use of internal pip structure (`#233 <https://github.com/fronzbot/blinkpy/pull/233>`__)
+- Update python-slugify requirement from ~=3.0.2 to ~=4.0.0 (`#234 <https://github.com/fronzbot/blinkpy/pull/234>`__)
+- Update python-dateutil requirement from ~=2.8.0 to ~=2.8.1 (`#230 <https://github.com/fronzbot/blinkpy/pull/230>`__)
+- Bump requests from 2.22.0 to 2.23.0 (`#231 <https://github.com/fronzbot/blinkpy/pull/231>`__)
+- Refactor login logic in preparation for 2FA (`#241 <https://github.com/fronzbot/blinkpy/pull/241>`__)
+- Add 2FA Support (`#242 <https://github.com/fronzbot/blinkpy/pull/242>`__) (fixes (`#210 <https://github.com/fronzbot/blinkpy/pull/210>`__))
+- Re-set key_required and available variables after setup (`#245 <https://github.com/fronzbot/blinkpy/pull/245>`__) 
+- Perform system refresh after setup (`#245 <https://github.com/fronzbot/blinkpy/pull/245>`__)
+- 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
+- Only allow ``motion_detected`` variable to trigger if system was armed
+- 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.
+- Previous logic for calculating percentage was incorrect
+- raw battery voltage can be accessed via ``BlinkCamera.battery_voltage``
+
+**Bug Fixes:**
+
+- Updated video endpoint (fixes broken motion detection)
+- Removed throttling from critical api methods which prevented proper operation of multi-sync unit setups
+- Slugify downloaded video names to allow for OS interoperability
+- Added one minute offset (``Blink.motion_interval``) when checking for recent motion to allow time for events to propagate to server prior to refresh call.
+
+**Everything else:**
+
+- Changed all urls to use ``rest-region`` rather than ``rest.region``.  Ability to revert to old method is enabled by instantiating ``Blink()`` with the ``legacy_subdomain`` variable set to ``True``.
+- Added debug mode to ``blinkpy.download_videos`` routine to simply print the videos prepped for download, rather than actually saving them.
+- Use UTC for time conversions, rather than local timezone
+
+
+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.
+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.
 
 - Adds throttle decorator
-- Decorate following functions with 4s throttle (call method with `force=True` to override):
+- Decorate following functions with 4s throttle (call method with ``force=True`` to override):
     - request_network_status
     - request_syncmodule
     - request_system_arm
@@ -24,16 +145,16 @@ Wifi status reported in dBm again, instead of bars (which is great).  Also, the
     - request_motion_detection_enable
     - request_motion_detection_disable
 - Use the updated homescreen api endpoint to retrieve camera information.  The old method to retrieve all cameras at once seems to not exist, and this was the only solution I could figure out and confirm to work.
-- Adds throttle decorator to refresh function to prevent too many frequent calls with `force_cache` flag set to `True`.  This additional throttle can be overridden with the `force=True` argument passed to the refresh function.
+- Adds throttle decorator to refresh function to prevent too many frequent calls with ``force_cache`` flag set to ``True``.  This additional throttle can be overridden with the ``force=True`` argument passed to the refresh function.
 - Add ability to cycle through login api endpoints to anticipate future endpoint deprecation
 
 
 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
@@ -41,22 +162,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
@@ -64,18 +185,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' 
+- 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>`__)
@@ -87,18 +208,18 @@ 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
 - Use session for http requests
 
 **Breaking change:**
-- Cameras now accessed through sync module Blink.sync.cameras
+- Cameras now accessed through sync module ``Blink.sync.cameras``
 
 
 0.8.1 (2018-09-24)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 - Update requirements_test.txt
 - Update linter versions
 - Fix pylint warnings
@@ -114,18 +235,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>`__)
@@ -139,7 +260,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!)
@@ -147,44 +268,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,89 +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 a Local Branch
-   
-   First, you will want to create a new branch to hold your changes:
-   ``git checkout -b <your-branch-name>``
-
-
-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)
-
-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.
-
-
-## 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.

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.7-alpine
+LABEL maintainer="Kevin Fronczak <kfronczak@gmail.com>"
+
+VOLUME /media
+
+RUN python -m pip install --upgrade pip
+RUN pip3 install blinkpy
+
+COPY app/ .
+
+ENTRYPOINT ["python", "./app.py"]
+CMD []

README.rst

@@ -1,9 +1,12 @@
-blinkpy |Build Status| |Coverage Status| |Docs| |PyPi Version| |Python Version|
-================================================================================
-A Python library for the Blink Camera system
+blinkpy |Build Status| |Coverage Status| |Docs| |PyPi Version| |Codestyle|
+=============================================================================================
+A Python library for the Blink Camera system (Python 3.6+)
 
-Disclaimer:
-~~~~~~~~~~~~~~~
+Like the library? Consider buying me a cup of coffee!
+
+`Buy me a Coffee! <https://buymeacoffee.com/kevinfronczak>`__
+
+**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.
@@ -14,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
@@ -31,47 +34,96 @@ 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
 =============
-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.
+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.  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
 
-    from blinkpy import blinkpy
-    blink = blinkpy.Blink(username='YOUR USER NAME', password='YOUR PASSWORD', refresh_rate=30)
+    from blinkpy.blinkpy import Blink
+   
+    blink = Blink()
     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.
 
+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
+
+    from blinkpy.blinkpy import Blink
+    from blinkpy.auth import Auth
+
+    blink = Blink()
+    # Can set no_prompt when initializing auth handler
+    auth = Auth({"username": <your username>, "password": <your password>}, no_prompt=True)
+    blink.auth = auth
+    blink.start()
+
+
+Since you will not be prompted for any 2FA pin, you must call the ``blink.auth.send_auth_key`` function.  There are two required parameters: the ``blink`` object as well as the ``key`` you received from Blink for 2FA:
+
+.. code:: python
+
+    auth.send_auth_key(blink, <your key>)
+    blink.setup_post_verify()
+
+
+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
+
+    from blinkpy.blinkpy import Blink
+    from blinkpy.auth import Auth
+    from blinkpy.helpers.util import json_load
+
+    blink = Blink()
+    auth = Auth(json_load("<File Location>"))
+    blink.auth = auth
+    blink.start()
+
+
+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
+
+    blink.save("<File location>")
+
+
+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:
 
 .. code:: python
 
-    from blinkpy import blinkpy
-
-    blink = blinkpy.Blink(username='YOUR USER NAME', password='YOUR PASSWORD')
-    blink.start()
-
     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.
+
+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`` flag, but this should be used for debugging only since it overrides the internal request throttling.
 
 .. code:: python
     
     camera = blink.cameras['SOME CAMERA NAME']
-    blink.refresh(force_cache=True)  # force a cache update USE WITH CAUTION
+    blink.refresh(force=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)
 
@@ -84,25 +136,60 @@ The ``blinkpy`` api also allows for saving images and videos to a file and snapp
     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.
+
+
+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 ``stop=`` variable.  Note that by default, the library will search the first ten pages which is sufficient in most use cases.  Additionally, you can specify 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
-.. |Coverage Status| image:: https://coveralls.io/repos/github/fronzbot/blinkpy/badge.svg?branch=dev
-    :target: https://coveralls.io/github/fronzbot/blinkpy?branch=dev
+.. |Build Status| image:: https://github.com/fronzbot/blinkpy/workflows/build/badge.svg
+   :target: https://github.com/fronzbot/blinkpy/actions?query=workflow%3Abuild
+.. |Coverage Status| image:: https://codecov.io/gh/fronzbot/blinkpy/branch/dev/graph/badge.svg
+    :target: https://codecov.io/gh/fronzbot/blinkpy
 .. |PyPi Version| image:: https://img.shields.io/pypi/v/blinkpy.svg
     :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
-.. |Python Version| image:: https://img.shields.io/pypi/pyversions/blinkpy.svg
-   :target: https://img.shields.io/pypi/pyversions/blinkpy.svg
+   :target: http://blinkpy.readthedocs.io/en/latest/?badge=latest   
+.. |Codestyle| image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://github.com/psf/black

app/__init__.py

@@ -0,0 +1 @@
+"""Python init file for app.py."""

app/app.py

@@ -0,0 +1,39 @@
+"""Script to run blinkpy as an app."""
+from os import environ
+from datetime import datetime, timedelta
+from blinkpy.blinkpy import Blink
+from blinkpy.auth import Auth
+from blinkpy.helpers.util import json_load
+
+
+CREDFILE = environ.get("CREDFILE")
+TIMEDELTA = timedelta(environ.get("TIMEDELTA", 1))
+
+
+def get_date():
+    """Return now - timedelta for blinkpy."""
+    return (datetime.now() - TIMEDELTA).isoformat()
+
+
+def download_videos(blink, save_dir="/media"):
+    """Make request to download videos."""
+    blink.download_videos(save_dir, since=get_date())
+
+
+def start():
+    """Startup blink app."""
+    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__":
+    main()

app/build.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+docker build -t fronzbot/blinkpy:latest ./

app/run.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# bash run.sh [username] [password]
+
+if [ "$#" -ne 2 ]; then
+    echo ""
+    echo "ERROR: Requries Blink username and password as arguments."
+    echo "bash run.sh [username] [password]"
+    echo ""
+    exit 1
+fi
+
+set -ex
+USER=fronzbot
+IMAGE=blinkpy
+CONFIG=$HOME/blinkpy_media
+USERNAME=$1
+PASSWORD=$2
+
+mkdir -p $CONFIG
+
+result=$(docker images -q $IMAGE)
+if [ $result ]; then
+    docker rm $IMAGE
+fi
+docker run -it --name ${IMAGE} \
+    -v $CONFIG:/media \
+    -e USERNAME=${USERNAME} \
+    -e PASSWORD=${PASSWORD} \
+    $USER/$IMAGE \
+    /bin/bash
+

blinkpy/api.py

@@ -2,45 +2,84 @@
 
 import logging
 from json import dumps
-import blinkpy.helpers.errors as ERROR
-from blinkpy.helpers.util import http_req, get_time, BlinkException, Throttle
-from blinkpy.helpers.constants import DEFAULT_URL
+from blinkpy.helpers.util import get_time, Throttle
+from blinkpy.helpers.constants import DEFAULT_URL, TIMEOUT, DEFAULT_USER_AGENT
 
 _LOGGER = logging.getLogger(__name__)
 
-MIN_THROTTLE_TIME = 2
+MIN_THROTTLE_TIME = 5
 
 
-def request_login(blink, url, username, password, is_retry=False):
+def request_login(
+    auth, url, login_data, is_retry=False,
+):
     """
     Login request.
 
-    :param blink: Blink instance.
+    :param auth: Auth instance.
     :param url: Login url.
-    :param username: Blink username.
-    :param password: Blink password.
-    :param is_retry: Is this part of a re-authorization attempt?
+    :login_data: Dictionary containing blink login data.
     """
     headers = {
-        'Host': DEFAULT_URL,
-        'Content-Type': 'application/json'
+        "Host": DEFAULT_URL,
+        "Content-Type": "application/json",
+        "Accept": "/",
+        "user-agent": DEFAULT_USER_AGENT,
     }
-    data = dumps({
-        'email': username,
-        'password': password,
-        'client_specifier': 'iPhone 9.2 | 2.2 | 222'
-    })
-    return http_req(blink, url=url, headers=headers, data=data,
-                    json_resp=False, reqtype='post', is_retry=is_retry)
+    data = dumps(
+        {
+            "email": login_data["username"],
+            "password": login_data["password"],
+            "notification_key": login_data["notification_key"],
+            "unique_id": login_data["uid"],
+            "device_identifier": login_data["device_id"],
+            "client_name": "Computer",
+            "reauth": "false",
+        }
+    )
+
+    return auth.query(
+        url=url,
+        headers=headers,
+        data=data,
+        json_resp=False,
+        reqtype="post",
+        is_retry=is_retry,
+    )
+
+
+def request_verify(auth, blink, verify_key):
+    """Send verification key to blink servers."""
+    url = f"{blink.urls.base_url}/api/v4/account/{blink.account_id}/client/{blink.client_id}/pin/verify"
+    data = dumps({"pin": verify_key})
+    return auth.query(
+        url=url, headers=auth.header, data=data, json_resp=False, reqtype="post",
+    )
 
 
 def request_networks(blink):
     """Request all networks information."""
-    url = "{}/networks".format(blink.urls.base_url)
+    url = f"{blink.urls.base_url}/networks"
+    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)
 
 
-@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_network_status(blink, network):
     """
     Request network information.
@@ -48,11 +87,10 @@ def request_network_status(blink, network):
     :param blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = "{}/network/{}".format(blink.urls.base_url, network)
+    url = f"{blink.urls.base_url}/network/{network}"
     return http_get(blink, url)
 
 
-@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_syncmodule(blink, network):
     """
     Request sync module info.
@@ -60,7 +98,7 @@ def request_syncmodule(blink, network):
     :param blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = "{}/network/{}/syncmodules".format(blink.urls.base_url, network)
+    url = f"{blink.urls.base_url}/network/{network}/syncmodules"
     return http_get(blink, url)
 
 
@@ -72,7 +110,7 @@ def request_system_arm(blink, network):
     :param blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = "{}/network/{}/arm".format(blink.urls.base_url, network)
+    url = f"{blink.urls.base_url}/api/v1/accounts/{blink.account_id}/networks/{network}/state/arm"
     return http_post(blink, url)
 
 
@@ -84,7 +122,7 @@ def request_system_disarm(blink, network):
     :param blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = "{}/network/{}/disarm".format(blink.urls.base_url, network)
+    url = f"{blink.urls.base_url}/api/v1/accounts/{blink.account_id}/networks/{network}/state/disarm"
     return http_post(blink, url)
 
 
@@ -96,17 +134,14 @@ def request_command_status(blink, network, command_id):
     :param network: Sync module network id.
     :param command_id: Command id to check.
     """
-    url = "{}/network/{}/command/{}".format(blink.urls.base_url,
-                                            network,
-                                            command_id)
+    url = f"{blink.urls.base_url}/network/{network}/command/{command_id}"
     return http_get(blink, url)
 
 
 @Throttle(seconds=MIN_THROTTLE_TIME)
 def request_homescreen(blink):
     """Request homescreen info."""
-    url = "{}/api/v3/accounts/{}/homescreen".format(blink.urls.base_url,
-                                                    blink.account_id)
+    url = f"{blink.urls.base_url}/api/v3/accounts/{blink.account_id}/homescreen"
     return http_get(blink, url)
 
 
@@ -118,7 +153,7 @@ def request_sync_events(blink, network):
     :param blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = "{}/events/network/{}".format(blink.urls.base_url, network)
+    url = f"{blink.urls.base_url}/events/network/{network}"
     return http_get(blink, url)
 
 
@@ -131,9 +166,7 @@ def request_new_image(blink, network, camera_id):
     :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)
+    url = f"{blink.urls.base_url}/network/{network}/camera/{camera_id}/thumbnail"
     return http_post(blink, url)
 
 
@@ -146,16 +179,14 @@ def request_new_video(blink, network, camera_id):
     :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)
+    url = f"{blink.urls.base_url}/network/{network}/camera/{camera_id}/clip"
     return http_post(blink, url)
 
 
 @Throttle(seconds=MIN_THROTTLE_TIME)
 def request_video_count(blink):
     """Request total video count."""
-    url = "{}/api/v2/videos/count".format(blink.urls.base_url)
+    url = f"{blink.urls.base_url}/api/v2/videos/count"
     return http_get(blink, url)
 
 
@@ -168,12 +199,10 @@ def request_videos(blink, time=None, page=0):
     :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)
+    url = f"{blink.urls.base_url}/api/v1/accounts/{blink.account_id}/media/changed?since={timestamp}&page={page}"
     return http_get(blink, url)
 
 
-@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_cameras(blink, network):
     """
     Request all camera information.
@@ -181,7 +210,7 @@ def request_cameras(blink, network):
     :param Blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = "{}/network/{}/cameras".format(blink.urls.base_url, network)
+    url = f"{blink.urls.base_url}/network/{network}/cameras"
     return http_get(blink, url)
 
 
@@ -193,12 +222,32 @@ def request_camera_info(blink, network, camera_id):
     :param network: Sync module network id.
     :param camera_id: Camera ID of camera to request info from.
     """
-    url = "{}/network/{}/camera/{}/config".format(blink.urls.base_url,
-                                                  network,
-                                                  camera_id)
+    url = f"{blink.urls.base_url}/network/{network}/camera/{camera_id}/config"
     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/v5/accounts/{blink.account_id}/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.
@@ -207,9 +256,7 @@ def request_camera_sensors(blink, network, camera_id):
     :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)
+    url = f"{blink.urls.base_url}/network/{network}/camera/{camera_id}/signals"
     return http_get(blink, url)
 
 
@@ -222,9 +269,7 @@ def request_motion_detection_enable(blink, network, camera_id):
     :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)
+    url = f"{blink.urls.base_url}/network/{network}/camera/{camera_id}/enable"
     return http_post(blink, url)
 
 
@@ -236,13 +281,11 @@ def request_motion_detection_disable(blink, network, camera_id):
     :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)
+    url = f"{blink.urls.base_url}/network/{network}/camera/{camera_id}/disable"
     return http_post(blink, url)
 
 
-def http_get(blink, url, stream=False, json=True, is_retry=False):
+def http_get(blink, url, stream=False, json=True, is_retry=False, timeout=TIMEOUT):
     """
     Perform an http get request.
 
@@ -251,23 +294,25 @@ def http_get(blink, url, stream=False, json=True, is_retry=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,
-                    is_retry=is_retry)
+    return blink.auth.query(
+        url=url,
+        headers=blink.auth.header,
+        reqtype="get",
+        stream=stream,
+        json_resp=json,
+        is_retry=is_retry,
+    )
 
 
-def http_post(blink, url, is_retry=False):
+def http_post(blink, url, is_retry=False, timeout=TIMEOUT):
     """
     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', is_retry=is_retry)
+    return blink.auth.query(
+        url=url, headers=blink.auth.header, reqtype="post", is_retry=is_retry
+    )

blinkpy/auth.py

@@ -0,0 +1,258 @@
+"""Login handler for blink."""
+import logging
+from functools import partial
+from requests import Request, Session, exceptions
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from blinkpy import api
+from blinkpy.helpers import util
+from blinkpy.helpers.constants import (
+    BLINK_URL,
+    DEFAULT_USER_AGENT,
+    LOGIN_ENDPOINT,
+    TIMEOUT,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Auth:
+    """Class to handle login communication."""
+
+    def __init__(self, login_data=None, no_prompt=False):
+        """
+        Initialize auth handler.
+
+        :param login_data: dictionary for login data
+                           must contain the following:
+                             - username
+                             - password
+        :param no_prompt: Should any user input prompts
+                          be supressed? True/FALSE
+        """
+        if login_data is None:
+            login_data = {}
+        self.data = login_data
+        self.token = login_data.get("token", None)
+        self.host = login_data.get("host", None)
+        self.region_id = login_data.get("region_id", None)
+        self.client_id = login_data.get("client_id", None)
+        self.account_id = login_data.get("account_id", None)
+        self.login_response = None
+        self.is_errored = False
+        self.no_prompt = no_prompt
+        self.session = self.create_session()
+
+    @property
+    def login_attributes(self):
+        """Return a dictionary of login attributes."""
+        self.data["token"] = self.token
+        self.data["host"] = self.host
+        self.data["region_id"] = self.region_id
+        self.data["client_id"] = self.client_id
+        self.data["account_id"] = self.account_id
+        return self.data
+
+    @property
+    def header(self):
+        """Return authorization header."""
+        if self.token is None:
+            return None
+        return {"TOKEN_AUTH": self.token, "user-agent": DEFAULT_USER_AGENT}
+
+    def create_session(self, opts=None):
+        """Create a session for blink communication."""
+        if opts is None:
+            opts = {}
+        backoff = opts.get("backoff", 1)
+        retries = opts.get("retries", 3)
+        retry_list = opts.get("retry_list", [429, 500, 502, 503, 504])
+        sess = Session()
+        assert_status_hook = [
+            lambda response, *args, **kwargs: response.raise_for_status()
+        ]
+        sess.hooks["response"] = assert_status_hook
+        retry = Retry(
+            total=retries, backoff_factor=backoff, status_forcelist=retry_list
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        sess.mount("https://", adapter)
+        sess.mount("http://", adapter)
+        sess.get = partial(sess.get, timeout=TIMEOUT)
+        return sess
+
+    def prepare_request(self, url, headers, data, reqtype):
+        """Prepare a request."""
+        req = Request(reqtype.upper(), url, headers=headers, data=data)
+        return req.prepare()
+
+    def validate_login(self):
+        """Check login information and prompt if not available."""
+        self.data["username"] = self.data.get("username", None)
+        self.data["password"] = self.data.get("password", None)
+        if not self.no_prompt:
+            self.data = util.prompt_login_data(self.data)
+
+        self.data = util.validate_login_data(self.data)
+
+    def login(self, login_url=LOGIN_ENDPOINT):
+        """Attempt login to blink servers."""
+        self.validate_login()
+        _LOGGER.info("Attempting login with %s", login_url)
+        response = api.request_login(self, login_url, self.data, is_retry=False,)
+        try:
+            if response.status_code == 200:
+                return response.json()
+            raise LoginError
+        except AttributeError:
+            raise LoginError
+
+    def refresh_token(self):
+        """Refresh auth token."""
+        self.is_errored = True
+        try:
+            _LOGGER.info("Token expired, attempting automatic refresh.")
+            self.login_response = self.login()
+            self.extract_login_info()
+            self.is_errored = False
+        except LoginError:
+            _LOGGER.error("Login endpoint failed. Try again later.")
+            raise TokenRefreshFailed
+        except (TypeError, KeyError):
+            _LOGGER.error("Malformed login response: %s", self.login_response)
+            raise TokenRefreshFailed
+        return True
+
+    def extract_login_info(self):
+        """Extract login info from login response."""
+        self.region_id = self.login_response["region"]["tier"]
+        self.host = f"{self.region_id}.{BLINK_URL}"
+        self.token = self.login_response["authtoken"]["authtoken"]
+        self.client_id = self.login_response["client"]["id"]
+        self.account_id = self.login_response["account"]["id"]
+
+    def startup(self):
+        """Initialize tokens for communication."""
+        self.validate_login()
+        if None in self.login_attributes.values():
+            self.refresh_token()
+
+    def validate_response(self, response, json_resp):
+        """Check for valid response."""
+        if not json_resp:
+            self.is_errored = False
+            return response
+        self.is_errored = True
+        try:
+            if response.status_code in [101, 401]:
+                raise UnauthorizedError
+            if response.status_code == 404:
+                raise exceptions.ConnectionError
+            json_data = response.json()
+        except KeyError:
+            pass
+        except (AttributeError, ValueError):
+            raise BlinkBadResponse
+
+        self.is_errored = False
+        return json_data
+
+    def query(
+        self,
+        url=None,
+        data=None,
+        headers=None,
+        reqtype="get",
+        stream=False,
+        json_resp=True,
+        is_retry=False,
+        timeout=TIMEOUT,
+    ):
+        """
+        Perform server requests.
+
+        :param url: URL to perform request
+        :param data: Data to send
+        :param headers: Headers to send
+        :param reqtype: Can be 'get' or 'post' (default: 'get')
+        :param stream: Stream response? True/FALSE
+        :param json_resp: Return JSON response? TRUE/False
+        :param is_retry: Is this part of a re-auth attempt? True/FALSE
+        """
+        req = self.prepare_request(url, headers, data, reqtype)
+        try:
+            response = self.session.send(req, stream=stream, timeout=timeout)
+            return self.validate_response(response, json_resp)
+        except (exceptions.ConnectionError, exceptions.Timeout):
+            _LOGGER.error(
+                "Connection error. Endpoint %s possibly down or throttled.", url,
+            )
+        except BlinkBadResponse:
+            code = None
+            reason = None
+            try:
+                code = response.status_code
+                reason = response.reason
+            except AttributeError:
+                pass
+            _LOGGER.error(
+                "Expected json response from %s, but received: %s: %s",
+                url,
+                code,
+                reason,
+            )
+        except UnauthorizedError:
+            try:
+                if not is_retry:
+                    self.refresh_token()
+                    return self.query(
+                        url=url,
+                        data=data,
+                        headers=self.header,
+                        reqtype=reqtype,
+                        stream=stream,
+                        json_resp=json_resp,
+                        is_retry=True,
+                        timeout=timeout,
+                    )
+                _LOGGER.error("Unable to access %s after token refresh.", url)
+            except TokenRefreshFailed:
+                _LOGGER.error("Unable to refresh token.")
+        return None
+
+    def send_auth_key(self, blink, key):
+        """Send 2FA key to blink servers."""
+        if key is not None:
+            response = api.request_verify(self, blink, key)
+            try:
+                json_resp = response.json()
+                blink.available = json_resp["valid"]
+            except (KeyError, TypeError):
+                _LOGGER.error("Did not receive valid response from server.")
+                return False
+        return True
+
+    def check_key_required(self):
+        """Check if 2FA key is required."""
+        try:
+            if self.login_response["client"]["verification_required"]:
+                return True
+        except (KeyError, TypeError):
+            pass
+        return False
+
+
+class TokenRefreshFailed(Exception):
+    """Class to throw failed refresh exception."""
+
+
+class LoginError(Exception):
+    """Class to throw failed login exception."""
+
+
+class BlinkBadResponse(Exception):
+    """Class to throw bad json response exception."""
+
+
+class UnauthorizedError(Exception):
+    """Class to throw an unauthorized access error."""

blinkpy/blinkpy.py

@@ -15,221 +15,234 @@ blinkpy is in no way affiliated with Blink, nor Immedia Inc.
 
 import os.path
 import time
-import getpass
 import logging
 from shutil import copyfileobj
 
 from requests.structures import CaseInsensitiveDict
 from dateutil.parser import parse
+from slugify import slugify
 
 from blinkpy import api
-from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.helpers import errors as ERROR
-from blinkpy.helpers.util import (
-    create_session, merge_dicts, get_time, BlinkURLHandler,
-    BlinkAuthenticationException, Throttle)
+from blinkpy.sync_module import BlinkSyncModule, BlinkOwl
+from blinkpy.helpers import util
 from blinkpy.helpers.constants import (
-    BLINK_URL, LOGIN_URL, OLD_LOGIN_URL, LOGIN_BACKUP_URL)
+    DEFAULT_MOTION_INTERVAL,
+    DEFAULT_REFRESH,
+    MIN_THROTTLE_TIME,
+    TIMEOUT_MEDIA,
+)
 from blinkpy.helpers.constants import __version__
-
-REFRESH_RATE = 30
-
-# Prevents rapid calls to blink.refresh()
-# with the force_cache flag set to True
-MIN_THROTTLE_TIME = 2
+from blinkpy.auth import Auth, TokenRefreshFailed, LoginError
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class Blink():
+class Blink:
     """Class to initialize communication."""
 
-    def __init__(self, username=None, password=None,
-                 refresh_rate=REFRESH_RATE):
+    def __init__(
+        self,
+        refresh_rate=DEFAULT_REFRESH,
+        motion_interval=DEFAULT_MOTION_INTERVAL,
+        no_owls=False,
+    ):
         """
         Initialize Blink system.
 
-        :param username: Blink username (usually email address)
-        :param password: Blink password
         :param refresh_rate: Refresh rate of blink information.
                              Defaults to 15 (seconds)
+        :param motion_interval: How far back to register motion in minutes.
+                                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._username = username
-        self._password = password
-        self._token = None
-        self._auth_header = None
-        self._host = None
+        self.auth = Auth()
         self.account_id = None
+        self.client_id = None
         self.network_ids = []
         self.urls = None
         self.sync = CaseInsensitiveDict({})
-        self.region = None
-        self.region_id = None
         self.last_refresh = None
         self.refresh_rate = refresh_rate
-        self.session = create_session()
         self.networks = []
         self.cameras = CaseInsensitiveDict({})
         self.video_list = CaseInsensitiveDict({})
-        self._login_url = LOGIN_URL
+        self.motion_interval = motion_interval
         self.version = __version__
+        self.available = False
+        self.key_required = False
+        self.homescreen = {}
+        self.no_owls = no_owls
 
-    @property
-    def auth_header(self):
-        """Return the authentication header."""
-        return self._auth_header
-
-    def start(self):
-        """
-        Perform full system setup.
-
-        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:
-            if not self.login():
-                return
-        elif not self.get_auth_token():
-            return
-
-        camera_list = self.get_cameras()
-        networks = self.get_ids()
-        for network_name, network_id in networks.items():
-            if network_id not in camera_list.keys():
-                camera_list[network_id] = {}
-                _LOGGER.warning("No cameras found for %s", network_name)
-            sync_module = BlinkSyncModule(self,
-                                          network_name,
-                                          network_id,
-                                          camera_list[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."""
-        self._username = input("Username:")
-        self._password = getpass.getpass("Password:")
-        if self.get_auth_token():
-            _LOGGER.debug("Login successful!")
-            return True
-        _LOGGER.warning("Unable to login with %s.", self._username)
-        return False
-
-    def get_auth_token(self, is_retry=False):
-        """Retrieve the authentication token from Blink."""
-        if not isinstance(self._username, str):
-            raise BlinkAuthenticationException(ERROR.USERNAME)
-        if not isinstance(self._password, str):
-            raise BlinkAuthenticationException(ERROR.PASSWORD)
-
-        login_urls = [LOGIN_URL, OLD_LOGIN_URL, LOGIN_BACKUP_URL]
-
-        response = self.login_request(login_urls, is_retry=is_retry)
-
-        if not response:
-            return False
-
-        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.urls = BlinkURLHandler(self.region_id)
-
-        return self._auth_header
-
-    def login_request(self, login_urls, is_retry=False):
-        """Make a login request."""
-        try:
-            login_url = login_urls.pop(0)
-        except IndexError:
-            _LOGGER.error("Could not login to blink servers.")
-            return False
-
-        _LOGGER.info("Attempting login with %s", login_url)
-
-        response = api.request_login(self,
-                                     login_url,
-                                     self._username,
-                                     self._password,
-                                     is_retry=is_retry)
-        try:
-            if response.status_code != 200:
-                response = self.login_request(login_urls)
-            response = response.json()
-            (self.region_id, self.region), = response['region'].items()
-
-        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._login_url = login_url
-        return response
-
-    def get_ids(self):
-        """Set the network ID and Account ID."""
-        response = api.request_networks(self)
-        all_networks = []
-        network_dict = {}
-        for network, status in self.networks.items():
-            if status['onboarded']:
-                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']) in all_networks:
-                self.account_id = resp['account_id']
-                break
-
-        self.network_ids = all_networks
-        return network_dict
-
-    def get_cameras(self):
-        """Retrieve a camera list for each onboarded network."""
-        response = api.request_homescreen(self)
-        try:
-            all_cameras = {}
-            for camera in response['cameras']:
-                camera_network = str(camera['network_id'])
-                camera_name = camera['name']
-                camera_id = camera['id']
-                camera_info = {'name': camera_name, 'id': camera_id}
-                if camera_network not in all_cameras:
-                    all_cameras[camera_network] = []
-
-                all_cameras[camera_network].append(camera_info)
-            return all_cameras
-        except KeyError:
-            _LOGGER.error("Initialization failue. Could not retrieve cameras.")
-            return {}
-
-    @Throttle(seconds=MIN_THROTTLE_TIME)
-    def refresh(self, force_cache=False):
+    @util.Throttle(seconds=MIN_THROTTLE_TIME)
+    def refresh(self, force=False, force_cache=False):
         """
         Perform a system refresh.
 
-        :param force_cache: Force an update of the camera cache
+        :param force: Used to override throttle, resets refresh
+        :param force_cache: Used to force update without overriding throttle
         """
-        if self.check_if_ok_to_update() or force_cache:
+        if self.check_if_ok_to_update() or force or force_cache:
+            if not self.available:
+                self.setup_post_verify()
+
+            self.get_homescreen()
             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)
+                sync_module.refresh(force_cache=(force or force_cache))
             if not force_cache:
                 # Prevents rapid clearing of motion detect property
                 self.last_refresh = int(time.time())
             return True
         return False
 
+    def start(self):
+        """Perform full system setup."""
+        try:
+            self.auth.startup()
+            self.setup_login_ids()
+            self.setup_urls()
+            self.get_homescreen()
+        except (LoginError, TokenRefreshFailed, BlinkSetupError):
+            _LOGGER.error("Cannot setup Blink platform.")
+            self.available = False
+            return False
+
+        self.key_required = self.auth.check_key_required()
+        if self.key_required:
+            if self.auth.no_prompt:
+                return True
+            self.setup_prompt_2fa()
+        return self.setup_post_verify()
+
+    def setup_prompt_2fa(self):
+        """Prompt for 2FA."""
+        email = self.auth.data["username"]
+        pin = input(f"Enter code sent to {email}: ")
+        result = self.auth.send_auth_key(self, pin)
+        self.key_required = not result
+
+    def setup_post_verify(self):
+        """Initialize blink system after verification."""
+        try:
+            self.setup_networks()
+            networks = self.setup_network_ids()
+            cameras = self.setup_camera_list()
+        except BlinkSetupError:
+            self.available = False
+            return False
+
+        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
+        self.key_required = False
+        return True
+
+    def setup_sync_module(self, name, network_id, cameras):
+        """Initialize a sync module."""
+        self.sync[name] = BlinkSyncModule(self, name, network_id, cameras)
+        self.sync[name].start()
+
+    def get_homescreen(self):
+        """Get homecreen information."""
+        if self.no_owls:
+            _LOGGER.debug("Skipping owl extraction.")
+            self.homescreen = {}
+            return
+        self.homescreen = api.request_homescreen(self)
+
+    def setup_owls(self):
+        """Check for mini cameras."""
+        network_list = []
+        camera_list = []
+        try:
+            for owl in self.homescreen["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_camera_usage(self)
+        try:
+            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)
+            raise BlinkSetupError
+
+    def setup_login_ids(self):
+        """Retrieve login id numbers from login response."""
+        self.client_id = self.auth.client_id
+        self.account_id = self.auth.account_id
+
+    def setup_urls(self):
+        """Create urls for api."""
+        try:
+            self.urls = util.BlinkURLHandler(self.auth.region_id)
+        except TypeError:
+            _LOGGER.error(
+                "Unable to extract region is from response %s", self.auth.login_response
+            )
+            raise BlinkSetupError
+
+    def setup_networks(self):
+        """Get network information."""
+        response = api.request_networks(self)
+        try:
+            self.networks = response["summary"]
+        except (KeyError, TypeError):
+            raise BlinkSetupError
+
+    def setup_network_ids(self):
+        """Create the network ids for onboarded networks."""
+        all_networks = []
+        network_dict = {}
+        try:
+            for network, status in self.networks.items():
+                if status["onboarded"]:
+                    all_networks.append(f"{network}")
+                    network_dict[status["name"]] = network
+        except AttributeError:
+            _LOGGER.error(
+                "Unable to retrieve network information from %s", self.networks
+            )
+            raise BlinkSetupError
+
+        self.network_ids = all_networks
+        return network_dict
+
     def check_if_ok_to_update(self):
         """Check if it is ok to perform an http request."""
         current_time = int(time.time())
@@ -244,20 +257,26 @@ class Blink():
         """Merge all sync camera dicts into one."""
         combined = CaseInsensitiveDict({})
         for sync in self.sync:
-            combined = merge_dicts(combined, self.sync[sync].cameras)
+            combined = util.merge_dicts(combined, self.sync[sync].cameras)
         return combined
 
-    def download_videos(self, path, since=None, camera='all', stop=10):
+    def save(self, file_name):
+        """Save login data to file."""
+        util.json_save(self.auth.login_attributes, file_name)
+
+    def download_videos(self, path, since=None, camera="all", stop=10, debug=False):
         """
         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
+                      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).
+        :param debug: Set to TRUE to prevent downloading of items.
+                      Instead of downloading, entries will be printed to log.
         """
         if since is None:
             since_epochs = self.last_refresh
@@ -265,7 +284,7 @@ class Blink():
             parsed_datetime = parse(since, fuzzy=True)
             since_epochs = parsed_datetime.timestamp()
 
-        formatted_date = get_time(time_to_convert=since_epochs)
+        formatted_date = util.get_time(time_to_convert=since_epochs)
         _LOGGER.info("Retrieving videos since %s", formatted_date)
 
         if not isinstance(camera, list):
@@ -275,48 +294,64 @@ class Blink():
             response = api.request_videos(self, time=since_epochs, page=page)
             _LOGGER.debug("Processing page %s", page)
             try:
-                result = response['videos']
+                result = response["media"]
                 if not result:
-                    raise IndexError
-            except (KeyError, IndexError):
+                    raise KeyError
+            except (KeyError, TypeError):
                 _LOGGER.info("No videos found on page %s. Exiting.", page)
                 break
 
-            self._parse_downloaded_items(result, camera, path)
+            self._parse_downloaded_items(result, camera, path, debug)
 
-    def _parse_downloaded_items(self, result, camera, path):
+    def _parse_downloaded_items(self, result, camera, path, debug):
         """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']
+                created_at = item["created_at"]
+                camera_name = item["device_name"]
+                is_deleted = item["deleted"]
+                address = item["media"]
             except KeyError:
                 _LOGGER.info("Missing clip information, skipping...")
                 continue
 
-            if camera_name not in camera and 'all' not in camera:
+            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)
+                _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)
+            clip_address = f"{self.urls.base_url}{address}"
+            filename = f"{camera_name}-{created_at}"
+            filename = f"{slugify(filename)}.mp4"
             filename = os.path.join(path, filename)
 
-            if os.path.isfile(filename):
-                _LOGGER.info("%s already exists, skipping...", filename)
-                continue
+            if not debug:
+                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)
+                response = api.http_get(
+                    self,
+                    url=clip_address,
+                    stream=True,
+                    json=False,
+                    timeout=TIMEOUT_MEDIA,
+                )
+                with open(filename, "wb") as vidfile:
+                    copyfileobj(response.raw, vidfile)
 
-            _LOGGER.info("Downloaded video to %s", filename)
+                _LOGGER.info("Downloaded video to %s", filename)
+            else:
+                print(
+                    (
+                        f"Camera: {camera_name}, Timestamp: {created_at}, "
+                        "Address: {address}, Filename: {filename}"
+                    )
+                )
+
+
+class BlinkSetupError(Exception):
+    """Class to handle setup errors."""

blinkpy/camera.py

@@ -3,11 +3,12 @@
 from shutil import copyfileobj
 import logging
 from blinkpy import api
+from blinkpy.helpers.constants import TIMEOUT_MEDIA
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class BlinkCamera():
+class BlinkCamera:
     """Class to initialize individual camera."""
 
     def __init__(self, sync):
@@ -29,38 +30,43 @@ class BlinkCamera():
         self.last_record = None
         self._cached_image = None
         self._cached_video = None
+        self.camera_type = ""
 
     @property
     def attributes(self):
         """Return dictionary of all camera attributes."""
         attributes = {
-            'name': self.name,
-            'camera_id': self.camera_id,
-            '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,
-            'motion_enabled': self.motion_enabled,
-            '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
+            "name": self.name,
+            "camera_id": self.camera_id,
+            "serial": self.serial,
+            "temperature": self.temperature,
+            "temperature_c": self.temperature_c,
+            "temperature_calibrated": self.temperature_calibrated,
+            "battery": self.battery,
+            "battery_voltage": self.battery_voltage,
+            "thumbnail": self.thumbnail,
+            "video": self.clip,
+            "motion_enabled": self.motion_enabled,
+            "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
 
     @property
     def battery(self):
-        """Return battery level as percentage."""
-        return round(self.battery_voltage / 180 * 100)
+        """Return battery as string."""
+        return self.battery_state
 
     @property
     def temperature_c(self):
         """Return temperature in celcius."""
-        return round((self.temperature - 32) / 9.0 * 5.0, 1)
+        try:
+            return round((self.temperature - 32) / 9.0 * 5.0, 1)
+        except TypeError:
+            return None
 
     @property
     def image_from_cache(self):
@@ -76,57 +82,88 @@ class BlinkCamera():
             return self._cached_video
         return None
 
+    @property
+    def arm(self):
+        """Return arm status of camera."""
+        return self.motion_enabled
+
+    @arm.setter
+    def arm(self, value):
+        """Set camera arm status."""
+        if value:
+            return api.request_motion_detection_enable(
+                self.sync.blink, self.network_id, self.camera_id
+            )
+        return api.request_motion_detection_disable(
+            self.sync.blink, self.network_id, self.camera_id
+        )
+
+    def get_media(self, media_type="image"):
+        """Download media (image or video)."""
+        url = self.thumbnail
+        if media_type.lower() == "video":
+            url = self.clip
+        return api.http_get(
+            self.sync.blink, url=url, stream=True, json=False, timeout=TIMEOUT_MEDIA,
+        )
+
     def snap_picture(self):
         """Take a picture with camera to create a new thumbnail."""
-        return api.request_new_image(self.sync.blink,
-                                     self.network_id,
-                                     self.camera_id)
+        return api.request_new_image(self.sync.blink, self.network_id, self.camera_id)
 
     def set_motion_detect(self, enable):
         """Set motion detection."""
+        _LOGGER.warning(
+            "Method is deprecated as of v0.16.0 and will be removed in a future version. Please use the BlinkCamera.arm property instead."
+        )
         if enable:
-            return api.request_motion_detection_enable(self.sync.blink,
-                                                       self.network_id,
-                                                       self.camera_id)
-        return api.request_motion_detection_disable(self.sync.blink,
-                                                    self.network_id,
-                                                    self.camera_id)
+            return api.request_motion_detection_enable(
+                self.sync.blink, self.network_id, self.camera_id
+            )
+        return api.request_motion_detection_disable(
+            self.sync.blink, self.network_id, self.camera_id
+        )
 
     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
-        resp = api.request_camera_sensors(self.sync.blink,
-                                          self.network_id,
-                                          self.camera_id)
+    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
+        )
         try:
-            self.temperature_calibrated = resp['temp']
-        except KeyError:
+            self.temperature_calibrated = resp["temp"]
+        except (TypeError, 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
+    def update_images(self, config, force_cache=False):
+        """Update images for camera."""
         new_thumbnail = None
-        if config['thumbnail']:
-            thumb_addr = config['thumbnail']
+        thumb_addr = None
+        if config.get("thumbnail", False):
+            thumb_addr = config["thumbnail"]
         else:
-            thumb_addr = self.get_thumb_from_homescreen()
+            _LOGGER.warning("Could not find thumbnail for camera %s", self.name)
 
         if thumb_addr is not None:
-            new_thumbnail = "{}{}.jpg".format(self.sync.urls.base_url,
-                                              thumb_addr)
+            new_thumbnail = f"{self.sync.urls.base_url}{thumb_addr}.jpg"
 
         try:
             self.motion_detected = self.sync.motion[self.name]
@@ -134,11 +171,12 @@ class BlinkCamera():
             self.motion_detected = False
 
         clip_addr = None
-        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)
+        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
@@ -151,15 +189,17 @@ class BlinkCamera():
             update_cached_video = True
 
         if new_thumbnail is not None and (update_cached_image or force_cache):
-            self._cached_image = api.http_get(self.sync.blink,
-                                              url=self.thumbnail,
-                                              stream=True,
-                                              json=False)
+            self._cached_image = self.get_media()
+
         if clip_addr is not None and (update_cached_video or force_cache):
-            self._cached_video = api.http_get(self.sync.blink,
-                                              url=self.clip,
-                                              stream=True,
-                                              json=False)
+            self._cached_video = self.get_media(media_type="video")
+
+    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):
         """
@@ -168,42 +208,64 @@ class BlinkCamera():
         :param path: Path to write file
         """
         _LOGGER.debug("Writing image from %s to %s", self.name, path)
-        response = self._cached_image
+        response = self.get_media()
         if response.status_code == 200:
-            with open(path, 'wb') as imgfile:
+            with open(path, "wb") as imgfile:
                 copyfileobj(response.raw, imgfile)
         else:
-            _LOGGER.error("Cannot write image to file, response %s",
-                          response.status_code,
-                          exc_info=True)
+            _LOGGER.error(
+                "Cannot write image to file, response %s", response.status_code
+            )
 
     def video_to_file(self, path):
-        """Write video to file.
+        """
+        Write video to file.
 
         :param path: Path to write file
         """
         _LOGGER.debug("Writing video from %s to %s", self.name, path)
-        response = self._cached_video
+        response = self.get_media(media_type="video")
         if response is None:
-            _LOGGER.error("No saved video exist for %s.",
-                          self.name,
-                          exc_info=True)
+            _LOGGER.error("No saved video exist for %s.", self.name)
             return
-        with open(path, 'wb') as vidfile:
+        with open(path, "wb") as vidfile:
             copyfileobj(response.raw, vidfile)
 
-    def get_thumb_from_homescreen(self):
-        """Retrieve thumbnail from homescreen."""
-        for device in self.sync.homescreen['devices']:
-            try:
-                device_type = device['device_type']
-                device_name = device['name']
-                device_thumb = device['thumbnail']
-                if device_type == 'camera' and device_name == self.name:
-                    return device_thumb
-            except KeyError:
-                pass
-        _LOGGER.error("Could not find thumbnail for camera %s",
-                      self.name,
-                      exc_info=True)
-        return None
+
+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

@@ -3,60 +3,68 @@
 import os
 
 MAJOR_VERSION = 0
-MINOR_VERSION = 13
-PATCH_VERSION = 0
+MINOR_VERSION = 17
+PATCH_VERSION = "0.dev1"
 
-__version__ = '{}.{}.{}'.format(MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION)
+__version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}.{PATCH_VERSION}"
 
-REQUIRED_PYTHON_VER = (3, 5, 3)
+REQUIRED_PYTHON_VER = (3, 6, 0)
 
-PROJECT_NAME = 'blinkpy'
-PROJECT_PACKAGE_NAME = 'blinkpy'
-PROJECT_LICENSE = 'MIT'
-PROJECT_AUTHOR = 'Kevin Fronczak'
-PROJECT_COPYRIGHT = ' 2017, {}'.format(PROJECT_AUTHOR)
-PROJECT_URL = 'https://github.com/fronzbot/blinkpy'
-PROJECT_EMAIL = 'kfronczak@gmail.com'
-PROJECT_DESCRIPTION = ('A Blink camera Python library '
-                       'running on Python 3.')
-PROJECT_LONG_DESCRIPTION = ('blinkpy is an open-source '
-                            'unofficial API for the Blink Camera '
-                            'system with the intention for easy '
-                            'integration into various home '
-                            'automation platforms.')
-if os.path.exists('README.rst'):
-    PROJECT_LONG_DESCRIPTION = open('README.rst').read()
+PROJECT_NAME = "blinkpy"
+PROJECT_PACKAGE_NAME = "blinkpy"
+PROJECT_LICENSE = "MIT"
+PROJECT_AUTHOR = "Kevin Fronczak"
+PROJECT_COPYRIGHT = f" 2017, {PROJECT_AUTHOR}"
+PROJECT_URL = "https://github.com/fronzbot/blinkpy"
+PROJECT_EMAIL = "kfronczak@gmail.com"
+PROJECT_DESCRIPTION = "A Blink camera Python library " "running on Python 3."
+PROJECT_LONG_DESCRIPTION = (
+    "blinkpy is an open-source "
+    "unofficial API for the Blink Camera "
+    "system with the intention for easy "
+    "integration into various home "
+    "automation platforms."
+)
+if os.path.exists("README.rst"):
+    PROJECT_LONG_DESCRIPTION = open("README.rst").read()
 PROJECT_CLASSIFIERS = [
-    'Intended Audience :: Developers',
-    'License :: OSI Approved :: MIT License',
-    'Operating System :: OS Independent',
-    'Programming Language :: Python :: 3.5',
-    'Programming Language :: Python :: 3.6',
-    'Programming Language :: Python :: 3.7',
-    'Topic :: Home Automation'
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.6",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Topic :: Home Automation",
 ]
 
-PROJECT_GITHUB_USERNAME = 'fronzbot'
-PROJECT_GITHUB_REPOSITORY = 'blinkpy'
+PROJECT_GITHUB_USERNAME = "fronzbot"
+PROJECT_GITHUB_REPOSITORY = "blinkpy"
 
-PYPI_URL = 'https://pypi.python.org/pypi/{}'.format(PROJECT_PACKAGE_NAME)
+PYPI_URL = f"https://pypi.python.org/pypi/{PROJECT_PACKAGE_NAME}"
 
-'''
+"""
 URLS
-'''
-BLINK_URL = 'immedia-semi.com'
-DEFAULT_URL = "{}.{}".format('prod', BLINK_URL)
-BASE_URL = "https://{}".format(DEFAULT_URL)
-LOGIN_URL = "{}/api/v2/login".format(BASE_URL)
-OLD_LOGIN_URL = "{}/login".format(BASE_URL)
-LOGIN_BACKUP_URL = "https://{}.{}/login".format('rest.piri', BLINK_URL)
+"""
+BLINK_URL = "immedia-semi.com"
+DEFAULT_URL = f"rest-prod.{BLINK_URL}"
+BASE_URL = f"https://{DEFAULT_URL}"
+LOGIN_ENDPOINT = f"{BASE_URL}/api/v4/account/login"
 
-'''
+"""
 Dictionaries
-'''
-ONLINE = {'online': True, 'offline': False}
+"""
+ONLINE = {"online": True, "offline": False}
 
-'''
+"""
 OTHER
-'''
-TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%S%Z'
+"""
+DEFAULT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36"
+DEVICE_ID = "Blinkpy"
+TIMESTAMP_FORMAT = "%Y-%m-%dT%H:%M:%S%z"
+DEFAULT_MOTION_INTERVAL = 1
+DEFAULT_REFRESH = 30
+MIN_THROTTLE_TIME = 2
+SIZE_NOTIFICATION_KEY = 152
+SIZE_UID = 16
+TIMEOUT = 10
+TIMEOUT_MEDIA = 90

blinkpy/helpers/errors.py

@@ -4,10 +4,12 @@ USERNAME = (0, "Username must be a string")
 PASSWORD = (1, "Password must be a string")
 AUTHENTICATE = (
     2,
-    "Cannot authenticate since either password or username has not been set"
+    "Cannot authenticate since either password or username has not been set",
 )
 AUTH_TOKEN = (
     3,
-    "Authentication header incorrect.  Are you sure you received your token?"
+    "Authentication header incorrect.  Are you sure you received your token?",
 )
 REQUEST = (4, "Cannot perform request (get/post type incorrect)")
+
+BLINK_ERRORS = [400, 404]

blinkpy/helpers/util.py

@@ -1,97 +1,91 @@
 """Useful functions for blinkpy."""
 
+import json
 import logging
 import time
+import secrets
+from calendar import timegm
 from functools import wraps
-from requests import Request, Session, exceptions
-from blinkpy.helpers.constants import BLINK_URL, TIMESTAMP_FORMAT
-import blinkpy.helpers.errors as ERROR
+from getpass import getpass
+import dateutil.parser
+from blinkpy.helpers import constants as const
 
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def json_load(file_name):
+    """Load json credentials from file."""
+    try:
+        with open(file_name, "r") as json_file:
+            data = json.load(json_file)
+        return data
+    except FileNotFoundError:
+        _LOGGER.error("Could not find %s", file_name)
+    except json.decoder.JSONDecodeError:
+        _LOGGER.error("File %s has improperly formatted json", file_name)
+    return None
+
+
+def json_save(data, file_name):
+    """Save data to file location."""
+    with open(file_name, "w") as json_file:
+        json.dump(data, json_file, indent=4)
+
+
+def gen_uid(size):
+    """Create a random sring."""
+    full_token = secrets.token_hex(size)
+    return full_token[0:size]
+
+
+def time_to_seconds(timestamp):
+    """Convert TIMESTAMP_FORMAT time to seconds."""
+    try:
+        dtime = dateutil.parser.isoparse(timestamp)
+    except ValueError:
+        _LOGGER.error("Incorrect timestamp format for conversion: %s.", timestamp)
+        return False
+    return timegm(dtime.timetuple())
+
+
 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))
+    return time.strftime(const.TIMESTAMP_FORMAT, time.gmtime(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)
+        _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()
-    return sess
+def prompt_login_data(data):
+    """Prompt user for username and password."""
+    if data["username"] is None:
+        data["username"] = input("Username:")
+    if data["password"] is None:
+        data["password"] = getpass("Password:")
+
+    return data
 
 
-def attempt_reauthorization(blink):
-    """Attempt to refresh auth token and links."""
-    _LOGGER.info("Auth token expired, attempting reauthorization.")
-    headers = blink.get_auth_token(is_retry=True)
-    return headers
+def validate_login_data(data):
+    """Check for missing keys."""
+    data["uid"] = data.get("uid", gen_uid(const.SIZE_UID))
+    data["notification_key"] = data.get(
+        "notification_key", gen_uid(const.SIZE_NOTIFICATION_KEY)
+    )
+    data["device_id"] = data.get("device_id", const.DEVICE_ID)
 
-
-def http_req(blink, url='http://example.com', data=None, headers=None,
-             reqtype='get', stream=False, json_resp=True, is_retry=False):
-    """
-    Perform server requests and check if reauthorization neccessary.
-
-    :param blink: Blink instance
-    :param url: URL to perform request
-    :param data: Data to send (default: None)
-    :param headers: Headers to send (default: None)
-    :param reqtype: Can be 'get' or 'post' (default: 'get')
-    :param stream: Stream response? True/FALSE
-    :param json_resp: Return JSON response? TRUE/False
-    :param is_retry: Is this a retry attempt? True/FALSE
-    """
-    if reqtype == 'post':
-        req = Request('POST', url, headers=headers, data=data)
-    elif reqtype == 'get':
-        req = Request('GET', url, headers=headers)
-    else:
-        _LOGGER.error("Invalid request type: %s", reqtype)
-        raise BlinkException(ERROR.REQUEST)
-
-    prepped = req.prepare()
-
-    try:
-        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)
-    except (exceptions.ConnectionError, exceptions.Timeout):
-        _LOGGER.info("Cannot connect to server with url %s.", url)
-        if not is_retry:
-            headers = attempt_reauthorization(blink)
-            return http_req(blink, url=url, data=data, headers=headers,
-                            reqtype=reqtype, stream=stream,
-                            json_resp=json_resp, is_retry=True)
-        _LOGGER.error("Endpoint %s failed. Possible issue with Blink servers.",
-                      url)
-        return None
-
-    if json_resp:
-        return response.json()
-
-    return response
+    return data
 
 
 class BlinkException(Exception):
@@ -108,21 +102,24 @@ class BlinkAuthenticationException(BlinkException):
     """Class to throw authentication exception."""
 
 
-class BlinkURLHandler():
+class BlinkURLHandler:
     """Class that handles Blink URLS."""
 
     def __init__(self, region_id):
         """Initialize the urls."""
-        self.base_url = "https://rest.{}.{}".format(region_id, BLINK_URL)
-        self.home_url = "{}/homescreen".format(self.base_url)
-        self.event_url = "{}/events/network".format(self.base_url)
-        self.network_url = "{}/network".format(self.base_url)
-        self.networks_url = "{}/networks".format(self.base_url)
-        self.video_url = "{}/api/v2/videos".format(self.base_url)
+        if region_id is None:
+            raise TypeError
+        self.subdomain = f"rest-{region_id}"
+        self.base_url = f"https://{self.subdomain}.{const.BLINK_URL}"
+        self.home_url = f"{self.base_url}/homescreen"
+        self.event_url = f"{self.base_url}/events/network"
+        self.network_url = f"{self.base_url}/network"
+        self.networks_url = f"{self.base_url}/networks"
+        self.video_url = f"{self.base_url}/api/v2/videos"
         _LOGGER.debug("Setting base url to %s.", self.base_url)
 
 
-class Throttle():
+class Throttle:
     """Class for throttling api calls."""
 
     def __init__(self, seconds=10):
@@ -132,6 +129,7 @@ class Throttle():
 
     def __call__(self, method):
         """Throttle caller method."""
+
         def throttle_method():
             """Call when method is throttled."""
             return None
@@ -139,7 +137,7 @@ class Throttle():
         @wraps(method)
         def wrapper(*args, **kwargs):
             """Wrap that checks for throttling."""
-            force = kwargs.pop('force', False)
+            force = kwargs.pop("force", False)
             now = int(time.time())
             last_call_delta = now - self.last_call
             if force or last_call_delta > self.throttle_time:

blinkpy/sync_module.py

@@ -4,13 +4,14 @@ 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
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class BlinkSyncModule():
+class BlinkSyncModule:
     """Class to initialize sync module."""
 
     def __init__(self, blink, network_name, network_id, camera_list):
@@ -20,34 +21,33 @@ class BlinkSyncModule():
         :param blink: Blink class instantiation
         """
         self.blink = blink
-        self._auth_header = blink.auth_header
         self.network_id = network_id
-        self.region = blink.region
-        self.region_id = blink.region_id
+        self.region_id = blink.auth.region_id
         self.name = network_name
         self.serial = None
-        self.status = None
+        self.status = "offline"
         self.sync_id = None
         self.host = None
         self.summary = None
         self.network_info = None
         self.events = []
         self.cameras = CaseInsensitiveDict({})
+        self.motion_interval = blink.motion_interval
         self.motion = {}
         self.last_record = {}
         self.camera_list = camera_list
+        self.available = False
 
     @property
     def attributes(self):
         """Return sync attributes."""
         attr = {
-            'name': self.name,
-            'id': self.sync_id,
-            'network_id': self.network_id,
-            'serial': self.serial,
-            'status': self.status,
-            'region': self.region,
-            'region_id': self.region_id,
+            "name": self.name,
+            "id": self.sync_id,
+            "network_id": self.network_id,
+            "serial": self.serial,
+            "status": self.status,
+            "region_id": self.region_id,
         }
         return attr
 
@@ -59,127 +59,238 @@ class BlinkSyncModule():
     @property
     def online(self):
         """Return boolean system online status."""
-        return ONLINE[self.status]
+        try:
+            return ONLINE[self.status]
+        except KeyError:
+            _LOGGER.error("Unknown sync module status %s", self.status)
+            self.available = False
+            return False
 
     @property
     def arm(self):
         """Return status of sync module: armed/disarmed."""
-        return self.network_info['network']['armed']
+        try:
+            return self.network_info["network"]["armed"]
+        except (KeyError, TypeError):
+            self.available = False
+            return None
 
     @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,
-                                          force=True)
-        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:
-            self.sync_id = self.summary['id']
-            self.serial = self.summary['serial']
-            self.status = self.summary['status']
+            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.network_info = api.request_network_status(self.blink,
-                                                       self.network_id)
+            _LOGGER.error("Could not extract some sync module info: %s", response)
 
+        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:
+                if "name" not in camera_config:
                     break
-                name = camera_config['name']
-                self.cameras[name] = BlinkCamera(self)
+                blink_camera_type = camera_config.get("type", "")
+                name = camera_config["name"]
                 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)
-            return False
+                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
+                )
+                self.cameras[name].update(camera_info, force_cache=True, force=True)
 
+        except KeyError:
+            _LOGGER.error("Could not create camera instances for %s", self.name)
+            return False
         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 (TypeError, KeyError):
+            pass
+        return None
+
     def get_events(self, **kwargs):
         """Retrieve events from server."""
-        force = kwargs.pop('force', False)
-        response = api.request_sync_events(self.blink,
-                                           self.network_id,
-                                           force=force)
+        force = kwargs.pop("force", False)
+        response = api.request_sync_events(self.blink, self.network_id, force=force)
         try:
-            return response['event']
+            return response["event"]
         except (TypeError, KeyError):
-            _LOGGER.error("Could not extract events: %s",
-                          response,
-                          exc_info=True)
+            _LOGGER.error("Could not extract events: %s", response)
             return False
 
-    def get_camera_info(self, camera_id):
+    def get_camera_info(self, camera_id, **kwargs):
         """Retrieve camera information."""
-        response = api.request_camera_info(self.blink,
-                                           self.network_id,
-                                           camera_id)
+        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]
+            return response["camera"][0]
         except (TypeError, KeyError):
-            _LOGGER.error("Could not extract camera info: %s",
-                          response,
-                          exc_info=True)
-            return []
+            _LOGGER.error("Could not extract camera info: %s", response)
+            return {}
+
+    def get_network_info(self):
+        """Retrieve network status."""
+        self.network_info = api.request_network_update(self.blink, self.network_id)
+        try:
+            if self.network_info["network"]["sync_module_error"]:
+                raise KeyError
+        except (TypeError, KeyError):
+            self.available = False
+            return False
+        return True
 
     def refresh(self, force_cache=False):
         """Get all blink cameras and pulls their most recent status."""
-        self.network_info = api.request_network_status(self.blink,
-                                                       self.network_id)
+        if not self.get_network_info():
+            return
         self.check_new_videos()
         for camera_name in self.cameras.keys():
             camera_id = self.cameras[camera_name].camera_id
-            camera_info = self.get_camera_info(camera_id)
-            self.cameras[camera_name].update(camera_info,
-                                             force_cache=force_cache)
+            camera_info = self.get_camera_info(
+                camera_id, owl_info=self.get_owl_info(camera_name)
+            )
+            self.cameras[camera_name].update(camera_info, force_cache=force_cache)
+        self.available = True
 
     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)
+        try:
+            interval = self.blink.last_refresh - self.motion_interval * 60
+        except TypeError:
+            # This is the first start, so refresh hasn't happened yet.
+            # No need to check for motion.
+            return False
+
+        resp = api.request_videos(self.blink, time=interval, page=1)
 
         for camera in self.cameras.keys():
             self.motion[camera] = False
 
         try:
-            info = resp['videos']
+            info = resp["media"]
         except (KeyError, TypeError):
             _LOGGER.warning("Could not check for motion. Response: %s", resp)
             return False
 
         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}
+                name = entry["device_name"]
+                clip = entry["media"]
+                timestamp = entry["created_at"]
+                if self.check_new_video_time(timestamp):
+                    self.motion[name] = True and self.arm
+                    self.last_record[name] = {"clip": clip, "time": timestamp}
             except KeyError:
                 _LOGGER.debug("No new videos since last refresh.")
 
         return True
+
+    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 (TypeError, 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

@@ -0,0 +1,15 @@
+codecov:
+  branch: dev
+coverage:
+  status:
+    project:
+      default:
+        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,104 @@
+=======================
+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 Retry Logic
+--------------------
+The built-in auth session via the ``create_session`` method allows for customizable retry intervals and conditions. These parameters are:
+
+- retries
+- backoff
+- retry_list
+
+``retries`` is the total number of retry attempts that each http request can do before timing out.  ``backoff`` is a parameter that allows for non-linear retry times such that the time between retries is backoff*(2^(retries) - 1).  ``retry_list`` is simply a list of status codes to force a retry.  By default ``retries=3``, ``backoff=1``, and ``retry_list=[429, 500, 502, 503, 504]``. To override them, you need to add you overrides to a dictionary and use that to create a new session with the ``opts`` variable in the ``create_session`` method. The following example can serve as a guide where only the number of retries and backoff factor are overridden:
+
+.. code:: python
+
+    from blinkpy.blinkpy import Blink
+    from blinkpy.auth import Auth
+
+    blink = Blink()
+    blink.auth = Auth()
+
+    opts = {"retries": 10, "backoff": 2}
+    blink.auth.session = blink.auth.create_session(opts=opts)
+
+
+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:
+

pylintrc

@@ -12,9 +12,12 @@ reports=no
 # unexpected-keyword-arg - doesn't allow for use of **kwargs, which is dumb
 
 disable=
+  format,
+  bad-continuation,
   locally-disabled,
   unused-argument,
   duplicate-code,
+  implicit-str-concat,
   too-many-arguments,
   too-many-branches,
   too-many-instance-attributes,

requirements.txt

@@ -1,3 +1,3 @@
-python-dateutil==2.7.5
-requests>=2.20.0
-testtools==2.3.0
+python-dateutil>=2.8.1
+requests>=2.24.0
+python-slugify>=4.0.1

requirements_test.txt

@@ -1,10 +1,14 @@
-flake8==3.5.0
-flake8-docstrings==1.3.0
-pylint==2.3.0
-pydocstyle==2.1.1
-pytest==3.7.1
-pytest-cov>=2.3.1
-pytest-sugar>=0.9.0
-pytest-timeout>=1.0.0
-restructuredtext-lint>=1.0.1
-pygments>=2.2.0
+black==19.10b0
+coverage==5.3
+flake8==3.8.4
+flake8-docstrings==1.5.0
+pre-commit==2.7.1
+pylint==2.6.0
+pydocstyle==5.1.1
+pytest==6.1.1
+pytest-cov==2.10.1
+pytest-sugar==0.9.4
+pytest-timeout==1.4.2
+restructuredtext-lint==1.3.1
+pygments==2.7.1
+testtools>=2.4.0

setup.cfg

@@ -0,0 +1,18 @@
+[flake8]
+exclude = .venv,.git,.tox,docs,venv,bin,lib,deps,build
+doctests = True
+# To work with Black
+max-line-length = 88
+
+# E501: line too long
+# W503: Line break occurred before a binary operator
+# E203: Whitespace before ':'
+# D202 No blank lines allowed after function docstring
+# W504 line break after binary operator
+
+ignore =
+    E501,
+    W503,
+    E203,
+    D202,
+    W504,

setup.py

@@ -1,48 +1,44 @@
+"""Setup file for blinkpy."""
 # -*- coding: utf-8 -*-
-from os.path import abspath, dirname, join
+from os.path import abspath, dirname
 from setuptools import setup, find_packages
-#  Fixes import error due to breaking change in pip 10
-#  https://stackoverflow.com/a/49867265
-#  pip > 10
-try:
-    from pip._internal.req import parse_requirements
-#  pip < 10
-except ImportError:
-    from pip.req import parse_requirements
 from blinkpy.helpers.constants import (
-    __version__, PROJECT_PACKAGE_NAME, PROJECT_LICENSE, PROJECT_URL,
-    PROJECT_EMAIL, PROJECT_DESCRIPTION, PROJECT_CLASSIFIERS, PROJECT_AUTHOR,
+    __version__,
+    PROJECT_PACKAGE_NAME,
+    PROJECT_LICENSE,
+    PROJECT_URL,
+    PROJECT_EMAIL,
+    PROJECT_DESCRIPTION,
+    PROJECT_CLASSIFIERS,
+    PROJECT_AUTHOR,
 )
 
-this_dir = abspath(dirname(__file__))
+PROJECT_VERSION = __version__
 
-install_reqs = parse_requirements('{}/requirements.txt'.format(this_dir), session=False)
-test_reqs = parse_requirements('{}/requirements_test.txt'.format(this_dir), session=False)
-REQUIRES = [str(ir.req) for ir in install_reqs]
-TEST_REQUIRES = [str(ir.req) for ir in test_reqs]
+THIS_DIR = abspath(dirname(__file__))
 
-PACKAGES = find_packages(exclude=['tests*', 'docs'])
+with open(f"{THIS_DIR}/requirements.txt") as req_file:
+    REQUIRES = [line.rstrip() for line in req_file]
 
-with open('{}/README.rst'.format(this_dir), encoding='utf-8') as readme_file:
-    long_description = readme_file.read()
+PACKAGES = find_packages(exclude=["tests*", "docs"])
 
-name = PROJECT_PACKAGE_NAME
-version = __version__
+with open("{}/README.rst".format(THIS_DIR), encoding="utf-8") as readme_file:
+    LONG_DESCRIPTION = readme_file.read()
 
 setup(
-    name = PROJECT_PACKAGE_NAME,
-    version = __version__,
-    description = PROJECT_DESCRIPTION,
-    long_description = long_description,
-    author = PROJECT_AUTHOR,
-    author_email = PROJECT_EMAIL,
-    license = PROJECT_LICENSE,
-    url = PROJECT_URL,
-    platforms = 'any',
-    py_modules = ['blinkpy'],
+    name=PROJECT_PACKAGE_NAME,
+    version=PROJECT_VERSION,
+    description=PROJECT_DESCRIPTION,
+    long_description=LONG_DESCRIPTION,
+    author=PROJECT_AUTHOR,
+    author_email=PROJECT_EMAIL,
+    license=PROJECT_LICENSE,
+    url=PROJECT_URL,
+    platforms="any",
+    py_modules=["blinkpy"],
     packages=PACKAGES,
-    include_package_data = True,
-    install_requires = REQUIRES,
-    test_suite = 'tests',
-    classifiers = PROJECT_CLASSIFIERS
+    include_package_data=True,
+    install_requires=REQUIRES,
+    test_suite="tests",
+    classifiers=PROJECT_CLASSIFIERS,
 )

tests/mock_responses.py

@@ -1,16 +1,5 @@
 """Simple mock responses definitions."""
 
-from blinkpy.helpers.util import BlinkURLHandler
-import blinkpy.helpers.constants as const
-
-LOGIN_RESPONSE = {
-    'region': {'mock': 'Test'},
-    'networks': {
-        '1234': {'name': 'test', 'onboarded': True}
-    },
-    'authtoken': {'authtoken': 'foobar123', 'message': 'auth'}
-}
-
 
 class MockResponse:
     """Class for mock request response."""
@@ -20,6 +9,7 @@ class MockResponse:
         self.json_data = json_data
         self.status_code = status_code
         self.raw_data = raw_data
+        self.reason = "foobar"
 
     def json(self):
         """Return json data from get_request."""
@@ -29,41 +19,3 @@ class MockResponse:
     def raw(self):
         """Return raw data from get request."""
         return self.raw_data
-
-
-def mocked_session_send(*args, **kwargs):
-    """Mock session."""
-    prepped = args[0]
-    url = prepped.url
-    header = prepped.headers
-    method = prepped.method
-    if method == 'GET':
-        expected_token = LOGIN_RESPONSE['authtoken']['authtoken']
-        if header['TOKEN_AUTH'] != expected_token:
-            response = {'message': 'Not Authorized', 'code': 400}
-            status = 400
-        elif url == 'use_bad_response':
-            response = {'foo': 'bar'}
-            status = 200
-        elif url == 'reauth':
-            response = {'message': 'REAUTH', 'code': 777}
-            status = 777
-        else:
-            response = {'test': 'foo'}
-            status = 200
-    elif method == 'POST':
-        if url in (const.LOGIN_URL, const.LOGIN_BACKUP_URL):
-            response = LOGIN_RESPONSE
-            status = 200
-        elif url == 'http://wrong.url/' or url is None:
-            response = {'message': 'Error', 'code': 404}
-            status = 404
-        else:
-            response = {'message': 'foo', 'code': 200}
-            status = 200
-
-    return MockResponse(response, status)
-
-
-class MockURLHandler(BlinkURLHandler):
-    """Mocks URL Handler in blinkpy module."""

tests/test_api.py

@@ -1,42 +0,0 @@
-"""Test various api functions."""
-
-import unittest
-from unittest import mock
-from blinkpy import api
-from blinkpy.blinkpy import Blink
-from blinkpy.helpers.util import create_session
-
-
-class TestBlinkAPI(unittest.TestCase):
-    """Test the blink api module."""
-
-    def setUp(self):
-        """Initialize the blink module."""
-        self.blink = Blink()
-        self.blink.session = create_session()
-        # pylint: disable=protected-access
-        self.blink._auth_header = {}
-
-    def tearDown(self):
-        """Tear down blink module."""
-        self.blink = None
-
-    @mock.patch('blinkpy.blinkpy.Blink.get_auth_token')
-    def test_http_req_connect_error(self, mock_auth):
-        """Test http_get error condition."""
-        mock_auth.return_value = {'foo': 'bar'}
-        firstlog = ("INFO:blinkpy.helpers.util:"
-                    "Cannot connect to server with url {}.").format(
-                        'http://notreal.fake')
-        nextlog = ("INFO:blinkpy.helpers.util:"
-                   "Auth token expired, attempting reauthorization.")
-        lastlog = ("ERROR:blinkpy.helpers.util:"
-                   "Endpoint {} failed. Possible issue with "
-                   "Blink servers.").format('http://notreal.fake')
-        expected = [firstlog, nextlog, firstlog, lastlog]
-        with self.assertLogs() as getlog:
-            api.http_get(self.blink, 'http://notreal.fake')
-        with self.assertLogs() as postlog:
-            api.http_post(self.blink, 'http://notreal.fake')
-        self.assertEqual(getlog.output, expected)
-        self.assertEqual(postlog.output, expected)

tests/test_auth.py

@@ -0,0 +1,299 @@
+"""Test login handler."""
+
+import unittest
+from unittest import mock
+from requests import exceptions
+from blinkpy.auth import (
+    Auth,
+    LoginError,
+    TokenRefreshFailed,
+    BlinkBadResponse,
+    UnauthorizedError,
+)
+import blinkpy.helpers.constants as const
+import tests.mock_responses as mresp
+
+USERNAME = "foobar"
+PASSWORD = "deadbeef"
+
+
+class TestAuth(unittest.TestCase):
+    """Test the Auth class in blinkpy."""
+
+    def setUp(self):
+        """Set up Login Handler."""
+        self.auth = Auth()
+
+    def tearDown(self):
+        """Clean up after test."""
+        self.auth = None
+
+    @mock.patch("blinkpy.helpers.util.gen_uid")
+    @mock.patch("blinkpy.auth.util.getpass")
+    def test_empty_init(self, getpwd, genuid):
+        """Test initialization with no params."""
+        auth = Auth()
+        self.assertDictEqual(auth.data, {})
+        getpwd.return_value = "bar"
+        genuid.return_value = 1234
+        with mock.patch("builtins.input", return_value="foo"):
+            auth.validate_login()
+        expected_data = {
+            "username": "foo",
+            "password": "bar",
+            "uid": 1234,
+            "notification_key": 1234,
+            "device_id": const.DEVICE_ID,
+        }
+        self.assertDictEqual(auth.data, expected_data)
+
+    @mock.patch("blinkpy.helpers.util.gen_uid")
+    @mock.patch("blinkpy.auth.util.getpass")
+    def test_barebones_init(self, getpwd, genuid):
+        """Test basebones initialization."""
+        login_data = {"username": "foo", "password": "bar"}
+        auth = Auth(login_data)
+        self.assertDictEqual(auth.data, login_data)
+        getpwd.return_value = "bar"
+        genuid.return_value = 1234
+        with mock.patch("builtins.input", return_value="foo"):
+            auth.validate_login()
+        expected_data = {
+            "username": "foo",
+            "password": "bar",
+            "uid": 1234,
+            "notification_key": 1234,
+            "device_id": const.DEVICE_ID,
+        }
+        self.assertDictEqual(auth.data, expected_data)
+
+    def test_full_init(self):
+        """Test full initialization."""
+        login_data = {
+            "username": "foo",
+            "password": "bar",
+            "token": "token",
+            "host": "host",
+            "region_id": "region_id",
+            "client_id": "client_id",
+            "account_id": "account_id",
+            "uid": 1234,
+            "notification_key": 4321,
+            "device_id": "device_id",
+        }
+        auth = Auth(login_data)
+        self.assertEqual(auth.token, "token")
+        self.assertEqual(auth.host, "host")
+        self.assertEqual(auth.region_id, "region_id")
+        self.assertEqual(auth.client_id, "client_id")
+        self.assertEqual(auth.account_id, "account_id")
+        auth.validate_login()
+        self.assertDictEqual(auth.login_attributes, login_data)
+
+    def test_bad_response_code(self):
+        """Check bad response code from server."""
+        self.auth.is_errored = False
+        fake_resp = mresp.MockResponse({"code": 404}, 404)
+        with self.assertRaises(exceptions.ConnectionError):
+            self.auth.validate_response(fake_resp, True)
+        self.assertTrue(self.auth.is_errored)
+
+        self.auth.is_errored = False
+        fake_resp = mresp.MockResponse({"code": 101}, 401)
+        with self.assertRaises(UnauthorizedError):
+            self.auth.validate_response(fake_resp, True)
+        self.assertTrue(self.auth.is_errored)
+
+    def test_good_response_code(self):
+        """Check good response code from server."""
+        fake_resp = mresp.MockResponse({"foo": "bar"}, 200)
+        self.auth.is_errored = True
+        self.assertEqual(self.auth.validate_response(fake_resp, True), {"foo": "bar"})
+        self.assertFalse(self.auth.is_errored)
+
+    def test_response_not_json(self):
+        """Check response when not json."""
+        fake_resp = "foobar"
+        self.auth.is_errored = True
+        self.assertEqual(self.auth.validate_response(fake_resp, False), "foobar")
+        self.assertFalse(self.auth.is_errored)
+
+    def test_response_bad_json(self):
+        """Check response when not json but expecting json."""
+        self.auth.is_errored = False
+        with self.assertRaises(BlinkBadResponse):
+            self.auth.validate_response(None, True)
+        self.assertTrue(self.auth.is_errored)
+
+    def test_header(self):
+        """Test header data."""
+        self.auth.token = "bar"
+        expected_header = {"TOKEN_AUTH": "bar", "user-agent": const.DEFAULT_USER_AGENT}
+        self.assertDictEqual(self.auth.header, expected_header)
+
+    def test_header_no_token(self):
+        """Test header without token."""
+        self.auth.token = None
+        self.assertEqual(self.auth.header, None)
+
+    @mock.patch("blinkpy.auth.Auth.validate_login", return_value=None)
+    @mock.patch("blinkpy.auth.api.request_login")
+    def test_login(self, mock_req, mock_validate):
+        """Test login handling."""
+        fake_resp = mresp.MockResponse({"foo": "bar"}, 200)
+        mock_req.return_value = fake_resp
+        self.assertEqual(self.auth.login(), {"foo": "bar"})
+
+    @mock.patch("blinkpy.auth.Auth.validate_login", return_value=None)
+    @mock.patch("blinkpy.auth.api.request_login")
+    def test_login_bad_response(self, mock_req, mock_validate):
+        """Test login handling when bad response."""
+        fake_resp = mresp.MockResponse({"foo": "bar"}, 404)
+        mock_req.return_value = fake_resp
+        self.auth.is_errored = False
+        with self.assertRaises(LoginError):
+            self.auth.login()
+        with self.assertRaises(TokenRefreshFailed):
+            self.auth.refresh_token()
+        self.assertTrue(self.auth.is_errored)
+
+    @mock.patch("blinkpy.auth.Auth.login")
+    def test_refresh_token(self, mock_login):
+        """Test refresh token method."""
+        mock_login.return_value = {
+            "region": {"tier": "test"},
+            "authtoken": {"authtoken": "foobar"},
+            "client": {"id": 1234},
+            "account": {"id": 5678},
+        }
+        self.assertTrue(self.auth.refresh_token())
+        self.assertEqual(self.auth.region_id, "test")
+        self.assertEqual(self.auth.token, "foobar")
+        self.assertEqual(self.auth.client_id, 1234)
+        self.assertEqual(self.auth.account_id, 5678)
+
+    @mock.patch("blinkpy.auth.Auth.login")
+    def test_refresh_token_failed(self, mock_login):
+        """Test refresh token failed."""
+        mock_login.return_value = {}
+        self.auth.is_errored = False
+        with self.assertRaises(TokenRefreshFailed):
+            self.auth.refresh_token()
+        self.assertTrue(self.auth.is_errored)
+
+    def test_check_key_required(self):
+        """Check key required method."""
+        self.auth.login_response = {}
+        self.assertFalse(self.auth.check_key_required())
+
+        self.auth.login_response = {"client": {"verification_required": False}}
+        self.assertFalse(self.auth.check_key_required())
+
+        self.auth.login_response = {"client": {"verification_required": True}}
+        self.assertTrue(self.auth.check_key_required())
+
+    @mock.patch("blinkpy.auth.api.request_verify")
+    def test_send_auth_key(self, mock_req):
+        """Check sending of auth key."""
+        mock_blink = MockBlink(None)
+        mock_req.return_value = mresp.MockResponse({"valid": True}, 200)
+        self.assertTrue(self.auth.send_auth_key(mock_blink, 1234))
+        self.assertTrue(mock_blink.available)
+
+        mock_req.return_value = mresp.MockResponse(None, 200)
+        self.assertFalse(self.auth.send_auth_key(mock_blink, 1234))
+
+        mock_req.return_value = mresp.MockResponse({}, 200)
+        self.assertFalse(self.auth.send_auth_key(mock_blink, 1234))
+
+        self.assertTrue(self.auth.send_auth_key(mock_blink, None))
+
+    @mock.patch("blinkpy.auth.api.request_verify")
+    def test_send_auth_key_fail(self, mock_req):
+        """Check handling of auth key failure."""
+        mock_blink = MockBlink(None)
+        mock_req.return_value = mresp.MockResponse(None, 200)
+        self.assertFalse(self.auth.send_auth_key(mock_blink, 1234))
+        mock_req.return_value = mresp.MockResponse({}, 200)
+        self.assertFalse(self.auth.send_auth_key(mock_blink, 1234))
+
+    @mock.patch("blinkpy.auth.Auth.validate_response")
+    @mock.patch("blinkpy.auth.Auth.refresh_token")
+    def test_query_retry(self, mock_refresh, mock_validate):
+        """Check handling of request retry."""
+        self.auth.session = MockSession()
+        mock_validate.side_effect = [UnauthorizedError, "foobar"]
+        mock_refresh.return_value = True
+        self.assertEqual(self.auth.query(url="http://example.com"), "foobar")
+
+    @mock.patch("blinkpy.auth.Auth.validate_response")
+    @mock.patch("blinkpy.auth.Auth.refresh_token")
+    def test_query_retry_failed(self, mock_refresh, mock_validate):
+        """Check handling of failed retry request."""
+        self.auth.session = MockSession()
+        mock_validate.side_effect = [UnauthorizedError, BlinkBadResponse]
+        mock_refresh.return_value = True
+        self.assertEqual(self.auth.query(url="http://example.com"), None)
+
+        mock_validate.side_effect = [UnauthorizedError, TokenRefreshFailed]
+        self.assertEqual(self.auth.query(url="http://example.com"), None)
+
+    def test_default_session(self):
+        """Test default session creation."""
+        sess = self.auth.create_session()
+        adapter = sess.adapters["https://"]
+        self.assertEqual(adapter.max_retries.total, 3)
+        self.assertEqual(adapter.max_retries.backoff_factor, 1)
+        self.assertEqual(
+            adapter.max_retries.status_forcelist, [429, 500, 502, 503, 504]
+        )
+
+    def test_custom_session_full(self):
+        """Test full custom session creation."""
+        opts = {"backoff": 2, "retries": 10, "retry_list": [404]}
+        sess = self.auth.create_session(opts=opts)
+        adapter = sess.adapters["https://"]
+        self.assertEqual(adapter.max_retries.total, 10)
+        self.assertEqual(adapter.max_retries.backoff_factor, 2)
+        self.assertEqual(adapter.max_retries.status_forcelist, [404])
+
+    def test_custom_session_partial(self):
+        """Test partial custom session creation."""
+        opts1 = {"backoff": 2}
+        opts2 = {"retries": 5}
+        opts3 = {"retry_list": [101, 202]}
+        sess1 = self.auth.create_session(opts=opts1)
+        sess2 = self.auth.create_session(opts=opts2)
+        sess3 = self.auth.create_session(opts=opts3)
+        adapt1 = sess1.adapters["https://"]
+        adapt2 = sess2.adapters["https://"]
+        adapt3 = sess3.adapters["https://"]
+
+        self.assertEqual(adapt1.max_retries.total, 3)
+        self.assertEqual(adapt1.max_retries.backoff_factor, 2)
+        self.assertEqual(adapt1.max_retries.status_forcelist, [429, 500, 502, 503, 504])
+
+        self.assertEqual(adapt2.max_retries.total, 5)
+        self.assertEqual(adapt2.max_retries.backoff_factor, 1)
+        self.assertEqual(adapt2.max_retries.status_forcelist, [429, 500, 502, 503, 504])
+
+        self.assertEqual(adapt3.max_retries.total, 3)
+        self.assertEqual(adapt3.max_retries.backoff_factor, 1)
+        self.assertEqual(adapt3.max_retries.status_forcelist, [101, 202])
+
+
+class MockSession:
+    """Object to mock a session."""
+
+    def send(self, *args, **kwargs):
+        """Mock send function."""
+        return None
+
+
+class MockBlink:
+    """Object to mock basic blink class."""
+
+    def __init__(self, login_response):
+        """Initialize mock blink class."""
+        self.available = False
+        self.login_response = login_response

tests/test_blink_functions.py

@@ -5,97 +5,51 @@ import logging
 
 from blinkpy import blinkpy
 from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.helpers.util import create_session, get_time
-import tests.mock_responses as mresp
-
-USERNAME = 'foobar'
-PASSWORD = 'deadbeef'
+from blinkpy.camera import BlinkCamera
+from blinkpy.helpers.util import get_time, BlinkURLHandler
 
 
 class MockSyncModule(BlinkSyncModule):
-    """Mock http requests from sync module."""
+    """Mock blink sync module object."""
 
-    def __init__(self, blink, header):
-        """Create mock sync module instance."""
-        super().__init__(blink, header)
-        self.blink = blink
-        self.header = header
-        self.return_value = None
-        self.return_value2 = None
-
-    def http_get(self, url, stream=False, json=True):
-        """Mock get request."""
-        if stream and self.return_value2 is not None:
-            return self.return_value2
-        return self.return_value
-
-    def http_post(self, url):
-        """Mock post request."""
-        return self.return_value
+    def get_network_info(self):
+        """Mock network info method."""
+        return True
+
+
+class MockCamera(BlinkCamera):
+    """Mock blink camera object."""
+
+    def update(self, config, force_cache=False, **kwargs):
+        """Mock camera update method."""
 
 
-@mock.patch('blinkpy.helpers.util.Session.send',
-            side_effect=mresp.mocked_session_send)
 class TestBlinkFunctions(unittest.TestCase):
     """Test Blink and BlinkCamera functions in blinkpy."""
 
     def setUp(self):
         """Set up Blink module."""
-        self.blink = blinkpy.Blink(username=USERNAME,
-                                   password=PASSWORD)
-        # pylint: disable=protected-access
-        self.blink._auth_header = {
-            'Host': 'test.url.tld',
-            'TOKEN_AUTH': 'foobar123'
-        }
-        self.blink.urls = blinkpy.BlinkURLHandler('test')
-        self.blink.session = create_session()
+        self.blink = blinkpy.Blink()
+        self.blink.urls = BlinkURLHandler("test")
 
     def tearDown(self):
         """Clean up after test."""
         self.blink = None
 
-    @mock.patch('blinkpy.blinkpy.api.request_login')
-    def test_backup_url(self, req, mock_sess):
-        """Test backup login method."""
-        json_resp = {
-            'authtoken': {'authtoken': 'foobar123'},
-            'networks': {'1234': {'name': 'foobar', 'onboarded': True}}
-        }
-        bad_req = mresp.MockResponse({}, 404)
-        new_req = mresp.MockResponse(json_resp, 200)
-        req.side_effect = [
-            bad_req,
-            bad_req,
-            new_req
-        ]
-        self.blink.login_request(['test1', 'test2', 'test3'])
-        # pylint: disable=protected-access
-        self.assertEqual(self.blink._login_url, 'test3')
-
-        req.side_effect = [
-            bad_req,
-            new_req,
-            bad_req
-        ]
-        self.blink.login_request(['test1', 'test2', 'test3'])
-        # pylint: disable=protected-access
-        self.assertEqual(self.blink._login_url, 'test2')
-
-    def test_merge_cameras(self, mock_sess):
+    def test_merge_cameras(self):
         """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
+        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'}
+        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):
+    @mock.patch("blinkpy.blinkpy.api.request_videos")
+    def test_download_video_exit(self, mock_req):
         """Test we exit method when provided bad response."""
         blink = blinkpy.Blink()
         # pylint: disable=protected-access
@@ -104,63 +58,73 @@ class TestBlinkFunctions(unittest.TestCase):
         mock_req.return_value = {}
         formatted_date = get_time(blink.last_refresh)
         expected_log = [
-            "INFO:blinkpy.blinkpy:Retrieving videos since {}".format(
-                formatted_date),
+            "INFO:blinkpy.blinkpy:Retrieving videos since {}".format(formatted_date),
             "DEBUG:blinkpy.blinkpy:Processing page 1",
-            "INFO:blinkpy.blinkpy:No videos found on page 1. Exiting."
+            "INFO:blinkpy.blinkpy:No videos found on page 1. Exiting.",
         ]
         with self.assertLogs() as dl_log:
-            blink.download_videos('/tmp')
+            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):
+    @mock.patch("blinkpy.blinkpy.api.request_videos")
+    def test_parse_downloaded_items(self, mock_req):
         """Test ability to parse downloaded items list."""
         blink = blinkpy.Blink()
         # pylint: disable=protected-access
         blinkpy._LOGGER.setLevel(logging.DEBUG)
         generic_entry = {
-            'created_at': '1970',
-            'camera_name': 'foo',
-            'deleted': True,
-            'address': '/bar.mp4'
+            "created_at": "1970",
+            "device_name": "foo",
+            "deleted": True,
+            "media": "/bar.mp4",
         }
         result = [generic_entry]
-        mock_req.return_value = {'videos': result}
+        mock_req.return_value = {"media": result}
         blink.last_refresh = 0
         formatted_date = get_time(blink.last_refresh)
         expected_log = [
-            "INFO:blinkpy.blinkpy:Retrieving videos since {}".format(
-                formatted_date),
+            "INFO:blinkpy.blinkpy:Retrieving videos since {}".format(formatted_date),
             "DEBUG:blinkpy.blinkpy:Processing page 1",
-            "DEBUG:blinkpy.blinkpy:foo: /bar.mp4 is marked as deleted."
+            "DEBUG:blinkpy.blinkpy:foo: /bar.mp4 is marked as deleted.",
         ]
         with self.assertLogs() as dl_log:
-            blink.download_videos('/tmp', stop=2)
+            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):
+    @mock.patch("blinkpy.blinkpy.api.request_videos")
+    def test_parse_camera_not_in_list(self, mock_req):
         """Test ability to parse downloaded items list."""
         blink = blinkpy.Blink()
         # pylint: disable=protected-access
         blinkpy._LOGGER.setLevel(logging.DEBUG)
         generic_entry = {
-            'created_at': '1970',
-            'camera_name': 'foo',
-            'deleted': True,
-            'address': '/bar.mp4'
+            "created_at": "1970",
+            "device_name": "foo",
+            "deleted": True,
+            "media": "/bar.mp4",
         }
         result = [generic_entry]
-        mock_req.return_value = {'videos': result}
+        mock_req.return_value = {"media": result}
         blink.last_refresh = 0
         formatted_date = get_time(blink.last_refresh)
         expected_log = [
-            "INFO:blinkpy.blinkpy:Retrieving videos since {}".format(
-                formatted_date),
+            "INFO:blinkpy.blinkpy:Retrieving videos since {}".format(formatted_date),
             "DEBUG:blinkpy.blinkpy:Processing page 1",
-            "DEBUG:blinkpy.blinkpy:Skipping videos for foo."
+            "DEBUG:blinkpy.blinkpy:Skipping videos for foo.",
         ]
         with self.assertLogs() as dl_log:
-            blink.download_videos('/tmp', camera='bar', stop=2)
+            blink.download_videos("/tmp", camera="bar", stop=2)
         self.assertEqual(dl_log.output, expected_log)
+
+    @mock.patch("blinkpy.blinkpy.api.request_network_update")
+    @mock.patch("blinkpy.auth.Auth.query")
+    def test_refresh(self, mock_req, mock_update):
+        """Test ability to refresh system."""
+        mock_update.return_value = {"network": {"sync_module_error": False}}
+        mock_req.return_value = None
+        self.blink.last_refresh = 0
+        self.blink.available = True
+        self.blink.sync["foo"] = MockSyncModule(self.blink, "foo", 1, [])
+        self.blink.cameras = {"bar": MockCamera(self.blink.sync)}
+        self.blink.sync["foo"].cameras = self.blink.cameras
+        self.assertTrue(self.blink.refresh())

tests/test_blinkpy.py

@@ -8,178 +8,290 @@ any communication related errors at startup.
 
 import unittest
 from unittest import mock
-from blinkpy import api
-from blinkpy.blinkpy import Blink
-from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.helpers.util import (
-    http_req, create_session, BlinkAuthenticationException,
-    BlinkException, BlinkURLHandler)
+from blinkpy.blinkpy import Blink, BlinkSetupError
+from blinkpy.sync_module import BlinkOwl
 from blinkpy.helpers.constants import __version__
-import tests.mock_responses as mresp
-
-USERNAME = 'foobar'
-PASSWORD = 'deadbeef'
 
 
-@mock.patch('blinkpy.helpers.util.Session.send',
-            side_effect=mresp.mocked_session_send)
 class TestBlinkSetup(unittest.TestCase):
     """Test the Blink class in blinkpy."""
 
     def setUp(self):
-        """Set up Blink module."""
-        self.blink_no_cred = Blink()
-        self.blink = Blink(username=USERNAME,
-                           password=PASSWORD)
-        self.blink.sync['test'] = BlinkSyncModule(self.blink,
-                                                  'test',
-                                                  '1234',
-                                                  [])
-        self.blink.urls = BlinkURLHandler('test')
-        self.blink.session = create_session()
+        """Initialize blink test object."""
+        self.blink = Blink()
+        self.blink.available = True
 
     def tearDown(self):
-        """Clean up after test."""
+        """Cleanup blink test object."""
         self.blink = None
-        self.blink_no_cred = None
 
-    def test_initialization(self, mock_sess):
+    def test_initialization(self):
         """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
-        self.assertEqual(self.blink._password, PASSWORD)
+        blink = Blink()
+        self.assertEqual(blink.version, __version__)
 
-    def test_no_credentials(self, mock_sess):
-        """Check that we throw an exception when no username/password."""
-        with self.assertRaises(BlinkAuthenticationException):
-            self.blink_no_cred.get_auth_token()
-        # pylint: disable=protected-access
-        self.blink_no_cred._username = USERNAME
-        with self.assertRaises(BlinkAuthenticationException):
-            self.blink_no_cred.get_auth_token()
+    def test_network_id_failure(self):
+        """Check that with bad network data a setup error is raised."""
+        self.blink.networks = None
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_network_ids()
 
-    def test_no_auth_header(self, mock_sess):
-        """Check that we throw an exception when no auth header given."""
-        # pylint: disable=unused-variable
-        (region_id, region), = mresp.LOGIN_RESPONSE['region'].items()
-        self.blink.urls = BlinkURLHandler(region_id)
-        with self.assertRaises(BlinkException):
-            self.blink.get_ids()
-
-    @mock.patch('blinkpy.blinkpy.getpass.getpass')
-    def test_manual_login(self, getpwd, mock_sess):
-        """Check that we can manually use the login() function."""
-        getpwd.return_value = PASSWORD
-        with mock.patch('builtins.input', return_value=USERNAME):
-            self.assertTrue(self.blink_no_cred.login())
-        # pylint: disable=protected-access
-        self.assertEqual(self.blink_no_cred._username, USERNAME)
-        # pylint: disable=protected-access
-        self.assertEqual(self.blink_no_cred._password, PASSWORD)
-
-    def test_bad_request(self, mock_sess):
-        """Check that we raise an Exception with a bad request."""
-        self.blink.session = create_session()
-        explog = ("ERROR:blinkpy.helpers.util:"
-                  "Cannot obtain new token for server auth.")
-        with self.assertRaises(BlinkException):
-            http_req(self.blink, reqtype='bad')
-
-        with self.assertLogs() as logrecord:
-            http_req(self.blink, reqtype='post', is_retry=True)
-        self.assertEqual(logrecord.output, [explog])
-
-    def test_authentication(self, mock_sess):
-        """Check that we can authenticate Blink up properly."""
-        authtoken = self.blink.get_auth_token()['TOKEN_AUTH']
-        expected = mresp.LOGIN_RESPONSE['authtoken']['authtoken']
-        self.assertEqual(authtoken, expected)
-
-    def test_reauthorization_attempt(self, mock_sess):
-        """Check that we can reauthorize after first unsuccessful attempt."""
-        original_header = self.blink.get_auth_token()
-        # pylint: disable=protected-access
-        bad_header = {'Host': self.blink._host, 'TOKEN_AUTH': 'BADTOKEN'}
-        # pylint: disable=protected-access
-        self.blink._auth_header = bad_header
-        self.assertEqual(self.blink.auth_header, bad_header)
-        api.request_homescreen(self.blink)
-        self.assertEqual(self.blink.auth_header, original_header)
-
-    @mock.patch('blinkpy.api.request_networks')
-    def test_multiple_networks(self, mock_net, mock_sess):
+    def test_multiple_networks(self):
         """Check that we handle multiple networks appropriately."""
-        mock_net.return_value = {
-            'networks': [{'id': 1234, 'account_id': 1111},
-                         {'id': 5678, 'account_id': 2222}]
+        self.blink.networks = {
+            "0000": {"onboarded": False, "name": "foo"},
+            "5678": {"onboarded": True, "name": "bar"},
+            "1234": {"onboarded": False, "name": "test"},
         }
-        self.blink.networks = {'0000': {'onboarded': False, 'name': 'foo'},
-                               '5678': {'onboarded': True, 'name': 'bar'},
-                               '1234': {'onboarded': False, 'name': 'test'}}
-        self.blink.get_ids()
-        self.assertTrue('5678' in self.blink.network_ids)
-        self.assertEqual(self.blink.account_id, 2222)
+        self.blink.setup_network_ids()
+        self.assertTrue("5678" in self.blink.network_ids)
 
-    @mock.patch('blinkpy.api.request_networks')
-    def test_multiple_onboarded_networks(self, mock_net, mock_sess):
+    def test_multiple_onboarded_networks(self):
         """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.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)
+        self.blink.setup_network_ids()
+        self.assertTrue("0000" not in self.blink.network_ids)
+        self.assertTrue("5678" in self.blink.network_ids)
+        self.assertTrue("1234" in self.blink.network_ids)
 
-    @mock.patch('blinkpy.blinkpy.time.time')
-    def test_throttle(self, mock_time, mock_sess):
+    @mock.patch("blinkpy.blinkpy.time.time")
+    def test_throttle(self, mock_time):
         """Check throttling functionality."""
         now = self.blink.refresh_rate + 1
         mock_time.return_value = now
         self.assertEqual(self.blink.last_refresh, None)
         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()
+        with mock.patch(
+            "blinkpy.sync_module.BlinkSyncModule.refresh", return_value=True
+        ), mock.patch("blinkpy.blinkpy.Blink.get_homescreen", return_value=True):
+            self.blink.refresh(force=True)
 
         self.assertEqual(self.blink.last_refresh, now)
         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):
+    def test_sync_case_insensitive_dict(self):
         """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')
+        self.blink.sync["test"] = 1234
+        self.assertEqual(self.blink.sync["test"], 1234)
+        self.assertEqual(self.blink.sync["TEST"], 1234)
+        self.assertEqual(self.blink.sync["tEsT"], 1234)
 
-    @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())
-
-    @mock.patch('blinkpy.api.request_homescreen')
-    def test_get_cameras(self, mock_home, mock_sess):
+    @mock.patch("blinkpy.api.request_camera_usage")
+    @mock.patch("blinkpy.api.request_homescreen")
+    def test_setup_cameras(self, mock_home, mock_req):
         """Check retrieval of camera information."""
-        mock_home.return_value = {
-            'cameras': [{'name': 'foo', 'network_id': 1234, 'id': 5678},
-                        {'name': 'bar', 'network_id': 1234, 'id': 5679},
-                        {'name': 'test', 'network_id': 4321, 'id': 0000}]
-        }
-        result = self.blink.get_cameras()
-        self.assertEqual(result, {'1234': [{'name': 'foo', 'id': 5678},
-                                           {'name': 'bar', 'id': 5679}],
-                                  '4321': [{'name': 'test', 'id': 0000}]})
-
-    @mock.patch('blinkpy.api.request_homescreen')
-    def test_get_cameras_failure(self, mock_home, mock_sess):
-        """Check that on failure we initialize empty info and move on."""
         mock_home.return_value = {}
-        result = self.blink.get_cameras()
-        self.assertEqual(result, {})
+        mock_req.return_value = {
+            "networks": [
+                {
+                    "network_id": 1234,
+                    "cameras": [
+                        {"id": 5678, "name": "foo"},
+                        {"id": 5679, "name": "bar"},
+                    ],
+                },
+                {"network_id": 4321, "cameras": [{"id": 0000, "name": "test"}]},
+            ]
+        }
+        result = self.blink.setup_camera_list()
+        self.assertEqual(
+            result,
+            {
+                "1234": [{"name": "foo", "id": 5678}, {"name": "bar", "id": 5679}],
+                "4321": [{"name": "test", "id": 0000}],
+            },
+        )
+
+    @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 = {}
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_camera_list()
+        mock_home.return_value = None
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_camera_list()
+
+    def test_setup_urls(self):
+        """Check setup of URLS."""
+        self.blink.auth.region_id = "test"
+        self.blink.setup_urls()
+        self.assertEqual(self.blink.urls.subdomain, "rest-test")
+
+    def test_setup_urls_failure(self):
+        """Check that on failure we raise a setup error."""
+        self.blink.auth.region_id = None
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_urls()
+
+    @mock.patch("blinkpy.api.request_networks")
+    def test_setup_networks(self, mock_networks):
+        """Check setup of networks."""
+        mock_networks.return_value = {"summary": "foobar"}
+        self.blink.setup_networks()
+        self.assertEqual(self.blink.networks, "foobar")
+
+    @mock.patch("blinkpy.api.request_networks")
+    def test_setup_networks_failure(self, mock_networks):
+        """Check that on failure we raise a setup error."""
+        mock_networks.return_value = {}
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_networks()
+        mock_networks.return_value = None
+        with self.assertRaises(BlinkSetupError):
+            self.blink.setup_networks()
+
+    @mock.patch("blinkpy.blinkpy.Auth.send_auth_key")
+    def test_setup_prompt_2fa(self, mock_key):
+        """Test setup with 2fa prompt."""
+        self.blink.auth.data["username"] = "foobar"
+        self.blink.key_required = True
+        mock_key.return_value = True
+        with mock.patch("builtins.input", return_value="foo"):
+            self.blink.setup_prompt_2fa()
+        self.assertFalse(self.blink.key_required)
+        mock_key.return_value = False
+        with mock.patch("builtins.input", return_value="foo"):
+            self.blink.setup_prompt_2fa()
+        self.assertTrue(self.blink.key_required)
+
+    @mock.patch("blinkpy.blinkpy.Blink.setup_camera_list")
+    @mock.patch("blinkpy.api.request_networks")
+    @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"}}
+        }
+        mock_camera.return_value = []
+        self.assertTrue(self.blink.setup_post_verify())
+        self.assertTrue(self.blink.available)
+        self.assertFalse(self.blink.key_required)
+
+    @mock.patch("blinkpy.api.request_networks")
+    def test_setup_post_verify_failure(self, mock_networks):
+        """Test failed setup after verification."""
+        self.blink.available = False
+        mock_networks.return_value = {}
+        self.assertFalse(self.blink.setup_post_verify())
+        self.assertFalse(self.blink.available)
+
+    def test_merge_cameras(self):
+        """Test merging of cameras."""
+        self.blink.sync = {
+            "foo": MockSync({"test": 123, "foo": "bar"}),
+            "bar": MockSync({"fizz": "buzz", "bar": "foo"}),
+        }
+        combined = self.blink.merge_cameras()
+        self.assertEqual(combined["test"], 123)
+        self.assertEqual(combined["foo"], "bar")
+        self.assertEqual(combined["fizz"], "buzz")
+        self.assertEqual(combined["bar"], "foo")
+
+    @mock.patch("blinkpy.blinkpy.BlinkOwl.start")
+    def test_initialize_blink_minis(self, mock_start):
+        """Test blink mini initialization."""
+        mock_start.return_value = True
+        self.blink.homescreen = {
+            "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")
+
+    def test_blink_mini_cameras_returned(self):
+        """Test that blink mini cameras are found if attached to sync module."""
+        self.blink.network_ids = ["1234"]
+        self.blink.homescreen = {
+            "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 = []
+        self.blink.get_homescreen()
+        result = self.blink.setup_owls()
+        self.assertEqual(self.blink.network_ids, [])
+        self.assertEqual(result, [])
+
+    @mock.patch("blinkpy.api.request_camera_usage")
+    def test_blink_mini_attached_to_sync(self, mock_usage):
+        """Test that blink mini cameras are properly attached to sync module."""
+        self.blink.network_ids = ["1234"]
+        self.blink.homescreen = {
+            "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."""
+
+    def __init__(self, cameras):
+        """Initialize fake class."""
+        self.cameras = cameras

tests/test_cameras.py

@@ -8,187 +8,178 @@ Blink system is set up.
 
 import unittest
 from unittest import mock
-from blinkpy import blinkpy
-from blinkpy.helpers.util import create_session, BlinkURLHandler
+from blinkpy.blinkpy import Blink
+from blinkpy.helpers.util import BlinkURLHandler
 from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.camera import BlinkCamera
-import tests.mock_responses as mresp
+from blinkpy.camera import BlinkCamera, BlinkCameraMini
 
-USERNAME = 'foobar'
-PASSWORD = 'deadbeef'
 
 CAMERA_CFG = {
-    'camera': [
+    "camera": [
         {
-            'battery_voltage': 90,
-            'motion_alert': True,
-            'wifi_strength': -30,
-            'temperature': 68
+            "battery_voltage": 90,
+            "motion_alert": True,
+            "wifi_strength": -30,
+            "temperature": 68,
         }
     ]
 }
 
 
-@mock.patch('blinkpy.helpers.util.Session.send',
-            side_effect=mresp.mocked_session_send)
+@mock.patch("blinkpy.auth.Auth.query")
 class TestBlinkCameraSetup(unittest.TestCase):
     """Test the Blink class in blinkpy."""
 
     def setUp(self):
         """Set up Blink module."""
-        self.blink = blinkpy.Blink(username=USERNAME,
-                                   password=PASSWORD)
-        header = {
-            'Host': 'abc.zxc',
-            'TOKEN_AUTH': mresp.LOGIN_RESPONSE['authtoken']['authtoken']
-        }
-        # pylint: disable=protected-access
-        self.blink._auth_header = header
-        self.blink.session = create_session()
-        self.blink.urls = BlinkURLHandler('test')
-        self.blink.sync['test'] = BlinkSyncModule(self.blink, 'test', 1234, [])
-        self.camera = BlinkCamera(self.blink.sync['test'])
-        self.camera.name = 'foobar'
-        self.blink.sync['test'].cameras['foobar'] = self.camera
+        self.blink = Blink()
+        self.blink.urls = BlinkURLHandler("test")
+        self.blink.sync["test"] = BlinkSyncModule(self.blink, "test", 1234, [])
+        self.camera = BlinkCamera(self.blink.sync["test"])
+        self.camera.name = "foobar"
+        self.blink.sync["test"].cameras["foobar"] = self.camera
 
     def tearDown(self):
         """Clean up after test."""
         self.blink = None
+        self.camera = None
 
-    def test_camera_update(self, mock_sess):
+    def test_camera_update(self, mock_resp):
         """Test that we can properly update camera properties."""
         config = {
-            'name': 'new',
-            'id': 1234,
-            'network_id': 5678,
-            'serial': '12345678',
-            'enabled': False,
-            'battery_voltage': 90,
-            'battery_state': 'ok',
-            'temperature': 68,
-            'wifi_strength': 4,
-            'thumbnail': '/thumb',
+            "name": "new",
+            "id": 1234,
+            "network_id": 5678,
+            "serial": "12345678",
+            "enabled": False,
+            "battery_voltage": 90,
+            "battery_state": "ok",
+            "temperature": 68,
+            "wifi_strength": 4,
+            "thumbnail": "/thumb",
         }
-        self.camera.last_record = ['1']
+        self.camera.last_record = ["1"]
         self.camera.sync.last_record = {
-            'new': {
-                'clip': '/test.mp4',
-                'time': '1970-01-01T00:00:00'
-            }
+            "new": {"clip": "/test.mp4", "time": "1970-01-01T00:00:00"}
         }
-        mock_sess.side_effect = [
-            mresp.MockResponse({'temp': 71}, 200),
-            'test',
-            'foobar'
+        mock_resp.side_effect = [
+            {"temp": 71},
+            "test",
+            "foobar",
         ]
         self.camera.update(config)
-        self.assertEqual(self.camera.name, 'new')
-        self.assertEqual(self.camera.camera_id, '1234')
-        self.assertEqual(self.camera.network_id, '5678')
-        self.assertEqual(self.camera.serial, '12345678')
+        self.assertEqual(self.camera.name, "new")
+        self.assertEqual(self.camera.camera_id, "1234")
+        self.assertEqual(self.camera.network_id, "5678")
+        self.assertEqual(self.camera.serial, "12345678")
         self.assertEqual(self.camera.motion_enabled, False)
-        self.assertEqual(self.camera.battery, 50)
+        self.assertEqual(self.camera.battery, "ok")
         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')
-        self.assertEqual(self.camera.clip,
-                         'https://rest.test.immedia-semi.com/test.mp4')
-        self.assertEqual(self.camera.image_from_cache, 'test')
-        self.assertEqual(self.camera.video_from_cache, 'foobar')
+        self.assertEqual(
+            self.camera.thumbnail, "https://rest-test.immedia-semi.com/thumb.jpg"
+        )
+        self.assertEqual(
+            self.camera.clip, "https://rest-test.immedia-semi.com/test.mp4"
+        )
+        self.assertEqual(self.camera.image_from_cache, "test")
+        self.assertEqual(self.camera.video_from_cache, "foobar")
 
-    def test_thumbnail_not_in_info(self, mock_sess):
-        """Test that we grab thumbanil if not in camera_info."""
-        mock_sess.side_effect = [
-            mresp.MockResponse({'temp': 71}, 200),
-            'foobar',
-            'barfoo'
-        ]
-        self.camera.last_record = ['1']
-        self.camera.sync.last_record = {
-            'new': {
-                'clip': '/test.mp4',
-                'time': '1970-01-01T00:00:00'
-            }
-        }
-        config = {
-            'name': 'new',
-            'id': 1234,
-            'network_id': 5678,
-            'serial': '12345678',
-            'enabled': False,
-            'battery_voltage': 90,
-            'battery_state': 'ok',
-            'temperature': 68,
-            'wifi_strength': 4,
-            'thumbnail': '',
-        }
-        self.camera.sync.homescreen = {
-            'devices': [
-                {'foo': 'bar'},
-                {'device_type': 'foobar'},
-                {'device_type': 'camera',
-                 'name': 'new',
-                 'thumbnail': '/new/thumb'}
-            ]
-        }
-        self.camera.update(config)
-        self.assertEqual(self.camera.thumbnail,
-                         'https://rest.test.immedia-semi.com/new/thumb.jpg')
-
-    def test_no_thumbnails(self, mock_sess):
+    def test_no_thumbnails(self, mock_resp):
         """Tests that thumbnail is 'None' if none found."""
-        mock_sess.return_value = 'foobar'
-        self.camera.last_record = ['1']
+        mock_resp.return_value = "foobar"
+        self.camera.last_record = ["1"]
         config = {
-            'name': 'new',
-            'id': 1234,
-            'network_id': 5678,
-            'serial': '12345678',
-            'enabled': False,
-            'battery_voltage': 90,
-            'battery_state': 'ok',
-            'temperature': 68,
-            'wifi_strength': 4,
-            'thumbnail': '',
-        }
-        self.camera.sync.homescreen = {
-            'devices': []
+            "name": "new",
+            "id": 1234,
+            "network_id": 5678,
+            "serial": "12345678",
+            "enabled": False,
+            "battery_voltage": 90,
+            "battery_state": "ok",
+            "temperature": 68,
+            "wifi_strength": 4,
+            "thumbnail": "",
         }
+        self.camera.sync.homescreen = {"devices": []}
         self.assertEqual(self.camera.temperature_calibrated, None)
         with self.assertLogs() as logrecord:
             self.camera.update(config, force=True)
         self.assertEqual(self.camera.thumbnail, None)
-        self.assertEqual(self.camera.last_record, ['1'])
+        self.assertEqual(self.camera.last_record, ["1"])
         self.assertEqual(self.camera.temperature_calibrated, 68)
         self.assertEqual(
             logrecord.output,
-            [("WARNING:blinkpy.camera:Could not retrieve calibrated "
-              "temperature."),
-             ("ERROR:blinkpy.camera:Could not find thumbnail for camera new"
-              "\nNoneType: None")]
+            [
+                (
+                    "WARNING:blinkpy.camera:Could not retrieve calibrated "
+                    "temperature."
+                ),
+                ("WARNING:blinkpy.camera:Could not find thumbnail for camera new"),
+            ],
         )
 
-    def test_no_video_clips(self, mock_sess):
+    def test_no_video_clips(self, mock_resp):
         """Tests that we still proceed with camera setup with no videos."""
-        mock_sess.return_value = 'foobar'
+        mock_resp.return_value = "foobar"
         config = {
-            'name': 'new',
-            'id': 1234,
-            'network_id': 5678,
-            'serial': '12345678',
-            'enabled': False,
-            'battery_voltage': 90,
-            'battery_state': 'ok',
-            'temperature': 68,
-            'wifi_strength': 4,
-            'thumbnail': '/foobar',
-        }
-        self.camera.sync.homescreen = {
-            'devices': []
+            "name": "new",
+            "id": 1234,
+            "network_id": 5678,
+            "serial": "12345678",
+            "enabled": False,
+            "battery_voltage": 90,
+            "battery_state": "ok",
+            "temperature": 68,
+            "wifi_strength": 4,
+            "thumbnail": "/foobar",
         }
+        self.camera.sync.homescreen = {"devices": []}
         self.camera.update(config, force_cache=True)
         self.assertEqual(self.camera.clip, None)
         self.assertEqual(self.camera.video_from_cache, None)
+
+    def test_camera_arm_status(self, mock_resp):
+        """Test arming and disarming camera."""
+        self.camera.motion_enabled = None
+        self.assertFalse(self.camera.arm)
+        self.camera.motion_enabled = False
+        self.assertFalse(self.camera.arm)
+        self.camera.motion_enabled = True
+        self.assertTrue(self.camera.arm)
+
+    @mock.patch("blinkpy.camera.api.request_motion_detection_enable")
+    @mock.patch("blinkpy.camera.api.request_motion_detection_disable")
+    def test_motion_detection_enable_disable(self, mock_dis, mock_en, mock_rep):
+        """Test setting motion detection enable properly."""
+        mock_dis.return_value = "disable"
+        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)
+
+    def test_camera_stream(self, mock_resp):
+        """Test that camera stream returns correct url."""
+        mock_resp.return_value = {"server": "rtsps://foo.bar"}
+        mini_camera = BlinkCameraMini(self.blink.sync["test"])
+        self.assertEqual(self.camera.get_liveview(), "rtsps://foo.bar")
+        self.assertEqual(mini_camera.get_liveview(), "rtsps://foo.bar")

tests/test_sync_module.py

@@ -2,45 +2,39 @@
 import unittest
 from unittest import mock
 
-from blinkpy import blinkpy
-from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.camera import BlinkCamera
-
-USERNAME = 'foobar'
-PASSWORD = 'deadbeef'
+from blinkpy.blinkpy import Blink
+from blinkpy.helpers.util import BlinkURLHandler
+from blinkpy.sync_module import BlinkSyncModule, BlinkOwl
+from blinkpy.camera import BlinkCamera, BlinkCameraMini
 
 
-@mock.patch('blinkpy.api.http_req')
+@mock.patch("blinkpy.auth.Auth.query")
 class TestBlinkSyncModule(unittest.TestCase):
     """Test BlinkSyncModule functions in blinkpy."""
 
     def setUp(self):
         """Set up Blink module."""
-        self.blink = blinkpy.Blink(username=USERNAME,
-                                   password=PASSWORD)
-        # pylint: disable=protected-access
-        self.blink._auth_header = {
-            'Host': 'test.url.tld',
-            'TOKEN_AUTH': 'foobar123'
-        }
-        self.blink.urls = blinkpy.BlinkURLHandler('test')
-        self.blink.sync['test'] = BlinkSyncModule(self.blink,
-                                                  'test',
-                                                  '1234',
-                                                  [])
+        self.blink = Blink(motion_interval=0)
+        self.blink.last_refresh = 0
+        self.blink.urls = BlinkURLHandler("test")
+        self.blink.sync["test"] = BlinkSyncModule(self.blink, "test", "1234", [])
         self.camera = BlinkCamera(self.blink.sync)
         self.mock_start = [
-            {'syncmodule': {
-                'id': 1234,
-                'network_id': 5678,
-                'serial': '12345678',
-                'status': 'foobar'}},
-            {'event': True},
+            {
+                "syncmodule": {
+                    "id": 1234,
+                    "network_id": 5678,
+                    "serial": "12345678",
+                    "status": "foobar",
+                }
+            },
+            {"event": True},
             {},
             {},
             None,
-            {'devicestatus': {}},
+            {"devicestatus": {}},
         ]
+        self.blink.sync["test"].network_info = {"network": {"armed": True}}
 
     def tearDown(self):
         """Clean up after test."""
@@ -48,99 +42,253 @@ class TestBlinkSyncModule(unittest.TestCase):
         self.camera = None
         self.mock_start = None
 
+    def test_bad_status(self, mock_resp):
+        """Check that we mark module unavaiable on bad status."""
+        self.blink.sync["test"].status = None
+        self.blink.sync["test"].available = True
+        self.assertFalse(self.blink.sync["test"].online)
+        self.assertFalse(self.blink.sync["test"].available)
+
+    def test_bad_arm(self, mock_resp):
+        """Check that we mark module unavaiable if bad arm status."""
+        self.blink.sync["test"].network_info = None
+        self.blink.sync["test"].available = True
+        self.assertEqual(self.blink.sync["test"].arm, None)
+        self.assertFalse(self.blink.sync["test"].available)
+        self.blink.sync["test"].network_info = {}
+        self.blink.sync["test"].available = True
+        self.assertEqual(self.blink.sync["test"].arm, None)
+        self.assertFalse(self.blink.sync["test"].available)
+
     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)
+        mock_resp.return_value = {"event": True}
+        self.assertEqual(self.blink.sync["test"].get_events(), True)
+
+    def test_get_events_fail(self, mock_resp):
+        """Test handling of failed get events function."""
+        mock_resp.return_value = None
+        self.assertFalse(self.blink.sync["test"].get_events())
+        mock_resp.return_value = {}
+        self.assertFalse(self.blink.sync["test"].get_events())
 
     def test_get_camera_info(self, mock_resp):
         """Test get camera info function."""
-        mock_resp.return_value = {'camera': ['foobar']}
-        self.assertEqual(self.blink.sync['test'].get_camera_info('1234'),
-                         'foobar')
+        mock_resp.return_value = {"camera": ["foobar"]}
+        self.assertEqual(self.blink.sync["test"].get_camera_info("1234"), "foobar")
+
+    def test_get_camera_info_fail(self, mock_resp):
+        """Test handling of failed get camera info function."""
+        mock_resp.return_value = None
+        self.assertEqual(self.blink.sync["test"].get_camera_info("1"), {})
+        mock_resp.return_value = {}
+        self.assertEqual(self.blink.sync["test"].get_camera_info("1"), {})
+        mock_resp.return_value = {"camera": None}
+        self.assertEqual(self.blink.sync["test"].get_camera_info("1"), {})
+
+    def test_get_network_info(self, mock_resp):
+        """Test network retrieval."""
+        mock_resp.return_value = {"network": {"sync_module_error": False}}
+        self.assertTrue(self.blink.sync["test"].get_network_info())
+        mock_resp.return_value = {"network": {"sync_module_error": True}}
+        self.assertFalse(self.blink.sync["test"].get_network_info())
+
+    def test_get_network_info_failure(self, mock_resp):
+        """Test failed network retrieval."""
+        mock_resp.return_value = {}
+        self.blink.sync["test"].available = True
+        self.assertFalse(self.blink.sync["test"].get_network_info())
+        self.assertFalse(self.blink.sync["test"].available)
+        self.blink.sync["test"].available = True
+        mock_resp.return_value = None
+        self.assertFalse(self.blink.sync["test"].get_network_info())
+        self.assertFalse(self.blink.sync["test"].available)
+
+    def test_check_new_videos_startup(self, mock_resp):
+        """Test that check_new_videos does not block startup."""
+        sync_module = self.blink.sync["test"]
+        self.blink.last_refresh = None
+        self.assertFalse(sync_module.check_new_videos())
 
     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'
-            }]
+            "media": [
+                {
+                    "device_name": "foo",
+                    "media": "/foo/bar.mp4",
+                    "created_at": "1990-01-01T00:00:00+00:00",
+                }
+            ]
         }
-        sync_module = self.blink.sync['test']
-        sync_module.cameras = {'foo': None}
+
+        sync_module = self.blink.sync["test"]
+        sync_module.cameras = {"foo": None}
+        sync_module.blink.last_refresh = 0
         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.assertEqual(
+            sync_module.last_record["foo"],
+            {"clip": "/foo/bar.mp4", "time": "1990-01-01T00:00:00+00:00"},
+        )
+        self.assertEqual(sync_module.motion, {"foo": True})
+        mock_resp.return_value = {"media": []}
         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'})
+        self.assertEqual(sync_module.motion, {"foo": False})
+        self.assertEqual(
+            sync_module.last_record["foo"],
+            {"clip": "/foo/bar.mp4", "time": "1990-01-01T00:00:00+00:00"},
+        )
+
+    def test_check_new_videos_old_date(self, mock_resp):
+        """Test videos return response with old date."""
+        mock_resp.return_value = {
+            "media": [
+                {
+                    "device_name": "foo",
+                    "media": "/foo/bar.mp4",
+                    "created_at": "1970-01-01T00:00:00+00:00",
+                }
+            ]
+        }
+
+        sync_module = self.blink.sync["test"]
+        sync_module.cameras = {"foo": None}
+        sync_module.blink.last_refresh = 1000
+        self.assertTrue(sync_module.check_new_videos())
+        self.assertEqual(sync_module.motion, {"foo": False})
+
+    def test_check_no_motion_if_not_armed(self, mock_resp):
+        """Test that motion detection is not set if module unarmed."""
+        mock_resp.return_value = {
+            "media": [
+                {
+                    "device_name": "foo",
+                    "media": "/foo/bar.mp4",
+                    "created_at": "1990-01-01T00:00:00+00:00",
+                }
+            ]
+        }
+        sync_module = self.blink.sync["test"]
+        sync_module.cameras = {"foo": None}
+        sync_module.blink.last_refresh = 1000
+        self.assertTrue(sync_module.check_new_videos())
+        self.assertEqual(sync_module.motion, {"foo": True})
+        sync_module.network_info = {"network": {"armed": False}}
+        self.assertTrue(sync_module.check_new_videos())
+        self.assertEqual(sync_module.motion, {"foo": False})
+
+    def test_check_multiple_videos(self, mock_resp):
+        """Test motion found even with multiple videos."""
+        mock_resp.return_value = {
+            "media": [
+                {
+                    "device_name": "foo",
+                    "media": "/foo/bar.mp4",
+                    "created_at": "1970-01-01T00:00:00+00:00",
+                },
+                {
+                    "device_name": "foo",
+                    "media": "/bar/foo.mp4",
+                    "created_at": "1990-01-01T00:00:00+00:00",
+                },
+                {
+                    "device_name": "foo",
+                    "media": "/foobar.mp4",
+                    "created_at": "1970-01-01T00:00:01+00:00",
+                },
+            ]
+        }
+        sync_module = self.blink.sync["test"]
+        sync_module.cameras = {"foo": None}
+        sync_module.blink.last_refresh = 1000
+        self.assertTrue(sync_module.check_new_videos())
+        self.assertEqual(sync_module.motion, {"foo": True})
+        expected_result = {
+            "foo": {"clip": "/bar/foo.mp4", "time": "1990-01-01T00:00:00+00:00"}
+        }
+        self.assertEqual(sync_module.last_record, expected_result)
 
     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}
+        mock_resp.side_effect = [None, "just a string", {}]
+        sync_module = self.blink.sync["test"]
+        sync_module.cameras = {"foo": None}
 
-        sync_module.motion['foo'] = True
+        sync_module.motion["foo"] = True
         self.assertFalse(sync_module.check_new_videos())
-        self.assertFalse(sync_module.motion['foo'])
+        self.assertFalse(sync_module.motion["foo"])
 
-        sync_module.motion['foo'] = True
+        sync_module.motion["foo"] = True
         self.assertFalse(sync_module.check_new_videos())
-        self.assertFalse(sync_module.motion['foo'])
+        self.assertFalse(sync_module.motion["foo"])
 
-        sync_module.motion['foo'] = True
+        sync_module.motion["foo"] = True
         self.assertFalse(sync_module.check_new_videos())
-        self.assertFalse(sync_module.motion['foo'])
+        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')
+        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())
+        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
+        self.mock_start[0]["syncmodule"] = None
         mock_resp.side_effect = self.mock_start
-        self.assertFalse(self.blink.sync['test'].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}
+        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)
+        self.blink.sync["test"].start()
+        self.assertEqual(self.blink.sync["test"].network_id, 8675309)
 
     def test_unexpected_camera_info(self, mock_resp):
         """Test unexpected camera info response."""
-        self.blink.sync['test'].cameras['foo'] = None
+        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})
+        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.blink.sync["test"].cameras["foo"] = None
         self.mock_start[5] = {}
-        self.blink.sync['test'].start()
-        self.assertEqual(self.blink.sync['test'].cameras, {'foo': None})
+        self.blink.sync["test"].start()
+        self.assertEqual(self.blink.sync["test"].cameras, {"foo": None})
+
+    def test_sync_attributes(self, mock_resp):
+        """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)

tests/test_util.py

@@ -3,7 +3,7 @@
 import unittest
 from unittest import mock
 import time
-from blinkpy.helpers.util import Throttle
+from blinkpy.helpers.util import json_load, Throttle, time_to_seconds
 
 
 class TestUtil(unittest.TestCase):
@@ -43,17 +43,18 @@ class TestUtil(unittest.TestCase):
         self.assertEqual(2, len(calls))
 
         # Fake time as 4 seconds from now
-        with mock.patch('time.time', return_value=now_plus_four):
+        with mock.patch("time.time", return_value=now_plus_four):
             test_throttle()
         self.assertEqual(2, len(calls))
 
         # Fake time as 6 seconds from now
-        with mock.patch('time.time', return_value=now_plus_six):
+        with mock.patch("time.time", return_value=now_plus_six):
             test_throttle()
         self.assertEqual(3, len(calls))
 
     def test_throttle_per_instance(self):
         """Test that throttle is done once per instance of class."""
+
         class Tester:
             """A tester class for throttling."""
 
@@ -66,8 +67,28 @@ class TestUtil(unittest.TestCase):
         self.assertEqual(throttled(), True)
         self.assertEqual(throttled(), None)
 
+    def test_throttle_multiple_objects(self):
+        """Test that function is throttled even if called by multiple objects."""
+
+        @Throttle(seconds=5)
+        def test_throttle_method():
+            return True
+
+        class Tester:
+            """A tester class for throttling."""
+
+            def test(self):
+                """Test function for throttle."""
+                return test_throttle_method()
+
+        tester1 = Tester()
+        tester2 = Tester()
+        self.assertEqual(tester1.test(), True)
+        self.assertEqual(tester2.test(), None)
+
     def test_throttle_on_two_methods(self):
         """Test that throttle works for multiple methods."""
+
         class Tester:
             """A tester class for throttling."""
 
@@ -91,10 +112,23 @@ class TestUtil(unittest.TestCase):
         self.assertEqual(tester.test1(), None)
         self.assertEqual(tester.test2(), None)
 
-        with mock.patch('time.time', return_value=now_plus_4):
+        with mock.patch("time.time", return_value=now_plus_4):
             self.assertEqual(tester.test1(), True)
             self.assertEqual(tester.test2(), None)
 
-        with mock.patch('time.time', return_value=now_plus_6):
+        with mock.patch("time.time", return_value=now_plus_6):
             self.assertEqual(tester.test1(), None)
             self.assertEqual(tester.test2(), True)
+
+    def test_time_to_seconds(self):
+        """Test time to seconds conversion."""
+        correct_time = "1970-01-01T00:00:05+00:00"
+        wrong_time = "1/1/1970 00:00:03"
+        self.assertEqual(time_to_seconds(correct_time), 5)
+        self.assertFalse(time_to_seconds(wrong_time))
+
+    def test_json_load_bad_data(self):
+        """Check that bad file is handled."""
+        self.assertEqual(json_load("fake.file"), None)
+        with mock.patch("builtins.open", mock.mock_open(read_data="")):
+            self.assertEqual(json_load("fake.file"), None)

tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = build, py35, py36, py37, py38, lint
+envlist = build, py36, py37, py38, lint
 skip_missing_interpreters = True
 skipsdist = True
 
@@ -8,23 +8,40 @@ setenv =
     LANG=en_US.UTF-8
     PYTHONPATH = {toxinidir}
 commands = 
-    py.test --timeout=30 --duration=10 --cov=blinkpy --cov-report term-missing {posargs}
+    pytest --timeout=9 --durations=10 --cov=blinkpy --cov-report term-missing {posargs}
 deps = 
     -r{toxinidir}/requirements.txt
     -r{toxinidir}/requirements_test.txt
-    
-[testenv:lint]
+
+[testenv:cov]
+setenv = 
+    LANG=en_US.UTF-8
+    PYTHONPATH = {toxinidir}
+commands = 
+    pytest --timeout=9 --durations=10 --cov=blinkpy --cov-report=xml {posargs}
+deps =
+    -r{toxinidir}/requirements.txt
+    -r{toxinidir}/requirements_test.txt
+
+[testenv:pylint]
 deps = 
     -r{toxinidir}/requirements.txt
     -r{toxinidir}/requirements_test.txt
 basepython = python3
 ignore_errors = True
 commands = 
-    pylint --rcfile={toxinidir}/pylintrc blinkpy tests
-    flake8 blinkpy tests
-    pydocstyle blinkpy tests
-    rst-lint README.rst
-    rst-lint CHANGES.rst
+    pylint --rcfile={toxinidir}/pylintrc blinkpy tests app
+
+[testenv:lint]
+deps = 
+    -r{toxinidir}/requirements.txt
+    -r{toxinidir}/requirements_test.txt
+basepython = python3
+commands = 
+    flake8 blinkpy tests app
+    pydocstyle blinkpy tests app
+    black --check --diff blinkpy tests app
+    rst-lint README.rst CHANGES.rst CONTRIBUTING.rst
 
 [testenv:build]
 recreate = True