Internal calls are now structured as multipart when handling files, as in java's setupMultipartRequest.

Author: fhasanaj28

docker/tox.ini

@@ -9,9 +9,10 @@ envlist = py26, py27, py33, py34
 
 [testenv]
 commands =
-    py.test {toxinidir}/tests
+    py.test {toxinidir}/tests -s
 deps =
     pytest
     pytest-pep8
     httpretty==0.8.10
-    epydoc
+    epydoc
+    requests

examples/sentiment.py

@@ -42,4 +42,4 @@ def run(key, altUrl='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"))
+    print(json.dumps(result, indent=2, ensure_ascii=False, sort_keys=True).encode("utf8"))

rosette/api.py

@@ -27,8 +27,10 @@
 import os
 from socket import gethostbyname, gaierror
 from datetime import datetime
+import requests
+from pprint import pprint
 
-_BINDING_VERSION = "0.8"
+_BINDING_VERSION = "0.10"
 _GZIP_BYTEARRAY = bytearray([0x1F, 0x8b, 0x08])
 N_RETRIES = 3
 HTTP_CONNECTION = None
@@ -229,24 +231,6 @@ def validate(cls, value, name):
                                    " is not one of " + ", ".join(values) + ".", repr(value))
 
 
-class DataFormat(_PseudoEnum):
-    """Data Format, as much as it is known."""
-    SIMPLE = "text/plain"
-    """The data is unstructured text, supplied as a possibly-unicode string."""
-    JSON = "application/json"
-    """To be supplied.  The API uses JSON internally, but that is not what this refers to."""
-    HTML = "text/html"
-    """The data is a 'loose' HTML page; that is, it may not be HTML-compliant, or may even not
-    really be HTML. The data must be a narrow (single-byte) string, not a python Unicode string,
-    perhaps read from a file. (Of course, it can be UTF-8 encoded)."""
-    XHTML = "application/xhtml+xml"
-    """The data is a compliant XHTML page. The data must be a narrow (single-byte) string, not a
-    python Unicode string, perhaps read from a file. (Of course, it can be UTF-8 encoded)."""
-    UNSPECIFIED = "application/octet-stream"
-    """The data is of unknown format, it may be a binary data type (the contents of a binary file),
-    or may not.  It will be sent as is and identified and analyzed by the server."""
-
-
 class MorphologyOutput(_PseudoEnum):
     LEMMAS = "lemmas"
     PARTS_OF_SPEECH = "parts-of-speech"
@@ -298,7 +282,7 @@ def _byteify(s):  # py 3 only
 class DocumentParameters(_DocumentParamSetBase):
     """Parameter object for all operations requiring input other than
     translated_name.
-    Three fields, C{content}, C{contentType}, and C{inputUri}, are set via
+    Two fields, C{content} and C{inputUri}, are set via
     the subscript operator, e.g., C{params["content"]}, or the
     convenience instance methods L{DocumentParameters.load_document_file}
     and L{DocumentParameters.load_document_string}.
@@ -307,13 +291,14 @@ class DocumentParameters(_DocumentParamSetBase):
 
     If the field C{contentUri} is set to the URL of a web page (only
     protocols C{http, https, ftp, ftps} are accepted), the server will
-    fetch the content from that web page.  In this case, neither C{content}
-    nor C{contentType} may be set.
+    fetch the content from that web page.  In this case, C{content} may not be set.
     """
 
     def __init__(self):
         """Create a L{DocumentParameters} object."""
-        _DocumentParamSetBase.__init__(self, ("content", "contentUri", "contentType", "language"))
+        _DocumentParamSetBase.__init__(self, ("content", "contentUri", "language"))
+        self.file_name = ""
+        self.useMultipart = False
 
     def validate(self):
         """Internal. Do not use."""
@@ -328,47 +313,26 @@ def serialize(self):
         """Internal. Do not use."""
         self.validate()
         slz = super(DocumentParameters, self).serialize()
-        if self["contentType"] is None and self["contentUri"] is None:
-            slz["contentType"] = DataFormat.SIMPLE
-        elif self["contentType"] in (DataFormat.HTML, DataFormat.XHTML, DataFormat.UNSPECIFIED):
-            content = slz["content"]
-            if _IsPy3 and isinstance(content, str):
-                content = _byteify(content)
-
-            encoded = base64.b64encode(content)
-            if _IsPy3:
-                encoded = encoded.decode("utf-8")  # if py3, need chars.
-            slz["content"] = encoded
         return slz
 
-    def load_document_file(self, path, data_type=DataFormat.UNSPECIFIED):
+    def load_document_file(self, path):
         """Loads a file into the object.
         The file will be read as bytes; the appropriate conversion will
         be determined by the server.
         @parameter path: Pathname of a file acceptable to the C{open} function.
-        @parameter data_type: One of L{DataFormat.HTML}, L{DataFormat.XHTML}, or L{DataFormat.UNSPECIFIED}.
-        No other types are acceptable at this time, although HTML is broad enough to include text strings
-        without markup.
-        If the data type is unknown, or describes a binary file, use the default (L{DataFormat.UNSPECIFIED}).
-        @type data_type: L{DataFormat}
         """
-        if data_type not in (DataFormat.HTML, DataFormat.XHTML, DataFormat.UNSPECIFIED):
-            raise RosetteException("badArgument", "Must supply one of HTML, XHTML, or UNSPECIFIED", data_type)
-        self.load_document_string(open(path, "rb").read(), data_type)
+        self.useMultipart = True
+        self.file_name = path
+        self.load_document_string(open(path, "rb").read())
 
