Merge pull request #165 from fronzbot/dev

0.13.1

.travis.yml

@@ -2,7 +2,7 @@ sudo: required
 matrix:
   fast_finish: true
   include:
-    - python: "3.6"
+    - python: "3.5.3"
       env: TOXENV=lint
     - python: "3.5.3"
       env: TOXENV=py35

CHANGES.rst

@@ -3,6 +3,47 @@ Changelog
 
 A list of changes between each release
 
+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.
+
+- Adds throttle decorator
+- Decorate following functions with 4s throttle (call method with `force=True` to override):
+    - request_network_status
+    - request_syncmodule
+    - request_system_arm
+    - request_system_disarm
+    - request_sync_events
+    - request_new_image
+    - request_new_video
+    - request_video_count
+    - request_cameras
+    - request_camera_info
+    - request_camera_sensors
+    - 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.
+- 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
+- Prevent blinkpy from failing at setup due to api error
+
+
 0.11.2 (2019-01-23)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Hotfix to prevent platform from stalling due to API change

README.rst

@@ -84,6 +84,17 @@ 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.
+
+Example usage, which downloads all videos recorded since July 4th, 2018 at 9:34am to the ``/home/blink`` directory:
+
+.. code:: python
+
+    blink = blinkpy.Blink(username="YOUR USER NAME", password="YOUR PASSWORD")
+    blink.start()
+    blink.download_videos('/home/blink', since='2018/07/04 09:34')
+
 
 .. |Build Status| image:: https://travis-ci.org/fronzbot/blinkpy.svg?branch=dev
    :target: https://travis-ci.org/fronzbot/blinkpy

blinkpy/api.py

@@ -3,14 +3,24 @@
 import logging
 from json import dumps
 import blinkpy.helpers.errors as ERROR
-from blinkpy.helpers.util import http_req, BlinkException
+from blinkpy.helpers.util import http_req, get_time, BlinkException, Throttle
 from blinkpy.helpers.constants import DEFAULT_URL
 
 _LOGGER = logging.getLogger(__name__)
 
+MIN_THROTTLE_TIME = 2
 
-def request_login(blink, url, username, password):
-    """Login request."""
+
+def request_login(blink, url, username, password, is_retry=False):
+    """
+    Login request.
+
+    :param blink: Blink instance.
+    :param url: Login url.
+    :param username: Blink username.
+    :param password: Blink password.
+    :param is_retry: Is this part of a re-authorization attempt?
+    """
     headers = {
         'Host': DEFAULT_URL,
         'Content-Type': 'application/json'
@@ -21,7 +31,7 @@ def request_login(blink, url, username, password):
         'client_specifier': 'iPhone 9.2 | 2.2 | 222'
     })
     return http_req(blink, url=url, headers=headers, data=data,
-                    json_resp=False, reqtype='post')
+                    json_resp=False, reqtype='post', is_retry=is_retry)
 
 
 def request_networks(blink):
@@ -30,138 +40,234 @@ def request_networks(blink):
     return http_get(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_network_status(blink, network):
-    """Request network information."""
+    """
+    Request network information.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}".format(blink.urls.base_url, network)
     return http_get(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_syncmodule(blink, network):
-    """Request sync module info."""
+    """
+    Request sync module info.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}/syncmodules".format(blink.urls.base_url, network)
     return http_get(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_system_arm(blink, network):
-    """Arm system."""
+    """
+    Arm system.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}/arm".format(blink.urls.base_url, network)
     return http_post(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_system_disarm(blink, network):
-    """Disarm system."""
+    """
+    Disarm system.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}/disarm".format(blink.urls.base_url, network)
     return http_post(blink, url)
 
 
 def request_command_status(blink, network, command_id):
