Merge ~jugmac00/lazr.restfulclient:apply-black into lazr.restfulclient:main

[Jürgen Gmach]

Apply black code formatter

[Colin Watson (cjwatson)]

review: Approve

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 0000000..135d4d2
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,2 @@
+# apply black
[phone]bd627c9906b9d4cbdff915e36a5
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index a9e24ce..ac3063e 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,10 +2,27 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v3.2.0
+    rev: v4.0.1
     hooks:
     -   id: check-added-large-files
     -   id: check-ast
+    -   id: check-json
     -   id: check-merge-conflict
+    -   id: check-toml
+    -   id: check-xml
     -   id: check-yaml
     -   id: debug-statements
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+-   repo: https://github.com/PyCQA/isort
+    rev: 5.10.1
+    hooks:
+    - id: isort
+-   repo: https://github.com/psf/black
+    rev: 21.10b0
+    hooks:
+    -   id: black
+-   repo: https://github.com/PyCQA/flake8
+    rev: 4.0.1
+    hooks:
+    -   id: flake8
diff --git a/NEWS.rst b/NEWS.rst
index 3559a22..c87b692 100644
--- a/NEWS.rst
+++ b/NEWS.rst
@@ -7,6 +7,7 @@ NEWS for lazr.restfulclient
 
   - Add ``pre-commit`` configuration.
   - Publish documentation on Read the Docs.
+  - Apply black code formatter.
 
 0.14.4 (2021-09-13)
 ===================
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..15e7219
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,8 @@
+[tool.black]
+line-length = 79
+target-version = ['py27']
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 79
diff --git a/setup.cfg b/setup.cfg
index 2a9acf1..1d922c2 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,2 +1,10 @@
 [bdist_wheel]
 universal = 1
+
+[flake8]
+ignore =
+    # incompatible with black
+    E203
+    # W503 and W504 are mutally exclusive
+    W503
+    W504
diff --git a/setup.py b/setup.py
index 2ddeb5b..764dd14 100644
--- a/setup.py
+++ b/setup.py
@@ -8,90 +8,93 @@
 # under the terms of the GNU Lesser General Public License as published by
 # the Free Software Foundation, version 3 of the License.
 #
-# lazr.restfulclient is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+# lazr.restfulclient is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 # License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public License
 # along with lazr.restfulclient.  If not, see <http://www.gnu.org/licenses/>.
 
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
+
 
 # generic helpers primarily for the long_description
 def generate(*docname_or_string):
-    marker = '.. pypi description ends here'
+    marker = ".. pypi description ends here"
     res = []
     for value in docname_or_string:
-        if value.endswith('.rst'):
+        if value.endswith(".rst"):
             with open(value) as f:
                 value = f.read()
             idx = value.find(marker)
             if idx >= 0:
                 value = value[:idx]
         res.append(value)
-        if not value.endswith('\n'):
-            res.append('')
-    return '\n'.join(res)
+        if not value.endswith("\n"):
+            res.append("")
+    return "\n".join(res)
+
+
 # end generic helpers
 
 
 tests_require = [
-    'fixtures>=1.3.0',
-    'lazr.authentication',
-    'lazr.restful>=0.11.0',
+    "fixtures>=1.3.0",
+    "lazr.authentication",
+    "lazr.restful>=0.11.0",
     'mock; python_version < "3"',
-    'oauth',
-    'testtools',
-    'wsgi_intercept',
-    'zope.testrunner',
-    ]
+    "oauth",
+    "testtools",
+    "wsgi_intercept",
+    "zope.testrunner",
+]
 
 setup(
-    name='lazr.restfulclient',
-    version='0.14.4',
-    namespace_packages=['lazr'],
-    packages=find_packages('src'),
-    package_dir={'':'src'},
+    name="lazr.restfulclient",
+    version="0.14.4",
+    namespace_packages=["lazr"],
+    packages=find_packages("src"),
+    package_dir={"": "src"},
     include_package_data=True,
     zip_safe=False,
-    maintainer='LAZR Developers',
-    maintainer_email='[e-mail]',
-    description=open('README.rst').readline().strip(),
+    maintainer="LAZR Developers",
+    maintainer_email="[e-mail]",
+    description=open("README.rst").readline().strip(),
     long_description=generate(
-        'src/lazr/restfulclient/docs/index.rst',
-        'NEWS.rst'),
-    license='LGPL v3',
+        "src/lazr/restfulclient/docs/index.rst", "NEWS.rst"
+    ),
+    license="LGPL v3",
     install_requires=[
-        'distro',
+        "distro",
         'httplib2; python_version < "3"',
         'httplib2>=0.7.7; python_version >= "3"',
         'importlib-metadata; python_version < "3.8"',
-        'oauthlib',
-        'setuptools',
-        'six',
-        'wadllib>=1.1.4',
-        ],
-    url='https://launchpad.net/lazr.restfulclient',
+        "oauthlib",
+        "setuptools",
+        "six",
+        "wadllib>=1.1.4",
+    ],
+    url="https://launchpad.net/lazr.restfulclient",
     project_urls={
         "Source": "https://code.launchpad.net/lazr.restfulclient",
         "Issue Tracker": "https://bugs.launchpad.net/lazr.restfulclient",
         "Documentation": "https://lazrrestfulclient.readthedocs.io/en/latest/",
     },
-    download_url= 'https://launchpad.net/lazr.restfulclient/+download',
+    download_url="https://launchpad.net/lazr.restfulclient/+download",
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Developers",
-        "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)",
+        "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)",  # noqa: E501
         "Operating System :: OS Independent",
         "Programming Language :: Python",
         "Programming Language :: Python :: 2",
         "Programming Language :: Python :: 3",
-        ],
+    ],
     tests_require=tests_require,
     extras_require=dict(
-        docs=['Sphinx'],
+        docs=["Sphinx"],
         test=tests_require,
     ),
-    test_suite='lazr.restfulclient.tests',
-    )
+    test_suite="lazr.restfulclient.tests",
+)
diff --git a/src/lazr/__init__.py b/src/lazr/__init__.py
index b2362fd..fcc94e2 100644
--- a/src/lazr/__init__.py
+++ b/src/lazr/__init__.py
@@ -6,9 +6,9 @@
 # under the terms of the GNU Lesser General Public License as published by
 # the Free Software Foundation, version 3 of the License.
 #
-# lazr.restfulclient is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+# lazr.restfulclient is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 # License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public License
@@ -17,7 +17,9 @@
 # this is a namespace package
 try:
     import pkg_resources
+
     pkg_resources.declare_namespace(__name__)
 except ImportError:
     import pkgutil
+
     __path__ = pkgutil.extend_path(__path__, __name__)
diff --git a/src/lazr/restfulclient/_browser.py b/src/lazr/restfulclient/_browser.py
index cc23467..d0b4211 100644
--- a/src/lazr/restfulclient/_browser.py
+++ b/src/lazr/restfulclient/_browser.py
@@ -25,32 +25,33 @@ lazr.restfulclient API. (But maybe it should be?)
 
 __metaclass__ = type
 __all__ = [
-    'Browser',
-    'RestfulHttp',
-    'ssl_certificate_validation_disabled',
-    ]
+    "Browser",
+    "RestfulHttp",
+    "ssl_certificate_validation_disabled",
+]
 
 import atexit
 import errno
-from hashlib import md5
-from io import BytesIO
-from json import dumps
 import os
 import re
 import shutil
 import sys
 import tempfile
+from hashlib import md5
+from io import BytesIO
+from json import dumps
+
 # Import sleep directly into the module so we can monkey-patch it
 # during a test.
 from time import sleep
-from httplib2 import (
-    Http,
-    urlnorm,
-    )
+
+from httplib2 import Http, urlnorm
+
 try:
     from httplib2 import proxy_info_from_environment
 except ImportError:
     from httplib2 import ProxyInfo
+
     proxy_info_from_environment = ProxyInfo.from_environment
 
 try:
@@ -60,14 +61,15 @@ except ImportError:
     from urllib import urlencode
 
 from wadllib.application import Application
-from lazr.uri import URI
-from lazr.restfulclient.errors import error_for, HTTPError
+
 from lazr.restfulclient._json import DatetimeJSONEncoder
+from lazr.restfulclient.errors import HTTPError, error_for
+from lazr.uri import URI
 
 if bytes is str:
     # Python 2
-    unicode_type = unicode
-    str_types = basestring
+    unicode_type = unicode  # noqa: F821
+    str_types = basestring  # noqa: F821
 else:
     unicode_type = str
     str_types = str
@@ -77,9 +79,9 @@ else:
 # from httplib2, but its cache name format changed in 0.12.0 and we want to
 # stick with the previous version.
 
-re_url_scheme = re.compile(br'^\w+://')
-re_url_scheme_s = re.compile(r'^\w+://')
-re_slash = re.compile(br'[?/:|]+')
+re_url_scheme = re.compile(br"^\w+://")
+re_url_scheme_s = re.compile(r"^\w+://")
+re_slash = re.compile(br"[?/:|]+")
 
 
 def safename(filename):
@@ -90,20 +92,20 @@ def safename(filename):
     """
     try:
         if isinstance(filename, bytes):
-            filename_match = filename.decode('utf-8')
+            filename_match = filename.decode("utf-8")
         else:
             filename_match = filename
 
         if re_url_scheme_s.match(filename_match):
             if isinstance(filename, bytes):
-                filename = filename.decode('utf-8')
-                filename = filename.encode('idna')
+                filename = filename.decode("utf-8")
+                filename = filename.encode("idna")
             else:
-                filename = filename.encode('idna')
+                filename = filename.encode("idna")
     except UnicodeError:
         pass
     if isinstance(filename, unicode_type):
-        filename = filename.encode('utf-8')
+        filename = filename.encode("utf-8")
     filemd5 = md5(filename).hexdigest()
     filename = re_url_scheme.sub(b"", filename)
     filename = re_slash.sub(b",", filename)
@@ -126,7 +128,7 @@ def safename(filename):
     maximum_length_before_md5_sum = maximum_filename_length - 32 - 1
     if len(filename) > maximum_length_before_md5_sum:
         filename = filename[:maximum_length_before_md5_sum]
-    return ",".join((filename.decode('utf-8'), filemd5))
+    return ",".join((filename.decode("utf-8"), filemd5))
 
 
 def ssl_certificate_validation_disabled():
@@ -136,12 +138,11 @@ def ssl_certificate_validation_disabled():
     error, we allow an environment variable,
     ``LP_DISABLE_SSL_CERTIFICATE_VALIDATION`` to disable the check.
     """
-    return bool(
-        os.environ.get('LP_DISABLE_SSL_CERTIFICATE_VALIDATION', False))
+    return bool(os.environ.get("LP_DISABLE_SSL_CERTIFICATE_VALIDATION", False))
 
 
-if os.path.exists('/etc/ssl/certs/ca-certificates.crt'):
-    SYSTEM_CA_CERTS = '/etc/ssl/certs/ca-certificates.crt'
+if os.path.exists("/etc/ssl/certs/ca-certificates.crt"):
+    SYSTEM_CA_CERTS = "/etc/ssl/certs/ca-certificates.crt"
 else:
     from httplib2 import CA_CERTS as SYSTEM_CA_CERTS
 
@@ -156,34 +157,61 @@ class RestfulHttp(Http):
 
     maximum_cache_filename_length = 143
 
-    def __init__(self, authorizer=None, cache=None, timeout=None,
-                 proxy_info=proxy_info_from_environment):
+    def __init__(
+        self,
+        authorizer=None,
+        cache=None,
+        timeout=None,
+        proxy_info=proxy_info_from_environment,
+    ):
         cert_disabled = ssl_certificate_validation_disabled()
         super(RestfulHttp, self).__init__(
-            cache, timeout, proxy_info,
+            cache,
+            timeout,
+            proxy_info,
             disable_ssl_certificate_validation=cert_disabled,
-            ca_certs=SYSTEM_CA_CERTS)
+            ca_certs=SYSTEM_CA_CERTS,
+        )
         self.authorizer = authorizer
         if self.authorizer is not None:
             self.authorizer.authorizeSession(self)
 
-    def _request(self, conn, host, absolute_uri, request_uri, method, body,
-                 headers, redirections, cachekey):
+    def _request(
+        self,
+        conn,
+        host,
+        absolute_uri,
+        request_uri,
+        method,
+        body,
+        headers,
+        redirections,
+        cachekey,
+    ):
         """Use the authorizer to authorize an outgoing request."""
-        if 'authorization' in headers:
+        if "authorization" in headers:
             # There's an authorization header left over from a
             # previous request that resulted in a redirect. Resources
             # protected by OAuth or HTTP Digest must send a distinct
             # Authorization header with each request, to prevent
             # playback attacks. Remove the Authorization header and
             # start again.
