Py3: compatible imports.

Also, drop use of 'iteritems'.

Author: tseaver

oauth2/__init__.py

@@ -23,31 +23,23 @@
 """
 
 import base64
-import urllib
+from hashlib import sha1
 import time
 import random
-import urlparse
 import hmac
 import binascii
 import httplib2
 
-try:
-    from urlparse import parse_qs
-except ImportError: #pragma NO COVER
-    # fall back for Python 2.5
-    from cgi import parse_qs
-else: #pragma NO COVER
-    parse_qs # placate pyflakes
-
-try:
-    from hashlib import sha1 as sha
-except ImportError: #pragma NO COVER
-    # hashlib was added in Python 2.5
-    import sha
-
-import _version
-
-__version__ = _version.__version__
+from ._compat import quote
+from ._compat import STRING_TYPES
+from ._compat import TEXT
+from ._compat import unquote
+from ._compat import unquote_to_bytes
+from ._compat import urlencode
+from ._compat import urlparse
+from ._compat import urlunparse
+from ._compat import parse_qs
+from ._version import __version__
 
 OAUTH_VERSION = '1.0'  # Hi Blaine!
 HTTP_METHOD = 'GET'
@@ -87,7 +79,7 @@ def build_xoauth_string(url, consumer, token=None):
     request.sign_request(signing_method, consumer, token)
 
     params = []
-    for k, v in sorted(request.iteritems()):
+    for k, v in sorted(request.items()):
         if v is not None:
             params.append('%s="%s"' % (k, escape(v)))
 
@@ -97,32 +89,33 @@ def build_xoauth_string(url, consumer, token=None):
 def to_unicode(s):
     """ Convert to unicode, raise exception with instructive error
     message if s is not unicode, ascii, or utf-8. """
-    if not isinstance(s, unicode):
-        if not isinstance(s, str):
+    if not isinstance(s, TEXT):
+        if not isinstance(s, bytes):
             raise TypeError('You are required to pass either unicode or '
-                            'string here, not: %r (%s)' % (type(s), s))
+                            'bytes here, not: %r (%s)' % (type(s), s))
         try:
             s = s.decode('utf-8')
         except UnicodeDecodeError as le:
             raise TypeError('You are required to pass either a unicode '
-                            'object or a utf-8 string here. You passed a '
-                            'Python string object which contained non-utf-8: '
-                            '%r. The UnicodeDecodeError that resulted from '
-                            'attempting to interpret it as utf-8 was: %s'
+                            'object or a utf-8-enccoded bytes string here. '
+                            'You passed a bytes object which contained '
+                            'non-utf-8: %r. The UnicodeDecodeError that '
+                            'resulted from attempting to interpret it as '
+                            'utf-8 was: %s'
                                 % (s, le,))
     return s
 
 def to_utf8(s):
     return to_unicode(s).encode('utf-8')
 
 def to_unicode_if_string(s):
-    if isinstance(s, basestring):
+    if isinstance(s, STRING_TYPES):
         return to_unicode(s)
     else:
         return s
 
 def to_utf8_if_string(s):
-    if isinstance(s, basestring):
+    if isinstance(s, STRING_TYPES):
         return to_utf8(s)
     else:
         return s
@@ -132,7 +125,7 @@ def to_unicode_optional_iterator(x):
     Raise TypeError if x is a str containing non-utf8 bytes or if x is
     an iterable which contains such a str.
     """
-    if isinstance(x, basestring):
+    if isinstance(x, STRING_TYPES):
         return to_unicode(x)
 
     try:
