Merge pull request #154 from fronzbot/dev

0.12.1

.travis.yml

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

CHANGES.rst

@@ -3,35 +3,6 @@ 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

README.rst

@@ -2,10 +2,6 @@ blinkpy |Build Status| |Coverage Status| |Docs| |PyPi Version| |Python Version|
 ================================================================================
 A Python library for the Blink Camera system
 
-Like the library? Consider buying me a cup of coffee!
-
-|Donate|
-
 Disclaimer:
 ~~~~~~~~~~~~~~~
 Published under the MIT license - See LICENSE file for more details.
@@ -110,6 +106,3 @@ Example usage, which downloads all videos recorded since July 4th, 2018 at 9:34a
    :target: http://blinkpy.readthedocs.io/en/latest/?badge=latest
 .. |Python Version| image:: https://img.shields.io/pypi/pyversions/blinkpy.svg
    :target: https://img.shields.io/pypi/pyversions/blinkpy.svg
-   
-.. |Donate| image:: https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif
-   :target: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=UR6Z2B8GXYUCC

blinkpy/api.py

@@ -3,13 +3,11 @@
 import logging
 from json import dumps
 import blinkpy.helpers.errors as ERROR
-from blinkpy.helpers.util import http_req, get_time, BlinkException, Throttle
+from blinkpy.helpers.util import http_req, get_time, BlinkException
 from blinkpy.helpers.constants import DEFAULT_URL
 
 _LOGGER = logging.getLogger(__name__)
 
-MIN_THROTTLE_TIME = 2
-
 
 def request_login(blink, url, username, password, is_retry=False):
     """
@@ -62,7 +60,6 @@ def request_syncmodule(blink, network):
     return http_get(blink, url)
 
 
-@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_system_arm(blink, network):
     """
     Arm system.
@@ -74,7 +71,6 @@ def request_system_arm(blink, network):
     return http_post(blink, url)
 
 
-@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_system_disarm(blink, network):
     """
     Disarm system.
@@ -100,15 +96,12 @@ def request_command_status(blink, network, command_id):
     return http_get(blink, url)
 
 
-@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_homescreen(blink):
     """Request homescreen info."""
-    url = "{}/api/v3/accounts/{}/homescreen".format(blink.urls.base_url,
-                                                    blink.account_id)
+    url = "{}/homescreen".format(blink.urls.base_url)
     return http_get(blink, url)
 
 
-@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_sync_events(blink, network):
     """
     Request events from sync module.