-    """Request command status."""
+    """
+    Request command status.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param command_id: Command id to check.
+    """
     url = "{}/network/{}/command/{}".format(blink.urls.base_url,
                                             network,
                                             command_id)
     return http_get(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_homescreen(blink):
     """Request homescreen info."""
-    url = "{}/homescreen".format(blink.urls.base_url)
+    url = "{}/api/v3/accounts/{}/homescreen".format(blink.urls.base_url,
+                                                    blink.account_id)
     return http_get(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_sync_events(blink, network):
-    """Request events from sync module."""
+    """
+    Request events from sync module.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/events/network/{}".format(blink.urls.base_url, network)
     return http_get(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_new_image(blink, network, camera_id):
-    """Request to capture new thumbnail for camera."""
+    """
+    Request to capture new thumbnail for camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to request new image from.
+    """
     url = "{}/network/{}/camera/{}/thumbnail".format(blink.urls.base_url,
                                                      network,
                                                      camera_id)
     return http_post(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_new_video(blink, network, camera_id):
-    """Request to capture new video clip."""
+    """
+    Request to capture new video clip.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to request new video from.
+    """
     url = "{}/network/{}/camera/{}/clip".format(blink.urls.base_url,
                                                 network,
                                                 camera_id)
     return http_post(blink, url)
 
 
-def request_video_count(blink, headers):
+@Throttle(seconds=MIN_THROTTLE_TIME)
+def request_video_count(blink):
     """Request total video count."""
     url = "{}/api/v2/videos/count".format(blink.urls.base_url)
     return http_get(blink, url)
 
 
-def request_videos(blink, page=0):
-    """Perform a request for videos."""
-    url = "{}/api/v2/videos/page/{}".format(blink.urls.base_url, page)
+def request_videos(blink, time=None, page=0):
+    """
+    Perform a request for videos.
+
+    :param blink: Blink instance.
+    :param time: Get videos since this time.  In epoch seconds.
+    :param page: Page number to get videos from.
+    """
+    timestamp = get_time(time)
+    url = "{}/api/v2/videos/changed?since={}&page={}".format(
+        blink.urls.base_url, timestamp, page)
     return http_get(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_cameras(blink, network):
-    """Request all camera information."""
+    """
+    Request all camera information.
+
+    :param Blink: Blink instance.
+    :param network: Sync module network id.
+    """
     url = "{}/network/{}/cameras".format(blink.urls.base_url, network)
     return http_get(blink, url)
 
 
 def request_camera_info(blink, network, camera_id):
-    """Request camera info for one camera."""
-    url = "{}/network/{}/camera/{}".format(blink.urls.base_url,
-                                           network,
-                                           camera_id)
+    """
+    Request camera info for one camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to request info from.
+    """
+    url = "{}/network/{}/camera/{}/config".format(blink.urls.base_url,
+                                                  network,
+                                                  camera_id)
     return http_get(blink, url)
 
 
 def request_camera_sensors(blink, network, camera_id):
-    """Request camera sensor info for one camera."""
+    """
+    Request camera sensor info for one camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to request sesnor info from.
+    """
     url = "{}/network/{}/camera/{}/signals".format(blink.urls.base_url,
                                                    network,
                                                    camera_id)
     return http_get(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_motion_detection_enable(blink, network, camera_id):
-    """Enable motion detection for a camera."""
+    """
+    Enable motion detection for a camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to enable.
+    """
     url = "{}/network/{}/camera/{}/enable".format(blink.urls.base_url,
                                                   network,
                                                   camera_id)
     return http_post(blink, url)
 
 
+@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_motion_detection_disable(blink, network, camera_id):
-    """Disable motion detection for a camera."""
+    """Disable motion detection for a camera.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: Camera ID of camera to disable.
+    """
     url = "{}/network/{}/camera/{}/disable".format(blink.urls.base_url,
                                                    network,
                                                    camera_id)
     return http_post(blink, url)
 
 
-def http_get(blink, url, stream=False, json=True):
+def http_get(blink, url, stream=False, json=True, is_retry=False):
     """
     Perform an http get request.
 
     :param url: URL to perform get request.
     :param stream: Stream response? True/FALSE
     :param json: Return json response? TRUE/False
+    :param is_retry: Is this part of a re-auth attempt?
     """
     if blink.auth_header is None:
         raise BlinkException(ERROR.AUTH_TOKEN)
     _LOGGER.debug("Making GET request to %s", url)
     return http_req(blink, url=url, headers=blink.auth_header,
-                    reqtype='get', stream=stream, json_resp=json)
+                    reqtype='get', stream=stream, json_resp=json,
+                    is_retry=is_retry)
 
 
-def http_post(blink, url):
+def http_post(blink, url, is_retry=False):
     """
     Perform an http post request.
 
     :param url: URL to perfom post request.
+    :param is_retry: Is this part of a re-auth attempt?
     """
     if blink.auth_header is None:
         raise BlinkException(ERROR.AUTH_TOKEN)
     _LOGGER.debug("Making POST request to %s", url)
-    return http_req(blink, url=url, headers=blink.auth_header, reqtype='post')
+    return http_req(blink, url=url, headers=blink.auth_header,
+                    reqtype='post', is_retry=is_retry)

blinkpy/blinkpy.py

@@ -1,32 +1,44 @@
 # -*- coding: utf-8 -*-
 """
-blinkpy by Kevin Fronczak - A Blink camera Python library.
+blinkpy is an unofficial api for the Blink security camera system.
+
+repo url: https://github.com/fronzbot/blinkpy
 
-https://github.com/fronzbot/blinkpy
 Original protocol hacking by MattTW :
 https://github.com/MattTW/BlinkMonitorProtocol
+
 Published under the MIT license - See LICENSE file for more details.
 "Blink Wire-Free HS Home Monitoring & Alert Systems" is a trademark
 owned by Immedia Inc., see www.blinkforhome.com for more information.
-I am in no way affiliated with Blink, nor Immedia Inc.
+blinkpy is in no way affiliated with Blink, nor Immedia Inc.
 """
 
+import os.path
 import time
 import getpass
 import logging
+from shutil import copyfileobj
+
 from requests.structures import CaseInsensitiveDict
-import blinkpy.helpers.errors as ERROR
+from dateutil.parser import parse
+
 from blinkpy import api
 from blinkpy.sync_module import BlinkSyncModule
+from blinkpy.helpers import errors as ERROR
 from blinkpy.helpers.util import (
-    create_session, merge_dicts, BlinkURLHandler,
-    BlinkAuthenticationException)
+    create_session, merge_dicts, get_time, BlinkURLHandler,
+    BlinkAuthenticationException, Throttle)
 from blinkpy.helpers.constants import (
-    BLINK_URL, LOGIN_URL, LOGIN_BACKUP_URL)
+    BLINK_URL, LOGIN_URL, OLD_LOGIN_URL, LOGIN_BACKUP_URL)
+from blinkpy.helpers.constants import __version__
 
 REFRESH_RATE = 30
 
-_LOGGER = logging.getLogger('blinkpy')
+# Prevents rapid calls to blink.refresh()
+# with the force_cache flag set to True
+MIN_THROTTLE_TIME = 2
+
+_LOGGER = logging.getLogger(__name__)
 
 
 class Blink():
@@ -55,10 +67,12 @@ class Blink():
         self.region_id = None
         self.last_refresh = None
         self.refresh_rate = refresh_rate
-        self.session = None
+        self.session = create_session()
         self.networks = []
         self.cameras = CaseInsensitiveDict({})
+        self.video_list = CaseInsensitiveDict({})
         self._login_url = LOGIN_URL
+        self.version = __version__
 
     @property
     def auth_header(self):
@@ -73,13 +87,21 @@ class Blink():
         Essentially this is just a wrapper function for ease of use.
         """
         if self._username is None or self._password is None:
-            self.login()
-        else:
-            self.get_auth_token()
+            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():
-            sync_module = BlinkSyncModule(self, network_name, network_id)
+            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()
@@ -89,57 +111,73 @@ class Blink():
         self._username = input("Username:")
         self._password = getpass.getpass("Password:")
         if self.get_auth_token():
-            _LOGGER.info("Login successful!")
+            _LOGGER.debug("Login successful!")
             return True
         _LOGGER.warning("Unable to login with %s.", self._username)
         return False
 
-    def get_auth_token(self):
+    def get_auth_token(self, is_retry=False):
         """Retrieve the authentication token from Blink."""
         if not isinstance(self._username, str):
             raise BlinkAuthenticationException(ERROR.USERNAME)
         if not isinstance(self._password, str):
             raise BlinkAuthenticationException(ERROR.PASSWORD)
 
-        login_url = LOGIN_URL
-        self.session = create_session()
-        response = api.request_login(self,
-                                     login_url,
-                                     self._username,
-                                     self._password)
+        login_urls = [LOGIN_URL, OLD_LOGIN_URL, LOGIN_BACKUP_URL]
 
-        if response.status_code == 200:
-            response = response.json()
-            (self.region_id, self.region), = response['region'].items()
-        else:
-            _LOGGER.debug(
-                ("Received response code %s "
-                 "when authenticating, "
-                 "trying new url"), response.status_code
-            )
-            login_url = LOGIN_BACKUP_URL
-            response = api.request_login(self,
-                                         login_url,
-                                         self._username,
-                                         self._password)
-            self.region_id = 'piri'
-            self.region = "UNKNOWN"
+        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.networks = response['networks']
         self.urls = BlinkURLHandler(self.region_id)
-        self._login_url = login_url
 
         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)
-        # Look for only onboarded network, flag warning if multiple
-        # since it's unexpected
         all_networks = []
         network_dict = {}
         for network, status in self.networks.items():
@@ -156,6 +194,26 @@ class Blink():
         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):
         """
         Perform a system refresh.
@@ -166,6 +224,11 @@ class Blink():
             for sync_name, sync_module in self.sync.items():
                 _LOGGER.debug("Attempting refresh of sync %s", sync_name)
                 sync_module.refresh(force_cache=force_cache)
+            if not force_cache:
+                # Prevents rapid clearing of motion detect property
+                self.last_refresh = int(time.time())
+            return True
+        return False
 
     def check_if_ok_to_update(self):
         """Check if it is ok to perform an http request."""
@@ -174,7 +237,6 @@ class Blink():
         if last_refresh is None:
             last_refresh = 0
         if current_time >= (last_refresh + self.refresh_rate):
-            self.last_refresh = current_time
             return True
         return False
 
@@ -184,3 +246,77 @@ class Blink():
         for sync in self.sync:
             combined = merge_dicts(combined, self.sync[sync].cameras)
         return combined
+
+    def download_videos(self, path, since=None, camera='all', stop=10):
+        """
+        Download all videos from server since specified time.
+
+        :param path: Path to write files.  /path/<cameraname>_<recorddate>.mp4
+        :param since: Date and time to get videos from.
+                      Ex: "2018/07/28 12:33:00" to retrieve videos since
+                           July 28th 2018 at 12:33:00
+        :param camera: Camera name to retrieve.  Defaults to "all".
+                       Use a list for multiple cameras.
+        :param stop: Page to stop on (~25 items per page. Default page 10).
+        """
+        if since is None:
+            since_epochs = self.last_refresh
+        else:
+            parsed_datetime = parse(since, fuzzy=True)
+            since_epochs = parsed_datetime.timestamp()
+
+        formatted_date = get_time(time_to_convert=since_epochs)
+        _LOGGER.info("Retrieving videos since %s", formatted_date)
+
+        if not isinstance(camera, list):
+            camera = [camera]
+
+        for page in range(1, stop):
+            response = api.request_videos(self, time=since_epochs, page=page)
+            _LOGGER.debug("Processing page %s", page)
+            try:
+                result = response['videos']
+                if not result:
+                    raise IndexError
+            except (KeyError, IndexError):
+                _LOGGER.info("No videos found on page %s. Exiting.", page)
+                break
+
+            self._parse_downloaded_items(result, camera, path)
+
+    def _parse_downloaded_items(self, result, camera, path):
+        """Parse downloaded videos."""
+        for item in result:
+            try:
+                created_at = item['created_at']
+                camera_name = item['camera_name']
+                is_deleted = item['deleted']
+                address = item['address']
+            except KeyError:
+                _LOGGER.info("Missing clip information, skipping...")
+                continue
+
+            if camera_name not in camera and 'all' not in camera:
+                _LOGGER.debug("Skipping videos for %s.", camera_name)
+                continue
+
+            if is_deleted:
+                _LOGGER.debug("%s: %s is marked as deleted.",
+                              camera_name,
+                              address)
+                continue
+
+            clip_address = "{}{}".format(self.urls.base_url, address)
+            filename = "{}_{}.mp4".format(camera_name, created_at)
+            filename = os.path.join(path, filename)
+
+            if os.path.isfile(filename):
+                _LOGGER.info("%s already exists, skipping...", filename)
+                continue
+
+            response = api.http_get(self, url=clip_address,
+                                    stream=True, json=False)
+            with open(filename, 'wb') as vidfile:
+                copyfileobj(response.raw, vidfile)
+
+            _LOGGER.info("Downloaded video to %s", filename)

blinkpy/camera.py

@@ -6,8 +6,6 @@ from blinkpy import api
 
 _LOGGER = logging.getLogger(__name__)
 
-MAX_CLIPS = 5
-
 
 class BlinkCamera():
     """Class to initialize individual camera."""
@@ -28,7 +26,7 @@ class BlinkCamera():
         self.battery_state = None
         self.motion_detected = None
         self.wifi_strength = None
-        self.last_record = []
+        self.last_record = None
         self._cached_image = None
         self._cached_video = None
 
@@ -94,10 +92,11 @@ class BlinkCamera():
                                                     self.network_id,
                                                     self.camera_id)
 
-    def update(self, config, force_cache=False):
+    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['camera_id'])
+        self.camera_id = str(config['id'])
         self.network_id = str(config['network_id'])
         self.serial = config['serial']
         self.motion_enabled = config['enabled']
@@ -113,7 +112,8 @@ class BlinkCamera():
         try:
             self.temperature_calibrated = resp['temp']
         except KeyError:
-            _LOGGER.error("Could not retrieve calibrated temperature.")
+            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
@@ -128,12 +128,15 @@ class BlinkCamera():
             new_thumbnail = "{}{}.jpg".format(self.sync.urls.base_url,
                                               thumb_addr)
 
-        # Check if a new motion clip has been recorded
-        # check_for_motion_method sets motion_detected variable
-        self.check_for_motion()
+        try:
+            self.motion_detected = self.sync.motion[self.name]
+        except KeyError:
+            self.motion_detected = False
+
         clip_addr = None
-        if self.last_record:
-            clip_addr = self.sync.all_clips[self.name][self.last_record[0]]
+        if self.name in self.sync.last_record:
+            clip_addr = self.sync.last_record[self.name]['clip']
+            self.last_record = self.sync.last_record[self.name]['time']
             self.clip = "{}{}".format(self.sync.urls.base_url,
                                       clip_addr)
 
@@ -158,25 +161,6 @@ class BlinkCamera():
                                               stream=True,
                                               json=False)
 
-    def check_for_motion(self):
-        """Check if motion detected.."""
-        try:
-            records = sorted(self.sync.record_dates[self.name])
-            new_clip = records.pop()
-            if new_clip not in self.last_record and self.last_record:
-                self.motion_detected = True
-                self.last_record.insert(0, new_clip)
-                if len(self.last_record) > MAX_CLIPS:
-                    self.last_record.pop()
-            elif not self.last_record:
-                self.last_record.insert(0, new_clip)
-                self.motion_detected = False
-            else:
-                self.motion_detected = False
-        except KeyError:
-            _LOGGER.info("Could not extract clip info from camera %s",
-                         self.name)
-
     def image_to_file(self, path):
         """
         Write image to file.
