Merge pull request #354 from fronzbot/dev-rc-bump

Dev rc bump

CHANGES.rst

@@ -4,6 +4,43 @@ Changelog
 
 A list of changes between each release
 
+0.16.1 (2020-07-29)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Unpin requeirements, 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:**

app/app.py

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

blinkpy/api.py

@@ -3,7 +3,7 @@
 import logging
 from json import dumps
 from blinkpy.helpers.util import get_time, Throttle
-from blinkpy.helpers.constants import DEFAULT_URL
+from blinkpy.helpers.constants import DEFAULT_URL, TIMEOUT
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -27,7 +27,7 @@ def request_login(
             "password": login_data["password"],
             "notification_key": login_data["notification_key"],
             "unique_id": login_data["uid"],
-            "app_version": "6.0.7 (520300) #afb0be72a",
+            "app_version": "6.0.12",
             "device_identifier": login_data["device_id"],
             "client_name": "Computer",
             "client_type": "android",
@@ -107,7 +107,7 @@ def request_system_arm(blink, network):
     :param blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = f"{blink.urls.base_url}/network/{network}/arm"
+    url = f"{blink.urls.base_url}/api/v1/accounts/{blink.account_id}/networks/{network}/state/arm"
     return http_post(blink, url)
 
 
@@ -119,7 +119,7 @@ def request_system_disarm(blink, network):
     :param blink: Blink instance.
     :param network: Sync module network id.
     """
-    url = f"{blink.urls.base_url}/network/{network}/disarm"
+    url = f"{blink.urls.base_url}/api/v1/accounts/{blink.account_id}/networks/{network}/state/disarm"
     return http_post(blink, url)
 
 
@@ -284,7 +284,7 @@ def request_motion_detection_disable(blink, network, camera_id):
     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.
 
@@ -304,7 +304,7 @@ def http_get(blink, url, stream=False, json=True, is_retry=False):
     )
 
 
-def http_post(blink, url, is_retry=False):
+def http_post(blink, url, is_retry=False, timeout=TIMEOUT):
     """
     Perform an http post request.
 

blinkpy/auth.py

@@ -2,9 +2,11 @@
 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, LOGIN_ENDPOINT
+from blinkpy.helpers.constants import BLINK_URL, LOGIN_ENDPOINT, TIMEOUT
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -51,12 +53,27 @@ class Auth:
         """Return authorization header."""
         if self.token is None:
             return None
-        return {"Host": self.host, "TOKEN_AUTH": self.token}
+        return {"TOKEN_AUTH": self.token}
 
-    def create_session(self):
+    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()
-        sess.get = partial(sess.get, timeout=10)
+        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):
@@ -140,6 +157,7 @@ class Auth:
         stream=False,
         json_resp=True,
         is_retry=False,
+        timeout=TIMEOUT,
     ):
         """
         Perform server requests.
@@ -154,21 +172,25 @@ class Auth:
         """
         req = self.prepare_request(url, headers, data, reqtype)
         try:
-            response = self.session.send(req, stream=stream)
+            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. %s: %s",
-                url,
-                response.status_code,
-                response.reason,
+                "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,
-                response.status_code,
-                response.reason,
+                code,
+                reason,
             )
         except UnauthorizedError:
             try:
@@ -182,6 +204,7 @@ class Auth:
                         stream=stream,
                         json_resp=json_resp,
                         is_retry=True,
+                        timeout=timeout,
                     )
                 _LOGGER.error("Unable to access %s after token refresh.", url)
             except TokenRefreshFailed:

blinkpy/blinkpy.py

@@ -29,6 +29,7 @@ from blinkpy.helpers.constants import (
     DEFAULT_MOTION_INTERVAL,
     DEFAULT_REFRESH,
     MIN_THROTTLE_TIME,
+    TIMEOUT_MEDIA,
 )
 from blinkpy.helpers.constants import __version__
 from blinkpy.auth import Auth, TokenRefreshFailed, LoginError
