Merge pull request #9 from sendgrid/fully-fluent

Fully fluent

Author: thinkingserious

CHANGELOG.md

@@ -2,6 +2,13 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.2.3] - 2016-3-01
+### Added
+- Can now reuse part of the chaining construction for multiple urls/requests
+- Thanks to [Kevin Gillette](https://github.com/extemporalgenome)!
+- Update of request headers simplified
+- Thanks to [Matt Bernier](https://github.com/mbernier)
+
 ## [1.1.3] - 2016-02-29
 ### Fixed
 - Various standardizations for commenting, syntax, pylint

examples/example.py

@@ -10,62 +10,62 @@
 local_path = '{0}/..'.format(os.path.abspath(os.path.dirname(__file__)))
 Config(local_path)
 api_key = os.environ.get('SENDGRID_API_KEY')
-request_headers = {
+headers = {
     "Authorization": 'Bearer {0}'.format(api_key),
     "Content-Type": "application/json"
 }
 client = Client(host=os.environ.get('MOCK_HOST'),
-                request_headers=request_headers,
+                request_headers=headers,
                 version=3)
 
 response = client.version(3).api_keys.get()
 print(response.response_headers)
 print(response.status_code)
 print(response.response_body)
 
-request_headers = {
+headers = {
     'X-Mock': 200
 }
-query_params = {'limit': 100}
-response = client.api_keys.get(query_params=query_params,
-                               request_headers=request_headers)
+params = {'limit': 100}
+response = client.api_keys.get(query_params=params,
+                               request_headers=headers)
 print('\nGET Mocked Example')
 print(response.response_headers)
 print(response.status_code)
 print(response.response_body)
 
 data = {'sample': 'data'}
-request_headers = {'X-Mock': 201}
+headers = {'X-Mock': 201}
 response = client.api_keys.post(request_body=data,
-                                request_headers=request_headers)
+                                request_headers=headers)
 print('\nPOST Mocked Example')
 print(response.response_headers)
 print(response.status_code)
 print(response.response_body)
 
 data = {'sample': 'data'}
-request_headers = {'X-Mock': 200}
+headers = {'X-Mock': 200}
 api_key_id = 'test_url_param'
 response = client.api_keys._(api_key_id).put(request_body=data,
-                                             request_headers=request_headers)
+                                             request_headers=headers)
 print('\nPUT Mocked Example')
 print(response.response_headers)
 print(response.status_code)
 print(response.response_body)
 
 data = {'sample': 'data'}
-request_headers = {'X-Mock': 200}
+headers = {'X-Mock': 200}
 api_key_id = 'test_url_param'
 response = client.api_keys._(api_key_id).patch(request_body=data,
-                                               request_headers=request_headers)
+                                               request_headers=headers)
 print('\nPATCH Mocked Example')
 print(response.response_headers)
 print(response.status_code)
 print(response.response_body)
 
-request_headers = {'X-Mock': 204}
+headers = {'X-Mock': 204}
 api_key_id = 'test_url_param'
-response = client.api_keys._(api_key_id).delete(request_headers=request_headers)
+response = client.api_keys._(api_key_id).delete(request_headers=headers)
 print('\nDELETE Mocked Example')
 print(response.response_headers)
 print(response.status_code)

examples/live_sendgrid_example.py

@@ -7,7 +7,7 @@
 host = os.environ.get('HOST')  # http://api.sendgrid.com
 api_key = os.environ.get('SENDGRID_API_KEY')
 request_headers = {
-    "Authorization": 'Bearer {0}'.format(api_key), 
+    "Authorization": 'Bearer {0}'.format(api_key),
     "Content-Type": "application/json"
 }
 version = 3  # we could also use client.version(3)

python_http_client/__init__.py

@@ -1,2 +1,2 @@
 from .client import Client
-from .config import Config
+from .config import Config

python_http_client/client.py

@@ -12,12 +12,47 @@
     from urllib import urlencode
 
 
+class Response(object):
+    """Holds the response from an API call."""
+    def __init__(self, response):
+        """
+        :param response: The return value from a open call
+                         on a urllib.build_opener()
+        :type response:  urllib response object
+        """
+        self._status_code = response.getcode()
+        self._response_body = response.read()
+        self._response_headers = response.info()
+
+    @property
+    def status_code(self):
+        """
+        :return: integer, status code of API call
+        """
+        return self._status_code
+
+    @property
+    def response_body(self):
+        """
+        :return: response from the API
+        """
+        return self._response_body
+
+    @property
+    def response_headers(self):
+        """
+        :return: dict of response headers
+        """
+        return self._response_headers
+
+
 class Client(object):
     """Quickly and easily access any REST or REST-like API."""
     def __init__(self,
                  host,
                  request_headers=None,
-                 version=None):
+                 version=None,
+                 url_path=None):
         """
         :param host: Base URL for the api. (e.g. https://api.sendgrid.com)
         :type host:  string
@@ -28,43 +63,25 @@ def __init__(self,
                         Subclass _build_versioned_url for custom behavior.
                         Or just pass the version as part of the URL
                         (e.g. client._("/v3"))
-        :type integer:
+        :type version: integer
+        :param url_path: A list of the url path segments
+        :type url_path: list of strings
         """
         self.host = host