-    def load_document_string(self, s, data_type):
+    def load_document_string(self, s):
         """Loads a string into the object.
         The string will be taken as bytes or as Unicode dependent upon
-        its native python type and the data type asked for; if the
-        type is HTML or XHTML, bytes, not python Unicode, are expected,
-        the encoding to be determined by the server.
+        its native python type.
         @parameter s: A string, possibly a unicode-string, to be loaded
-        for subsequent analysis, as per the C{data_type}.
-        @parameter data_type: The data type of the string, as per L{DataFormat}.
-        @type data_type: L{DataFormat}
+        for subsequent analysis.
         """
         self["content"] = s
-        self["contentType"] = data_type
 
 
 class RelationshipsParameters(DocumentParameters):
@@ -377,7 +341,8 @@ class RelationshipsParameters(DocumentParameters):
     to specify the relationships-unique options parameter."""
     def __init__(self):
         """Create a L{RelationshipsParameters} object."""
-        _DocumentParamSetBase.__init__(self, ("content", "contentUri", "contentType", "language", "options"))
+        self.useMultipart = False
+        _DocumentParamSetBase.__init__(self, ("content", "contentUri", "language", "options"))
 
 
 class NameTranslationParameters(_DocumentParamSetBase):
@@ -406,6 +371,7 @@ class NameTranslationParameters(_DocumentParamSetBase):
     """
 
     def __init__(self):
+        self.useMultipart = False
         _DocumentParamSetBase.__init__(self, ("name", "targetLanguage", "entityType", "sourceLanguageOfOrigin",
                                               "sourceLanguageOfUse", "sourceScript", "targetScript", "targetScheme"))
 
@@ -436,6 +402,7 @@ class NameSimilarityParameters(_DocumentParamSetBase):
     """
 
     def __init__(self):
+        self.useMultipart = False
         _DocumentParamSetBase.__init__(self, ("name1", "name2"))
 
     def validate(self):
@@ -469,7 +436,7 @@ def __init__(self, api, suburl):
         self.service_url = api.service_url
         self.user_key = api.user_key
         self.logger = api.logger
-        self.useMultipart = api.useMultipart
+        self.useMultipart = False
         self.checker = lambda: api.check_version()
         self.suburl = suburl
         self.debug = api.debug
@@ -498,9 +465,6 @@ def __finish_result(self, r, ename):
                                    complaint_url + " : failed to communicate with Rosette",
                                    msg)
 
-    def _set_use_multipart(self, value):
-        self.useMultipart = value
-
     def info(self):
         """Issues an "info" request to the L{EndpointCaller}'s specific endpoint.
         @return: A dictionary telling server version and other
@@ -575,22 +539,33 @@ def call(self, parameters):
 
         self.checker()
 
-        if self.useMultipart and (parameters['contentType'] != DataFormat.SIMPLE):
-            raise RosetteException("incompatible", "Multipart requires contentType SIMPLE",
-                                   repr(parameters['contentType']))
+        self.useMultipart = parameters.useMultipart
         url = self.service_url + self.suburl
-        if self.debug:
-            url = add_query(url, "debug", "true")
-        self.logger.info('operate: ' + url)
         params_to_serialize = parameters.serialize()
-        headers = {'Accept': "application/json", 'Accept-Encoding': "gzip"}
+        headers = {}
         if self.user_key is not None:
             headers["X-RosetteAPI-Key"] = self.user_key
-        headers['Content-Type'] = "application/json"
-        r = _post_http(url, params_to_serialize, headers)
-        # pprint.pprint(headers)
-        # pprint.pprint(url)
-        # pprint.pprint(params_to_serialize)
+        if self.useMultipart:
+            headers = {'Content-Disposition': 'attachment'}
+            params = dict((key,value) for key, value in params_to_serialize.iteritems() if key == 'language')
+            files =  {'content': (parameters.file_name, params_to_serialize["content"], 'text/plain'),
+                      'request': ('request_options', json.dumps(params), 'application/json')}
+            request = requests.Request('POST', url, files=files, headers=headers, params=[])
+            prepared_request = request.prepare()
+            session = requests.Session()
+            resp = session.send(prepared_request)
+            rdata = resp.content 
+            response_headers = {"responseHeaders": dict(resp.headers)}
+            status = resp.status_code 
+            r = _ReturnObject(_my_loads(rdata, response_headers), status)
+        else:
+            if self.debug:
+                url = add_query(url, "debug", "true")
+            self.logger.info('operate: ' + url)
+            headers['Accept'] = "application/json"
+            headers['Accept-Encoding'] = "gzip"
+            headers['Content-Type'] = "application/json"
+            r = _post_http(url, params_to_serialize, headers)
         return self.__finish_result(r, "operate")
 
 
@@ -612,7 +587,6 @@ def __init__(self, user_key=None, service_url='https://api.rosette.com/rest/v1/'
         self.logger = logging.getLogger('rosette.api')
         self.logger.info('Initialized on ' + self.service_url)
         self.debug = debug
-        self.useMultipart = False
         self.version_checked = False
 
         global N_RETRIES
@@ -639,9 +613,6 @@ def check_version(self):
         self.version_checked = True
         return True
 
-    def _set_use_multipart(self, value):
-        self.useMultipart = value
-
     def ping(self):
         """
         Create a ping L{EndpointCaller} for the server and ping it.