@@ -148,7 +141,7 @@ def to_utf8_optional_iterator(x):
     Raise TypeError if x is a str or if x is an iterable which
     contains a str.
     """
-    if isinstance(x, basestring):
+    if isinstance(x, STRING_TYPES):
         return to_utf8(x)
 
     try:
@@ -161,7 +154,7 @@ def to_utf8_optional_iterator(x):
 
 def escape(s):
     """Escape a URL including any /."""
-    return urllib.quote(s.encode('utf-8'), safe='~')
+    return quote(s.encode('utf-8'), safe='~')
 
 def generate_timestamp():
     """Get seconds since epoch (UTC)."""
@@ -212,7 +205,7 @@ def __str__(self):
         data = {'oauth_consumer_key': self.key,
             'oauth_consumer_secret': self.secret}
 
-        return urllib.urlencode(data)
+        return urlencode(data)
 
 
 class Token(object):
@@ -256,13 +249,13 @@ def set_verifier(self, verifier=None):
     def get_callback_url(self):
         if self.callback and self.verifier:
             # Append the oauth_verifier.
-            parts = urlparse.urlparse(self.callback)
+            parts = urlparse(self.callback)
             scheme, netloc, path, params, query, fragment = parts[:6]
             if query:
                 query = '%s&oauth_verifier=%s' % (query, self.verifier)
             else:
                 query = 'oauth_verifier=%s' % self.verifier
-            return urlparse.urlunparse((scheme, netloc, path, params,
+            return urlunparse((scheme, netloc, path, params,
                 query, fragment))
         return self.callback
 
@@ -280,7 +273,7 @@ def to_string(self):
 
         if self.callback_confirmed is not None:
             data['oauth_callback_confirmed'] = self.callback_confirmed
-        return urllib.urlencode(data)
+        return urlencode(data)
 
     @staticmethod
     def from_string(s):
@@ -351,7 +344,7 @@ def __init__(self, method=HTTP_METHOD, url=None, parameters=None,
             self.url = to_unicode(url)
         self.method = method
         if parameters is not None:
-            for k, v in parameters.iteritems():
+            for k, v in parameters.items():
                 k = to_unicode(k)
                 v = to_unicode_optional_iterator(v)
                 self[k] = v
@@ -363,8 +356,7 @@ def __init__(self, method=HTTP_METHOD, url=None, parameters=None,
     def url(self, value):
         self.__dict__['url'] = value
         if value is not None:
-            scheme, netloc, path, params, query, fragment = urlparse.urlparse(
-                                                                value)
+            scheme, netloc, path, params, query, fragment = urlparse(value)
 
             # Exclude default port numbers.
             if scheme == 'http' and netloc[-3:] == ':80':
@@ -375,7 +367,7 @@ def url(self, value):
                 raise ValueError("Unsupported URL %s (%s)." % (value, scheme))
 
             # Normalized URL excludes params, query, and fragment.
-            self.normalized_url = urlparse.urlunparse(
+            self.normalized_url = urlunparse(
                                     (scheme, netloc, path, None, None, None))
         else:
             self.normalized_url = None
@@ -390,7 +382,7 @@ def _get_timestamp_nonce(self):
 
     def get_nonoauth_parameters(self):
         """Get any non-OAuth parameters."""
-        return dict([(k, v) for k, v in self.iteritems() 
+        return dict([(k, v) for k, v in self.items() 
                     if not k.startswith('oauth_')])
 
     def to_header(self, realm=''):
@@ -410,17 +402,17 @@ def to_header(self, realm=''):
     def to_postdata(self):
         """Serialize as post data for a POST request."""
         d = {}
-        for k, v in self.iteritems():
+        for k, v in self.items():
             d[k.encode('utf-8')] = to_utf8_optional_iterator(v)
 
         # tell urlencode to deal with sequence values and map them correctly
         # to resulting querystring. for example self["k"] = ["v1", "v2"] will
         # result in 'k=v1&k=v2' and not k=%5B%27v1%27%2C+%27v2%27%5D
-        return urllib.urlencode(d, True).replace('+', '%20')
+        return urlencode(d, True).replace('+', '%20')
 
     def to_url(self):
         """Serialize as a URL for a GET request."""
-        base_url = urlparse.urlparse(self.url)
+        base_url = urlparse(self.url)
         try:
             query = base_url.query
         except AttributeError: #pragma NO COVER
@@ -445,8 +437,8 @@ def to_url(self):
             fragment = base_url[5]
 
         url = (scheme, netloc, path, params,
-               urllib.urlencode(query, True), fragment)
-        return urlparse.urlunparse(url)
+               urlencode(query, True), fragment)
+        return urlunparse(url)
 
     def get_parameter(self, parameter):
         ret = self.get(parameter)
@@ -458,12 +450,12 @@ def get_parameter(self, parameter):
     def get_normalized_parameters(self):
         """Return a string that contains the parameters that must be signed."""
         items = []
-        for key, value in self.iteritems():
+        for key, value in self.items():
             if key == 'oauth_signature':
                 continue
             # 1.0a/9.1.1 states that kvp must be sorted by key, then by value,
             # so we unpack sequence values into multiple items for sorting.
-            if isinstance(value, basestring):
+            if isinstance(value, STRING_TYPES):
                 items.append((to_utf8_if_string(key), to_utf8(value)))
             else:
                 try:
@@ -478,15 +470,15 @@ def get_normalized_parameters(self):
                             for item in value)
 
         # Include any query string parameters from the provided URL
-        query = urlparse.urlparse(self.url)[4]
+        query = urlparse(self.url)[4]
 
         url_items = self._split_url_string(query).items()
         url_items = [(to_utf8(k), to_utf8(v))
                         for k, v in url_items if k != 'oauth_signature' ]
         items.extend(url_items)
 
         items.sort()
-        encoded_str = urllib.urlencode(items)
+        encoded_str = urlencode(items)
         # Encode signature parameters per Oauth Core 1.0 protocol
         # spec draft 7, section 3.6
         # (http://tools.ietf.org/html/draft-hammer-oauth-07#section-3.6)
@@ -503,7 +495,7 @@ def sign_request(self, signature_method, consumer, token):
             # section 4.1.1 "OAuth Consumers MUST NOT include an
             # oauth_body_hash parameter on requests with form-encoded
             # request bodies."
-            self['oauth_body_hash'] = base64.b64encode(sha(self.body).digest())
+            self['oauth_body_hash'] = base64.b64encode(sha1(self.body).digest())
 
         if 'oauth_consumer_key' not in self:
             self['oauth_consumer_key'] = consumer.key
@@ -551,7 +543,7 @@ def from_request(cls, http_method, http_url, headers=None, parameters=None,
             parameters.update(query_params)
 
         # URL parameters.
-        param_str = urlparse.urlparse(http_url)[4] # query
+        param_str = urlparse(http_url)[4] # query
         url_params = cls._split_url_string(param_str)
         parameters.update(url_params)
 
@@ -613,16 +605,16 @@ def _split_header(header):
             # Split key-value.
             param_parts = param.split('=', 1)
             # Remove quotes and unescape the value.
-            params[param_parts[0]] = urllib.unquote(param_parts[1].strip('\"'))
+            params[param_parts[0]] = unquote(param_parts[1].strip('\"'))
         return params
 
     @staticmethod
     def _split_url_string(param_str):
         """Turn URL string into parameters."""
         parameters = parse_qs(param_str.encode('utf-8'),
                               keep_blank_values=True)
-        for k, v in parameters.iteritems():
-            parameters[k] = urllib.unquote(v[0])
+        for k, v in parameters.items():
+            parameters[k] = unquote_to_bytes(v[0])
         return parameters
 
 
@@ -676,8 +668,8 @@ def request(self, uri, method="GET", body='', headers=None,
 
         req.sign_request(self.method, self.consumer, self.token)
 
-        scheme, netloc, path, params, query, fragment = urlparse.urlparse(uri)
-        realm = urlparse.urlunparse((scheme, netloc, '', None, None, None))
+        scheme, netloc, path, params, query, fragment = urlparse(uri)
+        realm = urlunparse((scheme, netloc, '', None, None, None))
 
         if is_form_encoded:
             body = req.to_postdata()
@@ -842,7 +834,7 @@ def sign(self, request, consumer, token):
         """Builds the base signature string."""
         key, raw = self.signing_base(request, consumer, token)
 
-        hashed = hmac.new(key, raw, sha)
+        hashed = hmac.new(key, raw, sha1)
 
         # Calculate the digest base 64.
         return binascii.b2a_base64(hashed.digest())[:-1]

oauth2/_compat.py

@@ -3,7 +3,7 @@
 except NameError: #pragma NO COVER Py3k
     TEXT = str
     STRING_TYPES = (str, bytes)
-else:
+else: #pragma NO COVER Python2
     STRING_TYPES = (unicode, bytes)
 
 def u(x, encoding='ascii'):
@@ -13,3 +13,24 @@ def u(x, encoding='ascii'):
         return x.decode(encoding)
     except AttributeError:
         raise ValueError('WTF: %s' % x)
+
+try:
+    import urlparse
+except ImportError: #pragma NO COVER Py3k
+    from urllib.parse import parse_qs
+    from urllib.parse import parse_qsl
+    from urllib.parse import quote
+    from urllib.parse import unquote
+    from urllib.parse import unquote_to_bytes
+    from urllib.parse import urlencode
+    from urllib.parse import urlparse
+    from urllib.parse import urlunparse
+else: #pragma NO COVER Python2
+    from urlparse import parse_qs
+    from urlparse import parse_qsl
+    from urllib import quote
+    from urllib import unquote
+    from urllib import urlencode
+    from urlparse import urlparse
+    from urlparse import urlunparse
+    unquote_to_bytes = unquote