Migrate existing functions to ApiRequest class

Author: Thomas Basche

reposit/data/api.py

@@ -4,12 +4,11 @@
 import logging
 
 import requests
-import six
 
 from reposit.data.exceptions import InvalidControllerException
 from reposit.data.utils import is_valid_url
 from reposit.settings import BASE_URL
-
+from reposit.utilities import dict_iter
 
 logger = logging.getLogger(__name__)
 
@@ -29,7 +28,7 @@ def __str__(self):
         will leak the access token.
         :return:
         """
-        return self.url, self.schema
+        return '{} {}'.format(self.url, self.schema)
 
     def __init__(self, path, controller, schema, **kwargs):
         """
@@ -101,17 +100,35 @@ def _simple_format_for_fields(self, api_response):
         """
 
         data = api_response.json()
-        data_for_retrieval = []
-        schema_items = self.schema.items() if six.PY3 else self.schema.iteritems()
-        for key, _ in schema_items:
-            fetched_data = data.get(key)
-            if fetched_data:
-                data_for_retrieval.append(fetched_data)
-            del data[key]
-
-        # if its a list of only one thing then simplify it a smidge.
-        # Most routes tend to only be.
-        if len(data_for_retrieval) == 1:
-            return data_for_retrieval[0]
-
-        return data_for_retrieval
+        target_key = deepest_key(self.schema)
+        target_data = match_to_schema(data, target_key)
+        return target_data
+
+
+def deepest_key(_dict):
+    """Return the deepest key in a dict"""
+    for key, value in dict_iter(_dict):
+        if isinstance(value, dict) and bool(value):
+            return deepest_key(_dict[key])
+        return key
+
+
+def match_to_schema(_dict, requested_key):
+    """
+    Match the schema supplied with the response to return the
+    data we requested.
+    :param _dict:
+    :param requested_key:
+    :return:
+    """
+    if _dict.get(requested_key) is not None:
+        return _dict[requested_key]
+
+    for valid_key in _dict:
+        if valid_key == requested_key:
+            if not isinstance(_dict.get(valid_key), dict):
+                return _dict[valid_key]
+            else:
+                continue
+        elif valid_key != requested_key and isinstance(_dict.get(valid_key), dict):
+            return match_to_schema(_dict[valid_key], requested_key)

reposit/data/controller.py

@@ -4,7 +4,6 @@
 from __future__ import absolute_import
 
 from reposit.data.api import ApiRequest
-from reposit.data.utils import api_response, device_summary
 
 
 class Controller(object):
@@ -39,147 +38,167 @@ def battery_min_state_of_charge(self):
         Return the minimum state of charge of the battery
         :return:
         """
