Merge branch 'develop'

Author: Chris Park

examples/text_embedding.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+"""
+Example code to call Rosette API to get text vectors from a piece of text.
+"""
+
+import argparse
+import json
+import os
+
+from rosette.api import API, DocumentParameters
+
+
+def run(key, altUrl='https://api.rosette.com/rest/v1/'):
+    # Create an API instance
+    api = API(user_key=key, service_url=altUrl)
+    embeddings_data = "Cambridge, Massachusetts"
+    params = DocumentParameters()
+    params["content"] = embeddings_data
+    return api.text_embedding(params)
+
+parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint')
+parser.add_argument('-k', '--key', help='Rosette API Key', required=True)
+parser.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/')
+
+if __name__ == '__main__':
+    args = parser.parse_args()
+    result = run(args.key, args.url)
+    print(json.dumps(result, indent=2, ensure_ascii=False, sort_keys=True).encode("utf8"))

rosette/__init__.py

@@ -16,4 +16,4 @@
 limitations under the License.
 """
 
-__version__ = '1.2.0'
+__version__ = '1.3.0'

rosette/api.py

@@ -24,26 +24,16 @@
 import sys
 import time
 import os
-from socket import gaierror
 import requests
 import re
 import warnings
 
-_BINDING_VERSION = '1.1.1'
+_BINDING_VERSION = '1.3.0'
 _GZIP_BYTEARRAY = bytearray([0x1F, 0x8b, 0x08])
 
 _IsPy3 = sys.version_info[0] == 3
 
 
-try:
-    import urlparse
-except ImportError:
-    import urllib.parse as urlparse
-try:
-    import httplib
-except ImportError:
-    import http.client as httplib
-
 if _IsPy3:
     _GZIP_SIGNATURE = _GZIP_BYTEARRAY
 else:
@@ -482,8 +472,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 +502,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 +523,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 +546,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 +585,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 +629,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
@@ -842,3 +833,11 @@ def matched_name(self, parameters):
         @type parameters: L{NameSimilarityParameters}
         @return: A python dictionary containing the results of name matching."""
         return self.name_similarity(parameters)
+
+    def text_embedding(self, parameters):
+        """
+        Create an L{EndpointCaller}  to identify text vectors found in the texts
+        to which it is applied and call it.
+        @type parameters: L{DocumentParameters} or L{str}
+        @return: A python dictionary containing the results of text embedding."""
+        return EndpointCaller(self, "text-embedding").call(parameters)

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
 
 
@@ -561,3 +579,14 @@ def test_for_name_translation_required_parameters(api, json_response):
 
     httpretty.disable()
     httpretty.reset()
+
+
+def test_the_text_embedded_endpoint(api, json_response, doc_params):
+    httpretty.enable()
+    httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/text-embedding",
+                           body=json_response, status=200, content_type="application/json")
+
+    result = api.text_embedding(doc_params)
+    assert result["name"] == "Rosette API"
+    httpretty.disable()
+    httpretty.reset()