@@ -190,7 +174,8 @@ class BlinkCamera():
                 copyfileobj(response.raw, imgfile)
         else:
             _LOGGER.error("Cannot write image to file, response %s",
-                          response.status_code)
+                          response.status_code,
+                          exc_info=True)
 
     def video_to_file(self, path):
         """Write video to file.
@@ -200,7 +185,9 @@ class BlinkCamera():
         _LOGGER.debug("Writing video from %s to %s", self.name, path)
         response = self._cached_video
         if response is None:
-            _LOGGER.error("No saved video exist for %s.", self.name)
+            _LOGGER.error("No saved video exist for %s.",
+                          self.name,
+                          exc_info=True)
             return
         with open(path, 'wb') as vidfile:
             copyfileobj(response.raw, vidfile)
@@ -216,5 +203,7 @@ class BlinkCamera():
                     return device_thumb
             except KeyError:
                 pass
-        _LOGGER.error("Could not find thumbnail for camera %s", self.name)
+        _LOGGER.error("Could not find thumbnail for camera %s",
+                      self.name,
+                      exc_info=True)
         return None

blinkpy/helpers/constants.py

@@ -3,8 +3,8 @@
 import os
 
 MAJOR_VERSION = 0
-MINOR_VERSION = 11
-PATCH_VERSION = 2
+MINOR_VERSION = 13
+PATCH_VERSION = 1
 
 __version__ = '{}.{}.{}'.format(MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION)
 
@@ -47,10 +47,16 @@ URLS
 BLINK_URL = 'immedia-semi.com'
 DEFAULT_URL = "{}.{}".format('prod', BLINK_URL)
 BASE_URL = "https://{}".format(DEFAULT_URL)
-LOGIN_URL = "{}/login".format(BASE_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)
 
 '''
 Dictionaries
 '''
 ONLINE = {'online': True, 'offline': False}
+
+'''
+OTHER
+'''
+TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%S%Z'

blinkpy/helpers/util.py

@@ -1,14 +1,23 @@
 """Useful functions for blinkpy."""
 
 import logging
+import time
+from functools import wraps
 from requests import Request, Session, exceptions
-from blinkpy.helpers.constants import BLINK_URL
+from blinkpy.helpers.constants import BLINK_URL, TIMESTAMP_FORMAT
 import blinkpy.helpers.errors as ERROR
 
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def get_time(time_to_convert=None):
+    """Create blink-compatible timestamp."""
+    if time_to_convert is None:
+        time_to_convert = time.time()
+    return time.strftime(TIMESTAMP_FORMAT, time.localtime(time_to_convert))
+
+
 def merge_dicts(dict_a, dict_b):
     """Merge two dictionaries into one."""
     duplicates = [val for val in dict_a if val in dict_b]
@@ -27,7 +36,7 @@ def create_session():
 def attempt_reauthorization(blink):
     """Attempt to refresh auth token and links."""
     _LOGGER.info("Auth token expired, attempting reauthorization.")
-    headers = blink.get_auth_token()
+    headers = blink.get_auth_token(is_retry=True)
     return headers
 
 
@@ -56,13 +65,15 @@ def http_req(blink, url='http://example.com', data=None, headers=None,
     prepped = req.prepare()
 
     try:
-        response = blink.session.send(prepped, stream=stream)
+        response = blink.session.send(prepped, stream=stream, timeout=10)
         if json_resp and 'code' in response.json():
             if is_retry:
                 _LOGGER.error("Cannot obtain new token for server auth.")
                 return None
             else:
                 headers = attempt_reauthorization(blink)
+                if not headers:
+                    raise exceptions.ConnectionError
                 return http_req(blink, url=url, data=data, headers=headers,
                                 reqtype=reqtype, stream=stream,
                                 json_resp=json_resp, is_retry=True)
@@ -96,8 +107,6 @@ class BlinkException(Exception):
 class BlinkAuthenticationException(BlinkException):
     """Class to throw authentication exception."""
 
-    pass
-
 
 class BlinkURLHandler():
     """Class that handles Blink URLS."""
@@ -111,3 +120,33 @@ class BlinkURLHandler():
         self.networks_url = "{}/networks".format(self.base_url)
         self.video_url = "{}/api/v2/videos".format(self.base_url)
         _LOGGER.debug("Setting base url to %s.", self.base_url)
+
+
+class Throttle():
+    """Class for throttling api calls."""
+
+    def __init__(self, seconds=10):
+        """Initialize throttle class."""
+        self.throttle_time = seconds
+        self.last_call = 0
+
+    def __call__(self, method):
+        """Throttle caller method."""
+        def throttle_method():
+            """Call when method is throttled."""
+            return None
+
+        @wraps(method)
+        def wrapper(*args, **kwargs):
+            """Wrap that checks for throttling."""
+            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:
+                result = method(*args, *kwargs)
+                self.last_call = now
+                return result
+
+            return throttle_method()
+
+        return wrapper

blinkpy/sync_module.py

@@ -13,7 +13,7 @@ _LOGGER = logging.getLogger(__name__)
 class BlinkSyncModule():
     """Class to initialize sync module."""
 
-    def __init__(self, blink, network_name, network_id):
+    def __init__(self, blink, network_name, network_id, camera_list):
         """
         Initialize Blink sync module.
 
