Merge pull request #54 from rosette-api/RCB-463_python_requests

Updated make_request to use Requests

Author: fhasanaj

rosette/api.py

@@ -482,8 +482,8 @@ def call(self, parameters):
                     'application/json')}
             request = requests.Request(
                 'POST', url, files=files, headers=headers)
-            prepared_request = request.prepare()
             session = requests.Session()
+            prepared_request = session.prepare_request(request)
             resp = session.send(prepared_request)
             rdata = resp.content
             response_headers = {"responseHeaders": dict(resp.headers)}
@@ -512,7 +512,6 @@ def __init__(
             user_key=None,
             service_url='https://api.rosette.com/rest/v1/',
             retries=5,
-            reuse_connection=True,
             refresh_duration=0.5,
             debug=False):
         """ Create an L{API} object.
@@ -534,22 +533,18 @@ def __init__(
             refresh_duration = 0
 
         self.num_retries = retries
-        self.reuse_connection = reuse_connection
         self.connection_refresh_duration = refresh_duration
-        self.http_connection = None
         self.options = {}
         self.customHeaders = {}
+        self.maxPoolSize = 1
+        self.session = requests.Session()
 
-    def _connect(self, parsedUrl):
-        """ Simple connection method
-        @param parsedUrl: The URL on which to process
-        """
-        if not self.reuse_connection or self.http_connection is None:
-            loc = parsedUrl.netloc
-            if parsedUrl.scheme == "https":
-                self.http_connection = httplib.HTTPSConnection(loc)
-            else:
-                self.http_connection = httplib.HTTPConnection(loc)
+    def _set_pool_size(self):
+        adapter = requests.adapters.HTTPAdapter(pool_maxsize=self.maxPoolSize)
+        if 'https:' in self.service_url:
+            self.session.mount('https://', adapter)
+        else:
+            self.session.mount('http://', adapter)
 
     def _make_request(self, op, url, data, headers):
         """
@@ -561,32 +556,34 @@ def _make_request(self, op, url, data, headers):
         @param headers: request headers
         """
         headers['User-Agent'] = "RosetteAPIPython/" + _BINDING_VERSION
-        parsedUrl = urlparse.urlparse(url)
-
-        self._connect(parsedUrl)
 
         message = None
         code = "unknownError"
         rdata = None
         response_headers = {}
+
+        request = requests.Request(op, url, data=data, headers=headers)
+        session = requests.Session()
+        prepared_request = session.prepare_request(request)
+
         for i in range(self.num_retries + 1):
             try:
-                self.http_connection.request(op, url, data, headers)
-                response = self.http_connection.getresponse()
-                status = response.status
-                rdata = response.read()
-                response_headers["responseHeaders"] = (
-                    dict(response.getheaders()))
+                response = session.send(prepared_request)
+                status = response.status_code
+                rdata = response.content
+                dict_headers = dict(response.headers)
+                response_headers = {"responseHeaders": dict_headers}
+                if 'x-rosetteapi-concurrency' in dict_headers:
+                    if dict_headers['x-rosetteapi-concurrency'] != self.maxPoolSize:
+                        self.maxPoolSize = dict_headers['x-rosetteapi-concurrency']
+                        self._set_pool_size()
+
                 if status == 200:
-                    if not self.reuse_connection:
-                        self.http_connection.close()
                     return rdata, status, response_headers
                 if status == 429:
                     code = status
                     message = "{0} ({1})".format(rdata, i)
                     time.sleep(self.connection_refresh_duration)
-                    self.http_connection.close()
-                    self._connect(parsedUrl)
                     continue
                 if rdata is not None:
                     try:
@@ -598,17 +595,15 @@ def _make_request(self, op, url, data, headers):
                         else:
                             code = status
                         raise RosetteException(code, message, url)
+
                     except:
                         raise
-            except (httplib.BadStatusLine, gaierror):
+            except requests.exceptions.RequestException as e:
                 raise RosetteException(
-                    "ConnectionError",
+                    e.message,
                     "Unable to establish connection to the Rosette API server",
                     url)
 
-        if not self.reuse_connection:
-            self.http_connection.close()
-
         raise RosetteException(code, message, url)
 
     def _get_http(self, url, headers):
@@ -644,6 +639,12 @@ def _post_http(self, url, data, headers):
 
         return _ReturnObject(_my_loads(rdata, response_headers), status)
 
+    def getPoolSize(self):
+        """
+        Returns the maximum pool size, which is the returned x-rosetteapi-concurrency value
+        """
+        return int(self.maxPoolSize)
+
     def setOption(self, name, value):
         """
         Sets an option

tests/test_rosette_api.py

@@ -170,6 +170,24 @@ def test_for_409(api, json_409):
     httpretty.disable()
     httpretty.reset()
 
+# Test the maxPoolSize
+
+
+def test_the_max_pool_size(json_response, doc_params):
+    httpretty.enable()
+    httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/language",
+                           body=json_response, status=200, content_type="application/json",
+                           adding_headers={
+                               'x-rosetteapi-concurrency': 5
+                           })
+    api = API('bogus_key')
+    assert api.getPoolSize() == 1
+    result = api.language(doc_params)
+    assert result["name"] == "Rosette API"
+    assert api.getPoolSize() == 5
+    httpretty.disable()
+    httpretty.reset()
+
 # Test the language endpoint