-        self.request_headers = request_headers
+        self.request_headers = request_headers or {}
+        self._version = version
+        # _url_path keeps track of the dynamically built url
+        self._url_path = url_path or []
         # These are the supported HTTP verbs
         self.methods = ['delete', 'get', 'patch', 'post', 'put']
-        self._version = version
-        # _count and _url_path keep track of the dynamically built url
-        self._count = 0
-        self._url_path = {}
-        self._status_code = None
-        self._response_body = None
-        self._response_headers = None
-        self._response = None
-
-    def _reset(self):
-        """Resets the URL builder, so you can make a fresh new dynamic call."""
-        self._count = 0
-        self._url_path = {}
-        self._response = None
-
-    def _add_to_url_path(self, name):
-        """Takes the method chained call and adds to the url path.
-
-           :param name: The name of the method call
-           :type name: string
-        """
-        self._url_path[self._count] = name
-        self._count += 1
 
     def _build_versioned_url(self, url):
         """Subclass this function for your own needs.
            Or just pass the version as part of the URL
            (e.g. client._('/v3'))
         :param url: URI portion of the full URL being requested
         :type url: string
-        :return:
+        :return: string
         """
         return '{0}/v{1}{2}'.format(self.host, str(self._version), url)
 
@@ -73,7 +90,7 @@ def _build_url(self, query_params):
 
         :param query_params: A dictionary of all the query parameters
         :type query_params: dictionary
-        :return:
+        :return: string
         """
         url = ''
         count = 0
@@ -83,33 +100,30 @@ def _build_url(self, query_params):
         if query_params:
             url_values = urlencode(sorted(query_params.items()))
             url = '{0}?{1}'.format(url, url_values)
-        if self._version:
-            url = self._build_versioned_url(url)
-        else:
-            url = self.host + url
+        url = self._build_versioned_url(url) if self._version else self.host + url
         return url
 
-    def _set_response(self, response):
-        """Build the API call's response
+    def _update_headers(self, request_headers):
+        """Update the headers for the request
 
-        :param response: The response object from the API call from urllib
-        :type response: urllib.Request object
+        :param request_headers: headers to set for the API call
+        :type response: dictionary
+        :return: dictionary
         """
-        self._status_code = response.getcode()
-        self._response_body = response.read()
-        self._response_headers = response.info()
+        self.request_headers.update(request_headers)
 
-    def _set_headers(self, request_headers):
-        """Build the headers for the request
+    def _build_client(self, name=None):
+        """Make a new Client object
 