@@ -30,13 +30,12 @@ class BlinkSyncModule():
         self.sync_id = None
         self.host = None
         self.summary = None
-        self.homescreen = None
         self.network_info = None
-        self.record_dates = {}
-        self.videos = {}
         self.events = []
         self.cameras = CaseInsensitiveDict({})
-        self.all_clips = {}
+        self.motion = {}
+        self.last_record = {}
+        self.camera_list = camera_list
 
     @property
     def attributes(self):
@@ -65,7 +64,10 @@ class BlinkSyncModule():
     @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):
+            return None
 
     @arm.setter
     def arm(self, value):
@@ -77,111 +79,110 @@ class BlinkSyncModule():
 
     def start(self):
         """Initialize the system."""
-        response = api.request_syncmodule(self.blink, self.network_id)
-        self.summary = response['syncmodule']
-        self.sync_id = self.summary['id']
-        self.network_id = self.summary['network_id']
-        self.serial = self.summary['serial']
-        self.status = self.summary['status']
+        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)
+            return False
 
-        self.events = self.get_events()
-
-        self.homescreen = api.request_homescreen(self.blink)
+        try:
+            self.sync_id = self.summary['id']
+            self.serial = self.summary['serial']
+            self.status = self.summary['status']
+        except KeyError:
+            _LOGGER.error("Could not extract some sync module info: %s",
+                          response,
+                          exc_info=True)
 
         self.network_info = api.request_network_status(self.blink,
                                                        self.network_id)
 
-        camera_info = self.get_camera_info()
-        for camera_config in camera_info:
-            name = camera_config['name']
-            self.cameras[name] = BlinkCamera(self)
+        self.check_new_videos()
+        try:
+            for camera_config in self.camera_list:
+                if 'name' not in camera_config:
+                    break
+                name = camera_config['name']
+                self.cameras[name] = BlinkCamera(self)
+                self.motion[name] = False
+                camera_info = self.get_camera_info(camera_config['id'])
+                self.cameras[name].update(camera_info,
+                                          force_cache=True,
+                                          force=True)
+        except KeyError:
+            _LOGGER.error("Could not create cameras instances for %s",
+                          self.name,
+                          exc_info=True)
+            return False
 
-        self.videos = self.get_videos()
-        for camera_config in camera_info:
-            name = camera_config['name']
-            if name in self.cameras:
-                self.cameras[name].update(camera_config, force_cache=True)
+        return True
 
-    def get_events(self):
+    def get_events(self, **kwargs):
         """Retrieve events from server."""
-        response = api.request_sync_events(self.blink, self.network_id)
-        return response['event']
+        force = kwargs.pop('force', False)
+        response = api.request_sync_events(self.blink,
+                                           self.network_id,
+                                           force=force)
+        try:
+            return response['event']
+        except (TypeError, KeyError):
+            _LOGGER.error("Could not extract events: %s",
+                          response,
+                          exc_info=True)
+            return False
 
