Requests return dict objects with body, header, code properties

Affected functions: raw_requests, requests, interpret_response,
handle_api_error. The request function still returns the same type of
object.

Author: d-sparks

clever/__init__.py

@@ -137,6 +137,11 @@ def __init__(self, message, http_body=None, http_status=None, json_body=None):
 class AuthenticationError(CleverError):
   pass
 
+class TooManyRequestsError(CleverError):
+  def __init__(self, message, res):
+    self.headers = res
+  pass
+
 
 def convert_to_clever_object(klass, resp, auth):
   # TODO: to support includes we'll have to infer klass from resp['uri']
@@ -209,11 +214,12 @@ def jsonencode(cls, d):
     return json.dumps(d)
 
   def request(self, meth, url, params={}):
-    rbody, rcode, my_auth = self.request_raw(meth, url, params)
-    resp = self.interpret_response(rbody, rcode)
+    res, my_auth = self.request_raw(meth, url, params)
+    resp = self.interpret_response(res)
     return resp, my_auth
 
-  def handle_api_error(self, rbody, rcode, resp):
+  def handle_api_error(self, res, resp):
+    rbody, header, rcode, error = res['body'], res['header'], res['code'], None
     try:
       error = resp['error']
     except (KeyError, TypeError):
@@ -224,6 +230,8 @@ def handle_api_error(self, rbody, rcode, resp):
       raise InvalidRequestError(error, rbody, rcode, resp)
     elif rcode == 401:
       raise AuthenticationError(error, rbody, rcode, resp)
+    elif rcode == 429:
+      raise TooManyRequestsError(error, res)
     else:
       raise APIError(error, rbody, rcode, resp)
 
@@ -276,17 +284,18 @@ def request_raw(self, meth, url, params={}):
       raise CleverError(
           "Clever Python library bug discovered: invalid httplib %s.  Please report to support@clever.com" % (_httplib, ))
     logger.debug('API request to %s returned (response code, response body) of (%d, %r)' %
-                 (abs_url, rcode, rbody))
-    return rbody, rcode, my_auth
+                 (abs_url, res['code'], res['body']))
+    return res, my_auth
 
-  def interpret_response(self, rbody, rcode):
+  def interpret_response(self, http_res):
+    rbody, rheader, rcode= http_res['body'], http_res['header'], http_res['code']
     try:
-      resp = json.loads(rbody)
+      resp = json.loads(rbody) if rcode != 429 else {'error': 'Too Many Requests'}
     except Exception:
       raise APIError("Invalid response body from API: %s (HTTP response code was %d)" %
                      (rbody, rcode), rbody, rcode)
     if not (200 <= rcode < 300):
-      self.handle_api_error(rbody, rcode, resp)
+      self.handle_api_error(http_res, resp)
     return resp
 
   def requests_request(self, meth, abs_url, headers, params):
@@ -328,11 +337,12 @@ def requests_request(self, meth, abs_url, headers, params):
       # are succeptible to the same and should be updated.
       content = result.content
       status_code = result.status_code
+      header = result.headers
     except Exception, e:
       # Would catch just requests.exceptions.RequestException, but can
       # also raise ValueError, RuntimeError, etc.
       self.handle_requests_error(e)
-    return content, status_code
+    return {'body': content, 'header': header, 'code': status_code}
 
   def handle_requests_error(self, e):
     if isinstance(e, requests.exceptions.RequestException):
@@ -387,9 +397,7 @@ def pycurl_request(self, meth, abs_url, headers, params):
       curl.perform()
     except pycurl.error, e:
       self.handle_pycurl_error(e)
-    rbody = s.getvalue()
-    rcode = curl.getinfo(pycurl.RESPONSE_CODE)
-    return rbody, rcode
+    return {'body': s.getvalue(), 'header': 'feature pending', 'code': curl.getinfo(pycurl.RESPONSE_CODE)}
 
   def handle_pycurl_error(self, e):
     if e[0] in [pycurl.E_COULDNT_CONNECT,
@@ -433,7 +441,7 @@ def urlfetch_request(self, meth, abs_url, headers, params):
       result = urlfetch.fetch(**args)
     except urlfetch.Error, e:
       self.handle_urlfetch_error(e, abs_url)
-    return result.content, result.status_code
+    return {'body': result.content, 'header': result.headers, 'code': result.status_code}
 
   def handle_urlfetch_error(self, e, abs_url):
     if isinstance(e, urlfetch.InvalidURLError):
@@ -472,12 +480,13 @@ def urllib2_request(self, meth, abs_url, headers, params):
       response = urllib2.urlopen(req)
       rbody = response.read()
       rcode = response.code
+      rheader = 'feature pending'
     except urllib2.HTTPError, e:
       rcode = e.code
       rbody = e.read()
     except (urllib2.URLError, ValueError), e:
       self.handle_urllib2_error(e, abs_url)
-    return rbody, rcode
+    return {'body': rbody, 'header': rheader, 'code': rcode}
 
   def handle_urllib2_error(self, e, abs_url):
     msg = "Unexpected error communicating with Clever.  If this problem persists, let us know at support@clever.com."