@@ -120,7 +113,6 @@ def request_sync_events(blink, 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.
@@ -135,7 +127,6 @@ def request_new_image(blink, 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.
@@ -150,7 +141,6 @@ def request_new_video(blink, network, camera_id):
     return http_post(blink, url)
 
 
-@Throttle(seconds=MIN_THROTTLE_TIME)
 def request_video_count(blink):
     """Request total video count."""
     url = "{}/api/v2/videos/count".format(blink.urls.base_url)
@@ -166,8 +156,8 @@ def request_videos(blink, time=None, page=0):
     :param page: Page number to get videos from.
     """
     timestamp = get_time(time)
-    url = "{}/api/v1/accounts/{}/media/changed?since={}&page={}".format(
-        blink.urls.base_url, blink.account_id, timestamp, page)
+    url = "{}/api/v2/videos/changed?since={}&page={}".format(
+        blink.urls.base_url, timestamp, page)
     return http_get(blink, url)
 
 
@@ -190,9 +180,9 @@ def request_camera_info(blink, network, camera_id):
     :param network: Sync module network id.
     :param camera_id: Camera ID of camera to request info from.
     """
-    url = "{}/network/{}/camera/{}/config".format(blink.urls.base_url,
-                                                  network,
-                                                  camera_id)
+    url = "{}/network/{}/camera/{}".format(blink.urls.base_url,
+                                           network,
+                                           camera_id)
     return http_get(blink, url)
 
 
@@ -210,7 +200,6 @@ def request_camera_sensors(blink, 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.
@@ -225,7 +214,6 @@ def request_motion_detection_enable(blink, 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.
 

blinkpy/blinkpy.py

@@ -21,19 +21,18 @@ from shutil import copyfileobj
 
 from requests.structures import CaseInsensitiveDict
 from dateutil.parser import parse
-from slugify import slugify
 
 from blinkpy import api
 from blinkpy.sync_module import BlinkSyncModule
 from blinkpy.helpers import errors as ERROR
 from blinkpy.helpers.util import (
     create_session, merge_dicts, get_time, BlinkURLHandler,
-    BlinkAuthenticationException, Throttle)
+    BlinkAuthenticationException)
 from blinkpy.helpers.constants import (
-    BLINK_URL, LOGIN_URL, OLD_LOGIN_URL, LOGIN_BACKUP_URL,
-    DEFAULT_MOTION_INTERVAL, DEFAULT_REFRESH, MIN_THROTTLE_TIME)
+    BLINK_URL, LOGIN_URL, LOGIN_BACKUP_URL)
 from blinkpy.helpers.constants import __version__
 
+REFRESH_RATE = 30
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -42,9 +41,7 @@ class Blink():
     """Class to initialize communication."""
 
     def __init__(self, username=None, password=None,
-                 refresh_rate=DEFAULT_REFRESH,
-                 motion_interval=DEFAULT_MOTION_INTERVAL,
-                 legacy_subdomain=False):
+                 refresh_rate=REFRESH_RATE):
         """
         Initialize Blink system.
 
@@ -52,13 +49,6 @@ class Blink():
         :param password: Blink password
         :param refresh_rate: Refresh rate of blink information.
                              Defaults to 15 (seconds)
-        :param motion_interval: How far back to register motion in minutes.
-                             Defaults to last refresh time.
-                             Useful for preventing motion_detected property
-                             from de-asserting too quickly.
-        :param legacy_subdomain: Set to TRUE to use old 'rest.region'
-                             endpoints (only use if you are having
-                             api issues).
         """
         self._username = username
         self._password = password
@@ -78,9 +68,7 @@ class Blink():
         self.cameras = CaseInsensitiveDict({})
         self.video_list = CaseInsensitiveDict({})
         self._login_url = LOGIN_URL
-        self.motion_interval = DEFAULT_MOTION_INTERVAL
         self.version = __version__
-        self.legacy = legacy_subdomain
 
     @property
     def auth_header(self):
@@ -100,16 +88,9 @@ class Blink():
         elif not self.get_auth_token():
             return
 
-        camera_list = self.get_cameras()
         networks = self.get_ids()
         for network_name, network_id in networks.items():
-            if network_id not in camera_list.keys():
-                camera_list[network_id] = {}
-                _LOGGER.warning("No cameras found for %s", network_name)
-            sync_module = BlinkSyncModule(self,
-                                          network_name,
-                                          network_id,
-                                          camera_list[network_id])
+            sync_module = BlinkSyncModule(self, network_name, network_id)
             sync_module.start()
             self.sync[network_name] = sync_module
         self.cameras = self.merge_cameras()
@@ -131,33 +112,7 @@ class Blink():
         if not isinstance(self._password, str):
             raise BlinkAuthenticationException(ERROR.PASSWORD)
 
-        login_urls = [LOGIN_URL, OLD_LOGIN_URL, LOGIN_BACKUP_URL]
-
-        response = self.login_request(login_urls, is_retry=is_retry)
-
-        if not response:
-            return False
-
-        self._host = "{}.{}".format(self.region_id, BLINK_URL)
-        self._token = response['authtoken']['authtoken']
-        self.networks = response['networks']
-
-        self._auth_header = {'Host': self._host,
-                             'TOKEN_AUTH': self._token}
-        self.urls = BlinkURLHandler(self.region_id, legacy=self.legacy)
-
-        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)
-
+        login_url = LOGIN_URL
         response = api.request_login(self,
                                      login_url,
                                      self._username,
@@ -165,23 +120,36 @@ class Blink():
                                      is_retry=is_retry)
         try:
             if response.status_code != 200:
-                response = self.login_request(login_urls)
+                _LOGGER.debug("Received response code %s during login.",
+                              response.status_code)
+                login_url = LOGIN_BACKUP_URL
+                response = api.request_login(self,
+                                             login_url,
+                                             self._username,
+                                             self._password,
+                                             is_retry=is_retry)
             response = response.json()
             (self.region_id, self.region), = response['region'].items()
-
         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._host = "{}.{}".format(self.region_id, BLINK_URL)