-            del headers['authorization']
+            del headers["authorization"]
         if self.authorizer is not None:
             self.authorizer.authorizeRequest(
-                absolute_uri, method, body, headers)
+                absolute_uri, method, body, headers
+            )
         return super(RestfulHttp, self)._request(
-            conn, host, absolute_uri, request_uri, method, body, headers,
-            redirections, cachekey)
+            conn,
+            host,
+            absolute_uri,
+            request_uri,
+            method,
+            body,
+            headers,
+            redirections,
+            cachekey,
+        )
 
     def _getCachedHeader(self, uri, header):
         """Retrieve a cached value for an HTTP header."""
@@ -213,7 +241,7 @@ class AtomicFileCache(object):
         self._cache_dir = os.path.normpath(cache)
         self._get_safe_name = safe
         try:
-             os.makedirs(self._cache_dir)
+            os.makedirs(self._cache_dir)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
@@ -226,7 +254,8 @@ class AtomicFileCache(object):
             # possible that it will clash with a temporary file that we
             # create.
             raise ValueError(
-                "Cache key cannot start with '%s'" % self.TEMPFILE_PREFIX)
+                "Cache key cannot start with '%s'" % self.TEMPFILE_PREFIX
+            )
         return os.path.join(self._cache_dir, safe_key)
 
     def get(self, key):
@@ -242,7 +271,7 @@ class AtomicFileCache(object):
         """
         cache_full_path = self._get_key_path(key)
         try:
-            f = open(cache_full_path, 'rb')
+            f = open(cache_full_path, "rb")
             try:
                 return f.read()
             finally:
@@ -259,13 +288,14 @@ class AtomicFileCache(object):
         """
         # Open a temporary file
         handle, path_name = tempfile.mkstemp(
-            prefix=self.TEMPFILE_PREFIX, dir=self._cache_dir)
-        f = os.fdopen(handle, 'wb')
+            prefix=self.TEMPFILE_PREFIX, dir=self._cache_dir
+        )
+        f = os.fdopen(handle, "wb")
         f.write(value)
         f.close()
         cache_full_path = self._get_key_path(key)
         # And rename atomically (on POSIX at least)
-        if sys.platform == 'win32' and os.path.exists(cache_full_path):
+        if sys.platform == "win32" and os.path.exists(cache_full_path):
             os.unlink(cache_full_path)
         os.rename(path_name, cache_full_path)
 
@@ -299,10 +329,12 @@ class MultipleRepresentationCache(AtomicFileCache):
     This class is very much not thread-safe, but FileCache isn't
     thread-safe anyway.
     """
+
     def __init__(self, cache):
         """Tell FileCache to call append_media_type when generating keys."""
         super(MultipleRepresentationCache, self).__init__(
-            cache, self.append_media_type)
+            cache, self.append_media_type
+        )
         self.request_media_type = None
 
     def append_media_type(self, key):
@@ -313,20 +345,20 @@ class MultipleRepresentationCache(AtomicFileCache):
         media types.
         """
         if self.request_media_type is not None:
-            key = key + '-' + self.request_media_type
+            key = key + "-" + self.request_media_type
         return safename(key)
 
     def _getCachedHeader(self, uri, header):
         """Retrieve a cached value for an HTTP header."""
         (scheme, authority, request_uri, cachekey) = urlnorm(uri)
         cached_value = self.get(cachekey)
-        header_start = header + ':'
+        header_start = header + ":"
         if not isinstance(header_start, bytes):
-            header_start = header_start.encode('utf-8')
+            header_start = header_start.encode("utf-8")
         if cached_value is not None:
             for line in BytesIO(cached_value):
                 if line.startswith(header_start):
-                    return line[len(header_start):].strip()
+                    return line[len(header_start) :].strip()
         return None
 
 
@@ -336,8 +368,16 @@ class Browser:
     NOT_MODIFIED = object()
     MAX_RETRIES = 6
 
-    def __init__(self, service_root, credentials, cache=None, timeout=None,
-                 proxy_info=None, user_agent=None, max_retries=MAX_RETRIES):
+    def __init__(
+        self,
+        service_root,
+        credentials,
+        cache=None,
+        timeout=None,
+        proxy_info=None,
+        user_agent=None,
+        max_retries=MAX_RETRIES,
+    ):
         """Initialize, possibly creating a cache.
 
         If no cache is provided, a temporary directory will be used as
@@ -350,49 +390,64 @@ class Browser:
         if isinstance(cache, str_types):
             cache = MultipleRepresentationCache(cache)
         self._connection = service_root.httpFactory(
-            credentials, cache, timeout, proxy_info)
+            credentials, cache, timeout, proxy_info
+        )
         self.user_agent = user_agent
         self.max_retries = max_retries
 
     def _request_and_retry(self, url, method, body, headers):
-        for retry_count in range(0, self.max_retries+1):
+        for retry_count in range(0, self.max_retries + 1):
             response, content = self._connection.request(
-                url, method=method, body=body, headers=headers)
-            if (response.status in [502, 503]
-                and retry_count < self.max_retries):
+                url, method=method, body=body, headers=headers
+            )
+            if (
+                response.status in [502, 503]
+                and retry_count < self.max_retries
+            ):
                 # The server returned a 502 or 503. Sleep for 0, 1, 2,
                 # 4, 8, 16, ... seconds and try again.
-                sleep_for = int(2**(retry_count-1))
+                sleep_for = int(2 ** (retry_count - 1))
                 sleep(sleep_for)
             else:
                 break
         # Either the request succeeded or we gave up.
         return response, content
 
-    def _request(self, url, data=None, method='GET',
-                 media_type='application/json', extra_headers=None):
+    def _request(
+        self,
+        url,
+        data=None,
+        method="GET",
+        media_type="application/json",
+        extra_headers=None,
+    ):
         """Create an authenticated request object."""
         # If the user is trying to get data that has been redacted,
         # give a helpful message.
         if url == "tag:launchpad.net:2008:redacted":
-            raise ValueError("You tried to access a resource that you "
-                             "don't have the server-side permission to see.")
+            raise ValueError(
+                "You tried to access a resource that you "
+                "don't have the server-side permission to see."
+            )
 
         # Add extra headers for the request.
-        headers = {'Accept': media_type}
+        headers = {"Accept": media_type}
         if self.user_agent is not None:
-            headers['User-Agent'] = self.user_agent
+            headers["User-Agent"] = self.user_agent
         if isinstance(self._connection.cache, MultipleRepresentationCache):
             self._connection.cache.request_media_type = media_type
         if extra_headers is not None:
             headers.update(extra_headers)
         response, content = self._request_and_retry(
-            str(url), method=method, body=data, headers=headers)
+            str(url), method=method, body=data, headers=headers
+        )
         if response.status == 304:
             # The resource didn't change.
-            if content == b'':
-                if ('If-None-Match' in headers
-                    or 'If-Modified-Since' in headers):
+            if content == b"":
+                if (
+                    "If-None-Match" in headers
+                    or "If-Modified-Since" in headers
+                ):
                     # The caller made a conditional request, and the
                     # condition failed. Rather than send an empty
                     # representation, which might be misinterpreted,
@@ -434,7 +489,7 @@ class Browser:
         if isinstance(resource_or_uri, (str_types, URI)):
             url = resource_or_uri
         else:
-            method = resource_or_uri.get_method('get')
+            method = resource_or_uri.get_method("get")
             url = method.build_request_url()
         response, content = self._request(url, extra_headers=headers)
         if return_response:
@@ -443,45 +498,49 @@ class Browser:
 
     def get_wadl_application(self, url):
         """GET a WADL representation of the resource at the requested url."""
-        wadl_type = 'application/vnd.sun.wadl+xml'
+        wadl_type = "application/vnd.sun.wadl+xml"
         response, content = self._request(url, media_type=wadl_type)
         url = str(url)
         if not isinstance(content, bytes):
-            content = content.encode('utf-8')
+            content = content.encode("utf-8")
         return Application(url, content)
 
     def post(self, url, method_name, **kws):
         """POST a request to the web service."""
-        kws['ws.op'] = method_name
+        kws["ws.op"] = method_name
         data = urlencode(kws)
-        return self._request(url, data, 'POST')
+        return self._request(url, data, "POST")
 
     def put(self, url, representation, media_type, headers=None):
         """PUT the given representation to the URL."""
-        extra_headers = {'Content-Type': media_type}
+        extra_headers = {"Content-Type": media_type}
         if headers is not None:
             extra_headers.update(headers)
         return self._request(
-            url, representation, 'PUT', extra_headers=extra_headers)
+            url, representation, "PUT", extra_headers=extra_headers
+        )
 
     def delete(self, url):
         """DELETE the resource at the given URL."""
-        self._request(url, method='DELETE')
+        self._request(url, method="DELETE")
         return None
 
     def patch(self, url, representation, headers=None):
         """PATCH the object at url with the updated representation."""
-        extra_headers = {'Content-Type': 'application/json'}
+        extra_headers = {"Content-Type": "application/json"}
         if headers is not None:
             extra_headers.update(headers)
         # httplib2 doesn't know about the PATCH method, so we need to
         # do some work ourselves. Pull any cached value of "ETag" out
         # and use it as the value for "If-Match".
-        cached_etag = self._connection._getCachedHeader(str(url), 'etag')
+        cached_etag = self._connection._getCachedHeader(str(url), "etag")
         if cached_etag is not None and not self._connection.ignore_etag:
             # http://www.w3.org/1999/04/Editing/
-            headers['If-Match'] = cached_etag
+            headers["If-Match"] = cached_etag
 
         return self._request(
-            url, dumps(representation, cls=DatetimeJSONEncoder),
-            'PATCH', extra_headers=extra_headers)
+            url,
+            dumps(representation, cls=DatetimeJSONEncoder),
+            "PATCH",
+            extra_headers=extra_headers,
+        )
diff --git a/src/lazr/restfulclient/_json.py b/src/lazr/restfulclient/_json.py
index 136c564..e3bacf7 100644
--- a/src/lazr/restfulclient/_json.py
+++ b/src/lazr/restfulclient/_json.py
@@ -19,7 +19,7 @@
 """Classes for working with JSON."""
 
 __metaclass__ = type
-__all__ = ['DatetimeJSONEncoder']
+__all__ = ["DatetimeJSONEncoder"]
 
 import datetime
 from json import JSONEncoder
@@ -30,6 +30,7 @@ class DatetimeJSONEncoder(JSONEncoder):
 
     Datetime objects are formatted according to ISO 1601.
     """
+
     def default(self, obj):
         if isinstance(obj, datetime.datetime):
             return obj.isoformat()
diff --git a/src/lazr/restfulclient/authorize/__init__.py b/src/lazr/restfulclient/authorize/__init__.py
index 471a3f9..faedd2a 100644
--- a/src/lazr/restfulclient/authorize/__init__.py
+++ b/src/lazr/restfulclient/authorize/__init__.py
@@ -27,9 +27,9 @@ module.
 
 __metaclass__ = type
 __all__ = [
-    'BasicHttpAuthorizer',
-    'HttpAuthorizer',
-    ]
+    "BasicHttpAuthorizer",
+    "HttpAuthorizer",
+]
 
 import base64
 
@@ -47,6 +47,7 @@ class HttpAuthorizer:
     The base class is a null authorizer which does not perform any
     authentication at all.
     """
+
     def authorizeSession(self, client):
         """Set up credentials for the entire session."""
         pass
@@ -87,8 +88,12 @@ class BasicHttpAuthorizer(HttpAuthorizer):
 
         This sets the authorization header with the username/password.
         """
-        headers['authorization'] = 'Basic ' + base64.b64encode(
-            "%s:%s" % (self.username, self.password)).strip()
+        headers["authorization"] = (
+            "Basic "
+            + base64.b64encode(
+                "%s:%s" % (self.username, self.password)
+            ).strip()
+        )
 
     def authorizeSession(self, client):
         client.add_credentials(self.username, self.password)
diff --git a/src/lazr/restfulclient/authorize/oauth.py b/src/lazr/restfulclient/authorize/oauth.py
index 9296f22..09abf0b 100644
--- a/src/lazr/restfulclient/authorize/oauth.py
+++ b/src/lazr/restfulclient/authorize/oauth.py
@@ -24,31 +24,29 @@ try:
     from configparser import ConfigParser as SafeConfigParser
 except ImportError:
     from ConfigParser import SafeConfigParser
+
 import os
 import platform
-import stat
 import socket
+import stat
 
-from oauthlib import oauth1
 import six