-        :param request_headers: headers to set for the API call
-        :type response: dict
-        :return:
+        :param name: Name of the url segment
+        :type name: string
+        :return: A Client object
         """
-        if self.request_headers:
-            self.request_headers.update(request_headers)
-        else:
-            self.request_headers = request_headers
+        url_path = self._url_path+[name] if name else self._url_path
+        return Client(host=self.host,
+                      version=self._version,
+                      request_headers=self.request_headers,
+                      url_path=url_path)
 
     def _make_request(self, opener, request):
         """Make the API call and return the response. This is separated into
@@ -119,7 +133,7 @@ def _make_request(self, opener, request):
         :type opener:
         :param request: url payload to request
         :type request: urllib.Request object
-        :return:
+        :return: urllib response
         """
         return opener.open(request)
 
@@ -131,10 +145,9 @@ def _(self, name):
 
         :param name: Name of the url segment
         :type name: string
-        :return:
+        :return: Client object
         """
-        self._add_to_url_path(name)
-        return self
+        return self._build_client(name)
 
     def __getattr__(self, name):
         """Dynamically add method calls to the url, then call a method.
@@ -153,7 +166,7 @@ def get_version(*args, **kwargs):
                 :return: string, version
                 """
                 self._version = args[0]
-                return self
+                return self._build_client()
             return get_version
 
         # We have reached the end of the method chain, make the API call
@@ -167,7 +180,7 @@ def http_request(*args, **kwargs):
                 :return: Client object
                 """
                 if 'request_headers' in kwargs:
-                    self._set_headers(kwargs['request_headers'])
+                    self._update_headers(kwargs['request_headers'])
                 data = json.dumps(kwargs['request_body']).encode('utf-8')\
                     if 'request_body' in kwargs else None
                 params = kwargs['query_params']\
@@ -178,32 +191,8 @@ def http_request(*args, **kwargs):
                     for key, value in self.request_headers.items():
                         request.add_header(key, value)
                 request.get_method = lambda: method
-                self._response = self._make_request(opener, request)
-                self._set_response(self._response)
-                self._reset()
-                return self
+                return Response(self._make_request(opener, request))
             return http_request
         else:
-            self._add_to_url_path(name)
-        return self
-
-    @property
-    def status_code(self):
-        """
-        :return: integer, status code of API call
-        """
-        return self._status_code
-
-    @property
-    def response_body(self):
-        """
-        :return: response from the API
-        """
-        return self._response_body
-
-    @property
-    def response_headers(self):
-        """
-        :return: dict of response headers
-        """
-        return self._response_headers
+            # Add a segment to the URL
+            return self._(name)

setup.py

@@ -9,7 +9,7 @@ def getRequires():
     return deps
 
 base_url = 'https://github.com/sendgrid/'
-version = '1.1.3'
+version = '1.2.3'
 setup(
     name='python_http_client',
     version=version,

tests/profile.py

@@ -45,21 +45,24 @@ def get(self,
             request_body=None,
             query_params=None,
             request_headers=None):
-        self.make_request('get', request_body, query_params, request_headers)
+        self.make_request('get', request_body, query_params,
+                          request_headers)
         return self
 
     def post(self,
              request_body=None,
              query_params=None,
              request_headers=None):
-        self.make_request('post', request_body, query_params, request_headers)
+        self.make_request('post', request_body, query_params,
+                          request_headers)
         return self
 
     def put(self,
             request_body=None,
             query_params=None,
             request_headers=None):
-        self.make_request('put', request_body, query_params, request_headers)
+        self.make_request('put', request_body, query_params,
+                          request_headers)
         return self
 
     def patch(self,
@@ -74,7 +77,8 @@ def delete(self,
                request_body=None,
                query_params=None,
                request_headers=None):
-        self.make_request('delete', request_body, query_params, request_headers)
+        self.make_request('delete', request_body, query_params,
+                          request_headers)
         return self