+        self._token = response['authtoken']['authtoken']
+        self.networks = response['networks']
+
+        self._auth_header = {'Host': self._host,
+                             'TOKEN_AUTH': self._token}
+        self.urls = BlinkURLHandler(self.region_id)
         self._login_url = login_url
-        return response
+
+        return self._auth_header
 
     def get_ids(self):
         """Set the network ID and Account ID."""
@@ -202,26 +170,6 @@ 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.
@@ -235,8 +183,6 @@ class Blink():
             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."""
@@ -255,8 +201,7 @@ class Blink():
             combined = merge_dicts(combined, self.sync[sync].cameras)
         return combined
 
-    def download_videos(self, path, since=None,
-                        camera='all', stop=10, debug=False):
+    def download_videos(self, path, since=None, camera='all', stop=10):
         """
         Download all videos from server since specified time.
 
@@ -267,8 +212,6 @@ class Blink():
         :param camera: Camera name to retrieve.  Defaults to "all".
                        Use a list for multiple cameras.
         :param stop: Page to stop on (~25 items per page. Default page 10).
-        :param debug: Set to TRUE to prevent downloading of items.
-                      Instead of downloading, entries will be printed to log.
         """
         if since is None:
             since_epochs = self.last_refresh
@@ -286,23 +229,23 @@ class Blink():
             response = api.request_videos(self, time=since_epochs, page=page)
             _LOGGER.debug("Processing page %s", page)
             try:
-                result = response['media']
+                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, debug)
+            self._parse_downloaded_items(result, camera, path)
 
-    def _parse_downloaded_items(self, result, camera, path, debug):
+    def _parse_downloaded_items(self, result, camera, path):
         """Parse downloaded videos."""
         for item in result:
             try:
                 created_at = item['created_at']
-                camera_name = item['device_name']
+                camera_name = item['camera_name']
                 is_deleted = item['deleted']
-                address = item['media']
+                address = item['address']
             except KeyError:
                 _LOGGER.info("Missing clip information, skipping...")
                 continue
@@ -318,22 +261,16 @@ class Blink():
                 continue
 
             clip_address = "{}{}".format(self.urls.base_url, address)
-            filename = "{}-{}".format(camera_name, created_at)
-            filename = "{}.mp4".format(slugify(filename))
+            filename = "{}_{}.mp4".format(camera_name, created_at)
             filename = os.path.join(path, filename)
 
-            if not debug:
-                if os.path.isfile(filename):
-                    _LOGGER.info("%s already exists, skipping...", filename)
-                    continue
+            if os.path.isfile(filename):
+                _LOGGER.info("%s already exists, skipping...", filename)
+                continue
 
-                response = api.http_get(self, url=clip_address,
-                                        stream=True, json=False)
-                with open(filename, 'wb') as vidfile:
-                    copyfileobj(response.raw, vidfile)
+            response = api.http_get(self, url=clip_address,
+                                    stream=True, json=False)
+            with open(filename, 'wb') as vidfile:
+                copyfileobj(response.raw, vidfile)
 
-                _LOGGER.info("Downloaded video to %s", filename)
-            else:
-                print(("Camera: {}, Timestamp: {}, "
-                       "Address: {}, Filename: {}").format(
-                           camera_name, created_at, address, filename))
+            _LOGGER.info("Downloaded video to %s", filename)

blinkpy/camera.py

@@ -41,7 +41,6 @@ class BlinkCamera():
             'temperature_c': self.temperature_c,
             'temperature_calibrated': self.temperature_calibrated,
             'battery': self.battery,
-            'battery_voltage': self.battery_voltage,
             'thumbnail': self.thumbnail,
             'video': self.clip,
             'motion_enabled': self.motion_enabled,
@@ -55,8 +54,8 @@ class BlinkCamera():
 
     @property
     def battery(self):
-        """Return battery as string."""
-        return self.battery_state
+        """Return battery level as percentage."""
+        return round(self.battery_voltage / 180 * 100)
 
     @property
     def temperature_c(self):
@@ -93,11 +92,10 @@ class BlinkCamera():
                                                     self.network_id,
                                                     self.camera_id)
 
-    def update(self, config, force_cache=False, **kwargs):
+    def update(self, config, force_cache=False):
         """Update camera info."""
-        # force = kwargs.pop('force', False)
         self.name = config['name']
-        self.camera_id = str(config['id'])
+        self.camera_id = str(config['camera_id'])
         self.network_id = str(config['network_id'])
         self.serial = config['serial']
         self.motion_enabled = config['enabled']

blinkpy/helpers/constants.py

@@ -3,8 +3,8 @@
 import os
 
 MAJOR_VERSION = 0
-MINOR_VERSION = 14
-PATCH_VERSION = '0.dev2'
+MINOR_VERSION = 12
+PATCH_VERSION = 1
 
 __version__ = '{}.{}.{}'.format(MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION)
 
@@ -47,8 +47,7 @@ URLS
 BLINK_URL = 'immedia-semi.com'
 DEFAULT_URL = "{}.{}".format('prod', BLINK_URL)
 BASE_URL = "https://{}".format(DEFAULT_URL)
-LOGIN_URL = "{}/api/v2/login".format(BASE_URL)
-OLD_LOGIN_URL = "{}/login".format(BASE_URL)
+LOGIN_URL = "{}/login".format(BASE_URL)
 LOGIN_BACKUP_URL = "https://{}.{}/login".format('rest.piri', BLINK_URL)
 
 '''
@@ -60,7 +59,3 @@ ONLINE = {'online': True, 'offline': False}
 OTHER
 '''
 TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%S%Z'
-
-DEFAULT_MOTION_INTERVAL = 1
-DEFAULT_REFRESH = 30
-MIN_THROTTLE_TIME = 2

blinkpy/helpers/util.py

@@ -2,7 +2,6 @@
 
 import logging
 import time
-from functools import wraps
 from requests import Request, Session, exceptions
 from blinkpy.helpers.constants import BLINK_URL, TIMESTAMP_FORMAT
 import blinkpy.helpers.errors as ERROR
@@ -15,7 +14,7 @@ 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.gmtime(time_to_convert))
+    return time.strftime(TIMESTAMP_FORMAT, time.localtime(time_to_convert))
 
 
 def merge_dicts(dict_a, dict_b):
@@ -107,49 +106,18 @@ class BlinkException(Exception):
 class BlinkAuthenticationException(BlinkException):
     """Class to throw authentication exception."""
 
+    pass
+
 
 class BlinkURLHandler():
     """Class that handles Blink URLS."""
 
-    def __init__(self, region_id, legacy=False):
+    def __init__(self, region_id):
         """Initialize the urls."""
-        self.subdomain = 'rest-{}'.format(region_id)
-        if legacy:
-            self.subdomain = 'rest.{}'.format(region_id)
-        self.base_url = "https://{}.{}".format(self.subdomain, BLINK_URL)
+        self.base_url = "https://rest.{}.{}".format(region_id, BLINK_URL)
         self.home_url = "{}/homescreen".format(self.base_url)
         self.event_url = "{}/events/network".format(self.base_url)
         self.network_url = "{}/network".format(self.base_url)
         self.networks_url = "{}/networks".format(self.base_url)
         self.video_url = "{}/api/v2/videos".format(self.base_url)
         _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, camera_list):
+    def __init__(self, blink, network_name, network_id):
         """
         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.events = []
         self.cameras = CaseInsensitiveDict({})