-from six.moves.urllib.parse import (
-    parse_qs,
-    urlencode,
-    )
+from oauthlib import oauth1
+from six.moves.urllib.parse import parse_qs, urlencode
 
 from lazr.restfulclient.authorize import HttpAuthorizer
 from lazr.restfulclient.errors import CredentialsFileError
 
 __metaclass__ = type
 __all__ = [
-    'AccessToken',
-    'Consumer',
-    'OAuthAuthorizer',
-    'SystemWideConsumer',
-    ]
+    "AccessToken",
+    "Consumer",
+    "OAuthAuthorizer",
+    "SystemWideConsumer",
+]
 
 
-CREDENTIALS_FILE_VERSION = '1'
+CREDENTIALS_FILE_VERSION = "1"
 
 
 # For compatibility, Consumer and AccessToken are defined using terminology
@@ -56,7 +54,7 @@ CREDENTIALS_FILE_VERSION = '1'
 class Consumer:
     """An OAuth consumer (application)."""
 
-    def __init__(self, key, secret='', application_name=None):
+    def __init__(self, key, secret="", application_name=None):
         """Initialize
 
         :param key: The OAuth consumer key
@@ -74,16 +72,18 @@ class Consumer:
 class AccessToken:
     """An OAuth access token."""
 
-    def __init__(self, key, secret='', context=None):
+    def __init__(self, key, secret="", context=None):
         self.key = key
         self.secret = secret
         self.context = context
 
     def to_string(self):
-        return urlencode([
-            ("oauth_token_secret", self.secret),
-            ("oauth_token", self.key),
-            ])
+        return urlencode(
+            [
+                ("oauth_token_secret", self.secret),
+                ("oauth_token", self.key),
+            ]
+        )
 
     __str__ = to_string
 
@@ -111,9 +111,10 @@ class SystemWideConsumer(Consumer):
     desktop applications. The OAuth consumer key will be derived from
     system information (platform and hostname).
     """
+
     KEY_FORMAT = "System-wide: %s (%s)"
 
-    def __init__(self, application_name, secret=''):
+    def __init__(self, application_name, secret=""):
         """Constructor.
 
         :param application_name: An application name. This will be
@@ -122,7 +123,8 @@ class SystemWideConsumer(Consumer):
             a misfeature, and lazr.restful doesn't expect it.
         """
         super(SystemWideConsumer, self).__init__(
-            self.consumer_key, secret, application_name)
+            self.consumer_key, secret, application_name
+        )
 
     @property
     def consumer_key(self):
@@ -133,26 +135,33 @@ class SystemWideConsumer(Consumer):
         """
         try:
             import distro
+
             distname = distro.name()
         except Exception:
             # This can happen due to various kinds of failures with the data
             # sources used by the distro module.
-            distname = ''
-        if distname == '':
-            distname = platform.system() # (eg. "Windows")
+            distname = ""
+        if distname == "":
+            distname = platform.system()  # (eg. "Windows")
         return self.KEY_FORMAT % (distname, socket.gethostname())
 
 
 class OAuthAuthorizer(HttpAuthorizer):
     """A client that signs every outgoing request with OAuth credentials."""
 
-    def __init__(self, consumer_name=None, consumer_secret='',
-                 access_token=None, oauth_realm="OAuth",
-                 application_name=None):
+    def __init__(
+        self,
+        consumer_name=None,
+        consumer_secret="",
+        access_token=None,
+        oauth_realm="OAuth",
+        application_name=None,
+    ):
         self.consumer = None
         if consumer_name is not None:
             self.consumer = Consumer(
-                consumer_name, consumer_secret, application_name)
+                consumer_name, consumer_secret, application_name
+            )
         self.access_token = access_token
         self.oauth_realm = oauth_realm
 
@@ -165,9 +174,9 @@ class OAuthAuthorizer(HttpAuthorizer):
         params = {}
         if self.consumer is None:
             return params
-        params['oauth_consumer'] = self.consumer.key
+        params["oauth_consumer"] = self.consumer.key
         if self.consumer.application_name is not None:
-            params['application'] =  self.consumer.application_name
+            params["application"] = self.consumer.application_name
         return params
 
     def load(self, readable_file):
@@ -182,22 +191,21 @@ class OAuthAuthorizer(HttpAuthorizer):
         """
         # Attempt to load the access token from the file.
         parser = SafeConfigParser()
-        reader = getattr(parser, 'read_file', parser.readfp)
+        reader = getattr(parser, "read_file", parser.readfp)
         reader(readable_file)
         # Check the version number and extract the access token and
         # secret.  Then convert these to the appropriate instances.
         if not parser.has_section(CREDENTIALS_FILE_VERSION):
-            raise CredentialsFileError('No configuration for version %s' %
-                                       CREDENTIALS_FILE_VERSION)
-        consumer_key = parser.get(
-            CREDENTIALS_FILE_VERSION, 'consumer_key')
+            raise CredentialsFileError(
+                "No configuration for version %s" % CREDENTIALS_FILE_VERSION
+            )
+        consumer_key = parser.get(CREDENTIALS_FILE_VERSION, "consumer_key")
         consumer_secret = parser.get(
-            CREDENTIALS_FILE_VERSION, 'consumer_secret')
+            CREDENTIALS_FILE_VERSION, "consumer_secret"
+        )
         self.consumer = Consumer(consumer_key, consumer_secret)
-        access_token = parser.get(
-            CREDENTIALS_FILE_VERSION, 'access_token')
-        access_secret = parser.get(
-            CREDENTIALS_FILE_VERSION, 'access_secret')
+        access_token = parser.get(CREDENTIALS_FILE_VERSION, "access_token")
+        access_secret = parser.get(CREDENTIALS_FILE_VERSION, "access_secret")
         self.access_token = AccessToken(access_token, access_secret)
 
     @classmethod
@@ -214,7 +222,7 @@ class OAuthAuthorizer(HttpAuthorizer):
         :rtype: `Credentials`
         """
         credentials = cls()
-        credentials_file = open(path, 'r')
+        credentials_file = open(path, "r")
         credentials.load(credentials_file)
         credentials_file.close()
         return credentials
@@ -229,20 +237,22 @@ class OAuthAuthorizer(HttpAuthorizer):
             access token
         """
         if self.consumer is None:
-            raise CredentialsFileError('No consumer')
+            raise CredentialsFileError("No consumer")
         if self.access_token is None:
-            raise CredentialsFileError('No access token')
+            raise CredentialsFileError("No access token")
 
         parser = SafeConfigParser()
         parser.add_section(CREDENTIALS_FILE_VERSION)
-        parser.set(CREDENTIALS_FILE_VERSION,
-                   'consumer_key', self.consumer.key)
-        parser.set(CREDENTIALS_FILE_VERSION,
-                   'consumer_secret', self.consumer.secret)
-        parser.set(CREDENTIALS_FILE_VERSION,
-                   'access_token', self.access_token.key)
-        parser.set(CREDENTIALS_FILE_VERSION,
-                   'access_secret', self.access_token.secret)
+        parser.set(CREDENTIALS_FILE_VERSION, "consumer_key", self.consumer.key)
+        parser.set(
+            CREDENTIALS_FILE_VERSION, "consumer_secret", self.consumer.secret
+        )
+        parser.set(
+            CREDENTIALS_FILE_VERSION, "access_token", self.access_token.key
+        )
+        parser.set(
+            CREDENTIALS_FILE_VERSION, "access_secret", self.access_token.secret
+        )
         parser.write(writable_file)
 
     def save_to_path(self, path):
@@ -256,8 +266,13 @@ class OAuthAuthorizer(HttpAuthorizer):
         :type path: string
         """
         credentials_file = os.fdopen(
-            os.open(path, (os.O_CREAT | os.O_TRUNC | os.O_WRONLY),
-                    (stat.S_IREAD | stat.S_IWRITE)), 'w')
+            os.open(
+                path,
+                (os.O_CREAT | os.O_TRUNC | os.O_WRONLY),
+                (stat.S_IREAD | stat.S_IWRITE),
+            ),
+            "w",
+        )
         self.save(credentials_file)
         credentials_file.close()
 
@@ -266,10 +281,11 @@ class OAuthAuthorizer(HttpAuthorizer):
         client = oauth1.Client(
             self.consumer.key,
             client_secret=self.consumer.secret,
-            resource_owner_key=TruthyString(self.access_token.key or ''),
+            resource_owner_key=TruthyString(self.access_token.key or ""),
             resource_owner_secret=self.access_token.secret,
             signature_method=oauth1.SIGNATURE_PLAINTEXT,
-            realm=self.oauth_realm)
+            realm=self.oauth_realm,
+        )
         # The older oauth library (which may still be used on the server)
         # requires the oauth_token parameter to be present and will fail
         # authentication if it isn't.  This hack forces it to be present
@@ -280,6 +296,6 @@ class OAuthAuthorizer(HttpAuthorizer):
             # client.sign returns Unicode headers; convert these to native
             # strings.
             if six.PY2:
-                key = key.encode('UTF-8')
-                value = value.encode('UTF-8')
+                key = key.encode("UTF-8")
+                value = value.encode("UTF-8")
             headers[key] = value
diff --git a/src/lazr/restfulclient/docs/Makefile b/src/lazr/restfulclient/docs/Makefile
index 28fde7e..4784813 100644
--- a/src/lazr/restfulclient/docs/Makefile
+++ b/src/lazr/restfulclient/docs/Makefile
@@ -17,4 +17,4 @@ help:
 # Catch-all target: route all unknown targets to Sphinx using the new
 # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
 %: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
\ No newline at end of file
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/src/lazr/restfulclient/docs/authorizer.standalone.rst b/src/lazr/restfulclient/docs/authorizer.standalone.rst
index 025e3df..f9bca0c 100644
--- a/src/lazr/restfulclient/docs/authorizer.standalone.rst
+++ b/src/lazr/restfulclient/docs/authorizer.standalone.rst
@@ -266,4 +266,3 @@ they request anonymous access.
 Teardown.
 
     >>> _ = wsgi_intercept.remove_wsgi_intercept("api.launchpad.dev", 80)
-
diff --git a/src/lazr/restfulclient/docs/conf.py b/src/lazr/restfulclient/docs/conf.py
index 5bbb48f..4b8f219 100644
--- a/src/lazr/restfulclient/docs/conf.py
+++ b/src/lazr/restfulclient/docs/conf.py
@@ -34,21 +34,21 @@ from lazr.restfulclient import __version__
 extensions = []
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
 # source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
+source_suffix = ".rst"
 
 # The master toctree document.
-master_doc = 'index'
+master_doc = "index"
 
 # General information about the project.
-project = u'lazr.restfulclient'
-copyright = u'2008-2018, Canonical Ltd.'
-author = u'LAZR Developers <[e-mail]>'
+project = u"lazr.restfulclient"
+copyright = u"2008-2018, Canonical Ltd."
+author = u"LAZR Developers <[e-mail]>"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -69,10 +69,10 @@ language = None
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = False
@@ -83,7 +83,7 @@ todo_include_todos = False
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'alabaster'
+html_theme = "alabaster"
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
@@ -94,7 +94,7 @@ html_theme = 'alabaster'
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-#html_static_path = ['_static']
+# html_static_path = ['_static']
 
 # Custom sidebar templates, must be a dictionary that maps document names
 # to template names.
@@ -102,9 +102,9 @@ html_theme = 'alabaster'
 # This is required for the alabaster theme
 # refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
 html_sidebars = {
-    '**': [
-        'relations.html',  # needs 'show_related': True theme option to display
-        'searchbox.html',
+    "**": [
+        "relations.html",  # needs 'show_related': True theme option to display
+        "searchbox.html",
     ]
 }
 
@@ -112,7 +112,7 @@ html_sidebars = {
 # -- Options for HTMLHelp output ------------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'lazrrestfulclientdoc'
+htmlhelp_basename = "lazrrestfulclientdoc"
 
 
 # -- Options for LaTeX output ---------------------------------------------
@@ -121,15 +121,12 @@ latex_elements = {
     # The paper size ('letterpaper' or 'a4paper').
     #
     # 'papersize': 'letterpaper',
-
     # The font size ('10pt', '11pt' or '12pt').
     #
     # 'pointsize': '10pt',
-
     # Additional stuff for the LaTeX preamble.
     #
     # 'preamble': '',
-
     # Latex figure (float) alignment
     #
     # 'figure_align': 'htbp',
@@ -139,8 +136,13 @@ latex_elements = {
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, 'lazrrestfulclient.tex', u'lazr.restfulclient Documentation',
-     u'LAZR Developers', 'manual'),
+    (
+        master_doc,
+        "lazrrestfulclient.tex",
+        u"lazr.restfulclient Documentation",
+        u"LAZR Developers",
+        "manual",
+    ),
 ]
 
 
@@ -149,8 +151,13 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    (master_doc, 'lazrrestfulclient', u'lazr.restfulclient Documentation',
-     [author], 1)
+    (
+        master_doc,
+        "lazrrestfulclient",
+        u"lazr.restfulclient Documentation",
+        [author],
+        1,
+    )
 ]
 
 
@@ -160,10 +167,13 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (master_doc, 'lazrrestfulclient', u'lazr.restfulclient Documentation',
-     author, 'lazrrestfulclient', 'One line description of project.',
-     'Miscellaneous'),
+    (
+        master_doc,
+        "lazrrestfulclient",
+        u"lazr.restfulclient Documentation",
+        author,
+        "lazrrestfulclient",
+        "One line description of project.",
+        "Miscellaneous",
+    ),
 ]
-
-
-
diff --git a/src/lazr/restfulclient/docs/toplevel.rst b/src/lazr/restfulclient/docs/toplevel.rst
index 469b326..eb796f6 100644
--- a/src/lazr/restfulclient/docs/toplevel.rst
+++ b/src/lazr/restfulclient/docs/toplevel.rst
@@ -207,4 +207,3 @@ different HTTPError subclasses, see tests/test_error.py.
 
     >>> print isinstance(e, HTTPError)
     True
-
diff --git a/src/lazr/restfulclient/errors.py b/src/lazr/restfulclient/errors.py
index 6b702b7..3859d17 100644
--- a/src/lazr/restfulclient/errors.py
+++ b/src/lazr/restfulclient/errors.py
@@ -20,21 +20,21 @@
 
 __metaclass__ = type
 __all__ = [
-    'BadRequest',
-    'Conflict',
-    'ClientError',
-    'CredentialsError',
-    'CredentialsFileError',
-    'HTTPError',
-    'MethodNotAllowed',
-    'NotFound',
-    'PreconditionFailed',
-    'RestfulError',
-    'ResponseError',
-    'ServerError',
-    'Unauthorized',
-    'UnexpectedResponseError',
-    ]
+    "BadRequest",
+    "Conflict",
+    "ClientError",
+    "CredentialsError",
+    "CredentialsFileError",
+    "HTTPError",
+    "MethodNotAllowed",
+    "NotFound",
+    "PreconditionFailed",
+    "RestfulError",
+    "ResponseError",
+    "ServerError",
+    "Unauthorized",
+    "UnexpectedResponseError",
+]
 
 
 class RestfulError(Exception):
@@ -62,7 +62,7 @@ class UnexpectedResponseError(ResponseError):
     """An unexpected response was received."""
 
     def __str__(self):
-        return '%s: %s' % (self.response.status, self.response.reason)
+        return "%s: %s" % (self.response.status, self.response.reason)
 
 
 class HTTPError(ResponseError):
@@ -70,12 +70,14 @@ class HTTPError(ResponseError):
 
     def __str__(self):
         """Show the error code, response headers, and response body."""
-        headers = "\n".join(["%s: %s" % pair
-                             for pair in sorted(self.response.items())])
-        return ("HTTP Error %s: %s\n"
-                "Response headers:\n---\n%s\n---\n"
-                "Response body:\n---\n%s\n---\n") % (
-            self.response.status, self.response.reason, headers, self.content)
+        headers = "\n".join(
+            ["%s: %s" % pair for pair in sorted(self.response.items())]
+        )
+        return (
+            "HTTP Error %s: %s\n"
+            "Response headers:\n---\n%s\n---\n"
+            "Response body:\n---\n%s\n---\n"
+        ) % (self.response.status, self.response.reason, headers, self.content)
 
 
 class ClientError(HTTPError):
@@ -114,6 +116,7 @@ class PreconditionFailed(ClientError):
     object is now out of date.
     """
 