-    def get_camera_info(self):
+    def get_camera_info(self, camera_id):
         """Retrieve camera information."""
-        response = api.request_cameras(self.blink, self.network_id)
-        return response['devicestatus']
+        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 []
 
     def refresh(self, force_cache=False):
         """Get all blink cameras and pulls their most recent status."""
-        self.events = self.get_events()
-        self.videos = self.get_videos()
-        self.homescreen = api.request_homescreen(self.blink)
         self.network_info = api.request_network_status(self.blink,
                                                        self.network_id)
-        camera_info = self.get_camera_info()
-        for camera_config in camera_info:
-            name = camera_config['name']
-            self.cameras[name].update(camera_config, force_cache=force_cache)
+        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)
 
-    def get_videos(self, start_page=0, end_page=1):
-        """
-        Retrieve last recorded videos per camera.
+    def check_new_videos(self):
+        """Check if new videos since last refresh."""
+        resp = api.request_videos(self.blink,
+                                  time=self.blink.last_refresh,
+                                  page=0)
 
-        :param start_page: Page to start reading from on blink servers
-                           (defaults to 0)
-        :param end_page: Page to stop reading from (defaults to 1)
-        """
-        videos = list()
-        all_dates = dict()
+        for camera in self.cameras.keys():
+            self.motion[camera] = False
 
-        for page_num in range(start_page, end_page + 1):
-            this_page = api.request_videos(self.blink, page=page_num)
-            if not this_page:
-                break
-            elif 'message' in this_page:
-                _LOGGER.warning("Could not retrieve videos. Message: %s",
-                                this_page['message'])
-                break
+        try:
+            info = resp['videos']
+        except (KeyError, TypeError):
+            _LOGGER.warning("Could not check for motion. Response: %s", resp)
+            return False
 
-            videos.append(this_page)
-        _LOGGER.debug("Getting videos from page %s through %s",
-                      start_page,
-                      end_page)
-        for page in videos:
-            for entry in page:
-                try:
-                    camera_name = entry['camera_name']
-                    clip_addr = entry['address']
-                    thumb_addr = entry['thumbnail']
-                except TypeError:
-                    _LOGGER.warning("Could not extract video information.")
-                    break
-                clip_date = clip_addr.split('_')[-6:]
-                clip_date = '_'.join(clip_date)
-                clip_date = clip_date.split('.')[0]
-                try:
-                    self.all_clips[camera_name][clip_date] = clip_addr
-                except KeyError:
-                    self.all_clips[camera_name] = {clip_date: clip_addr}
+        for entry in info:
+            try:
+                name = entry['camera_name']
+                clip = entry['address']
+                timestamp = entry['created_at']
+                self.motion[name] = True
+                self.last_record[name] = {'clip': clip, 'time': timestamp}
+            except KeyError:
+                _LOGGER.debug("No new videos since last refresh.")
 
-                if camera_name not in all_dates:
-                    all_dates[camera_name] = list()
-                all_dates[camera_name].append(clip_date)
-                try:
-                    self.videos[camera_name].append(
-                        {
-                            'clip': clip_addr,
-                            'thumb': thumb_addr,
-                        }
-                    )
-                except KeyError:
-                    self.videos[camera_name] = [
-                        {
-                            'clip': clip_addr,
-                            'thumb': thumb_addr,
-                        }
-                    ]
-        self.record_dates = all_dates
-        _LOGGER.debug("Retrieved a total of %s records", len(all_dates))
-        return self.videos
+        return True

pylintrc

@@ -8,6 +8,8 @@ reports=no
 # too-many-* - are not enforced for the sake of readability
 # too-few-* - same as too-many-*
 # no-else-return - I don't see any reason to enforce this. both forms are readable
+# no-self-use - stupid and only annoying
+# unexpected-keyword-arg - doesn't allow for use of **kwargs, which is dumb
 
 disable=
   locally-disabled,
@@ -23,3 +25,5 @@ disable=
   too-many-lines,
   too-few-public-methods,
   no-else-return,
+  no-self-use,
+  unexpected-keyword-arg,

requirements.txt

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

requirements_test.txt

@@ -1,6 +1,6 @@
 flake8==3.5.0
 flake8-docstrings==1.3.0
-pylint==2.1.1
+pylint==2.3.0
 pydocstyle==2.1.1
 pytest==3.7.1
 pytest-cov>=2.3.1

tests/mock_responses.py

@@ -67,5 +67,3 @@ def mocked_session_send(*args, **kwargs):
 
 class MockURLHandler(BlinkURLHandler):
     """Mocks URL Handler in blinkpy module."""
-
-    pass

tests/test_blink_functions.py

@@ -1,12 +1,11 @@
 """Tests camera and system functions."""
 import unittest
 from unittest import mock
-
-from requests import Request
+import logging
 
 from blinkpy import blinkpy
 from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.helpers.util import create_session
+from blinkpy.helpers.util import create_session, get_time
 import tests.mock_responses as mresp
 
 USERNAME = 'foobar'
@@ -56,29 +55,112 @@ class TestBlinkFunctions(unittest.TestCase):
         """Clean up after test."""
         self.blink = None
 
-    @mock.patch('blinkpy.blinkpy.api.http_req')
+    @mock.patch('blinkpy.blinkpy.api.request_login')
     def test_backup_url(self, req, mock_sess):
         """Test backup login method."""
-        fake_req = Request('POST', 'http://wrong.url').prepare()
+        json_resp = {
+            'authtoken': {'authtoken': 'foobar123'},
+            'networks': {'1234': {'name': 'foobar', 'onboarded': True}}
+        }
+        bad_req = mresp.MockResponse({}, 404)
+        new_req = mresp.MockResponse(json_resp, 200)
         req.side_effect = [
-            mresp.mocked_session_send(fake_req),
-            {'authtoken': {'authtoken': 'foobar123'},
-             'networks': {'1234': {'name': 'foobar', 'onboarded': True}}}
+            bad_req,
+            bad_req,
+            new_req
         ]
-        self.blink.get_auth_token()
-        self.assertEqual(self.blink.region_id, 'piri')
-        self.assertEqual(self.blink.region, 'UNKNOWN')
+        self.blink.login_request(['test1', 'test2', 'test3'])
         # pylint: disable=protected-access