@@ -40,7 +41,10 @@ class Blink:
     """Class to initialize communication."""
 
     def __init__(
-        self, refresh_rate=DEFAULT_REFRESH, motion_interval=DEFAULT_MOTION_INTERVAL,
+        self,
+        refresh_rate=DEFAULT_REFRESH,
+        motion_interval=DEFAULT_MOTION_INTERVAL,
+        no_owls=False,
     ):
         """
         Initialize Blink system.
@@ -51,6 +55,7 @@ class Blink:
                                 Defaults to last refresh time.
                                 Useful for preventing motion_detected property
                                 from de-asserting too quickly.
+        :param no_owls: Disable searching for owl entries (blink mini cameras only known entity).  Prevents an uneccessary API call if you don't have these in your network.
         """
         self.auth = Auth()
         self.account_id = None
@@ -68,6 +73,7 @@ class Blink:
         self.available = False
         self.key_required = False
         self.homescreen = {}
+        self.no_owls = no_owls
 
     @util.Throttle(seconds=MIN_THROTTLE_TIME)
     def refresh(self, force=False):
@@ -95,6 +101,7 @@ class Blink:
             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
@@ -128,7 +135,6 @@ class Blink:
             sync_cameras = cameras.get(network_id, {})
             self.setup_sync_module(name, network_id, sync_cameras)
 
-        self.setup_owls()
         self.cameras = self.merge_cameras()
 
         self.available = True
@@ -140,15 +146,27 @@ class Blink:
         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."""
-        response = api.request_homescreen(self)
-        self.homescreen = response
         network_list = []
+        camera_list = []
         try:
-            for owl in response["owls"]:
+            for owl in self.homescreen["owls"]:
                 name = owl["name"]
-                network_id = owl["network_id"]
+                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)
@@ -158,6 +176,7 @@ class Blink:
             pass
 
         self.network_ids.extend(network_list)
+        return camera_list
 
     def setup_camera_list(self):
         """Create camera list for onboarded networks."""
@@ -172,6 +191,10 @@ class Blink:
                     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)
@@ -308,7 +331,13 @@ class Blink:
                     _LOGGER.info("%s already exists, skipping...", filename)
                     continue
 
-                response = api.http_get(self, url=clip_address, stream=True, json=False)
+                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)
 

blinkpy/camera.py

@@ -3,6 +3,7 @@
 from shutil import copyfileobj
 import logging
 from blinkpy import api
+from blinkpy.helpers.constants import TIMEOUT_MEDIA
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -29,6 +30,7 @@ class BlinkCamera:
         self.last_record = None
         self._cached_image = None
         self._cached_video = None
+        self.camera_type = ""
 
     @property
     def attributes(self):
@@ -61,7 +63,10 @@ class BlinkCamera:
     @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):
@@ -146,9 +151,7 @@ class BlinkCamera:
         if config.get("thumbnail", False):
             thumb_addr = config["thumbnail"]
         else:
-            _LOGGER.warning(
-                "Could not find thumbnail for camera %s", self.name, exc_info=True
-            )
+            _LOGGER.warning("Could not find thumbnail for camera %s", self.name)
 
         if thumb_addr is not None:
             new_thumbnail = f"{self.sync.urls.base_url}{thumb_addr}.jpg"
@@ -178,11 +181,19 @@ class BlinkCamera:
 
         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.sync.blink,
+                url=self.thumbnail,
+                stream=True,
+                json=False,
+                timeout=TIMEOUT_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.sync.blink,
+                url=self.clip,
+                stream=True,
+                json=False,
+                timeout=TIMEOUT_MEDIA,
             )
 
     def get_liveview(self):
@@ -226,6 +237,11 @@ class BlinkCamera:
 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."""
@@ -234,7 +250,9 @@ class BlinkCameraMini(BlinkCamera):
     @arm.setter
     def arm(self, value):
         """Set camera arm status."""