-        return api_response(
-            url='https://{}/v2/deployments/{}/battery/min_soc',
+        request = ApiRequest(
+            path='v2/deployments/{}/battery/min_soc'.format(self.user_key),
             controller=self,
-            field='min_soc'
+            schema={'min_soc': {}}
         )
 
+        return request.get()
+
     @property
     def has_battery(self):
         """
         If the system has a battery installed
         :return:
         """
-        return api_response(
-            url='https://{}/v2/deployments/{}/components',
+        request = ApiRequest(
+            path='v2/deployments/{}/components'.format(self.user_key),
             controller=self,
-            field='data',
-            subfield='battery',
+            schema={
+                'data': {
+                    'battery': {}
+                }
+            }
         )
+        return request.get()
 
     @property
     def has_inverter(self):
         """
         If the system has an inverter installed
         :return:
         """
-        return api_response(
-            url='https://{}/v2/deployments/{}/components',
+        request = ApiRequest(
+            path='v2/deployments/{}/components'.format(self.user_key),
             controller=self,
-            field='data',
-            subfield='inverter',
+            schema={
+                'data': {
+                    'inverter': {}
+                }
+            }
         )
+        return request.get()
 
     @property
     def latest_historical_generation(self):
         """
         Return a list of data points as lists. Time are in GMT
         :return:
         """
-
-        return api_response(
-            url='https://{}/v2/deployments/{}/generation/historical/p',
+        request = ApiRequest(
+            path='v2/deployments/{}/generation/historical/p'.format(self.user_key),
             controller=self,
-            field='solarP',
-            format_list=True
+            schema={
+                'solarP': {}
+            }
         )
+        return request.get()
 
     @property
     def latest_historical_house(self):
         """
         Return a list of data points as lists. Time are in GMT
         :return:
         """
-
-        return api_response(
-            url='https://{}/v2/deployments/{}/house/historical',
+        request = ApiRequest(
+            path='v2/deployments/{}/house/historical'.format(self.user_key),
             controller=self,
-            field='data',
-            subfield='houseP',
-            format_list=True
+            schema={
+                'data': {
+                    'houseP': {}
+                }
+            }
         )
+        return request.get()
 
     @property
     def latest_historical_grid_credits(self):
         """
         Return a list of data points as lists. Times are in GMT
         :return:
         """
-        return api_response(
-            url='https://{}/v2/deployments/{}/gridcredits/historical',
+
+        request = ApiRequest(
+            path='v2/deployments/{}/gridcredits/historical'.format(self.user_key),
             controller=self,
-            field='gridcredits',
-            format_list=True
+            schema={
+                'gridcredits': {}
+            }
         )
+        return request.get()
 
     @property
     def latest_historical_inverter(self):
         """
         Return a list of data points as lists. Times are in GMT
         :return:
         """
-        return api_response(
-            url='https://{}/v2/deployments/{}/inverter/historical/p',
+        request = ApiRequest(
+            path='v2/deployments/{}/inverter/historical/p'.format(self.user_key),
             controller=self,
-            field='inverterP',
-            format_list=True
+            schema={
+                'inverterP': {}
+            }
         )
+        return request.get()
 
     @property
     def latest_historical_meter(self):
         """
         Return a list of data points as lists. Times are in GMT
         :return:
         """
-        return api_response(
-            url='https://{}/v2/deployments/{}/meter/historical/p',
+        request = ApiRequest(
+            path='v2/deployments/{}/meter/historical/p'.format(self.user_key),
             controller=self,
-            field='meterP',
-            format_list=True
+            schema={
+                'meterP': {}
+            }
         )
-
+        return request.get()
 
     @property
     def weekday_tou_tariff(self):
         """
         Returns a list of dicts of weekday time of use tariff information
         :return:
         """
-        return api_response(
-            url='https://{}/v2/deployments/{}/tariff/tou',
+        request = ApiRequest(
+            path='v2/deployments/{}/tariff/tou'.format(self.user_key),
             controller=self,
-            field='weekday'
+            schema={
+                'weekday': {}
+            }
         )
+        return request.get()
 
     @property
     def weekend_tou_tariff(self):
         """
         Returns a list of dicts of weekend time of use tariff information
         :return:
         """
-        return api_response(
-            url='https://{}/v2/deployments/{}/tariff/tou',
+        request = ApiRequest(
+            path='v2/deployments/{}/tariff/tou'.format(self.user_key),
             controller=self,
-            field='weekend'
+            schema={
+                'weekend': {}
+            }
         )
+        return request.get()
 
     @property
     def feed_in_tariff(self):
         """
         The feed in tariff cost as a float
         :return:
         """
-        return api_response(
-            url='https://{}/v2/deployments/{}/tariff/tou',
+        request = ApiRequest(
+            path='v2/deployments/{}/tariff/tou'.format(self.user_key),
             controller=self,
-            field='fit'
+            schema={
+                'fit': {}
+            }
         )
-
-    @property
-    def summary(self):
-        """
-        Return current system information as a dict
-        :return:
-        """
-        return device_summary(self)
+        return request.get()

reposit/data/utils.py

@@ -5,13 +5,6 @@
 
 import re
 
-import arrow
-import requests
-import six
-
-from reposit.settings import BASE_URL
-
-
 # adapted from Django :)
 VALID_URL_REGEX = re.compile(
     r'^(?:http|ftp)s?://'  # http:// or https://
@@ -25,67 +18,3 @@ def is_valid_url(url):
     :return:
     """
     return bool(re.match(VALID_URL_REGEX, url))
-
-
-def api_response(url, controller, field, subfield=None, format_list=False, no_user_key=False):
-    """
-    Simple data fetch for a reposit controller
-    :param url: api url
-    :param controller: Controller instance
-    :param field: the first level field
-    :param subfield: optional second level field
-    :return:
-    """
-    subfield_check = bool(subfield)
-    if subfield == 0:  # in case some fields are actually a zero
-        subfield_check = True
-
-    if no_user_key:
-        resp = requests.get(url.format(BASE_URL), headers=controller.auth_headers)
-    else:
-        resp = requests.get(url.format(BASE_URL, controller.user_key),
-                            headers=controller.auth_headers)
-
-    resp.raise_for_status()
-    if not subfield_check and not format_list:
-        return resp.json()[field]
-
-    if format_list:
-        data = resp.json()
-        if subfield:
-            for data_point in data[field][subfield]:
-                data_point[0] = arrow.get(data_point[0]).format('HH:mm:ss DD-MM-YYYY')
-            return data[field][subfield]
-        else:
-            for data_point in data[field]:
-                data_point[0] = arrow.get(data_point[0]).format('HH:mm:ss DD-MM-YYYY')
-        return data[field]
-
-    return resp.json()[field][subfield]
-
-
-def device_summary(controller):
-    """
-    Retrieve current summary for the device
-    :param controller: Controller instance
-    :return:
-    """
-    url = '{}/v2/deployments/{}/summary/now'.format(BASE_URL, controller.user_key)
-    resp = requests.get(url, headers=controller.auth_headers)
-    resp.raise_for_status()
-    summary = format_summary_response(resp.json())
-    return summary
-
-
-def format_summary_response(data):
-    """
-    For a summary set, pull out the interesting values
-    :param data: dict of info
-    :return:
-    """
-    response = {}
-    data_items = data['data'].items() if six.PY3 else data['data'].iteritems()
-    for key, value in data_items:
-        if key in ('battery', 'grid', 'house', 'solar'):
-            response[key] = {'state': value['state'], 'value': value['val']}
-    return response

reposit/utilities/__init__.py

@@ -0,0 +1,4 @@
+"""
+Shortcut imports
+"""
+from reposit.utilities.utils import dict_iter