+
 class ServerError(HTTPError):
     """An exception representing a server-side error."""
 
@@ -126,12 +129,12 @@ def error_for(response, content):
     if nothing else is appropriate.
     """
     http_errors_by_status_code = {
-        400 : BadRequest,
-        401 : Unauthorized,
-        404 : NotFound,
-        405 : MethodNotAllowed,
-        409 : Conflict,
-        412 : PreconditionFailed,
+        400: BadRequest,
+        401: Unauthorized,
+        404: NotFound,
+        405: MethodNotAllowed,
+        409: Conflict,
+        412: PreconditionFailed,
     }
 
     if response.status // 100 <= 3:
diff --git a/src/lazr/restfulclient/resource.py b/src/lazr/restfulclient/resource.py
index 70e3c05..a330676 100644
--- a/src/lazr/restfulclient/resource.py
+++ b/src/lazr/restfulclient/resource.py
@@ -20,13 +20,13 @@
 
 __metaclass__ = type
 __all__ = [
-    'Collection',
-    'CollectionWithKeyBasedLookup',
-    'Entry',
-    'NamedOperation',
-    'Resource',
-    'ServiceRoot',
-    ]
+    "Collection",
+    "CollectionWithKeyBasedLookup",
+    "Entry",
+    "NamedOperation",
+    "Resource",
+    "ServiceRoot",
+]
 
 
 from email.message import Message
@@ -35,26 +35,27 @@ from json import dumps, loads
 
 try:
     # Python 3.
-    from urllib.parse import urljoin, urlparse, parse_qs, unquote, urlencode
+    from urllib.parse import parse_qs, unquote, urlencode, urljoin, urlparse
 except ImportError:
     from urlparse import urljoin, urlparse, parse_qs
     from urllib import unquote, urlencode
 
 import sys
+
 if sys.version_info[0] >= 3:
     text_type = str
     binary_type = bytes
 else:
-    text_type = unicode
+    text_type = unicode  # noqa: F821
     binary_type = str
 
-from lazr.uri import URI
 from wadllib.application import Resource as WadlResource
 
 from lazr.restfulclient import __version__
 from lazr.restfulclient._browser import Browser, RestfulHttp
 from lazr.restfulclient._json import DatetimeJSONEncoder
 from lazr.restfulclient.errors import HTTPError
+from lazr.uri import URI
 
 missing = object()
 
@@ -70,6 +71,7 @@ class HeaderDictionary:
     the underlying dictionary. That way wadllib can pass in the
     official header name and httplib2 will get the lowercased name.
     """
+
     def __init__(self, wrapped_dictionary):
         self.wrapped_dictionary = wrapped_dictionary
 
@@ -88,7 +90,7 @@ class HeaderDictionary:
 class RestfulBase:
     """Base class for classes that know about lazr.restful services."""
 
-    JSON_MEDIA_TYPE = 'application/json'
+    JSON_MEDIA_TYPE = "application/json"
 
     def _transform_resources_to_links(self, dictionary):
         new_dictionary = {}
@@ -119,8 +121,8 @@ class Resource(RestfulBase):
             root = self
         # These values need to be put directly into __dict__ to avoid
         # calling __setattr__, which would cause an infinite recursion.
-        self.__dict__['_root'] = root
-        self.__dict__['_wadl_resource'] = wadl_resource
+        self.__dict__["_root"] = root
+        self.__dict__["_wadl_resource"] = wadl_resource
 
     FIND_COLLECTIONS = object()
     FIND_ENTRIES = object()
@@ -149,19 +151,22 @@ class Resource(RestfulBase):
         names = []
         for method in self._wadl_resource.method_iter:
             name = method.name.lower()
-            if name == 'get':
-                params = method.request.params(['query', 'plain'])
-            elif name == 'post':
-                for media_type in ['application/x-www-form-urlencoded',
-                                   'multipart/form-data']:
+            if name == "get":
+                params = method.request.params(["query", "plain"])
+            elif name == "post":
+                for media_type in [
+                    "application/x-www-form-urlencoded",
+                    "multipart/form-data",
+                ]:
                     definition = method.request.get_representation_definition(
-                        media_type)
+                        media_type
+                    )
                     if definition is not None:
                         definition = definition.resolve_definition()
                         break
                 params = definition.params(self._wadl_resource)
             for param in params:
-                if param.name == 'ws.op':
+                if param.name == "ws.op":
                     names.append(param.fixed_value)
                     break
         return names
@@ -170,19 +175,18 @@ class Resource(RestfulBase):
     def __members__(self):
         """A hook into dir() that returns web service-derived members."""
         return self._get_parameter_names(
-            self.FIND_COLLECTIONS, self.FIND_ENTRIES, self.FIND_ATTRIBUTES)
+            self.FIND_COLLECTIONS, self.FIND_ENTRIES, self.FIND_ATTRIBUTES
+        )
 
     __methods__ = lp_operations
 
     def _get_parameter_names(self, *kinds):
         """Retrieve some subset of the resource's parameters."""
         names = []
-        for parameter in self._wadl_resource.parameters(
-            self.JSON_MEDIA_TYPE):
+        for parameter in self._wadl_resource.parameters(self.JSON_MEDIA_TYPE):
             name = parameter.name
             link = parameter.link
-            if (name != 'self_link' and link is not None
-                and link.can_follow):
+            if name != "self_link" and link is not None and link.can_follow:
                 # This is a link to a resource with a WADL
                 # description.  Since this is a lazr.restful web
                 # service, we know it's either an entry or a
@@ -192,7 +196,7 @@ class Resource(RestfulBase):
                 # self_link is a special case. 'obj.self' will always
                 # work, but it's not useful. 'obj.self_link' is
                 # useful, so we advertise the scalar value instead.
-                if name.endswith('_collection_link'):
+                if name.endswith("_collection_link"):
                     # It's a link to a collection.
                     if self.FIND_COLLECTIONS in kinds:
                         names.append(name[:-16])
@@ -222,9 +226,8 @@ class Resource(RestfulBase):
                  representation, if the parameter is a link.
         """
         self._ensure_representation()
-        for suffix in ['_link', '_collection_link']:
-            param = self._wadl_resource.get_parameter(
-                param_name + suffix)
+        for suffix in ["_link", "_collection_link"]:
+            param = self._wadl_resource.get_parameter(param_name + suffix)
             if param is not None:
                 try:
                     param.get_value()
@@ -239,7 +242,8 @@ class Resource(RestfulBase):
                     return None
                 linked_resource = param.linked_resource
                 return self._create_bound_resource(
-                    self._root, linked_resource, param_name=param.name)
+                    self._root, linked_resource, param_name=param.name
+                )
         param = self._wadl_resource.get_parameter(param_name)
         if param is None:
             raise KeyError("No such parameter: %s" % param_name)
@@ -251,21 +255,27 @@ class Resource(RestfulBase):
         :return: A NamedOperation instance that can be called with
                  appropriate arguments to invoke the operation.
         """