-        self.sync.arm = value
+        _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."""

blinkpy/helpers/constants.py

@@ -4,7 +4,7 @@ import os
 
 MAJOR_VERSION = 0
 MINOR_VERSION = 16
-PATCH_VERSION = "0-rc3"
+PATCH_VERSION = "2-rc0"
 
 __version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}.{PATCH_VERSION}"
 
@@ -65,3 +65,5 @@ DEFAULT_REFRESH = 30
 MIN_THROTTLE_TIME = 2
 SIZE_NOTIFICATION_KEY = 152
 SIZE_UID = 16
+TIMEOUT = 10
+TIMEOUT_MEDIA = 90

blinkpy/sync_module.py

@@ -77,8 +77,10 @@ class BlinkSyncModule:
 
     @arm.setter
     def arm(self, value):
-        """Arm or disarm system."""
-        _LOGGER.warning("Arm/Disarm API for %s not currently implemented.", self.name)
+        """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."""
@@ -91,9 +93,7 @@ class BlinkSyncModule:
             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
-            )
+            _LOGGER.error("Could not extract some sync module info: %s", response)
 
         is_ok = self.get_network_info()
         self.check_new_videos()
@@ -122,16 +122,33 @@ class BlinkSyncModule:
             for camera_config in self.camera_list:
                 if "name" not in camera_config:
                     break
+                blink_camera_type = camera_config.get("type", "")
                 name = camera_config["name"]
-                self.cameras[name] = camera_type(self)
                 self.motion[name] = False
-                camera_info = self.get_camera_info(camera_config["id"])
+                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 KeyError:
+            pass
+        return None
+
     def get_events(self, **kwargs):
         """Retrieve events from server."""
         force = kwargs.pop("force", False)
@@ -139,17 +156,20 @@ class BlinkSyncModule:
         try:
             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."""
+        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]
         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."""
@@ -169,7 +189,9 @@ class BlinkSyncModule:
         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)
+            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
 
@@ -241,7 +263,7 @@ class BlinkOwl(BlinkSyncModule):
         """Update sync-less cameras."""
         return super().update_cameras(camera_type=BlinkCameraMini)
 
-    def get_camera_info(self, camera_id):
+    def get_camera_info(self, camera_id, **kwargs):
         """Retrieve camera information."""
         try:
             for owl in self.blink.homescreen["owls"]:
@@ -272,23 +294,3 @@ class BlinkOwl(BlinkSyncModule):
     @network_info.setter
     def network_info(self, value):
         """Set network_info property."""
-
-    @property
-    def arm(self):
-        """Return arm status."""
-        try:
-            return self.network_info["network"]["armed"]
-        except (KeyError, TypeError):
-            self.available = False
-            return None
-
-    @arm.setter
-    def arm(self, value):
-        """Arm or disarm camera."""
-        if value:
-            return api.request_motion_detection_enable(
-                self.blink, self.network_id, self.sync_id
-            )
-        return api.request_motion_detection_disable(
-            self.blink, self.network_id, self.sync_id
-        )

codecov.yml

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

docs/advanced.rst

@@ -30,6 +30,29 @@ By default, the ``blink.auth.Auth`` class creates its own websession via its ``c
     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.

requirements.txt

@@ -1,4 +1,4 @@
-python-dateutil~=2.8.1
-requests~=2.23.0
-python-slugify~=4.0.0
-testtools==2.4.0
+python-dateutil>=2.8.1
+requests>=2.24.0
+python-slugify>=4.0.1
+testtools>=2.4.0

requirements_test.txt

@@ -1,13 +1,13 @@
 black==19.10b0
-coverage==5.1
+coverage==5.2.1
 flake8==3.8.3
 flake8-docstrings==1.5.0
-pre-commit==2.5.0
+pre-commit==2.6.0
 pylint==2.5.3
 pydocstyle==5.0.2
-pytest==5.4.3
-pytest-cov==2.9.0
-pytest-sugar==0.9.3
-pytest-timeout==1.3.4
+pytest==6.0.1
+pytest-cov==2.10.0
+pytest-sugar==0.9.4
+pytest-timeout==1.4.2
 restructuredtext-lint==1.3.1
 pygments==2.6.1

setup.py

@@ -3,23 +3,26 @@
 from os.path import abspath, dirname
 from setuptools import setup, find_packages
 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,
 )
 
 PROJECT_VERSION = __version__
 
 THIS_DIR = abspath(dirname(__file__))
 
-REQUIRES = [
-    "python-dateutil~=2.8.1",
-    "requests~=2.23.0",
-    "python-slugify~=4.0.0",
-]
+with open(f"{THIS_DIR}/requirements.txt") as req_file:
+    REQUIRES = [line.rstrip() for line in req_file]
 
-PACKAGES = find_packages(exclude=['tests*', 'docs'])
+PACKAGES = find_packages(exclude=["tests*", "docs"])
 
-with open('{}/README.rst'.format(THIS_DIR), encoding='utf-8') as readme_file:
+with open("{}/README.rst".format(THIS_DIR), encoding="utf-8") as readme_file:
     LONG_DESCRIPTION = readme_file.read()
 
 setup(
@@ -31,11 +34,11 @@ setup(
     author_email=PROJECT_EMAIL,
     license=PROJECT_LICENSE,
     url=PROJECT_URL,
-    platforms='any',
-    py_modules=['blinkpy'],
+    platforms="any",
+    py_modules=["blinkpy"],
     packages=PACKAGES,
     include_package_data=True,
     install_requires=REQUIRES,
-    test_suite='tests',
-    classifiers=PROJECT_CLASSIFIERS
+    test_suite="tests",
+    classifiers=PROJECT_CLASSIFIERS,
 )

tests/test_auth.py

@@ -128,8 +128,7 @@ class TestAuth(unittest.TestCase):
     def test_header(self):
         """Test header data."""
         self.auth.token = "bar"
-        self.auth.host = "foo"
-        expected_header = {"Host": "foo", "TOKEN_AUTH": "bar"}
+        expected_header = {"TOKEN_AUTH": "bar"}
         self.assertDictEqual(self.auth.header, expected_header)
 
     def test_header_no_token(self):
@@ -231,7 +230,7 @@ class TestAuth(unittest.TestCase):
     @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.seession = MockSession()
+        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)
@@ -239,6 +238,49 @@ class TestAuth(unittest.TestCase):
         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."""