-        self.assertEqual(self.blink._token, 'foobar123')
+        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):
         """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'] = BlinkSyncModule(self.blink, 'foo', 1, [])
+        self.blink.sync['bar'] = BlinkSyncModule(self.blink, 'bar', 2, [])
         self.blink.sync['foo'].cameras = first_dict
         self.blink.sync['bar'].cameras = next_dict
         result = self.blink.merge_cameras()
         expected = {'foo': 'bar', 'test': 123, 'foobar': 456, 'bar': 'foo'}
         self.assertEqual(expected, result)
+
+    @mock.patch('blinkpy.blinkpy.api.request_videos')
+    def test_download_video_exit(self, mock_req, mock_sess):
+        """Test we exit method when provided bad response."""
+        blink = blinkpy.Blink()
+        # pylint: disable=protected-access
+        blinkpy._LOGGER.setLevel(logging.DEBUG)
+        blink.last_refresh = 0
+        mock_req.return_value = {}
+        formatted_date = get_time(blink.last_refresh)
+        expected_log = [
+            "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."
+        ]
+        with self.assertLogs() as dl_log:
+            blink.download_videos('/tmp')
+        self.assertEqual(dl_log.output, expected_log)
+
+    @mock.patch('blinkpy.blinkpy.api.request_videos')
+    def test_parse_downloaded_items(self, mock_req, mock_sess):
+        """Test ability to parse downloaded items list."""
+        blink = blinkpy.Blink()
+        # pylint: disable=protected-access
+        blinkpy._LOGGER.setLevel(logging.DEBUG)
+        generic_entry = {
+            'created_at': '1970',
+            'camera_name': 'foo',
+            'deleted': True,
+            'address': '/bar.mp4'
+        }
+        result = [generic_entry]
+        mock_req.return_value = {'videos': result}
+        blink.last_refresh = 0
+        formatted_date = get_time(blink.last_refresh)
+        expected_log = [
+            "INFO:blinkpy.blinkpy:Retrieving videos since {}".format(
+                formatted_date),
+            "DEBUG:blinkpy.blinkpy:Processing page 1",
+            "DEBUG:blinkpy.blinkpy:foo: /bar.mp4 is marked as deleted."
+        ]
+        with self.assertLogs() as dl_log:
+            blink.download_videos('/tmp', stop=2)
+        self.assertEqual(dl_log.output, expected_log)
+
+    @mock.patch('blinkpy.blinkpy.api.request_videos')
+    def test_parse_camera_not_in_list(self, mock_req, mock_sess):
+        """Test ability to parse downloaded items list."""
+        blink = blinkpy.Blink()
+        # pylint: disable=protected-access
+        blinkpy._LOGGER.setLevel(logging.DEBUG)
+        generic_entry = {
+            'created_at': '1970',
+            'camera_name': 'foo',
+            'deleted': True,
+            'address': '/bar.mp4'
+        }
+        result = [generic_entry]
+        mock_req.return_value = {'videos': result}
+        blink.last_refresh = 0
+        formatted_date = get_time(blink.last_refresh)
+        expected_log = [
+            "INFO:blinkpy.blinkpy:Retrieving videos since {}".format(
+                formatted_date),
+            "DEBUG:blinkpy.blinkpy:Processing page 1",
+            "DEBUG:blinkpy.blinkpy:Skipping videos for foo."
+        ]
+        with self.assertLogs() as dl_log:
+            blink.download_videos('/tmp', camera='bar', stop=2)
+        self.assertEqual(dl_log.output, expected_log)

tests/test_blinkpy.py

@@ -14,6 +14,7 @@ from blinkpy.sync_module import BlinkSyncModule
 from blinkpy.helpers.util import (
     http_req, create_session, BlinkAuthenticationException,
     BlinkException, BlinkURLHandler)
+from blinkpy.helpers.constants import __version__
 import tests.mock_responses as mresp
 
 USERNAME = 'foobar'
@@ -30,7 +31,10 @@ class TestBlinkSetup(unittest.TestCase):
         self.blink_no_cred = Blink()
         self.blink = Blink(username=USERNAME,
                            password=PASSWORD)
-        self.blink.sync['test'] = BlinkSyncModule(self.blink, 'test', '1234')
+        self.blink.sync['test'] = BlinkSyncModule(self.blink,
+                                                  'test',
+                                                  '1234',
+                                                  [])
         self.blink.urls = BlinkURLHandler('test')
         self.blink.session = create_session()
 
@@ -41,6 +45,7 @@ class TestBlinkSetup(unittest.TestCase):
 
     def test_initialization(self, mock_sess):
         """Verify we can initialize blink."""
+        self.assertEqual(self.blink.version, __version__)
         # pylint: disable=protected-access
         self.assertEqual(self.blink._username, USERNAME)
         # pylint: disable=protected-access
@@ -138,9 +143,13 @@ class TestBlinkSetup(unittest.TestCase):
         now = self.blink.refresh_rate + 1
         mock_time.return_value = now
         self.assertEqual(self.blink.last_refresh, None)
-        result = self.blink.check_if_ok_to_update()
+        self.assertEqual(self.blink.check_if_ok_to_update(), True)
+        self.assertEqual(self.blink.last_refresh, None)
+        with mock.patch('blinkpy.sync_module.BlinkSyncModule.refresh',
+                        return_value=True):
+            self.blink.refresh()
+
         self.assertEqual(self.blink.last_refresh, now)
-        self.assertEqual(result, True)
         self.assertEqual(self.blink.check_if_ok_to_update(), False)
         self.assertEqual(self.blink.last_refresh, now)
 
@@ -148,3 +157,29 @@ class TestBlinkSetup(unittest.TestCase):
         """Check that we can access sync modules ignoring case."""
         self.assertEqual(self.blink.sync['test'].name, 'test')
         self.assertEqual(self.blink.sync['TEST'].name, 'test')
+
+    @mock.patch('blinkpy.api.request_login')
+    def test_unexpected_login(self, mock_login, mock_sess):
+        """Check that we appropriately handle unexpected login info."""
+        mock_login.return_value = None
+        self.assertFalse(self.blink.get_auth_token())
+
+    @mock.patch('blinkpy.api.request_homescreen')
+    def test_get_cameras(self, mock_home, mock_sess):
+        """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, {})

tests/test_cameras.py

@@ -11,7 +11,7 @@ from unittest import mock
 from blinkpy import blinkpy
 from blinkpy.helpers.util import create_session, BlinkURLHandler
 from blinkpy.sync_module import BlinkSyncModule
-from blinkpy.camera import BlinkCamera, MAX_CLIPS
+from blinkpy.camera import BlinkCamera
 import tests.mock_responses as mresp
 
 USERNAME = 'foobar'
@@ -46,7 +46,7 @@ class TestBlinkCameraSetup(unittest.TestCase):
         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.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
@@ -55,37 +55,11 @@ class TestBlinkCameraSetup(unittest.TestCase):
         """Clean up after test."""
         self.blink = None
 