-        params = {'ws.op': operation_name}
-        method = self._wadl_resource.get_method('get', query_params=params)
+        params = {"ws.op": operation_name}
+        method = self._wadl_resource.get_method("get", query_params=params)
         if method is None:
             method = self._wadl_resource.get_method(
-                'post', representation_params=params)
+                "post", representation_params=params
+            )
         if method is None:
             raise KeyError("No operation with name: %s" % operation_name)
         return NamedOperation(self._root, self, method)
 
     @classmethod
     def _create_bound_resource(
-        cls, root, resource, representation=None,
-        representation_media_type='application/json',
-        representation_needs_processing=True, representation_definition=None,
-        param_name=None):
+        cls,
+        root,
+        resource,
+        representation=None,
+        representation_media_type="application/json",
+        representation_needs_processing=True,
+        representation_definition=None,
+        param_name=None,
+    ):
         """Create a lazr.restful Resource subclass from a wadllib Resource.
 
         :param resource: The wadllib Resource to wrap.
@@ -295,18 +305,20 @@ class Resource(RestfulBase):
         resource_type = urlparse(type_url)[-1]
         default = Entry
 
-        if (type_url.endswith('-page')
-            or (param_name is not None
-                and param_name.endswith('_collection_link'))):
+        if type_url.endswith("-page") or (
+            param_name is not None and param_name.endswith("_collection_link")
+        ):
             default = Collection
         r_class = root.RESOURCE_TYPE_CLASSES.get(resource_type, default)
         if representation is not None:
             # We've been given a representation. Bind the resource
             # immediately.
             resource = resource.bind(
-                representation, representation_media_type,
+                representation,
+                representation_media_type,
                 representation_needs_processing,
-                representation_definition=representation_definition)
+                representation_definition=representation_definition,
+            )
         else:
             # We'll fetch a representation and bind the resource when
             # necessary.
@@ -319,16 +331,18 @@ class Resource(RestfulBase):
             self._wadl_resource._url = new_url
         headers = {}
         if etag is not None:
-            headers['If-None-Match'] = etag
+            headers["If-None-Match"] = etag
         representation = self._root._browser.get(
-            self._wadl_resource, headers=headers)
+            self._wadl_resource, headers=headers
+        )
         if representation == self._root._browser.NOT_MODIFIED:
             # The entry wasn't modified. No need to do anything.
             return
         # __setattr__ assumes we're setting an attribute of the resource,
         # so we manipulate __dict__ directly.
-        self.__dict__['_wadl_resource'] = self._wadl_resource.bind(
-            representation, self.JSON_MEDIA_TYPE)
+        self.__dict__["_wadl_resource"] = self._wadl_resource.bind(
+            representation, self.JSON_MEDIA_TYPE
+        )
 
     def __getattr__(self, attr):
         """Try to retrive a named operation or parameter of the given name."""
@@ -339,13 +353,15 @@ class Resource(RestfulBase):
         try:
             return self.lp_get_parameter(attr)
         except KeyError:
-            raise AttributeError("%s object has no attribute '%s'"
-                % (self, attr))
+            raise AttributeError(
+                "%s object has no attribute '%s'" % (self, attr)
+            )
 
     def lp_values_for(self, param_name):
         """Find the set of possible values for a parameter."""
         parameter = self._wadl_resource.get_parameter(
-            param_name, self.JSON_MEDIA_TYPE)
+            param_name, self.JSON_MEDIA_TYPE
+        )
         options = parameter.options
         if len(options) > 0:
             return [option.value for option in options]
@@ -353,7 +369,7 @@ class Resource(RestfulBase):
 
     def _get_external_param_name(self, param_name):
         """What's this parameter's name in the underlying representation?"""
-        for suffix in ['_link', '_collection_link', '']:
+        for suffix in ["_link", "_collection_link", ""]:
             name = param_name + suffix
             if self._wadl_resource.get_parameter(name):
                 return name
@@ -365,7 +381,7 @@ class Resource(RestfulBase):
             # Get a representation of the linked resource.
             representation = self._root._browser.get(self._wadl_resource)
             if isinstance(representation, binary_type):
-                representation = representation.decode('utf-8')
+                representation = representation.decode("utf-8")
             representation = loads(representation)
 
             # In rare cases, the resource type served by the
@@ -377,15 +393,20 @@ class Resource(RestfulBase):
             # defined by Entry, since it's not relevant to other
             # resource types.
             if isinstance(representation, dict):
-                type_link = representation['resource_type_link']
-                if (type_link is not None
-                    and type_link != self._wadl_resource.type_url):
+                type_link = representation["resource_type_link"]
+                if (
+                    type_link is not None
+                    and type_link != self._wadl_resource.type_url
+                ):
                     resource_type = self._root._wadl.get_resource_type(
-                        type_link)
+                        type_link
+                    )
                     self._wadl_resource.tag = resource_type.tag
-            self.__dict__['_wadl_resource'] = self._wadl_resource.bind(
-                representation, self.JSON_MEDIA_TYPE,
-                representation_needs_processing=False)
+            self.__dict__["_wadl_resource"] = self._wadl_resource.bind(
+                representation,
+                self.JSON_MEDIA_TYPE,
+                representation_needs_processing=False,
+            )
 
     def __ne__(self, other):
         """Inequality operator."""
@@ -405,9 +426,9 @@ class ScalarValue(Resource):
 class HostedFile(Resource):
     """A resource representing a file managed by a lazr.restful service."""
 
-    def open(self, mode='r', content_type=None, filename=None):
+    def open(self, mode="r", content_type=None, filename=None):
         """Open the file on the server for read or write access."""
-        if mode in ('r', 'w'):
+        if mode in ("r", "w"):
             return HostedFileBuffer(self, mode, content_type, filename)
         else:
             raise ValueError("Invalid mode. Supported modes are: r, w")
@@ -429,8 +450,10 @@ class HostedFile(Resource):
         retrieve or modify the hosted file contents is to open a
         filehandle, which goes direct to the server.
         """
-        return (other is not None and
-                self._wadl_resource.url == other._wadl_resource.url)
+        return (
+            other is not None
+            and self._wadl_resource.url == other._wadl_resource.url
+        )
 
 
 class ServiceRoot(Resource):
@@ -441,12 +464,22 @@ class ServiceRoot(Resource):
 
     # Custom subclasses of Resource to use when
     # instantiating resources of a certain WADL type.
-    RESOURCE_TYPE_CLASSES = {'HostedFile': HostedFile,
-                             'ScalarValue': ScalarValue}
-
-    def __init__(self, authorizer, service_root, cache=None,
-                 timeout=None, proxy_info=None, version=None,
-                 base_client_name='', max_retries=Browser.MAX_RETRIES):
+    RESOURCE_TYPE_CLASSES = {
+        "HostedFile": HostedFile,
+        "ScalarValue": ScalarValue,
+    }
+
+    def __init__(
+        self,
+        authorizer,
+        service_root,
+        cache=None,
+        timeout=None,
+        proxy_info=None,
+        version=None,
+        base_client_name="",
+        max_retries=Browser.MAX_RETRIES,
+    ):
         """Root access to a lazr.restful API.
 
         :param credentials: The credentials used to access the service.
@@ -454,11 +487,11 @@ class ServiceRoot(Resource):
         :type service_root: string
         """
         if version is not None:
-            if service_root[-1] != '/':
-                service_root += '/'
+            if service_root[-1] != "/":
+                service_root += "/"
             service_root += str(version)
-            if service_root[-1] != '/':
-                service_root += '/'
+            if service_root[-1] != "/":
+                service_root += "/"
         self._root_uri = URI(service_root)
 
         # Set up data necessary to calculate the User-Agent header.
@@ -467,14 +500,21 @@ class ServiceRoot(Resource):
         # Get the WADL definition.
         self.credentials = authorizer
         self._browser = Browser(
-            self, authorizer, cache, timeout, proxy_info, self._user_agent,
-            max_retries)
+            self,
+            authorizer,
+            cache,
+            timeout,
+            proxy_info,
+            self._user_agent,
+            max_retries,
+        )
         self._wadl = self._browser.get_wadl_application(self._root_uri)
 
         # Get the root resource.
-        root_resource = self._wadl.get_resource_by_path('')
+        root_resource = self._wadl.get_resource_by_path("")
         bound_root = root_resource.bind(
-            self._browser.get(root_resource), 'application/json')
+            self._browser.get(root_resource), "application/json"
+        )
         super(ServiceRoot, self).__init__(None, bound_root)
 
     @property
@@ -490,17 +530,17 @@ class ServiceRoot(Resource):
         user agent (such as the application name).
         """
         base_portion = "lazr.restfulclient %s" % __version__
-        if self._base_client_name != '':
-            base_portion = self._base_client_name + ' (' + base_portion + ')'
+        if self._base_client_name != "":
+            base_portion = self._base_client_name + " (" + base_portion + ")"
 
         message = Message()
-        message['User-Agent'] = base_portion
+        message["User-Agent"] = base_portion
         if self.credentials is not None:
             user_agent_params = self.credentials.user_agent_params
             for key in sorted(user_agent_params):
                 value = user_agent_params[key]
-                message.set_param(key, value, 'User-Agent')
-        return message['User-Agent']
+                message.set_param(key, value, "User-Agent")
+        return message["User-Agent"]
 
     def httpFactory(self, authorizer, cache, timeout, proxy_info):
         return RestfulHttp(authorizer, cache, timeout, proxy_info)
@@ -508,28 +548,33 @@ class ServiceRoot(Resource):
     def load(self, url):
         """Load a resource given its URL."""
         parsed = urlparse(url)
-        if parsed.scheme == '':
+        if parsed.scheme == "":
             # This is a relative URL. Make it absolute by joining
             # it with the service root resource.
-            if url[:1] == '/':
+            if url[:1] == "/":
                 url = url[1:]
             url = str(self._root_uri.append(url))
         document = self._browser.get(url)
         if isinstance(document, binary_type):
-            document = document.decode('utf-8')
+            document = document.decode("utf-8")
         try:
             representation = loads(document)
         except ValueError:
             raise ValueError("%s doesn't serve a JSON document." % url)
         type_link = representation.get("resource_type_link")
         if type_link is None:
-            raise ValueError("Couldn't determine the resource type of %s."
-                             % url)
+            raise ValueError(
+                "Couldn't determine the resource type of %s." % url
+            )
         resource_type = self._root._wadl.get_resource_type(type_link)
         wadl_resource = WadlResource(self._root._wadl, url, resource_type.tag)
         return self._create_bound_resource(
-            self._root, wadl_resource, representation, 'application/json',
-            representation_needs_processing=False)
+            self._root,
+            wadl_resource,
+            representation,
+            "application/json",
+            representation_needs_processing=False,
+        )
 
 
 class NamedOperation(RestfulBase):
@@ -544,27 +589,33 @@ class NamedOperation(RestfulBase):
     def __call__(self, *args, **kwargs):
         """Invoke the method and process the result."""
         if len(args) > 0:
-            raise TypeError('Method must be called with keyword args.')
+            raise TypeError("Method must be called with keyword args.")
         http_method = self.wadl_method.name
         args = self._transform_resources_to_links(kwargs)
         request = self.wadl_method.request
 
-        if http_method in ('get', 'head', 'delete'):
+        if http_method in ("get", "head", "delete"):
             params = request.query_params
         else:
             definition = request.get_representation_definition(
-                'multipart/form-data')
+                "multipart/form-data"
+            )
             if definition is None:
                 definition = request.get_representation_definition(
-                    'application/x-www-form-urlencoded')
+                    "application/x-www-form-urlencoded"
+                )
             assert definition is not None, (
                 "A POST named operation must define a multipart or "
                 "form-urlencoded request representation."
-                )
+            )
             params = definition.params(self.resource._wadl_resource)
-        send_as_is_params = set([param.name for param in params
-                                 if param.type == 'binary'
-                                 or len(param.options) > 0])
+        send_as_is_params = set(
+            [
+                param.name
+                for param in params
+                if param.type == "binary" or len(param.options) > 0
+            ]
+        )
         for key, value in args.items():
             # Certain parameter values should not be JSON-encoded:
             # binary parameters (because they can't be JSON-encoded)
@@ -573,16 +624,17 @@ class NamedOperation(RestfulBase):
             # is a little hacky, but it's the best solution for now.
             if key not in send_as_is_params:
                 args[key] = dumps(value, cls=DatetimeJSONEncoder)
-        if http_method in ('get', 'head', 'delete'):
+        if http_method in ("get", "head", "delete"):
             url = self.wadl_method.build_request_url(**args)
-            in_representation = ''
+            in_representation = ""
             extra_headers = {}
         else:
             url = self.wadl_method.build_request_url()
-            (media_type,
-             in_representation) = self.wadl_method.build_representation(
-                **args)
-            extra_headers = {'Content-type': media_type}
+            (
+                media_type,
+                in_representation,
+            ) = self.wadl_method.build_representation(**args)
+            extra_headers = {"Content-type": media_type}
         # Pass uppercase method names to httplib2, as that is what it works
         # with. If you pass a lowercase method name to httplib then it doesn't
         # consider it to be a GET, PUT, etc., and so will do things like not
@@ -590,18 +642,21 @@ class NamedOperation(RestfulBase):
         # is compared in this method, but httplib2 expects the opposite, hence
         # the .upper() call.
         response, content = self.root._browser._request(
-            url, in_representation, http_method.upper(),
-            extra_headers=extra_headers)
+            url,
+            in_representation,
+            http_method.upper(),
+            extra_headers=extra_headers,
+        )
 
         if response.status == 201:
             return self._handle_201_response(url, response, content)
         else:
-            if http_method == 'post':
+            if http_method == "post":
                 # The method call probably modified this resource in
                 # an unknown way. If it moved to a new location, reload it or
                 # else just refresh its representation.
                 if response.status == 301:
-                    url = response['location']
+                    url = response["location"]
                     response, content = self.root._browser._request(url)
                 else:
                     self.resource.lp_refresh()
@@ -610,32 +665,33 @@ class NamedOperation(RestfulBase):
     def _handle_201_response(self, url, response, content):
         """Handle the creation of a new resource by fetching it."""
         wadl_response = self.wadl_method.response.bind(
-            HeaderDictionary(response))
-        wadl_parameter = wadl_response.get_parameter('Location')
+            HeaderDictionary(response)
+        )
+        wadl_parameter = wadl_response.get_parameter("Location")
         wadl_resource = wadl_parameter.linked_resource
         # Fetch a representation of the new resource.
-        response, content = self.root._browser._request(
-            wadl_resource.url)
+        response, content = self.root._browser._request(wadl_resource.url)
         # Return an instance of the appropriate lazr.restful
         # Resource subclass.
         return Resource._create_bound_resource(
-            self.root, wadl_resource, content, response['content-type'])
+            self.root, wadl_resource, content, response["content-type"]
+        )
 
     def _handle_200_response(self, url, response, content):
         """Process the return value of an operation."""
-        content_type = response['content-type']
+        content_type = response["content-type"]
         # Process the returned content, assuming we know how.
         response_definition = self.wadl_method.response
         representation_definition = (
-            response_definition.get_representation_definition(
-                content_type))
+            response_definition.get_representation_definition(content_type)
+        )
 
         if representation_definition is None:
             # The operation returned a document with nothing
             # special about it.
             if content_type == self.JSON_MEDIA_TYPE:
                 if isinstance(content, binary_type):
-                    content = content.decode('utf-8')
+                    content = content.decode("utf-8")
                 return loads(content)
             # We don't know how to process the content.
             return content
@@ -643,8 +699,8 @@ class NamedOperation(RestfulBase):
         # The operation returned a representation of some
         # resource. Instantiate a Resource object for it.
         if isinstance(content, binary_type):
-            content = content.decode('utf-8')
-        
+            content = content.decode("utf-8")
+
         document = loads(content)
         if document is None:
             # The operation returned a null value.
@@ -656,9 +712,11 @@ class NamedOperation(RestfulBase):
             # object will support all of the right named operations.
             url = document["self_link"]
             resource_type = self.root._wadl.get_resource_type(
-                document["resource_type_link"])
-            wadl_resource = WadlResource(self.root._wadl, url,
-                                         resource_type.tag)
+                document["resource_type_link"]
+            )
+            wadl_resource = WadlResource(
+                self.root._wadl, url, resource_type.tag
+            )
         else:
             # The operation returned a collection. It's probably an ad
             # hoc collection that doesn't correspond to any resource
@@ -666,14 +724,20 @@ class NamedOperation(RestfulBase):
             # representation type defined in the return value, instead
             # of a resource type tag.
             representation_definition = (
-                representation_definition.resolve_definition())
+                representation_definition.resolve_definition()
+            )
             wadl_resource = WadlResource(
-                self.root._wadl, url, representation_definition.tag)
+                self.root._wadl, url, representation_definition.tag
+            )
 
         return Resource._create_bound_resource(
-            self.root, wadl_resource, document, content_type,
+            self.root,
+            wadl_resource,
+            document,
+            content_type,
             representation_needs_processing=False,
-            representation_definition=representation_definition)
+            representation_definition=representation_definition,
+        )
 
     def _get_external_param_name(self, param_name):
         """Named operation parameter names are sent as is."""
@@ -695,13 +759,15 @@ class Entry(Resource):
         # occur.  Poking this directly into self.__dict__ means that
         # the check for self._dirty_attributes won't call __getattr__(),
         # breaking the cycle.
-        self.__dict__['_dirty_attributes'] = {}
+        self.__dict__["_dirty_attributes"] = {}
         super(Entry, self).__init__(root, wadl_resource)
 
     def __repr__(self):
         """Return the WADL resource type and the URL to the resource."""
-        return '<%s at %s>' % (
-            URI(self.resource_type_link).fragment, self.self_link)
+        return "<%s at %s>" % (
+            URI(self.resource_type_link).fragment,
+            self.self_link,
+        )
 
     def lp_delete(self):
         """Delete the resource."""
@@ -713,7 +779,7 @@ class Entry(Resource):
 
     def __getattr__(self, name):
         """Try to retrive a parameter of the given name."""
-        if name != '_dirty_attributes':
+        if name != "_dirty_attributes":
             if name in self._dirty_attributes:
                 return self._dirty_attributes[name]
         return super(Entry, self).__getattr__(name)
@@ -721,8 +787,10 @@ class Entry(Resource):
     def __setattr__(self, name, value):
         """Set the parameter of the given name."""
         if not self.lp_has_parameter(name):
-            raise AttributeError("'%s' object has no attribute '%s'" %
-                                 (self.__class__.__name__, name))
+            raise AttributeError(
+                "'%s' object has no attribute '%s'"
+                % (self.__class__.__name__, name)
+            )
         self._dirty_attributes[name] = value
 
     def __eq__(self, other):
@@ -733,44 +801,47 @@ class Entry(Resource):
         contain the same values.
         """
         return (
-            other is not None and
-            self.self_link == other.self_link and
-            self.http_etag == other.http_etag and
-            self._dirty_attributes == other._dirty_attributes)
+            other is not None
+            and self.self_link == other.self_link
+            and self.http_etag == other.http_etag
+            and self._dirty_attributes == other._dirty_attributes
+        )
 
     def lp_refresh(self, new_url=None):
         """Update this resource's representation."""