-        self.motion_interval = blink.motion_interval
         self.motion = {}
         self.last_record = {}
-        self.camera_list = camera_list
 
     @property
     def attributes(self):
@@ -65,10 +64,7 @@ class BlinkSyncModule():
     @property
     def arm(self):
         """Return status of sync module: armed/disarmed."""
-        try:
-            return self.network_info['network']['armed']
-        except (KeyError, TypeError):
-            return None
+        return self.network_info['network']['armed']
 
     @arm.setter
     def arm(self, value):
@@ -80,8 +76,7 @@ class BlinkSyncModule():
 
     def start(self):
         """Initialize the system."""
-        response = api.request_syncmodule(self.blink,
-                                          self.network_id)
+        response = api.request_syncmodule(self.blink, self.network_id)
         try:
             self.summary = response['syncmodule']
             self.network_id = self.summary['network_id']
@@ -99,35 +94,24 @@ class BlinkSyncModule():
                           response,
                           exc_info=True)
 
+        self.events = self.get_events()
+        self.homescreen = api.request_homescreen(self.blink)
         self.network_info = api.request_network_status(self.blink,
                                                        self.network_id)
 
         self.check_new_videos()
-        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
+        camera_info = self.get_camera_info()
+        for camera_config in camera_info:
+            name = camera_config['name']
+            self.cameras[name] = BlinkCamera(self)
+            self.motion[name] = False
+            self.cameras[name].update(camera_config, force_cache=True)
 
         return True
 