-    def test_check_for_motion(self, mock_sess):
-        """Test check for motion function."""
-        self.assertEqual(self.camera.last_record, [])
-        self.assertEqual(self.camera.motion_detected, None)
-        self.camera.sync.record_dates = {'foobar': [1, 3, 2, 4]}
-        self.camera.check_for_motion()
-        self.assertEqual(self.camera.last_record, [4])
-        self.assertEqual(self.camera.motion_detected, False)
-        self.camera.sync.record_dates = {'foobar': [7, 1, 3, 4]}
-        self.camera.check_for_motion()
-        self.assertEqual(self.camera.last_record, [7, 4])
-        self.assertEqual(self.camera.motion_detected, True)
-        self.camera.check_for_motion()
-        self.assertEqual(self.camera.last_record, [7, 4])
-        self.assertEqual(self.camera.motion_detected, False)
-
-    def test_max_motion_clips(self, mock_sess):
-        """Test that we only maintain certain number of records."""
-        for i in range(0, MAX_CLIPS):
-            self.camera.last_record.append(i)
-        self.camera.sync.record_dates['foobar'] = [MAX_CLIPS+2]
-        self.assertEqual(len(self.camera.last_record), MAX_CLIPS)
-        self.camera.check_for_motion()
-        self.assertEqual(self.camera.motion_detected, True)
-        self.assertEqual(len(self.camera.last_record), MAX_CLIPS)
-
     def test_camera_update(self, mock_sess):
         """Test that we can properly update camera properties."""
         config = {
             'name': 'new',
-            'camera_id': 1234,
+            'id': 1234,
             'network_id': 5678,
             'serial': '12345678',
             'enabled': False,
@@ -96,7 +70,12 @@ class TestBlinkCameraSetup(unittest.TestCase):
             'thumbnail': '/thumb',
         }
         self.camera.last_record = ['1']
-        self.camera.sync.all_clips = {'new': {'1': '/test.mp4'}}
+        self.camera.sync.last_record = {
+            'new': {
+                'clip': '/test.mp4',
+                'time': '1970-01-01T00:00:00'
+            }
+        }
         mock_sess.side_effect = [
             mresp.MockResponse({'temp': 71}, 200),
             'test',
@@ -128,11 +107,15 @@ class TestBlinkCameraSetup(unittest.TestCase):
             'barfoo'
         ]
         self.camera.last_record = ['1']
-        self.camera.sync.record_dates['new'] = ['1']
-        self.camera.sync.all_clips = {'new': {'1': '/test.mp4'}}
+        self.camera.sync.last_record = {
+            'new': {
+                'clip': '/test.mp4',
+                'time': '1970-01-01T00:00:00'
+            }
+        }
         config = {
             'name': 'new',
-            'camera_id': 1234,
+            'id': 1234,
             'network_id': 5678,
             'serial': '12345678',
             'enabled': False,
@@ -159,11 +142,9 @@ class TestBlinkCameraSetup(unittest.TestCase):
         """Tests that thumbnail is 'None' if none found."""
         mock_sess.return_value = 'foobar'
         self.camera.last_record = ['1']
-        self.camera.sync.record_dates['new'] = ['1']
-        self.camera.sync.all_clips = {'new': {'1': '/test.mp4'}}
         config = {
             'name': 'new',
-            'camera_id': 1234,
+            'id': 1234,
             'network_id': 5678,
             'serial': '12345678',
             'enabled': False,
@@ -176,13 +157,18 @@ class TestBlinkCameraSetup(unittest.TestCase):
         self.camera.sync.homescreen = {
             'devices': []
         }
+        self.assertEqual(self.camera.temperature_calibrated, None)
         with self.assertLogs() as logrecord:
-            self.camera.update(config)
+            self.camera.update(config, force=True)
         self.assertEqual(self.camera.thumbnail, None)
+        self.assertEqual(self.camera.last_record, ['1'])
+        self.assertEqual(self.camera.temperature_calibrated, 68)
         self.assertEqual(
             logrecord.output,
-            ["ERROR:blinkpy.camera:Could not retrieve calibrated temperature.",
-             "ERROR:blinkpy.camera:Could not find thumbnail for camera new"]
+            [("WARNING:blinkpy.camera:Could not retrieve calibrated "
+              "temperature."),
+             ("ERROR:blinkpy.camera:Could not find thumbnail for camera new"
+              "\nNoneType: None")]
         )
 
     def test_no_video_clips(self, mock_sess):
@@ -190,7 +176,7 @@ class TestBlinkCameraSetup(unittest.TestCase):
         mock_sess.return_value = 'foobar'
         config = {
             'name': 'new',
-            'camera_id': 1234,
+            'id': 1234,
             'network_id': 5678,
             'serial': '12345678',
             'enabled': False,

tests/test_sync_module.py

@@ -24,62 +24,12 @@ class TestBlinkSyncModule(unittest.TestCase):
             'TOKEN_AUTH': 'foobar123'
         }
         self.blink.urls = blinkpy.BlinkURLHandler('test')
-        self.blink.sync['test'] = BlinkSyncModule(self.blink, 'test', '1234')
+        self.blink.sync['test'] = BlinkSyncModule(self.blink,
+                                                  'test',
+                                                  '1234',
+                                                  [])
         self.camera = BlinkCamera(self.blink.sync)
-
-    def tearDown(self):
-        """Clean up after test."""
-        self.blink = None
-        self.camera = None
-
-    def test_get_events(self, mock_resp):
-        """Test get events function."""
-        mock_resp.return_value = {'event': True}
-        self.assertEqual(self.blink.sync['test'].get_events(), True)
-
-    def test_get_camera_info(self, mock_resp):
-        """Test get camera info function."""
-        mock_resp.return_value = {'devicestatus': True}
-        self.assertEqual(self.blink.sync['test'].get_camera_info(), True)
-
-    def test_get_videos_one_page(self, mock_resp):
-        """Test video access."""
-        mock_resp.return_value = [
-            {
-                'camera_name': 'foobar',
-                'address': '/test/clip_1900_01_01_12_00_00AM.mp4',
-                'thumbnail': '/test/thumb'
-            }
-        ]
-        expected_videos = {'foobar': [
-            {'clip': '/test/clip_1900_01_01_12_00_00AM.mp4',
-             'thumb': '/test/thumb'}]}
-        expected_recs = {'foobar': ['1900_01_01_12_00_00AM']}
-        expected_clips = {'foobar': {
-            '1900_01_01_12_00_00AM': '/test/clip_1900_01_01_12_00_00AM.mp4'}}
-        self.blink.sync['test'].get_videos(start_page=0, end_page=0)
-        self.assertEqual(self.blink.sync['test'].videos, expected_videos)
-        self.assertEqual(self.blink.sync['test'].record_dates, expected_recs)
-        self.assertEqual(self.blink.sync['test'].all_clips, expected_clips)
-
-    def test_get_videos_multi_page(self, mock_resp):
-        """Test video access with multiple pages."""
-        mock_resp.return_value = [
-            {
-                'camera_name': 'test',
-                'address': '/foo/bar_1900_01_01_12_00_00AM.mp4',
-                'thumbnail': '/foobar'
-            }
-        ]
-        self.blink.sync['test'].get_videos()
-        self.assertEqual(mock_resp.call_count, 2)
-        mock_resp.reset_mock()
-        self.blink.sync['test'].get_videos(start_page=0, end_page=9)
-        self.assertEqual(mock_resp.call_count, 10)
-
-    def test_sync_start(self, mock_resp):
-        """Test sync start function."""
-        mock_resp.side_effect = [
+        self.mock_start = [
             {'syncmodule': {
                 'id': 1234,
                 'network_id': 5678,
@@ -88,13 +38,109 @@ class TestBlinkSyncModule(unittest.TestCase):
             {'event': True},
             {},
             {},
-            {'devicestatus': {}},
             None,
-            None
+            {'devicestatus': {}},
         ]
+
+    def tearDown(self):
+        """Clean up after test."""
+        self.blink = None
+        self.camera = None
+        self.mock_start = None
+
+    def test_get_events(self, mock_resp):
+        """Test get events function."""
+        mock_resp.return_value = {'event': True}
+        self.assertEqual(self.blink.sync['test'].get_events(), True)
+
+    def test_get_camera_info(self, mock_resp):
+        """Test get camera info function."""
+        mock_resp.return_value = {'camera': ['foobar']}
+        self.assertEqual(self.blink.sync['test'].get_camera_info('1234'),
+                         'foobar')
+
+    def test_check_new_videos(self, mock_resp):
+        """Test recent video response."""
+        mock_resp.return_value = {
+            'videos': [{
+                'camera_name': 'foo',
+                'address': '/foo/bar.mp4',
+                'created_at': '1970-01-01T00:00:00+0:00'
+            }]
+        }
+        sync_module = self.blink.sync['test']
+        sync_module.cameras = {'foo': None}
+        self.assertEqual(sync_module.motion, {})
+        self.assertTrue(sync_module.check_new_videos())
+        self.assertEqual(sync_module.last_record['foo'],
+                         {'clip': '/foo/bar.mp4',
+                          'time': '1970-01-01T00:00:00+0:00'})
+        self.assertEqual(sync_module.motion, {'foo': True})
+        mock_resp.return_value = {'videos': []}
+        self.assertTrue(sync_module.check_new_videos())
+        self.assertEqual(sync_module.motion, {'foo': False})
+        self.assertEqual(sync_module.last_record['foo'],
+                         {'clip': '/foo/bar.mp4',
+                          'time': '1970-01-01T00:00:00+0:00'})
+
+    def test_check_new_videos_failed(self, mock_resp):
+        """Test method when response is unexpected."""
+        mock_resp.side_effect = [None, 'just a string', {}]
+        sync_module = self.blink.sync['test']
+        sync_module.cameras = {'foo': None}
+
+        sync_module.motion['foo'] = True
+        self.assertFalse(sync_module.check_new_videos())
+        self.assertFalse(sync_module.motion['foo'])
+
+        sync_module.motion['foo'] = True
+        self.assertFalse(sync_module.check_new_videos())
+        self.assertFalse(sync_module.motion['foo'])
+
+        sync_module.motion['foo'] = True
+        self.assertFalse(sync_module.check_new_videos())
+        self.assertFalse(sync_module.motion['foo'])
+
+    def test_sync_start(self, mock_resp):
+        """Test sync start function."""
+        mock_resp.side_effect = self.mock_start
         self.blink.sync['test'].start()
         self.assertEqual(self.blink.sync['test'].name, 'test')
         self.assertEqual(self.blink.sync['test'].sync_id, 1234)
         self.assertEqual(self.blink.sync['test'].network_id, 5678)
         self.assertEqual(self.blink.sync['test'].serial, '12345678')
         self.assertEqual(self.blink.sync['test'].status, 'foobar')
+
+    def test_unexpected_summary(self, mock_resp):
+        """Test unexpected summary response."""
+        self.mock_start[0] = None
+        mock_resp.side_effect = self.mock_start
+        self.assertFalse(self.blink.sync['test'].start())
+
+    def test_summary_with_no_network_id(self, mock_resp):
+        """Test handling of bad summary."""
+        self.mock_start[0]['syncmodule'] = None
+        mock_resp.side_effect = self.mock_start
+        self.assertFalse(self.blink.sync['test'].start())
+
+    def test_summary_with_only_network_id(self, mock_resp):
+        """Test handling of sparse summary."""
+        self.mock_start[0]['syncmodule'] = {'network_id': 8675309}
+        mock_resp.side_effect = self.mock_start
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].network_id, 8675309)
+
+    def test_unexpected_camera_info(self, mock_resp):
+        """Test unexpected camera info response."""
+        self.blink.sync['test'].cameras['foo'] = None
+        self.mock_start[5] = None
+        mock_resp.side_effect = self.mock_start
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].cameras, {'foo': None})
+
+    def test_missing_camera_info(self, mock_resp):
+        """Test missing key from camera info response."""
+        self.blink.sync['test'].cameras['foo'] = None
+        self.mock_start[5] = {}
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].cameras, {'foo': None})

