Unicode Updates

Remove specific uses of Unicode strings and ‘default’ the package to
prefer the usage of ‘str’ strings.

Author: cmlccie

ciscosparkapi/__init__.py

@@ -1,15 +1,10 @@
+# -*- coding: utf-8 -*-
 """Python API wrapper for the Cisco Spark APIs."""
 
 
 from __future__ import absolute_import
-from __future__ import unicode_literals
-from past.builtins import basestring
 from builtins import object
-
-# Versioneer version control
-from ._version import get_versions
-__version__ = get_versions()['version']
-del get_versions
+from six import string_types
 
 import os
 
@@ -25,6 +20,12 @@
 from .api.webhooks import Webhook, WebhooksAPI
 
 
+# Versioneer version control
+from ._version import get_versions
+__version__ = get_versions()['version']
+del get_versions
+
+
 DEFAULT_BASE_URL = 'https://api.ciscospark.com/v1/'
 
 
@@ -50,10 +51,10 @@ def __init__(self, access_token=None, base_url=DEFAULT_BASE_URL,
         via one of these two methods.
 
         Args:
-            access_token(unicode, str): The access token to be used for API
+            access_token(string_types): The access token to be used for API
                 calls to the Cisco Spark service.  Defaults to checking for a
                 SPARK_ACCESS_TOKEN environment variable.
-            base_url(unicode, str): The base URL to be prefixed to the
+            base_url(string_types): The base URL to be prefixed to the
                 individual API endpoint suffixes.
                 Defaults to ciscosparkapi.DEFAULT_BASE_URL.
             timeout(int): Timeout (in seconds) for RESTful HTTP requests.
@@ -65,21 +66,21 @@ def __init__(self, access_token=None, base_url=DEFAULT_BASE_URL,
         Raises:
             AssertionError: If the parameter types are incorrect.
             ciscosparkapiException: If an access token is not provided via the
-                access_token argument or SPARK_ACCESS_TOKEN environement
+                access_token argument or SPARK_ACCESS_TOKEN environment
                 variable.
 
         """
         # Process args
-        assert access_token is None or isinstance(access_token, basestring)
-        assert isinstance(base_url, basestring)
+        assert access_token is None or isinstance(access_token, string_types)
+        assert isinstance(base_url, string_types)
         assert isinstance(timeout, int)
         spark_access_token = os.environ.get('SPARK_ACCESS_TOKEN', None)
         access_token = access_token if access_token else spark_access_token
         if not access_token:
             error_message = "You must provide an access token to interact " \
                             "with the Cisco Spark APIs, either via the " \
                             "access_token argument or via a " \
-                            "SPARK_ACCESS_TOKEN environement variable.  " \
+                            "SPARK_ACCESS_TOKEN environment variable.  " \
                             "None provided."
             raise ciscosparkapiException(error_message)
         session_args = {u'timeout': timeout}

ciscosparkapi/_version.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 
 # This file helps to compute a version number in source trees obtained from
 # git-archive tarball (such as those provided by githubs download-from-tag
@@ -10,7 +11,6 @@
 
 """Git implementation of _version.py."""
 from __future__ import print_function
-from __future__ import unicode_literals
 from builtins import str
 from builtins import object
 

ciscosparkapi/api/accesstokens.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 """Cisco Spark Access-Tokens-API wrapper classes.
 
 Classes:
@@ -9,22 +10,21 @@
 """
 
 
-from __future__ import unicode_literals
 from future import standard_library
 standard_library.install_aliases()
-from past.builtins import basestring
 from builtins import object
+from six import string_types
 
 import urllib.parse
 
 import requests
 
-from ciscosparkapi.helper import utf8, ERC, validate_base_url, \
+from ciscosparkapi.helper import ERC, validate_base_url, \
     check_response_code, extract_and_parse_json
 from ciscosparkapi.sparkdata import SparkData
 
 
-API_ENDPOINT = u"access_token"
+API_ENDPOINT = "access_token"
 
 
 class AccessToken(SparkData):
@@ -34,7 +34,7 @@ def __init__(self, json):
         """Init a new AccessToken data object from a JSON dictionary or string.
 
         Args:
-            json(dict, unicode, str): Input JSON object.
+            json(dict, string_types): Input JSON object.
 
         Raises:
             TypeError: If the input object is not a dictionary or string.
@@ -45,22 +45,22 @@ def __init__(self, json):
     @property
     def access_token(self):
         """Cisco Spark access_token."""
-        return self._json.get(u'access_token')
+        return self._json.get('access_token')
 
     @property
     def expires_in(self):
         """Access token expires_in number of seconds."""
-        return self._json.get(u'expires_in')
+        return self._json.get('expires_in')
 
     @property
     def refresh_token(self):
         """refresh_token used to request a new/refreshed access_token."""
-        return self._json.get(u'refresh_token')
+        return self._json.get('refresh_token')
 
     @property
     def refresh_token_expires_in(self):
         """refresh_token_expires_in number of seconds."""
-        return self._json.get(u'refresh_token_expires_in')
+        return self._json.get('refresh_token_expires_in')
 
 
 class AccessTokensAPI(object):
@@ -75,21 +75,21 @@ def __init__(self, base_url, timeout=None):
         """Init a new AccessTokensAPI object with the provided RestSession.
 
         Args:
-            base_url(unicode, str): The base URL the API endpoints.
+            base_url(string_types): The base URL the API endpoints.
             timeout(int): Timeout in seconds for the API requests.
 
         Raises:
             AssertionError: If the parameter types are incorrect.
 
         """
-        assert isinstance(base_url, basestring)
+        assert isinstance(base_url, string_types)
         assert timeout is None or isinstance(timeout, int)
         super(AccessTokensAPI, self).__init__()
-        self._base_url = validate_base_url(base_url)
+        self._base_url = str(validate_base_url(base_url))
         self._timeout = timeout
         self._endpoint_url = urllib.parse.urljoin(self.base_url, API_ENDPOINT)
         self._request_kwargs = {}
-        self._request_kwargs[u"timeout"] = timeout
+        self._request_kwargs["timeout"] = timeout
 
     @property
     def base_url(self):
@@ -106,13 +106,13 @@ def get(self, client_id, client_secret, code, redirect_uri):
         invoke the APIs.
 
         Args:
-            client_id(unicode, str): Provided when you created your
+            client_id(string_types): Provided when you created your
                 integration.
-            client_secret(unicode, str): Provided when you created your
+            client_secret(string_types): Provided when you created your
                 integration.
-            code(unicode, str): The Authorization Code provided by the user
+            code(string_types): The Authorization Code provided by the user
                 OAuth process.
-            redirect_uri(unicode, str): The redirect URI used in the user OAuth
+            redirect_uri(string_types): The redirect URI used in the user OAuth
                 process.
 
         Returns:
@@ -125,17 +125,17 @@ def get(self, client_id, client_secret, code, redirect_uri):
 
         """
         # Process args
-        assert isinstance(client_id, basestring)
-        assert isinstance(client_secret, basestring)
-        assert isinstance(code, basestring)
-        assert isinstance(redirect_uri, basestring)
+        assert isinstance(client_id, string_types)
+        assert isinstance(client_secret, string_types)
+        assert isinstance(code, string_types)
+        assert isinstance(redirect_uri, string_types)
         # Build request parameters
         data = {}
-        data[u"grant_type"] = u"authorization_code"
-        data[u"client_id"] = utf8(client_id)
-        data[u"client_secret"] = utf8(client_secret)
-        data[u"code"] = utf8(code)
-        data[u"redirect_uri"] = utf8(redirect_uri)
+        data["grant_type"] = "authorization_code"
+        data["client_id"] = client_id
+        data["client_secret"] = client_secret
+        data["code"] = code
+        data["redirect_uri"] = redirect_uri
         # API request
         response = requests.post(self._endpoint_url, data=data,
                                  **self._request_kwargs)
@@ -148,11 +148,11 @@ def refresh(self, client_id, client_secret, refresh_token):
         """Return a refreshed Access Token via the provided refresh_token.
 
         Args:
-            client_id(unicode, str): Provided when you created your
+            client_id(string_types): Provided when you created your
                 integration.
-            client_secret(unicode, str): Provided when you created your
+            client_secret(string_types): Provided when you created your
                 integration.
-            refresh_token(unicode, str): Provided when you requested the Access
+            refresh_token(string_types): Provided when you requested the Access
                 Token.
 
         Returns:
@@ -165,15 +165,15 @@ def refresh(self, client_id, client_secret, refresh_token):
 
         """
         # Process args
-        assert isinstance(client_id, basestring)
-        assert isinstance(client_secret, basestring)
-        assert isinstance(refresh_token, basestring)
+        assert isinstance(client_id, string_types)
+        assert isinstance(client_secret, string_types)
+        assert isinstance(refresh_token, string_types)
         # Build request parameters
         data = {}
-        data[u"grant_type"] = u"refresh_token"
-        data[u"client_id"] = utf8(client_id)
-        data[u"client_secret"] = utf8(client_secret)
-        data[u"refresh_token"] = utf8(refresh_token)
+        data["grant_type"] = "refresh_token"
+        data["client_id"] = client_id
+        data["client_secret"] = client_secret
+        data["refresh_token"] = refresh_token
         # API request
         response = requests.post(self._endpoint_url, data=data,
                                  **self._request_kwargs)