-    def get_events(self, **kwargs):
+    def get_events(self):
         """Retrieve events from server."""
-        force = kwargs.pop('force', False)
-        response = api.request_sync_events(self.blink,
-                                           self.network_id,
-                                           force=force)
+        response = api.request_sync_events(self.blink, self.network_id)
         try:
             return response['event']
         except (TypeError, KeyError):
@@ -136,13 +120,11 @@ class BlinkSyncModule():
                           exc_info=True)
             return False
 
-    def get_camera_info(self, camera_id):
+    def get_camera_info(self):
         """Retrieve camera information."""
-        response = api.request_camera_info(self.blink,
-                                           self.network_id,
-                                           camera_id)
+        response = api.request_cameras(self.blink, self.network_id)
         try:
-            return response['camera'][0]
+            return response['devicestatus']
         except (TypeError, KeyError):
             _LOGGER.error("Could not extract camera info: %s",
                           response,
@@ -151,41 +133,35 @@ class BlinkSyncModule():
 
     def refresh(self, force_cache=False):
         """Get all blink cameras and pulls their most recent status."""
+        self.events = self.get_events()
+        self.homescreen = api.request_homescreen(self.blink)
         self.network_info = api.request_network_status(self.blink,
                                                        self.network_id)
+        camera_info = self.get_camera_info()
         self.check_new_videos()
-        for camera_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)
+        for camera_config in camera_info:
+            name = camera_config['name']
+            self.cameras[name].update(camera_config, force_cache=force_cache)
 
     def check_new_videos(self):
         """Check if new videos since last refresh."""
-        try:
-            interval = self.blink.last_refresh - self.motion_interval*60
-        except TypeError:
-            # This is the first start, so refresh hasn't happened yet.
-            # No need to check for motion.
-            return False
-
         resp = api.request_videos(self.blink,
-                                  time=interval,
-                                  page=1)
+                                  time=self.blink.last_refresh,
+                                  page=0)
 
         for camera in self.cameras.keys():
             self.motion[camera] = False
 
         try:
-            info = resp['media']
+            info = resp['videos']
         except (KeyError, TypeError):
             _LOGGER.warning("Could not check for motion. Response: %s", resp)
             return False
 
         for entry in info:
             try:
-                name = entry['device_name']
-                clip = entry['media']
+                name = entry['camera_name']
+                clip = entry['address']
                 timestamp = entry['created_at']
                 self.motion[name] = True
                 self.last_record[name] = {'clip': clip, 'time': timestamp}

pylintrc

@@ -8,8 +8,6 @@ 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,
@@ -25,5 +23,3 @@ disable=
   too-many-lines,
   too-few-public-methods,
   no-else-return,
-  no-self-use,
-  unexpected-keyword-arg,

requirements.txt

@@ -1,4 +1,3 @@
 python-dateutil==2.7.5
 requests>=2.20.0
-python-slugify==3.0.2
 testtools==2.3.0

requirements_test.txt

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

tests/mock_responses.py

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

tests/test_blink_functions.py

@@ -2,6 +2,7 @@
 import unittest
 from unittest import mock
 import logging
+from requests import Request
 
 from blinkpy import blinkpy
 from blinkpy.sync_module import BlinkSyncModule
@@ -55,39 +56,31 @@ class TestBlinkFunctions(unittest.TestCase):
         """Clean up after test."""
         self.blink = None
 
-    @mock.patch('blinkpy.blinkpy.api.request_login')
+    @mock.patch('blinkpy.blinkpy.api.http_req')
     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 = [
-            bad_req,
-            bad_req,
+            mresp.mocked_session_send(fake_req),
             new_req
         ]
-        self.blink.login_request(['test1', 'test2', 'test3'])
+        self.blink.get_auth_token()
+        self.assertEqual(self.blink.region_id, 'piri')
+        self.assertEqual(self.blink.region, 'UNKNOWN')
         # pylint: disable=protected-access