-        etag = getattr(self, 'http_etag', None)
+        etag = getattr(self, "http_etag", None)
         super(Entry, self).lp_refresh(new_url, etag)
         self._dirty_attributes.clear()
 
     def lp_save(self):
         """Save changes to the entry."""
         representation = self._transform_resources_to_links(
-            self._dirty_attributes)
+            self._dirty_attributes
+        )
 
         # If the entry contains an ETag, set the If-Match header
         # to that value.
         headers = {}
-        etag = getattr(self, 'http_etag', None)
+        etag = getattr(self, "http_etag", None)
         if etag is not None:
-            headers['If-Match'] = etag
+            headers["If-Match"] = etag
 
         # PATCH the new representation to the 'self' link.  It's possible that
         # this will cause the object to be permanently moved.  Catch that
         # exception and refresh our representation.
         response, content = self._root._browser.patch(
-            URI(self.self_link), representation, headers)
+            URI(self.self_link), representation, headers
+        )
         if response.status == 301:
-            self.lp_refresh(response['location'])
+            self.lp_refresh(response["location"])
         self._dirty_attributes.clear()
 
-        content_type = response['content-type']
+        content_type = response["content-type"]
         if response.status == 209 and content_type == self.JSON_MEDIA_TYPE:
             # The server sent back a new representation of the object.
             # Use it in preference to the existing representation.
             if isinstance(content, binary_type):
-                content = content.decode('utf-8')
+                content = content.decode("utf-8")
             new_representation = loads(content)
             self._wadl_resource.representation = new_representation
             self._wadl_resource.media_type = content_type
@@ -799,7 +870,7 @@ class Collection(Resource):
             # not directly present.
             return total_size.value
         else:
-            raise TypeError('collection size is not available')
+            raise TypeError("collection size is not available")
 
     def __iter__(self):
         """Iterate over the items in the collection.
@@ -811,14 +882,15 @@ class Collection(Resource):
         current_page = self._wadl_resource.representation
         while True:
             for resource in self._convert_dicts_to_entries(
-                current_page.get('entries', {})):
+                current_page.get("entries", {})
+            ):
                 yield resource
-            next_link = current_page.get('next_collection_link')
+            next_link = current_page.get("next_collection_link")
             if next_link is None:
                 break
             next_get = self._root._browser.get(URI(next_link))
             if isinstance(next_get, binary_type):
-                next_get = next_get.decode('utf-8')
+                next_get = next_get.decode("utf-8")
             current_page = loads(next_get)
 
     def __getitem__(self, key):
@@ -845,15 +917,19 @@ class Collection(Resource):
         stop = slice.stop
 
         if start < 0:
-            raise ValueError("Collection slices must have a nonnegative "
-                             "start point.")
+            raise ValueError(
+                "Collection slices must have a nonnegative " "start point."
+            )
         if stop < 0:
-            raise ValueError("Collection slices must have a definite, "
-                             "nonnegative end point.")
+            raise ValueError(
+                "Collection slices must have a definite, "
+                "nonnegative end point."
+            )
 
         existing_representation = self._wadl_resource.representation
-        if (existing_representation is not None
-            and start < len(existing_representation['entries'])):
+        if existing_representation is not None and start < len(
+            existing_representation["entries"]
+        ):
             # An optimization: the first page of entries has already
             # been loaded. This can happen if this collection is the
             # return value of a named operation, or if the client did
@@ -870,11 +946,11 @@ class Collection(Resource):
             # objects to retrieve from the server later. This saves us
             # time and bandwidth, and it might let us save a whole
             # HTTP request.
-            entry_page = existing_representation['entries']
+            entry_page = existing_representation["entries"]
 
             first_page_size = len(entry_page)
             entry_dicts = entry_page[start:stop]
-            page_url = existing_representation.get('next_collection_link')
+            page_url = existing_representation.get("next_collection_link")
         else:
             # No part of this collection has been loaded yet, or the
             # slice starts beyond the part that has been loaded. We'll
@@ -884,7 +960,8 @@ class Collection(Resource):
             first_page_size = None
             entry_dicts = []
             page_url = self._with_url_query_variable_set(
-                self._wadl_resource.url, 'ws.start', start)
+                self._wadl_resource.url, "ws.start", start
+            )
 
         desired_size = stop - start
         more_needed = desired_size - len(entry_dicts)
@@ -893,13 +970,13 @@ class Collection(Resource):
         while more_needed > 0 and page_url is not None:
             page_get = self._root._browser.get(page_url)
             if isinstance(page_get, binary_type):
-                page_get = page_get.decode('utf-8')
+                page_get = page_get.decode("utf-8")
             representation = loads(page_get)
-            current_page_entries = representation['entries']
+            current_page_entries = representation["entries"]
             entry_dicts += current_page_entries[:more_needed]
             more_needed = desired_size - len(entry_dicts)
 
-            page_url = representation.get('next_collection_link')
+            page_url = representation.get("next_collection_link")
             if page_url is None:
                 # We've gotten the entire collection; there are no
                 # more entries.
@@ -915,14 +992,17 @@ class Collection(Resource):
                 # need. If we're wrong, there's no problem; we'll just
                 # keep looping.
                 page_url = self._with_url_query_variable_set(
-                    page_url, 'ws.size', more_needed)
+                    page_url, "ws.size", more_needed
+                )
 
         if slice.step is not None:
-            entry_dicts = entry_dicts[::slice.step]
+            entry_dicts = entry_dicts[:: slice.step]
 
         # Convert entry_dicts into a list of Entry objects.
-        return [resource for resource
-                in self._convert_dicts_to_entries(entry_dicts)]
+        return [
+            resource
+            for resource in self._convert_dicts_to_entries(entry_dicts)
+        ]
 
     def _convert_dicts_to_entries(self, entries):
         """Convert dictionaries describing entries to Entry objects.