tests/test_blinkpy.py

@@ -83,8 +83,10 @@ class TestBlinkSetup(unittest.TestCase):
         self.assertEqual(self.blink.sync["tEsT"], 1234)
 
     @mock.patch("blinkpy.api.request_camera_usage")
-    def test_setup_cameras(self, mock_req):
+    @mock.patch("blinkpy.api.request_homescreen")
+    def test_setup_cameras(self, mock_home, mock_req):
         """Check retrieval of camera information."""
+        mock_home.return_value = {}
         mock_req.return_value = {
             "networks": [
                 {
@@ -195,12 +197,11 @@ class TestBlinkSetup(unittest.TestCase):
         self.assertEqual(combined["fizz"], "buzz")
         self.assertEqual(combined["bar"], "foo")
 
-    @mock.patch("blinkpy.api.request_homescreen")
     @mock.patch("blinkpy.blinkpy.BlinkOwl.start")
-    def test_initialize_blink_minis(self, mock_start, mock_home):
+    def test_initialize_blink_minis(self, mock_start):
         """Test blink mini initialization."""
         mock_start.return_value = True
-        mock_home.return_value = {
+        self.blink.homescreen = {
             "owls": [
                 {
                     "enabled": False,
@@ -233,6 +234,60 @@ class TestBlinkSetup(unittest.TestCase):
         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."""

tests/test_cameras.py

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

tests/test_sync_module.py

@@ -80,11 +80,11 @@ class TestBlinkSyncModule(unittest.TestCase):
     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"), [])
+        self.assertEqual(self.blink.sync["test"].get_camera_info("1"), {})
         mock_resp.return_value = {}
-        self.assertEqual(self.blink.sync["test"].get_camera_info("1"), [])
+        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"), [])
+        self.assertEqual(self.blink.sync["test"].get_camera_info("1"), {})
 
     def test_get_network_info(self, mock_resp):
         """Test network retrieval."""