-        self.assertEqual(self.blink._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')
+        self.assertEqual(self.blink._token, 'foobar123')
 
     def test_merge_cameras(self, mock_sess):
         """Test merge camera functionality."""
         first_dict = {'foo': 'bar', 'test': 123}
         next_dict = {'foobar': 456, 'bar': 'foo'}
-        self.blink.sync['foo'] = BlinkSyncModule(self.blink, 'foo', 1, [])
-        self.blink.sync['bar'] = BlinkSyncModule(self.blink, 'bar', 2, [])
+        self.blink.sync['foo'] = 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()
@@ -121,12 +114,12 @@ class TestBlinkFunctions(unittest.TestCase):
         blinkpy._LOGGER.setLevel(logging.DEBUG)
         generic_entry = {
             'created_at': '1970',
-            'device_name': 'foo',
+            'camera_name': 'foo',
             'deleted': True,
-            'media': '/bar.mp4'
+            'address': '/bar.mp4'
         }
         result = [generic_entry]
-        mock_req.return_value = {'media': result}
+        mock_req.return_value = {'videos': result}
         blink.last_refresh = 0
         formatted_date = get_time(blink.last_refresh)
         expected_log = [
@@ -147,12 +140,12 @@ class TestBlinkFunctions(unittest.TestCase):
         blinkpy._LOGGER.setLevel(logging.DEBUG)
         generic_entry = {
             'created_at': '1970',
-            'device_name': 'foo',
+            'camera_name': 'foo',
             'deleted': True,
-            'media': '/bar.mp4'
+            'address': '/bar.mp4'
         }
         result = [generic_entry]
-        mock_req.return_value = {'media': result}
+        mock_req.return_value = {'videos': result}
         blink.last_refresh = 0
         formatted_date = get_time(blink.last_refresh)
         expected_log = [

tests/test_blinkpy.py

@@ -31,10 +31,7 @@ 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()
 
@@ -163,23 +160,3 @@ class TestBlinkSetup(unittest.TestCase):
         """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

@@ -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
@@ -59,7 +59,7 @@ class TestBlinkCameraSetup(unittest.TestCase):
         """Test that we can properly update camera properties."""
         config = {
             'name': 'new',
-            'id': 1234,
+            'camera_id': 1234,
             'network_id': 5678,
             'serial': '12345678',
             'enabled': False,
@@ -87,15 +87,15 @@ class TestBlinkCameraSetup(unittest.TestCase):
         self.assertEqual(self.camera.network_id, '5678')
         self.assertEqual(self.camera.serial, '12345678')
         self.assertEqual(self.camera.motion_enabled, False)
-        self.assertEqual(self.camera.battery, 'ok')
+        self.assertEqual(self.camera.battery, 50)
         self.assertEqual(self.camera.temperature, 68)
         self.assertEqual(self.camera.temperature_c, 20)
         self.assertEqual(self.camera.temperature_calibrated, 71)
         self.assertEqual(self.camera.wifi_strength, 4)
         self.assertEqual(self.camera.thumbnail,
-                         'https://rest-test.immedia-semi.com/thumb.jpg')
+                         'https://rest.test.immedia-semi.com/thumb.jpg')
         self.assertEqual(self.camera.clip,
-                         'https://rest-test.immedia-semi.com/test.mp4')
+                         'https://rest.test.immedia-semi.com/test.mp4')
         self.assertEqual(self.camera.image_from_cache, 'test')
         self.assertEqual(self.camera.video_from_cache, 'foobar')
 
@@ -115,7 +115,7 @@ class TestBlinkCameraSetup(unittest.TestCase):
         }
         config = {
             'name': 'new',
-            'id': 1234,
+            'camera_id': 1234,
             'network_id': 5678,
             'serial': '12345678',
             'enabled': False,
@@ -136,7 +136,7 @@ class TestBlinkCameraSetup(unittest.TestCase):
         }
         self.camera.update(config)
         self.assertEqual(self.camera.thumbnail,
-                         'https://rest-test.immedia-semi.com/new/thumb.jpg')
+                         'https://rest.test.immedia-semi.com/new/thumb.jpg')
 
     def test_no_thumbnails(self, mock_sess):
         """Tests that thumbnail is 'None' if none found."""
@@ -144,7 +144,7 @@ class TestBlinkCameraSetup(unittest.TestCase):
         self.camera.last_record = ['1']
         config = {
             'name': 'new',
-            'id': 1234,
+            'camera_id': 1234,
             'network_id': 5678,
             'serial': '12345678',
             'enabled': False,
@@ -159,7 +159,7 @@ class TestBlinkCameraSetup(unittest.TestCase):
         }
         self.assertEqual(self.camera.temperature_calibrated, None)
         with self.assertLogs() as logrecord:
-            self.camera.update(config, force=True)
+            self.camera.update(config)
         self.assertEqual(self.camera.thumbnail, None)
         self.assertEqual(self.camera.last_record, ['1'])
         self.assertEqual(self.camera.temperature_calibrated, 68)
@@ -176,7 +176,7 @@ class TestBlinkCameraSetup(unittest.TestCase):
         mock_sess.return_value = 'foobar'
         config = {
             'name': 'new',
-            'id': 1234,
+            'camera_id': 1234,
             'network_id': 5678,
             'serial': '12345678',
             'enabled': False,

tests/test_sync_module.py

@@ -17,19 +17,14 @@ class TestBlinkSyncModule(unittest.TestCase):
     def setUp(self):
         """Set up Blink module."""
         self.blink = blinkpy.Blink(username=USERNAME,
-                                   password=PASSWORD,
-                                   motion_interval=0)
+                                   password=PASSWORD)
         # pylint: disable=protected-access
         self.blink._auth_header = {
             'Host': 'test.url.tld',
             'TOKEN_AUTH': 'foobar123'
         }
-        self.blink.last_refresh = 0
         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)
         self.mock_start = [
             {'syncmodule': {
@@ -57,22 +52,15 @@ class TestBlinkSyncModule(unittest.TestCase):
 
     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_startup(self, mock_resp):
-        """Test that check_new_videos does not block startup."""
-        sync_module = self.blink.sync['test']
-        self.blink.last_refresh = None
-        self.assertFalse(sync_module.check_new_videos())
+        mock_resp.return_value = {'devicestatus': True}
+        self.assertEqual(self.blink.sync['test'].get_camera_info(), True)
 
     def test_check_new_videos(self, mock_resp):
         """Test recent video response."""
         mock_resp.return_value = {
-            'media': [{
-                'device_name': 'foo',
-                'media': '/foo/bar.mp4',
+            'videos': [{
+                'camera_name': 'foo',
+                'address': '/foo/bar.mp4',
                 'created_at': '1970-01-01T00:00:00+0:00'
             }]
         }
@@ -84,7 +72,7 @@ class TestBlinkSyncModule(unittest.TestCase):
                          {'clip': '/foo/bar.mp4',
                           'time': '1970-01-01T00:00:00+0:00'})
         self.assertEqual(sync_module.motion, {'foo': True})
-        mock_resp.return_value = {'media': []}
+        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'],
@@ -138,6 +126,20 @@ class TestBlinkSyncModule(unittest.TestCase):
         self.blink.sync['test'].start()
         self.assertEqual(self.blink.sync['test'].network_id, 8675309)
 
+    def test_unexpected_events(self, mock_resp):
+        """Test unexpected events response."""
+        self.mock_start[1] = None
+        mock_resp.side_effect = self.mock_start
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].events, False)
+
+    def test_missing_events(self, mock_resp):
+        """Test missing events key from response."""
+        self.mock_start[1] = {}
+        mock_resp.side_effect = self.mock_start
+        self.blink.sync['test'].start()
+        self.assertEqual(self.blink.sync['test'].events, False)
+
     def test_unexpected_camera_info(self, mock_resp):
         """Test unexpected camera info response."""
         self.blink.sync['test'].cameras['foo'] = None

tests/test_util.py

@@ -1,107 +0,0 @@
-"""Test various api functions."""
-
-import unittest
-from unittest import mock
-import time
-from blinkpy.helpers.util import Throttle, BlinkURLHandler
-
-
-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)
-
-    def test_legacy_subdomains(self):
-        """Test that subdomain can be set to legacy mode."""
-        urls = BlinkURLHandler('test')
-        self.assertEqual(urls.subdomain, 'rest-test')
-        urls = BlinkURLHandler('test', legacy=True)
-        self.assertEqual(urls.subdomain, 'rest.test')