tests/test_util.py

@@ -0,0 +1,100 @@
+"""Test various api functions."""
+
+import unittest
+from unittest import mock
+import time
+from blinkpy.helpers.util import Throttle
+
+
+class TestUtil(unittest.TestCase):
+    """Test the helpers/util module."""
+
+    def setUp(self):
+        """Initialize the blink module."""
+
+    def tearDown(self):
+        """Tear down blink module."""
+
+    def test_throttle(self):
+        """Test the throttle decorator."""
+        calls = []
+
+        @Throttle(seconds=5)
+        def test_throttle():
+            calls.append(1)
+
+        now = int(time.time())
+        now_plus_four = now + 4
+        now_plus_six = now + 6
+
+        test_throttle()
+        self.assertEqual(1, len(calls))
+
+        # Call again, still shouldn't fire
+        test_throttle()
+        self.assertEqual(1, len(calls))
+
+        # Call with force
+        test_throttle(force=True)
+        self.assertEqual(2, len(calls))
+
+        # Call without throttle, shouldn't fire
+        test_throttle()
+        self.assertEqual(2, len(calls))
+
+        # Fake time as 4 seconds from now
+        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):
+            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."""
+
+            def test(self):
+                """Test the throttle."""
+                return True
+
+        tester = Tester()
+        throttled = Throttle(seconds=1)(tester.test)
+        self.assertEqual(throttled(), True)
+        self.assertEqual(throttled(), None)
+
+    def test_throttle_on_two_methods(self):
+        """Test that throttle works for multiple methods."""
+        class Tester:
+            """A tester class for throttling."""
+
+            @Throttle(seconds=3)
+            def test1(self):
+                """Test function for throttle."""
+                return True
+
+            @Throttle(seconds=5)
+            def test2(self):
+                """Test function for throttle."""
+                return True
+
+        tester = Tester()
+        now = time.time()
+        now_plus_4 = now + 4
+        now_plus_6 = now + 6
+
+        self.assertEqual(tester.test1(), True)
+        self.assertEqual(tester.test2(), True)
+        self.assertEqual(tester.test1(), None)
+        self.assertEqual(tester.test2(), None)
+
+        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):
+            self.assertEqual(tester.test1(), None)
+            self.assertEqual(tester.test2(), True)