@@ -937,17 +1017,20 @@ class Collection(Resource):
         :yield: A sequence of Entry instances.
         """
         for entry_dict in entries:
-            resource_url = entry_dict['self_link']
-            resource_type_link = entry_dict['resource_type_link']
+            resource_url = entry_dict["self_link"]
+            resource_type_link = entry_dict["resource_type_link"]
             wadl_application = self._wadl_resource.application
             resource_type = wadl_application.get_resource_type(
-                resource_type_link)
+                resource_type_link
+            )
             resource = WadlResource(
-                self._wadl_resource.application, resource_url,
-                resource_type.tag)
+                self._wadl_resource.application,
+                resource_url,
+                resource_type.tag,
+            )
             yield Resource._create_bound_resource(
-                self._root, resource, entry_dict, self.JSON_MEDIA_TYPE,
-                False)
+                self._root, resource, entry_dict, self.JSON_MEDIA_TYPE, False
+            )
 
     def _with_url_query_variable_set(self, url, variable, new_value):
         """A helper method to set a query variable in a URL."""
@@ -1008,7 +1091,8 @@ class CollectionWithKeyBasedLookup(Collection):
             # this will save us one round trip.
             representation = None
             resource_type_link = urljoin(
-                self._root._wadl.markup_url, '#' + self.collection_of)
+                self._root._wadl.markup_url, "#" + self.collection_of
+            )
         else:
             # We don't know what kind of resource this is. Either the
             # subclass wasn't programmed with this knowledge, or
@@ -1020,7 +1104,7 @@ class CollectionWithKeyBasedLookup(Collection):
             try:
                 url_get = self._root._browser.get(url)
                 if isinstance(url_get, binary_type):
-                    url_get = url_get.decode('utf-8')                
+                    url_get = url_get.decode("utf-8")
                 representation = loads(url_get)
             except HTTPError as error:
                 # There's no resource corresponding to the given ID.
@@ -1029,12 +1113,15 @@ class CollectionWithKeyBasedLookup(Collection):
                 raise
             # We know that every lazr.restful resource has a
             # 'resource_type_link' in its representation.
-            resource_type_link = representation['resource_type_link']
+            resource_type_link = representation["resource_type_link"]
 
         resource = WadlResource(self._root._wadl, url, resource_type_link)
         return self._create_bound_resource(
-            self._root, resource, representation=representation,
-            representation_needs_processing=False)
+            self._root,
+            resource,
+            representation=representation,
+            representation_needs_processing=False,
+        )
 
     # If provided, this should be a string designating the ID of a
     # resource_type from a specific service's WADL file.
@@ -1047,35 +1134,43 @@ class CollectionWithKeyBasedLookup(Collection):
 
 class HostedFileBuffer(BytesIO):
     """The contents of a file hosted by a lazr.restful service."""
+
     def __init__(self, hosted_file, mode, content_type=None, filename=None):
         self.url = hosted_file._wadl_resource.url
-        if mode == 'r':
+        if mode == "r":
             if content_type is not None:
-                raise ValueError("Files opened for read access can't "
-                                 "specify content_type.")
+                raise ValueError(
+                    "Files opened for read access can't "
+                    "specify content_type."
+                )
             if filename is not None:
-                raise ValueError("Files opened for read access can't "
-                                 "specify filename.")
+                raise ValueError(
+                    "Files opened for read access can't " "specify filename."
+                )
             response, value = hosted_file._root._browser.get(
-                self.url, return_response=True)
-            content_type = response['content-type']
-            last_modified = response.get('last-modified')
+                self.url, return_response=True
+            )
+            content_type = response["content-type"]
+            last_modified = response.get("last-modified")
 
             # The Content-Location header contains the URL of the file
             # hosted by the web service. We happen to know that the
             # final component of the URL is the name of the uploaded
             # file.
-            content_location = response['content-location']
+            content_location = response["content-location"]
             path = urlparse(content_location)[2]
             filename = unquote(path.split("/")[-1])
-        elif mode == 'w':
-            value = ''
+        elif mode == "w":
+            value = ""
             if content_type is None:
-                raise ValueError("Files opened for write access must "
-                                 "specify content_type.")
+                raise ValueError(
+                    "Files opened for write access must "
+                    "specify content_type."
+                )
             if filename is None:
-                raise ValueError("Files opened for write access must "
-                                 "specify filename.")
+                raise ValueError(
+                    "Files opened for write access must " "specify filename."
+                )
             last_modified = None
         else:
             raise ValueError("Invalid mode. Supported modes are: r, w")
@@ -1088,11 +1183,14 @@ class HostedFileBuffer(BytesIO):
         BytesIO.__init__(self, value)
 
     def close(self):
-        if self.mode == 'w':
+        if self.mode == "w":
             disposition = 'attachment; filename="%s"' % self.filename
             self.hosted_file._root._browser.put(
-                self.url, self.getvalue(),
-                self.content_type, {'Content-Disposition': disposition})
+                self.url,
+                self.getvalue(),
+                self.content_type,
+                {"Content-Disposition": disposition},
+            )
         BytesIO.close(self)
 
     def write(self, b):
diff --git a/src/lazr/restfulclient/tests/__init__.py b/src/lazr/restfulclient/tests/__init__.py
index 1764b70..de07b86 100644
--- a/src/lazr/restfulclient/tests/__init__.py
+++ b/src/lazr/restfulclient/tests/__init__.py
@@ -6,9 +6,9 @@
 # under the terms of the GNU Lesser General Public License as published by
 # the Free Software Foundation, version 3 of the License.
 #
-# lazr.restfulclient is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+# lazr.restfulclient is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 # License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public License
diff --git a/src/lazr/restfulclient/tests/example.py b/src/lazr/restfulclient/tests/example.py
index 0c37c6b..d9c00a6 100644
--- a/src/lazr/restfulclient/tests/example.py
+++ b/src/lazr/restfulclient/tests/example.py
@@ -6,9 +6,9 @@
 # under the terms of the GNU Lesser General Public License as published by
 # the Free Software Foundation, version 3 of the License.
 #
-# lazr.restfulclient is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+# lazr.restfulclient is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 # License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public License
@@ -17,8 +17,8 @@
 
 __metaclass__ = type
 __all__ = [
-    'CookbookWebServiceClient',
-    ]
+    "CookbookWebServiceClient",
+]
 
 
 try:
@@ -28,7 +28,9 @@ except ImportError:
     from urllib import quote
 
 from lazr.restfulclient.resource import (
-    CollectionWithKeyBasedLookup, ServiceRoot)
+    CollectionWithKeyBasedLookup,
+    ServiceRoot,
+)
 
 
 class CookbookSet(CollectionWithKeyBasedLookup):
@@ -36,8 +38,11 @@ class CookbookSet(CollectionWithKeyBasedLookup):
 
     def _get_url_from_id(self, id):
         """Transform a cookbook name into the URL to a cookbook resource."""
-        return (str(self._root._root_uri.ensureSlash())
-                + 'cookbooks/' + quote(str(id)))
+        return (
+            str(self._root._root_uri.ensureSlash())
+            + "cookbooks/"
+            + quote(str(id))
+        )
 
     collection_of = "cookbook"
 
@@ -47,7 +52,7 @@ class RecipeSet(CollectionWithKeyBasedLookup):
 
     def _get_url_from_id(self, id):
         """Transform a recipe ID into the URL to a recipe resource."""
-        return str(self._root._root_uri.ensureSlash()) + 'recipes/' + str(id)
+        return str(self._root._root_uri.ensureSlash()) + "recipes/" + str(id)
 
     collection_of = "recipe"
 
@@ -55,13 +60,18 @@ class RecipeSet(CollectionWithKeyBasedLookup):
 class CookbookWebServiceClient(ServiceRoot):
 
     RESOURCE_TYPE_CLASSES = dict(ServiceRoot.RESOURCE_TYPE_CLASSES)
-    RESOURCE_TYPE_CLASSES['recipes'] = RecipeSet
-    RESOURCE_TYPE_CLASSES['cookbooks'] = CookbookSet
+    RESOURCE_TYPE_CLASSES["recipes"] = RecipeSet
+    RESOURCE_TYPE_CLASSES["cookbooks"] = CookbookSet
 
     DEFAULT_SERVICE_ROOT = "http://cookbooks.dev/"
     DEFAULT_VERSION = "1.0"
 
-    def __init__(self, service_root=DEFAULT_SERVICE_ROOT,
-                 version=DEFAULT_VERSION, cache=None):
+    def __init__(
+        self,
+        service_root=DEFAULT_SERVICE_ROOT,
+        version=DEFAULT_VERSION,
+        cache=None,
+    ):
         super(CookbookWebServiceClient, self).__init__(
-            None, service_root, cache=cache, version=version)
+            None, service_root, cache=cache, version=version
+        )
diff --git a/src/lazr/restfulclient/tests/test_atomicfilecache.py b/src/lazr/restfulclient/tests/test_atomicfilecache.py
index f767b53..b879bd2 100644
--- a/src/lazr/restfulclient/tests/test_atomicfilecache.py
+++ b/src/lazr/restfulclient/tests/test_atomicfilecache.py
@@ -20,29 +20,28 @@
 __metaclass__ = type
 
 import shutil
+import sys
 import tempfile
 import unittest
 
-import sys
+import httplib2
+
+from lazr.restfulclient._browser import AtomicFileCache, safename
+
 PY3 = sys.version_info[0] >= 3
 if PY3:
     binary_type = bytes
 else:
     binary_type = str
 
-import httplib2
-
-from lazr.restfulclient._browser import (
-    AtomicFileCache, safename)
-
 
 class TestFileCacheInterface(unittest.TestCase):
     """Tests for ``AtomicFileCache``."""
 
     file_cache_factory = httplib2.FileCache
 
-    unicode_bytes = b'pa\xc9\xaa\xce\xb8\xc9\x99n'
-    unicode_text = unicode_bytes.decode('utf-8')
+    unicode_bytes = b"pa\xc9\xaa\xce\xb8\xc9\x99n"
+    unicode_text = unicode_bytes.decode("utf-8")
 
     def setUp(self):
         super(TestFileCacheInterface, self).setUp()
@@ -59,34 +58,34 @@ class TestFileCacheInterface(unittest.TestCase):
     def test_get_non_existent_key(self):
         # get() returns None if the key does not exist.
         cache = self.make_file_cache()
-        self.assertIs(None, cache.get('nonexistent'))
+        self.assertIs(None, cache.get("nonexistent"))
 
     def test_set_key(self):
         # A key set with set() can be got by get().
         cache = self.make_file_cache()
-        cache.set('key', b'value')
-        self.assertEqual(b'value', cache.get('key'))
+        cache.set("key", b"value")
+        self.assertEqual(b"value", cache.get("key"))
 
     def test_set_twice_overrides(self):
         # Setting a key again overrides the value.
         cache = self.make_file_cache()
-        cache.set('key', b'value')
-        cache.set('key', b'new-value')
-        self.assertEqual(b'new-value', cache.get('key'))
+        cache.set("key", b"value")
+        cache.set("key", b"new-value")
+        self.assertEqual(b"new-value", cache.get("key"))
 
     def test_delete_absent_key(self):
         # Deleting a key that's not there does nothing.
         cache = self.make_file_cache()
-        cache.delete('nonexistent')
-        self.assertIs(None, cache.get('nonexistent'))
+        cache.delete("nonexistent")
+        self.assertIs(None, cache.get("nonexistent"))
 
     def test_delete_key(self):
         # A key once set can be deleted.  Further attempts to get that key
         # return None.
         cache = self.make_file_cache()
-        cache.set('key', b'value')
-        cache.delete('key')
-        self.assertIs(None, cache.get('key'))
+        cache.set("key", b"value")
+        cache.delete("key")
+        self.assertIs(None, cache.get("key"))
 
     def test_get_non_string_key(self):
         # get() raises TypeError if asked to get a non-string key.
@@ -101,15 +100,15 @@ class TestFileCacheInterface(unittest.TestCase):
     def test_set_non_string_key(self):
         # set() raises TypeError if asked to set a non-string key.
         cache = self.make_file_cache()
-        self.assertRaises(TypeError, cache.set, 42, 'the answer')
+        self.assertRaises(TypeError, cache.set, 42, "the answer")
 
     def test_set_non_string_value(self):
         # set() raises TypeError if asked to set a key to a non-string value.
         # Attempts to retrieve that value return the empty string.  This is
         # probably a bug in httplib2.FileCache.
         cache = self.make_file_cache()
-        self.assertRaises(TypeError, cache.set, 'answer', 42)
-        self.assertEqual(b'', cache.get('answer'))
+        self.assertRaises(TypeError, cache.set, "answer", 42)
+        self.assertEqual(b"", cache.get("answer"))
 
     def test_get_unicode(self):
         # get() can retrieve unicode keys.
@@ -118,20 +117,19 @@ class TestFileCacheInterface(unittest.TestCase):
 
     def test_set_unicode_keys(self):
         cache = self.make_file_cache()
-        cache.set(self.unicode_text, b'value')
-        self.assertEqual(b'value', cache.get(self.unicode_text))
+        cache.set(self.unicode_text, b"value")
+        self.assertEqual(b"value", cache.get(self.unicode_text))
 
     def test_set_unicode_value(self):
         # set() cannot store unicode values.  Values must be bytes.
         cache = self.make_file_cache()
         error = TypeError if PY3 else UnicodeEncodeError
-        self.assertRaises(
-            error, cache.set, 'key', self.unicode_text)
+        self.assertRaises(error, cache.set, "key", self.unicode_text)
 
     def test_delete_unicode(self):
         # delete() can remove unicode keys.
         cache = self.make_file_cache()
-        cache.set(self.unicode_text, b'value')
+        cache.set(self.unicode_text, b"value")
         cache.delete(self.unicode_text)
         self.assertIs(None, cache.get(self.unicode_text))
 
@@ -144,7 +142,7 @@ class TestAtomicFileCache(TestFileCacheInterface):
     @staticmethod
     def prefix_safename(x):
         if isinstance(x, binary_type):
-            x = x.decode('utf-8')
+            x = x.decode("utf-8")
         return AtomicFileCache.TEMPFILE_PREFIX + x
 
     def test_set_non_string_value(self):
@@ -153,22 +151,22 @@ class TestAtomicFileCache(TestFileCacheInterface):
         #
         # Note: This behaviour differs from httplib2.FileCache.
         cache = self.make_file_cache()
-        self.assertRaises(TypeError, cache.set, 'answer', 42)
-        self.assertIs(None, cache.get('answer'))
+        self.assertRaises(TypeError, cache.set, "answer", 42)
+        self.assertIs(None, cache.get("answer"))
 
     # Implementation-specific tests follow.
 
     def test_bad_safename_get(self):
         safename = self.prefix_safename
         cache = AtomicFileCache(self.cache_dir, safename)
-        self.assertRaises(ValueError, cache.get, 'key')
+        self.assertRaises(ValueError, cache.get, "key")
 
     def test_bad_safename_set(self):
         safename = self.prefix_safename
         cache = AtomicFileCache(self.cache_dir, safename)
-        self.assertRaises(ValueError, cache.set, 'key', b'value')
+        self.assertRaises(ValueError, cache.set, "key", b"value")
 
     def test_bad_safename_delete(self):
         safename = self.prefix_safename
         cache = AtomicFileCache(self.cache_dir, safename)
-        self.assertRaises(ValueError, cache.delete, 'key')
+        self.assertRaises(ValueError, cache.delete, "key")
diff --git a/src/lazr/restfulclient/tests/test_docs.py b/src/lazr/restfulclient/tests/test_docs.py
index a350b40..df3807a 100644
--- a/src/lazr/restfulclient/tests/test_docs.py
+++ b/src/lazr/restfulclient/tests/test_docs.py
@@ -6,9 +6,9 @@
 # under the terms of the GNU Lesser General Public License as published by
 # the Free Software Foundation, version 3 of the License.
 #
-# lazr.restfulclient is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+# lazr.restfulclient is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 # License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public License
@@ -19,16 +19,20 @@
 
 __metaclass__ = type
 __all__ = [
-    'load_tests',
-    ]
+    "load_tests",
+]
 
 import atexit
 import doctest
 import os
 
-from pkg_resources import (
-    resource_filename, resource_exists, resource_listdir, cleanup_resources)
 import wsgi_intercept
+from pkg_resources import (
+    cleanup_resources,
+    resource_exists,
+    resource_filename,
+    resource_listdir,
+)
 from wsgi_intercept.httplib2_intercept import install, uninstall
 
 # We avoid importing anything from lazr.restful into the module level,
@@ -36,21 +40,24 @@ from wsgi_intercept.httplib2_intercept import install, uninstall
 # lazr.restful.
 
 DOCTEST_FLAGS = (
-    doctest.ELLIPSIS |
-    doctest.NORMALIZE_WHITESPACE |
-    doctest.REPORT_NDIFF)
+    doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE | doctest.REPORT_NDIFF
+)
 
 
 def setUp(test):
     from lazr.restful.example.base.tests.test_integration import WSGILayer
+
     install()
     wsgi_intercept.add_wsgi_intercept(
-        'cookbooks.dev', 80, WSGILayer.make_application)
+        "cookbooks.dev", 80, WSGILayer.make_application
+    )
 
 
 def tearDown(test):
-    from lazr.restful.example.base.interfaces import IFileManager
     from zope.component import getUtility
+
+    from lazr.restful.example.base.interfaces import IFileManager
+
     uninstall()
     file_manager = getUtility(IFileManager)
     file_manager.files = {}
@@ -61,29 +68,40 @@ def find_doctests(suffix, ignore_suffix=None):
     """Find doctests matching a certain suffix."""
     doctest_files = []
     # Match doctests against the suffix.
-    if resource_exists('lazr.restfulclient', 'docs'):
-        for name in resource_listdir('lazr.restfulclient', 'docs'):
+    if resource_exists("lazr.restfulclient", "docs"):
+        for name in resource_listdir("lazr.restfulclient", "docs"):
             if ignore_suffix is not None and name.endswith(ignore_suffix):
                 continue
             if name.endswith(suffix):
                 doctest_files.append(
                     os.path.abspath(
                         resource_filename(
-                            'lazr.restfulclient', 'docs/%s' % name)))
+                            "lazr.restfulclient", "docs/%s" % name
+                        )
+                    )
+                )
     return doctest_files
 
 
 def load_tests(loader, tests, pattern):
     """Load all the doctests."""
     from lazr.restful.example.base.tests.test_integration import WSGILayer
+
     atexit.register(cleanup_resources)
     restful_suite = doctest.DocFileSuite(
-        *find_doctests('.rst', ignore_suffix='.standalone.rst'),
-        module_relative=False, optionflags=DOCTEST_FLAGS,
-        setUp=setUp, tearDown=tearDown)
+        *find_doctests(".rst", ignore_suffix=".standalone.rst"),
+        module_relative=False,
+        optionflags=DOCTEST_FLAGS,
+        setUp=setUp,
+        tearDown=tearDown
+    )
     restful_suite.layer = WSGILayer
     tests.addTest(restful_suite)
-    tests.addTest(doctest.DocFileSuite(
-        *find_doctests('.standalone.rst'),
-        module_relative=False, optionflags=DOCTEST_FLAGS))
+    tests.addTest(
+        doctest.DocFileSuite(
+            *find_doctests(".standalone.rst"),
+            module_relative=False,
+            optionflags=DOCTEST_FLAGS
+        )
+    )
     return tests
diff --git a/src/lazr/restfulclient/tests/test_error.py b/src/lazr/restfulclient/tests/test_error.py
index 7a43d4a..30c1090 100644
--- a/src/lazr/restfulclient/tests/test_error.py
+++ b/src/lazr/restfulclient/tests/test_error.py
@@ -22,19 +22,27 @@ __metaclass__ = type
 import unittest
 
 from lazr.restfulclient.errors import (
-    ClientError, Conflict, MethodNotAllowed, NotFound,
-    PreconditionFailed, ResponseError, ServerError, Unauthorized, error_for)
+    ClientError,
+    Conflict,
+    MethodNotAllowed,
+    NotFound,
+    PreconditionFailed,
+    ResponseError,
+    ServerError,
+    Unauthorized,
+    error_for,
+)
 
 
 class DummyRequest(object):
     """Just enough of a request to fool error_for()."""
+
     def __init__(self, status):
         self.status = status
 
 
 class TestErrorFor(unittest.TestCase):
-
-    def error_for_status(self, status, expected_error, content=''):
+    def error_for_status(self, status, expected_error, content=""):
         """Make sure error_for returns the right HTTPError subclass."""
         request = DummyRequest(status)
         error = error_for(request, content)
diff --git a/src/lazr/restfulclient/tests/test_oauth.py b/src/lazr/restfulclient/tests/test_oauth.py
index be0d87d..e87914c 100644
--- a/src/lazr/restfulclient/tests/test_oauth.py
+++ b/src/lazr/restfulclient/tests/test_oauth.py
@@ -25,10 +25,7 @@ import os.path
 import stat
 import unittest
 
-from fixtures import (
-    MockPatch,
-    TempDir,
-    )
+from fixtures import MockPatch, TempDir
 from testtools import TestCase
 
 from lazr.restfulclient.authorize.oauth import (
@@ -36,11 +33,10 @@ from lazr.restfulclient.authorize.oauth import (
     Consumer,
     OAuthAuthorizer,
     SystemWideConsumer,
-    )
+)
 
 
 class TestConsumer(TestCase):
-
     def test_data_fields(self):
         consumer = Consumer("key", "secret", "application")
         self.assertEqual(consumer.key, "key")
@@ -54,7 +50,6 @@ class TestConsumer(TestCase):
 
 
 class TestAccessToken(TestCase):
-
     def test_data_fields(self):
         access_token = AccessToken("key", "secret", "context")
         self.assertEqual(access_token.key, "key")
@@ -70,47 +65,46 @@ class TestAccessToken(TestCase):
         access_token = AccessToken("lock&key", "secret=password")
         self.assertEqual(
             "oauth_token_secret=secret%3Dpassword&oauth_token=lock%26key",
-            str(access_token))
+            str(access_token),
+        )
 
     def test_from_string(self):
         access_token = AccessToken.from_string(
-            "oauth_token_secret=secret%3Dpassword&oauth_token=lock%26key")
+            "oauth_token_secret=secret%3Dpassword&oauth_token=lock%26key"
+        )
         self.assertEqual(access_token.key, "lock&key")
         self.assertEqual(access_token.secret, "secret=password")
 
 
 class TestSystemWideConsumer(TestCase):
-
     def test_useful_distro_name(self):
         # If distro.name returns a useful string, as it does on Ubuntu,
         # we'll use the first string for the system type.
-        self.useFixture(MockPatch('distro.name', return_value='Fooix'))
-        self.useFixture(MockPatch('platform.system', return_value='FooOS'))
-        self.useFixture(MockPatch('socket.gethostname', return_value='foo'))
+        self.useFixture(MockPatch("distro.name", return_value="Fooix"))
+        self.useFixture(MockPatch("platform.system", return_value="FooOS"))
+        self.useFixture(MockPatch("socket.gethostname", return_value="foo"))
         consumer = SystemWideConsumer("app name")
-        self.assertEqual(
-            consumer.key, 'System-wide: Fooix (foo)')
+        self.assertEqual(consumer.key, "System-wide: Fooix (foo)")
 
     def test_empty_distro_name(self):
         # If distro.name returns an empty string, as it does on Windows and
         # Mac OS X, we fall back to the result of platform.system().
-        self.useFixture(MockPatch('distro.name', return_value=''))
-        self.useFixture(MockPatch('platform.system', return_value='BarOS'))
-        self.useFixture(MockPatch('socket.gethostname', return_value='bar'))
+        self.useFixture(MockPatch("distro.name", return_value=""))
+        self.useFixture(MockPatch("platform.system", return_value="BarOS"))
+        self.useFixture(MockPatch("socket.gethostname", return_value="bar"))
         consumer = SystemWideConsumer("app name")
-        self.assertEqual(
-            consumer.key, 'System-wide: BarOS (bar)')
+        self.assertEqual(consumer.key, "System-wide: BarOS (bar)")
 
     def test_broken_distro_name(self):
         # If distro.name raises an exception, we fall back to the result of
         # platform.system().
         self.useFixture(
-            MockPatch('distro.name', side_effect=Exception('Oh noes!')))
-        self.useFixture(MockPatch('platform.system', return_value='BazOS'))
-        self.useFixture(MockPatch('socket.gethostname', return_value='baz'))
+            MockPatch("distro.name", side_effect=Exception("Oh noes!"))
+        )
+        self.useFixture(MockPatch("platform.system", return_value="BazOS"))
+        self.useFixture(MockPatch("socket.gethostname", return_value="baz"))
         consumer = SystemWideConsumer("app name")
-        self.assertEqual(
-            consumer.key, 'System-wide: BazOS (baz)')
+        self.assertEqual(consumer.key, "System-wide: BazOS (baz)")
 
 
 class TestOAuthAuthorizer(TestCase):
@@ -120,26 +114,29 @@ class TestOAuthAuthorizer(TestCase):
         # Credentials can be saved to and loaded from a file using
         # save_to_path() and load_from_path().
         temp_dir = self.useFixture(TempDir()).path
-        credentials_path = os.path.join(temp_dir, 'credentials')
+        credentials_path = os.path.join(temp_dir, "credentials")
         credentials = OAuthAuthorizer(
-            'consumer.key', consumer_secret='consumer.secret',
-            access_token=AccessToken('access.key', 'access.secret'))
+            "consumer.key",
+            consumer_secret="consumer.secret",
+            access_token=AccessToken("access.key", "access.secret"),
+        )
         credentials.save_to_path(credentials_path)
         self.assertTrue(os.path.exists(credentials_path))
 
         # Make sure the file is readable and writable by the user, but
         # not by anyone else.
-        self.assertEqual(stat.S_IMODE(os.stat(credentials_path).st_mode),
-                          stat.S_IREAD | stat.S_IWRITE)
+        self.assertEqual(
+            stat.S_IMODE(os.stat(credentials_path).st_mode),
+            stat.S_IREAD | stat.S_IWRITE,
+        )
 
         loaded_credentials = OAuthAuthorizer.load_from_path(credentials_path)
-        self.assertEqual(loaded_credentials.consumer.key, 'consumer.key')
-        self.assertEqual(
-            loaded_credentials.consumer.secret, 'consumer.secret')
-        self.assertEqual(
-            loaded_credentials.access_token.key, 'access.key')
+        self.assertEqual(loaded_credentials.consumer.key, "consumer.key")
+        self.assertEqual(loaded_credentials.consumer.secret, "consumer.secret")
+        self.assertEqual(loaded_credentials.access_token.key, "access.key")
         self.assertEqual(
-            loaded_credentials.access_token.secret, 'access.secret')
+            loaded_credentials.access_token.secret, "access.secret"
+        )
 
 
 def test_suite():
diff --git a/tox.ini b/tox.ini
index 214d128..e1b6eb9 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,5 +1,5 @@
 [tox]
-envlist = 
+envlist =
     py27,lint,docs
 
 [testenv]