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

[Jürgen Gmach]

Apply black code formatter

[Guruprasad (lgp171188)]

I read the diff, tested the changes locally by running the unit tests on Python 3.9. The tests passed. This looks good to me. 👍

review: Approve

[Jürgen Gmach (jugmac00)]

Thanks for the review!

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 0000000..04ed7f8
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,2 @@
+# apply black
+2605ef4e4b85988957963224e51f03ce7778405d
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index d368f14..c8c0353 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,7 +2,7 @@
 # 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
@@ -10,7 +10,7 @@ repos:
     -   id: check-yaml
     -   id: debug-statements
 -   repo: https://github.com/PyCQA/flake8
-    rev: 3.9.2
+    rev: 4.0.1
     hooks:
     -   id: flake8
 -   repo: https://github.com/get-woke/woke
@@ -19,3 +19,7 @@ repos:
     -   id: woke-from-source
         # NEWS.rst mentions API changes
         exclude: NEWS.rst
+-   repo: https://github.com/psf/black
+    rev: 21.10b0
+    hooks:
+    - id: black
diff --git a/NEWS.rst b/NEWS.rst
index 3b8f8f3..74ee44e 100644
--- a/NEWS.rst
+++ b/NEWS.rst
@@ -18,6 +18,7 @@ NEWS for lazr.restful
   => ``lazr.restful.testing.webservice.StubAbsoluteURL``,
   ``lazr.restful.testing.webservice.DummyRootResourceURL``
   => ``lazr.restful.testing.webservice.StubRootResourceURL``
+- Apply black code formatter via pre-commit.
 
 1.1.0 (2021-10-07)
 ==================
diff --git a/setup.py b/setup.py
index 4fc49fc..71f4fd8 100755
--- a/setup.py
+++ b/setup.py
@@ -23,69 +23,69 @@ from setuptools import setup, find_packages
 def generate(*docname_or_string):
     res = []
     for value in docname_or_string:
-        if value.endswith('.rst'):
+        if value.endswith(".rst"):
             f = open(value)
-            value = f.read().split('..\n    end-pypi', 1)[0]
+            value = f.read().split("..\n    end-pypi", 1)[0]
             f.close()
         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
 
 
 setup(
-    name='lazr.restful',
-    version='1.1.0',
-    namespace_packages=['lazr'],
-    packages=find_packages('src'),
-    package_dir={'':'src'},
+    name="lazr.restful",
+    version="1.1.0",
+    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(),
-    long_description=generate(
-        'src/lazr/restful/docs/index.rst',
-        'NEWS.rst'),
-    license='LGPL v3',
+    maintainer="LAZR Developers",
+    maintainer_email="[e-mail]",
+    description=open("README.rst").readline().strip(),
+    long_description=generate("src/lazr/restful/docs/index.rst", "NEWS.rst"),
+    license="LGPL v3",
     install_requires=[
-        'docutils>=0.3.9',
-        'grokcore.component>=1.6',
+        "docutils>=0.3.9",
+        "grokcore.component>=1.6",
         'importlib-metadata; python_version < "3.8"',
-        'lazr.batchnavigator>=1.2.0-dev',
-        'lazr.delegates>=2.0.3',
-        'lazr.enum',
-        'lazr.lifecycle',
-        'lazr.uri',
-        'martian>=0.11',
-        'pytz',
-        'setuptools',
-        'simplejson>=2.1.0',
-        'six>=1.13.0',
-        'testtools',
-        'van.testing',
+        "lazr.batchnavigator>=1.2.0-dev",
+        "lazr.delegates>=2.0.3",
+        "lazr.enum",
+        "lazr.lifecycle",
+        "lazr.uri",
+        "martian>=0.11",
+        "pytz",
+        "setuptools",
+        "simplejson>=2.1.0",
+        "six>=1.13.0",
+        "testtools",
+        "van.testing",
         'wsgiref; python_version < "3"',
-        'zope.component [zcml]',
-        'zope.configuration',
-        'zope.datetime',
-        'zope.event',
-        'zope.interface>=3.8.0',
-        'zope.pagetemplate',
-        'zope.processlifetime',
-        'zope.proxy',
+        "zope.component [zcml]",
+        "zope.configuration",
+        "zope.datetime",
+        "zope.event",
+        "zope.interface>=3.8.0",
+        "zope.pagetemplate",
+        "zope.processlifetime",
+        "zope.proxy",
         'zope.publisher; python_version < "3"',
         'zope.publisher>=6.0.0; python_version >= "3"',
-        'zope.schema',
-        'zope.security',
-        'zope.traversing',
-        ],
-    url='https://launchpad.net/lazr.restful',
-    download_url= 'https://launchpad.net/lazr.restful/+download',
+        "zope.schema",
+        "zope.security",
+        "zope.traversing",
+    ],
+    url="https://launchpad.net/lazr.restful",
+    download_url="https://launchpad.net/lazr.restful/+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",
@@ -97,11 +97,13 @@ setup(
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
-        ],
+    ],
     extras_require=dict(
-        docs=['Sphinx'],
-        test=['zope.testing>=4.6.0'],
-        xml=['lxml',]  # requiring this of normal users is too much
+        docs=["Sphinx"],
+        test=["zope.testing>=4.6.0"],
+        xml=[
+            "lxml",
+        ],  # requiring this of normal users is too much
     ),
-    test_suite='lazr.restful.tests',
-    )
+    test_suite="lazr.restful.tests",
+)
diff --git a/src/lazr/__init__.py b/src/lazr/__init__.py
index 20416d1..465f504 100644
--- a/src/lazr/__init__.py
+++ b/src/lazr/__init__.py
@@ -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/restful/__init__.py b/src/lazr/restful/__init__.py
index 54321dc..25235cd 100644
--- a/src/lazr/restful/__init__.py
+++ b/src/lazr/restful/__init__.py
@@ -38,6 +38,7 @@ try:
     from lazr.restful._operation import __all__ as _operation_all
     from lazr.restful._resource import *  # noqa: F401, F403
     from lazr.restful._resource import __all__ as _resource_all
+
     __all__ = []
     __all__.extend(_bytestorage_all)
     __all__.extend(_operation_all)
diff --git a/src/lazr/restful/_bytestorage.py b/src/lazr/restful/_bytestorage.py
index 382e2d9..7d6c6a0 100644
--- a/src/lazr/restful/_bytestorage.py
+++ b/src/lazr/restful/_bytestorage.py
@@ -20,8 +20,8 @@ from __future__ import absolute_import, print_function
 
 __metaclass__ = type
 __all__ = [
-    'ByteStorageResource',
-    ]
+    "ByteStorageResource",
+]
 
 from zope.interface import implementer
 from zope.publisher.interfaces import NotFound
@@ -44,13 +44,15 @@ class ByteStorageResource(HTTPResource):
                 # Read-only resources only support GET.
                 allow_string = "GET"
             elif self.request.method == "PUT":
-                type = self.request.headers['Content-Type']
+                type = self.request.headers["Content-Type"]
                 disposition, params = self._parseContentDispositionHeader(
-                    self.request.headers['Content-Disposition'])
+                    self.request.headers["Content-Disposition"]
+                )
                 cache_stream = self.request.bodyStream.getCacheStream()
                 representation = cache_stream.read()
-                return self.do_PUT(type, representation,
-                                   params.get('filename'))
+                return self.do_PUT(
+                    type, representation, params.get("filename")
+                )
             elif self.request.method == "DELETE":
                 return self.do_DELETE()
             else:
@@ -64,20 +66,20 @@ class ByteStorageResource(HTTPResource):
         media_type = self.getPreferredSupportedContentType()
         if media_type in [self.WADL_TYPE, self.DEPRECATED_WADL_TYPE]:
             result = self.toWADL().encode("utf-8")
-            self.request.response.setHeader('Content-Type', media_type)
+            self.request.response.setHeader("Content-Type", media_type)
             return result
         if not self.context.is_stored:
             # No stored document exists here yet.
             raise NotFound(self.context, self.context.filename, self.request)
-        self.request.response.setStatus(303) # See Other
-        self.request.response.setHeader('Location', self.context.alias_url)
+        self.request.response.setStatus(303)  # See Other
+        self.request.response.setHeader("Location", self.context.alias_url)
 
     def do_PUT(self, type, representation, filename):
         """See `IByteStorageResource`."""
         try:
             self.context.field.validate(representation)
         except ValidationError as e:
-            self.request.response.setStatus(400) # Bad Request
+            self.request.response.setStatus(400)  # Bad Request
             return str(e)
         self.context.createStored(type, representation, filename)
 
diff --git a/src/lazr/restful/_operation.py b/src/lazr/restful/_operation.py
index fc7c037..af48e48 100644
--- a/src/lazr/restful/_operation.py
+++ b/src/lazr/restful/_operation.py
@@ -13,36 +13,48 @@ from zope.interface import Attribute, implementer, providedBy
 from zope.interface.interfaces import IInterface
 from zope.schema import Field
 from zope.schema.interfaces import (
-    IField, RequiredMissing, ValidationError, WrongType)
+    IField,
+    RequiredMissing,
+    ValidationError,
+    WrongType,
+)
 from zope.security.proxy import isinstance as zope_isinstance
 
 from lazr.lifecycle.event import ObjectModifiedEvent
 from lazr.lifecycle.snapshot import Snapshot
 
 from lazr.restful.interfaces import (
-    ICollection, IFieldMarshaller, IResourceDELETEOperation,
-    IResourceGETOperation, IResourcePOSTOperation, IWebServiceConfiguration)
+    ICollection,
+    IFieldMarshaller,
+    IResourceDELETEOperation,
+    IResourceGETOperation,
+    IResourcePOSTOperation,
+    IWebServiceConfiguration,
+)
 from lazr.restful.interfaces import ICollectionField, IReference
 from lazr.restful.utils import is_total_size_link_active
 from lazr.restful._resource import (
-    BatchingResourceMixin, CollectionResource, ResourceJSONEncoder)
+    BatchingResourceMixin,
+    CollectionResource,
+    ResourceJSONEncoder,
+)
 
 
 __metaclass__ = type
 __all__ = [
-    'IObjectLink',
-    'ObjectLink',
-    'ResourceOperation',
-    'ResourceGETOperation',
-    'ResourceDELETEOperation',
-    'ResourcePOSTOperation'
+    "IObjectLink",
+    "ObjectLink",
+    "ResourceOperation",
+    "ResourceGETOperation",
+    "ResourceDELETEOperation",
+    "ResourcePOSTOperation",
 ]
 
 
 class ResourceOperation(BatchingResourceMixin):
     """A one-off operation associated with a resource."""
 
-    JSON_TYPE = 'application/json'
+    JSON_TYPE = "application/json"
     send_modification_event = False
 
     def __init__(self, context, request):
@@ -67,20 +79,21 @@ class ResourceOperation(BatchingResourceMixin):
             return None
         base = str(self.request.URL)
         query = navigator.getCleanQueryString()
-        if query != '':
-            query += '&'
-        return base + '?' + query + "ws.show=total_size"
+        if query != "":
+            query += "&"
+        return base + "?" + query + "ws.show=total_size"
 
     def __call__(self):
         values, errors = self.validate()
         if len(errors) > 0:
             self.request.response.setStatus(400)
-            self.request.response.setHeader('Content-type', 'text/plain')
+            self.request.response.setHeader("Content-type", "text/plain")
             return "\n".join(errors)
 
         if self.send_modification_event:
             snapshot = Snapshot(
-                self.context, providing=providedBy(self.context))
+                self.context, providing=providedBy(self.context)
+            )
 
         response = self.call(**values)
 
@@ -88,7 +101,8 @@ class ResourceOperation(BatchingResourceMixin):
             event = ObjectModifiedEvent(
                 object=self.context,
                 object_before_modification=snapshot,
-                edited_fields=None)
+                edited_fields=None,
+            )
             notify(event)
         return self.encodeResult(response)
 
@@ -100,8 +114,10 @@ class ResourceOperation(BatchingResourceMixin):
         responsible for setting the Content-Type header and the status
         code.
         """
-        if (self.request.response.getHeader('Content-Type') is not None
-            or self.request.response.getStatus() != 599):
+        if (
+            self.request.response.getHeader("Content-Type") is not None
+            or self.request.response.getStatus() != 599
+        ):
             # The operation took care of everything and just needs
             # this object served to the client.
             return result
@@ -116,23 +132,24 @@ class ResourceOperation(BatchingResourceMixin):
             if self.total_size_only:
                 result = resource.get_total_size(collection)
             else:
-                result = resource.batch() + '}'
+                result = resource.batch() + "}"
         elif self.should_batch(result):
             if self.total_size_only:
                 result = self.get_total_size(result)
             else:
-                result = self.batch(result, self.request) + '}'
+                result = self.batch(result, self.request) + "}"
         else:
             # Serialize the result to JSON. Any embedded entries will be
             # automatically serialized.
             try:
                 result = simplejson.dumps(result, cls=ResourceJSONEncoder)
             except TypeError:
-                raise TypeError("Could not serialize object %s to JSON." %
-                                result)
+                raise TypeError(
+                    "Could not serialize object %s to JSON." % result
+                )
 
         self.request.response.setStatus(200)
-        self.request.response.setHeader('Content-Type', self.JSON_TYPE)
+        self.request.response.setHeader("Content-Type", self.JSON_TYPE)
         return result
 
     def should_batch(self, result):
@@ -147,7 +164,8 @@ class ResourceOperation(BatchingResourceMixin):
             return True
 
         if zope_isinstance(
-                result, (bytes, six.text_type, dict, set, list, tuple)):
+            result, (bytes, six.text_type, dict, set, list, tuple)
+        ):
             # Ordinary Python data structures generally are not
             # batched.
             return False
@@ -184,15 +202,19 @@ class ResourceOperation(BatchingResourceMixin):
         for field in self.params:
             name = field.__name__
             field = field.bind(self.context)
-            if (self.request.get(name, missing) is missing
-                and not field.required):
+            if (
+                self.request.get(name, missing) is missing
+                and not field.required
+            ):
                 value = field.default
             else:
                 marshaller = getMultiAdapter(
-                    (field, self.request), IFieldMarshaller)
+                    (field, self.request), IFieldMarshaller
+                )
                 try:
                     value = marshaller.marshall_from_request(
-                        self.request.form.get(name))
+                        self.request.form.get(name)
+                    )
                 except ValueError as e:
                     errors.append(u"%s: %s" % (name, e))
                     continue
@@ -229,8 +251,9 @@ class ResourcePOSTOperation(ResourceOperation):
 class IObjectLink(IField):
     """Field containing a link to an object."""
 
-    schema = Attribute("schema",
-        u"The Interface of the Object on the other end of the link.")
+    schema = Attribute(
+        "schema", u"The Interface of the Object on the other end of the link."
+    )
 
 
 @implementer(IObjectLink)
diff --git a/src/lazr/restful/_resource.py b/src/lazr/restful/_resource.py
index 0b411e8..f720b30 100644
--- a/src/lazr/restful/_resource.py
+++ b/src/lazr/restful/_resource.py
@@ -7,28 +7,28 @@ from __future__ import absolute_import, division, print_function
 __metaclass__ = type
 
 __all__ = [
-    'BatchingResourceMixin',
-    'Collection',
-    'CollectionResource',
-    'Entry',
-    'EntryAdapterUtility',
-    'EntryField',
-    'EntryFieldResource',
-    'EntryHTMLView',
-    'EntryResource',
-    'HTTPResource',
-    'JSONDate',
-    'JSONItem',
-    'ReadOnlyResource',
-    'RedirectResource',
-    'register_versioned_request_utility',
-    'render_field_to_html',
-    'ResourceJSONEncoder',
-    'RESTUtilityBase',
-    'ScopedCollection',
-    'ServiceRootResource',
-    'WADL_SCHEMA_FILE',
-    ]
+    "BatchingResourceMixin",
+    "Collection",
+    "CollectionResource",
+    "Entry",
+    "EntryAdapterUtility",
+    "EntryField",
+    "EntryFieldResource",
+    "EntryHTMLView",
+    "EntryResource",
+    "HTTPResource",
+    "JSONDate",
+    "JSONItem",
+    "ReadOnlyResource",
+    "RedirectResource",
+    "register_versioned_request_utility",
+    "render_field_to_html",
+    "ResourceJSONEncoder",
+    "RESTUtilityBase",
+    "ScopedCollection",
+    "ServiceRootResource",
+    "WADL_SCHEMA_FILE",
+]
 
 from collections import OrderedDict
 from email.utils import formatdate
@@ -43,9 +43,11 @@ import time
 # Import SHA in a way compatible with both Python 2.4 and Python 2.6.
 try:
     import hashlib
+
     sha_constructor = hashlib.sha1
 except ImportError:
     import sha
+
     sha_constructor = sha.new
 
 try:
@@ -63,7 +65,7 @@ from zope.component import (
     getSiteManager,
     getUtility,
     queryMultiAdapter,
-    )
+)
 from zope.event import notify
 from zope.interface import (
     alsoProvides,
@@ -71,13 +73,13 @@ from zope.interface import (
     implementedBy,
     providedBy,
     Interface,
-    )
+)
 from zope.interface.common.idatetime import IDate
 from zope.interface.common.sequence import IFiniteSequence
 from zope.interface.interfaces import (
     ComponentLookupError,
     IInterface,
-    )
+)
 from zope.location.interfaces import ILocation
 from zope.pagetemplate.engine import TrustedAppPT
 from zope.pagetemplate.pagetemplatefile import PageTemplateFile
@@ -87,7 +89,11 @@ from zope.publisher.interfaces import NotFound
 from zope.publisher.interfaces.http import IHTTPRequest
 from zope.schema import ValidationError, getFieldsInOrder
 from zope.schema.interfaces import (
-    ConstraintNotSatisfied, IBytes, IField, RequiredMissing)
+    ConstraintNotSatisfied,
+    IBytes,
+    IField,
+    RequiredMissing,
+)
 from zope.security.interfaces import Unauthorized
 from zope.security.proxy import getChecker, removeSecurityProxy
 from zope.security.management import checkPermission
@@ -127,19 +133,18 @@ from lazr.restful.interfaces import (
     IWebServiceLayer,
     IWebServiceVersion,
     LAZR_WEBSERVICE_NAME,
-    )
+)
 from lazr.restful.marshallers import URLDereferencingMixin
 from lazr.restful.utils import (
     extract_write_portion,
     get_current_web_service_request,
     parse_accept_style_header,
     sorted_named_things,
-    )
+)
 
 
 # The path to the WADL XML Schema definition.
-WADL_SCHEMA_FILE = os.path.join(os.path.dirname(__file__),
-                                'wadl20061109.xsd')
+WADL_SCHEMA_FILE = os.path.join(os.path.dirname(__file__), "wadl20061109.xsd")
 
 # Constants and levels of detail to use when unmarshalling the data.
 MISSING = object()
@@ -149,7 +154,7 @@ CLOSEUP_DETAIL = object()
 # XXX leonardr 2009-01-29
 # bug=https://bugs.edge.launchpad.net/zope3/+bug/322486:
 # Add nonstandard status methods to Zope's status_reasons dictionary.
-for code, reason in [(209, 'Content Returned')]:
+for code, reason in [(209, "Content Returned")]:
     if code not in status_reasons:
         status_reasons[code] = reason
 init_status_codes()
@@ -188,7 +193,8 @@ def register_versioned_request_utility(interface, version):
     """
     alsoProvides(interface, IWebServiceVersion)
     getSiteManager().registerUtility(
-        interface, IWebServiceVersion, name=version)
+        interface, IWebServiceVersion, name=version
+    )
 
 
 class LazrPageTemplateFile(TrustedAppPT, PageTemplateFile):
@@ -205,7 +211,7 @@ class ResourceJSONEncoder(simplejson.encoder.JSONEncoderForHTML):
     """
 
     def __init__(self, *args, **kwargs):
-        self.media_type = kwargs.pop('media_type', HTTPResource.JSON_TYPE)
+        self.media_type = kwargs.pop("media_type", HTTPResource.JSON_TYPE)
         super(ResourceJSONEncoder, self).__init__(*args, **kwargs)
 
     def default(self, obj):
@@ -280,18 +286,18 @@ class HTTPResource:
     """See `IHTTPResource`."""
 
     # Some interesting media types.
-    WADL_TYPE = 'application/vnd.sun.wadl+xml'
-    JSON_TYPE = 'application/json'
-    JSON_PLUS_XHTML_TYPE = 'application/json;include=lp_html'
-    XHTML_TYPE = 'application/xhtml+xml'
+    WADL_TYPE = "application/vnd.sun.wadl+xml"
+    JSON_TYPE = "application/json"
+    JSON_PLUS_XHTML_TYPE = "application/json;include=lp_html"
+    XHTML_TYPE = "application/xhtml+xml"
 
     # This misspelling of the WADL media type was used for a while,
     # and lazr.restful still supports it to avoid breaking clients
     # that depend on it.
-    DEPRECATED_WADL_TYPE = 'application/vd.sun.wadl+xml'
+    DEPRECATED_WADL_TYPE = "application/vd.sun.wadl+xml"
 
     # A preparsed template file for WADL representations of resources.
-    WADL_TEMPLATE = LazrPageTemplateFile('templates/wadl-resource.pt')
+    WADL_TEMPLATE = LazrPageTemplateFile("templates/wadl-resource.pt")
 
     # All resources serve WADL and JSON representations. Only entry
     # resources serve XHTML representations and JSON+XHTML representations.
@@ -316,8 +322,8 @@ class HTTPResource:
         """
         if request is None:
             request = self.request
-        override = request.headers.get('X-HTTP-Method-Override')
-        if override is not None and request.method == 'POST':
+        override = request.headers.get("X-HTTP-Method-Override")
+        if override is not None and request.method == "POST":
             # POST is the only HTTP method for which we respect
             # X-HTTP-Method-Override.
             return override
@@ -335,12 +341,12 @@ class HTTPResource:
             incoming ETag matched the generated ETag and there is no
             need to serve anything else.
         """
-        incoming_etags = self._parseETags('If-None-Match')
+        incoming_etags = self._parseETags("If-None-Match")
 
         media_type = self.getPreferredSupportedContentType()
         existing_etag = self.getETag(media_type)
         if existing_etag is not None:
-            self.request.response.setHeader('ETag', existing_etag)
+            self.request.response.setHeader("ETag", existing_etag)
             if existing_etag in incoming_etags:
                 # The client already has this representation.
                 # No need to send it again.
@@ -368,9 +374,9 @@ class HTTPResource:
             generated ETag and the incoming representation should be
             ignored.
         """
-        media_type = self.request.headers.get('X-Content-Type-Override')
+        media_type = self.request.headers.get("X-Content-Type-Override")
         if media_type is not None:
-            if self.request.method != 'POST':
+            if self.request.method != "POST":
                 # X-C-T-O should not be used unless the underlying
                 # method is POST. Set response code 400 ("Bad
                 # Request").
@@ -378,9 +384,10 @@ class HTTPResource:
                 return None
         else:
             media_type = self.request.headers.get(
-                'Content-Type', self.JSON_TYPE)
+                "Content-Type", self.JSON_TYPE
+            )
 
-        incoming_etags = self._parseETags('If-Match')
+        incoming_etags = self._parseETags("If-Match")
         if len(incoming_etags) == 0:
             # This is not a conditional write.
             return media_type
@@ -459,16 +466,19 @@ class HTTPResource:
         custom POST operations.
         """
         adapters = list(
-            getAdapters((self.context, self.request), IResourcePOSTOperation))
+            getAdapters((self.context, self.request), IResourcePOSTOperation)
+        )
         return len(adapters) > 0
 
     def implementsDELETE(self):
         """Returns True if this resource will respond to DELETE."""
         adapters = list(
-            getAdapters(
-                (self.context, self.request), IResourceDELETEOperation))
-        assert len(adapters) < 2, ("%s has more than one registered DELETE "
-                                   "handler." % self.context.__class__)
+            getAdapters((self.context, self.request), IResourceDELETEOperation)
+        )
+        assert len(adapters) < 2, (
+            "%s has more than one registered DELETE "
+            "handler." % self.context.__class__
+        )
         return len(adapters) > 0
 
     def toWADL(self):
@@ -477,7 +487,7 @@ class HTTPResource:
         The WADL document describes the capabilities of this resource.
         """
         namespace = self.WADL_TEMPLATE.pt_getContext()
-        namespace['context'] = self
+        namespace["context"] = self
         return self.WADL_TEMPLATE.pt_render(namespace)
 
     def getPreferredSupportedContentType(self):
@@ -504,8 +514,9 @@ class HTTPResource:
 
     def getPreferredContentTypes(self):
         """Find which content types the client prefers to receive."""
-        accept_header = (self.request.form.pop('ws.accept', None)
-            or self.request.get('HTTP_ACCEPT'))
+        accept_header = self.request.form.pop(
+            "ws.accept", None
+        ) or self.request.get("HTTP_ACCEPT")
         return parse_accept_style_header(accept_header)
 
     def _parseETags(self, header_name):
@@ -522,15 +533,16 @@ class HTTPResource:
             return []
         utility = getUtility(IWebServiceConfiguration)
         strip_gzip_from_etag = (
-            utility.compensate_for_mod_compress_etag_modification)
+            utility.compensate_for_mod_compress_etag_modification
+        )
         etags = []
         # We're kind of cheating, because entity tags can technically
         # have commas in them, but none of our tags contain commas, so
         # this will work.
-        for etag in header.split(','):
+        for etag in header.split(","):
             etag = etag.strip()
             if strip_gzip_from_etag:
-                if etag.endswith('-gzip'):
+                if etag.endswith("-gzip"):
                     etag = etag[:-5]
                 elif etag.endswith('-gzip"'):
                     etag = etag[:-6] + '"'
@@ -547,11 +559,11 @@ class HTTPResource:
         params = {}
         if value is None:
             return (disposition, params)
-        pieces = value.split(';')
+        pieces = value.split(";")
         if len(pieces) > 1:
             disposition = pieces[0].strip()
         for name_value in pieces[1:]:
-            name_and_value = name_value.split('=', 2)
+            name_and_value = name_value.split("=", 2)
             if len(name_and_value) == 2:
                 name = name_and_value[0].strip()
                 value = name_and_value[1].strip()
@@ -560,7 +572,7 @@ class HTTPResource:
                 # very likely that a client will quote even short
                 # filenames, and unlikely that a filename will
                 # actually begin and end with quotes.
-                if (value[0] == '"' and value[-1] == '"'):
+                if value[0] == '"' and value[-1] == '"':
                     value = value[1:-1]
             else:
                 name = name_and_value
@@ -612,7 +624,7 @@ class BatchingResourceMixin:
 
         :return: a JSON string representing the number of objects in the list
         """
-        if not hasattr(entries, '__len__'):
+        if not hasattr(entries, "__len__"):
             entries = IFiniteSequence(entries)
 
         return simplejson.dumps(len(entries))
@@ -639,12 +651,12 @@ class BatchingResourceMixin:
         keys to the JSON hash. It's the caller's responsibility to add
         a '}' to the end of the string returned from this method.
         """
-        if not hasattr(entries, '__len__'):
+        if not hasattr(entries, "__len__"):
             entries = IFiniteSequence(entries)
         navigator = WebServiceBatchNavigator(entries, request)
 
         view_permission = getUtility(IWebServiceConfiguration).view_permission
-        batch = {'start': navigator.batch.start}
+        batch = {"start": navigator.batch.start}
         # If this is the last batch, then total() is easy to
         # calculate. Let's use it and save the client from having to
         # ask for the total size of the collection.
@@ -658,27 +670,33 @@ class BatchingResourceMixin:
                 # lazr.batchnavigator uses -1 for an empty list.
                 # We want to use 0.
                 total_size = 0
-            batch['total_size'] = total_size
+            batch["total_size"] = total_size
         else:
-            batch['total_size_link'] = total_size_link
+            batch["total_size_link"] = total_size_link
         next_url = navigator.nextBatchURL()
         if next_url != "":
-            batch['next_collection_link'] = next_url
+            batch["next_collection_link"] = next_url
         prev_url = navigator.prevBatchURL()
         if prev_url != "":
-            batch['prev_collection_link'] = prev_url
+            batch["prev_collection_link"] = prev_url
         json_string = simplejson.dumps(batch, cls=ResourceJSONEncoder)
 
         # String together a bunch of entry representations, possibly
         # obtained from a representation cache.
-        resources = [EntryResource(entry, request)
-                     for entry in navigator.batch
-                     if checkPermission(view_permission, entry)]
+        resources = [
+            EntryResource(entry, request)
+            for entry in navigator.batch
+            if checkPermission(view_permission, entry)
+        ]
         entry_strings = [
             resource._representation(HTTPResource.JSON_TYPE)
-            for resource in resources]
-        json_string = (json_string[:-1] + ', "entries": ['
-                       + (", ".join(entry_strings) + ']'))
+            for resource in resources
+        ]
+        json_string = (
+            json_string[:-1]
+            + ', "entries": ['
+            + (", ".join(entry_strings) + "]")
+        )
         # The caller is responsible for tacking on the final curly brace.
         return json_string
 
@@ -709,15 +727,17 @@ class CustomOperationResourceMixin:
             return "Expected a single operation: %r" % (operation_name,)
 
         try:
-            operation = getMultiAdapter((self.context, self.request),
-                                        IResourceGETOperation,
-                                        name=operation_name)
+            operation = getMultiAdapter(
+                (self.context, self.request),
+                IResourceGETOperation,
+                name=operation_name,
+            )
         except ComponentLookupError:
             self.request.response.setStatus(400)
             return "No such operation: " + operation_name
 
-        show = self.request.form.get('ws.show')
-        if show == 'total_size':
+        show = self.request.form.get("ws.show")
+        if show == "total_size":
             operation.total_size_only = True
         return operation()
 
@@ -735,9 +755,11 @@ class CustomOperationResourceMixin:
             return "Expected a single operation: %r" % (operation_name,)
 
         try:
-            operation = getMultiAdapter((self.context, self.request),
-                                        IResourcePOSTOperation,
-                                        name=operation_name)
+            operation = getMultiAdapter(
+                (self.context, self.request),
+                IResourcePOSTOperation,
+                name=operation_name,
+            )
         except ComponentLookupError:
             self.request.response.setStatus(400)
             return "No such operation: " + operation_name
@@ -752,18 +774,19 @@ class CustomOperationResourceMixin:
         should eventually go into CollectionResource that implements
         POST to create a new entry inside the collection.
         """
-        operation_name = self.request.form.get('ws.op')
+        operation_name = self.request.form.get("ws.op")
         if operation_name is None:
             self.request.response.setStatus(400)
             return "No operation name given."
-        del self.request.form['ws.op']
+        del self.request.form["ws.op"]
         return self.handleCustomPOST(operation_name)
 
     def do_DELETE(self):
         """Invoke a destructor operation."""
         try:
-            operation = getMultiAdapter((self.context, self.request),
-                                        IResourceDELETEOperation)
+            operation = getMultiAdapter(
+                (self.context, self.request), IResourceDELETEOperation
+            )
         except ComponentLookupError:
             # This should never happen because implementsDELETE()
             # makes sure there is a registered
@@ -779,7 +802,7 @@ class FieldUnmarshallerMixin:
 
     # The representation value used when the client doesn't have
     # authorization to see the real value.
-    REDACTED_VALUE = 'tag:launchpad.net:2008:redacted'
+    REDACTED_VALUE = "tag:launchpad.net:2008:redacted"
 
     def __init__(self, context, request):
         """A basic constructor."""
@@ -798,7 +821,8 @@ class FieldUnmarshallerMixin:
         cached_value = MISSING
         if detail is NORMAL_DETAIL:
             cached_value = self._unmarshalled_field_cache.get(
-                field_name, MISSING)
+                field_name, MISSING
+            )
         if cached_value is not MISSING:
             return cached_value[0]
 
@@ -815,7 +839,8 @@ class FieldUnmarshallerMixin:
                 repr_value = marshaller.unmarshall(self.entry, value)
             elif detail is CLOSEUP_DETAIL:
                 repr_value = marshaller.unmarshall_to_closeup(
-                    self.entry, value)
+                    self.entry, value
+                )
             else:
                 raise AssertionError("Invalid level of detail specified")
         except Unauthorized:
@@ -832,7 +857,9 @@ class FieldUnmarshallerMixin:
 
         if detail is NORMAL_DETAIL:
             self._unmarshalled_field_cache[field_name] = (
-                unmarshalled, (field, value, flag))
+                unmarshalled,
+                (field, value, flag),
+            )
         return unmarshalled
 
     def _field_with_html_renderer(self, field_name, field):
@@ -848,14 +875,16 @@ class FieldUnmarshallerMixin:
             # Try to get a renderer for this particular field.
             renderer = getMultiAdapter(
                 (self.entry.context, field, self.request),
-                IFieldHTMLRenderer, name=field.__name__)
+                IFieldHTMLRenderer,
+                name=field.__name__,
+            )
         except ComponentLookupError:
             # There's no field-specific renderer. Look up an
             # IFieldHTMLRenderer for this _type_ of field.
             field = field.bind(self.entry.context)
             renderer = getMultiAdapter(
-                (self.entry.context, field, self.request),
-                IFieldHTMLRenderer)
+                (self.entry.context, field, self.request), IFieldHTMLRenderer
+            )
         return name, value, renderer
 
     def unmarshallFieldToHTML(self, field_name, field):
@@ -867,7 +896,8 @@ class FieldUnmarshallerMixin:
         :return: a 2-tuple (representation_name, representation_value).
         """
         name, value, renderer = self._field_with_html_renderer(
-            field_name, field)
+            field_name, field
+        )
         return name, renderer(value)
 
 
@@ -976,7 +1006,7 @@ class EntryHTMLView:
     """An HTML view of an entry."""
 
     # A preparsed template file for HTML representations of the resource.
-    HTML_TEMPLATE = LazrPageTemplateFile('templates/html-resource.pt')
+    HTML_TEMPLATE = LazrPageTemplateFile("templates/html-resource.pt")
 
     def __init__(self, context, request):
         """Initialize with respect to a data object and request."""
@@ -988,10 +1018,13 @@ class EntryHTMLView:
         """Send the entry data through an HTML template."""
         namespace = self.HTML_TEMPLATE.pt_getContext()
         names_and_values = self.resource.toDataStructure(
-            HTTPResource.XHTML_TYPE).items()
-        data = [{'name': name, 'value': decode_value(value)}
-                for name, value in names_and_values]
-        namespace['context'] = sorted(data, key=itemgetter('name'))
+            HTTPResource.XHTML_TYPE
+        ).items()
+        data = [
+            {"name": name, "value": decode_value(value)}
+            for name, value in names_and_values
+        ]
+        namespace["context"] = sorted(data, key=itemgetter("name"))
         return self.HTML_TEMPLATE.pt_render(namespace)
 
 
@@ -1008,9 +1041,9 @@ class EntryManipulatingResource(ReadWriteResource):
         """Process an incoming representation as a JSON document."""
         if not media_type.startswith(self.JSON_TYPE):
             self.request.response.setStatus(415)
-            return None, 'Expected a media type of %s.' % self.JSON_TYPE
+            return None, "Expected a media type of %s." % self.JSON_TYPE
         try:
-            h = simplejson.loads(representation.decode('utf-8'))
+            h = simplejson.loads(representation.decode("utf-8"))
         except ValueError:
             self.request.response.setStatus(400)
             return None, "Entity-body was not a well-formed JSON document."
@@ -1032,48 +1065,51 @@ class EntryManipulatingResource(ReadWriteResource):
 
         # Some fields aren't part of the schema, so they're handled
         # separately.
-        modified_read_only_attribute = (u"%s: You tried to modify a "
-                                         "read-only attribute.")
-        if 'self_link' in changeset:
-            if changeset['self_link'] != absoluteURL(self.entry.context,
-                                                     self.request):
-                errors.append(modified_read_only_attribute % 'self_link')
-            del changeset['self_link']
-
-        if 'web_link' in changeset:
-            browser_request = IWebBrowserOriginatingRequest(
-                self.request, None)
+        modified_read_only_attribute = (
+            u"%s: You tried to modify a " "read-only attribute."
+        )
+        if "self_link" in changeset:
+            if changeset["self_link"] != absoluteURL(
+                self.entry.context, self.request
+            ):
+                errors.append(modified_read_only_attribute % "self_link")
+            del changeset["self_link"]
+
+        if "web_link" in changeset:
+            browser_request = IWebBrowserOriginatingRequest(self.request, None)
             if browser_request is not None:
                 existing_web_link = absoluteURL(
-                    self.entry.context, browser_request)
-                if changeset['web_link'] != existing_web_link:
-                    errors.append(modified_read_only_attribute % 'web_link')
-                del changeset['web_link']
-
-        if 'resource_type_link' in changeset:
-            if changeset['resource_type_link'] != self.type_url:
-                errors.append(modified_read_only_attribute %
-                              'resource_type_link')
-            del changeset['resource_type_link']
-
-        if 'http_etag' in changeset:
-            if changeset['http_etag'] != self.getETag(media_type):
-                errors.append(modified_read_only_attribute %
-                              'http_etag')
-            del changeset['http_etag']
-
-        if 'lp_html' in changeset:
+                    self.entry.context, browser_request
+                )
+                if changeset["web_link"] != existing_web_link:
+                    errors.append(modified_read_only_attribute % "web_link")
+                del changeset["web_link"]
+
+        if "resource_type_link" in changeset:
+            if changeset["resource_type_link"] != self.type_url:
+                errors.append(
+                    modified_read_only_attribute % "resource_type_link"
+                )
+            del changeset["resource_type_link"]
+
+        if "http_etag" in changeset:
+            if changeset["http_etag"] != self.getETag(media_type):
+                errors.append(modified_read_only_attribute % "http_etag")
+            del changeset["http_etag"]
+
+        if "lp_html" in changeset:
             if media_type == self.JSON_PLUS_XHTML_TYPE:
                 # The HTML portion of the representation is read-only,
                 # so ignore it.
-                del changeset['lp_html']
+                del changeset["lp_html"]
 
         # For every field in the schema, see if there's a corresponding
         # field in the changeset.
         for name, field in get_entry_fields_in_write_order(self.entry):
             field = field.bind(self.entry.context)
-            marshaller = getMultiAdapter((field, self.request),
-                                         IFieldMarshaller)
+            marshaller = getMultiAdapter(
+                (field, self.request), IFieldMarshaller
+            )
             repr_name = marshaller.representation_name
             if repr_name not in changeset:
                 # The client didn't try to set a value for this field.
@@ -1084,7 +1120,8 @@ class EntryManipulatingResource(ReadWriteResource):
             # way to see if the client changed the value.
             try:
                 current_value = marshaller.unmarshall(
-                    self.entry, getattr(self.entry, name))
+                    self.entry, getattr(self.entry, name)
+                )
             except Unauthorized:
                 # The client doesn't have permission to see the old
                 # value. That doesn't necessarily mean they can't set
@@ -1114,8 +1151,10 @@ class EntryManipulatingResource(ReadWriteResource):
                 # error message if the new value is not identical to the
                 # current one.
                 if value != current_value:
-                    errors.append(u"%s: You tried to modify a collection "
-                                   "attribute." % repr_name)
+                    errors.append(
+                        u"%s: You tried to modify a collection "
+                        "attribute." % repr_name
+                    )
                 continue
 
             if IBytes.providedBy(field):
@@ -1126,15 +1165,15 @@ class EntryManipulatingResource(ReadWriteResource):
                 # storage resource as a str, but
                 # BytesFieldMarshaller.marshall_from_json_data returns
                 # bytes.
-                if value != current_value.encode('UTF-8'):
+                if value != current_value.encode("UTF-8"):
                     if field.readonly:
-                        errors.append(modified_read_only_attribute
-                                      % repr_name)
+                        errors.append(modified_read_only_attribute % repr_name)
                     else:
                         errors.append(
                             u"%s: To modify this field you need to send a PUT "
-                             "request to its URI (%s)."
-                            % (repr_name, current_value))
+                            "request to its URI (%s)."
+                            % (repr_name, current_value)
+                        )
                 continue
 
             # If the new value is an object, make sure it provides the correct
@@ -1146,8 +1185,10 @@ class EntryManipulatingResource(ReadWriteResource):
                 # possible for Vocabulary fields to specify a schema
                 # class the way IReference fields can.
                 if value is not None and not field.schema.providedBy(value):
-                    errors.append(u"%s: Your value points to the "
-                                   "wrong kind of object" % repr_name)
+                    errors.append(
+                        u"%s: Your value points to the "
+                        "wrong kind of object" % repr_name
+                    )
                     continue
 
             # Obtain the current value of the field.  This gives us an easy
@@ -1162,8 +1203,7 @@ class EntryManipulatingResource(ReadWriteResource):
             if field.readonly:
                 change_this_field = False
                 if value != current_value:
-                    errors.append(modified_read_only_attribute
-                                  % repr_name)
+                    errors.append(modified_read_only_attribute % repr_name)
                     continue
 
             if change_this_field is True and value != current_value:
@@ -1175,8 +1215,9 @@ class EntryManipulatingResource(ReadWriteResource):
                     # the exception; otherwise use a generic message
                     # instead of whatever object the raise site
                     # thought would be a good idea.
-                    if (len(e.args) > 0 and
-                        isinstance(e.args[0], six.string_types)):
+                    if len(e.args) > 0 and isinstance(
+                        e.args[0], six.string_types
+                    ):
                         error = e.args[0]
                     else:
                         error = "Constraint not satisfied."
@@ -1196,13 +1237,15 @@ class EntryManipulatingResource(ReadWriteResource):
         # fields that don't correspond to some field in the
         # schema. They're all errors.
         for invalid_field in changeset.keys():
-            errors.append(u"%s: You tried to modify a nonexistent "
-                          "attribute." % invalid_field)
+            errors.append(
+                u"%s: You tried to modify a nonexistent "
+                "attribute." % invalid_field
+            )
 
         # If there were errors, display them and send a status of 400.
         if len(errors) > 0:
             self.request.response.setStatus(400)
-            self.request.response.setHeader('Content-type', 'text/plain')
+            self.request.response.setHeader("Content-type", "text/plain")
             return "\n".join(errors)
 
         # Store the entry's current URL so we can see if it changes.
@@ -1213,7 +1256,8 @@ class EntryManipulatingResource(ReadWriteResource):
 
             # Make a snapshot of the entry to use in a notification event.
             entry_before_modification = Snapshot(
-                self.entry.context, providing=providedBy(self.entry.context))
+                self.entry.context, providing=providedBy(self.entry.context)
+            )
 
             # Make the changes, in the same order obtained from
             # get_entry_fields_in_write_order.
@@ -1227,8 +1271,8 @@ class EntryManipulatingResource(ReadWriteResource):
             event = ObjectModifiedEvent(
                 object=self.entry.context,
                 object_before_modification=entry_before_modification,
-                edited_fields=[
-                    field for field, value in validated_changeset])
+                edited_fields=[field for field, value in validated_changeset],
+            )
             notify(event)
 
             # The changeset contained new values for some of this object's
@@ -1246,7 +1290,7 @@ class EntryManipulatingResource(ReadWriteResource):
                     if flag is not Unauthorized:
                         force_clear = True
                 if force_clear or new_value != old_value:
-                    del(self._unmarshalled_field_cache[name])
+                    del self._unmarshalled_field_cache[name]
 
         self._applyChangesPostHook()
 
@@ -1257,17 +1301,18 @@ class EntryManipulatingResource(ReadWriteResource):
             # the whole entry!
             self.request.response.setStatus(209)
             media_type = self.getPreferredSupportedContentType()
-            self.request.response.setHeader('Content-type', media_type)
-            return self._representation(media_type).encode('UTF-8')
+            self.request.response.setHeader("Content-type", media_type)
+            return self._representation(media_type).encode("UTF-8")
         else:
             # The object moved. Serve a redirect to its new location.
             # This might not necessarily be the location of the entry!
             self.request.response.setStatus(301)
             self.request.response.setHeader(
-                'Location', absoluteURL(self.context, self.request))
+                "Location", absoluteURL(self.context, self.request)
+            )
             # RFC 2616 says the body of a 301 response, if present,
             # SHOULD be a note linking to the new object.
-            return ''
+            return ""
 
     def _applyChangesPostHook(self):
         """A hook method called near the end of applyChanges.
@@ -1282,8 +1327,7 @@ class EntryManipulatingResource(ReadWriteResource):
 class EntryFieldResource(FieldUnmarshallerMixin, EntryManipulatingResource):
     """An individual field of an entry."""
 
-    SUPPORTED_CONTENT_TYPES = [HTTPResource.JSON_TYPE,
-                               HTTPResource.XHTML_TYPE]
+    SUPPORTED_CONTENT_TYPES = [HTTPResource.JSON_TYPE, HTTPResource.XHTML_TYPE]
 
     def __init__(self, context, request):
         """Initialize with respect to a context and request."""
@@ -1297,8 +1341,8 @@ class EntryFieldResource(FieldUnmarshallerMixin, EntryManipulatingResource):
             # The conditional GET succeeded. Serve nothing.
             return b""
         else:
-            self.request.response.setHeader('Content-Type', media_type)
-            return self._representation(media_type).encode('UTF-8')
+            self.request.response.setHeader("Content-Type", media_type)
+            return self._representation(media_type).encode("UTF-8")
 
     def do_PUT(self, media_type, representation):
         """Overwrite the field's existing value with a new value."""
@@ -1317,29 +1361,31 @@ class EntryFieldResource(FieldUnmarshallerMixin, EntryManipulatingResource):
 
         :arg cache: is ignored.
         """
-        value = self._unmarshallField(
-            self.context.name, self.context.field)[1]
+        value = self._unmarshallField(self.context.name, self.context.field)[1]
 
         # Append the revision number, because the algorithm for
         # generating the representation might itself change across
         # versions.
         revno = getUtility(IWebServiceConfiguration).code_revision
-        return [core.encode('utf-8') for core in [revno, six.text_type(value)]]
+        return [core.encode("utf-8") for core in [revno, six.text_type(value)]]
 
     def _representation(self, media_type):
         """Create a representation of the field value."""
         if media_type == self.JSON_TYPE:
             name, value = self._unmarshallField(
-                self.context.name, self.context.field, CLOSEUP_DETAIL)
+                self.context.name, self.context.field, CLOSEUP_DETAIL
+            )
             return simplejson.dumps(value)
         elif media_type == self.XHTML_TYPE:
             name, value = self.unmarshallFieldToHTML(
-                self.context.name, self.context.field)
+                self.context.name, self.context.field
+            )
             return decode_value(value)
         else:
             raise AssertionError(
-                    "No representation implementation for media type %s"
-                    % media_type)
+                "No representation implementation for media type %s"
+                % media_type
+            )
 
 
 @implementer(IEntryField, ILocation)
@@ -1376,14 +1422,14 @@ def make_entry_etag_cores(field_details):
     unwritable_values = []
     writable_values = []
     for name, details in field_details:
-        if details['writable']:
+        if details["writable"]:
             # The client can write to this value.
             bucket = writable_values
         else:
             # The client can't write to this value (it might be read-only or
             # it might just be non-web-service writable.
             bucket = unwritable_values
-        bucket.append(decode_value(details['value']))
+        bucket.append(decode_value(details["value"]))
 
     unwritable = "\0".join(unwritable_values).encode("utf-8")
     writable = "\0".join(writable_values).encode("utf-8")
@@ -1391,15 +1437,20 @@ def make_entry_etag_cores(field_details):
 
 
 @implementer(IEntryResource, IJSONPublishable)
-class EntryResource(CustomOperationResourceMixin,
-                    FieldUnmarshallerMixin, EntryManipulatingResource):
+class EntryResource(
+    CustomOperationResourceMixin,
+    FieldUnmarshallerMixin,
+    EntryManipulatingResource,
+):
     """An individual object, published to the web."""
 
-    SUPPORTED_CONTENT_TYPES = [HTTPResource.WADL_TYPE,
-                               HTTPResource.DEPRECATED_WADL_TYPE,
-                               HTTPResource.XHTML_TYPE,
-                               HTTPResource.JSON_TYPE,
-                               HTTPResource.JSON_PLUS_XHTML_TYPE]
+    SUPPORTED_CONTENT_TYPES = [
+        HTTPResource.WADL_TYPE,
+        HTTPResource.DEPRECATED_WADL_TYPE,
+        HTTPResource.XHTML_TYPE,
+        HTTPResource.JSON_TYPE,
+        HTTPResource.JSON_PLUS_XHTML_TYPE,
+    ]
 
     def __init__(self, context, request):
         """Associate this resource with a specific object and request."""
@@ -1422,8 +1473,9 @@ class EntryResource(CustomOperationResourceMixin,
             # This might not necessarily be the location of the entry!
             self.request.response.setStatus(301)
             self.request.response.setHeader(
-                'Location', absoluteURL(self.context, self.request))
-            return ''
+                "Location", absoluteURL(self.context, self.request)
+            )
+            return ""
         return value
 
     def _getETagCores(self, unmarshalled_field_values=None):
@@ -1441,11 +1493,12 @@ class EntryResource(CustomOperationResourceMixin,
             details = {}
             # Add in any values provided by the caller.
             # The value of the field is either passed in, or extracted.
-            details['value'] = unmarshalled_field_values.get(
-                name, self._unmarshallField(name, field)[1])
+            details["value"] = unmarshalled_field_values.get(
+                name, self._unmarshallField(name, field)[1]
+            )
 
             # The client can write to this field.
-            details['writable'] = self.isModifiableField(field, True)
+            details["writable"] = self.isModifiableField(field, True)
 
             field_details.append((name, details))
 
@@ -1478,21 +1531,26 @@ class EntryResource(CustomOperationResourceMixin,
         of media_type.
         """
         data = OrderedDict()
-        data['self_link'] = absoluteURL(self.context, self.request)
+        data["self_link"] = absoluteURL(self.context, self.request)
         if self.adapter_utility.publish_web_link:
             # Objects in the web service correspond to pages on some website.
             # Provide the link to the corresponding page on the website.
             browser_request = IWebBrowserOriginatingRequest(self.request)
-            data['web_link'] = absoluteURL(self.context, browser_request)
-        data['resource_type_link'] = self.type_url
+            data["web_link"] = absoluteURL(self.context, browser_request)
+        data["resource_type_link"] = self.type_url
         unmarshalled_field_values = {}
         html_renderings = {}
         for name, field in getFieldsInOrder(self.entry.schema):
             if media_type.startswith(self.JSON_TYPE):
-                repr_name, repr_value, html_renderer = (
-                    self._field_with_html_renderer(name, field))
-                if (media_type == self.JSON_PLUS_XHTML_TYPE
-                    and html_renderer != _default_html_renderer):
+                (
+                    repr_name,
+                    repr_value,
+                    html_renderer,
+                ) = self._field_with_html_renderer(name, field)
+                if (
+                    media_type == self.JSON_PLUS_XHTML_TYPE
+                    and html_renderer != _default_html_renderer
+                ):
                     # This field has an unusual HTML renderer.
                     if repr_value == self.REDACTED_VALUE:
                         # The data is redacted, so the HTML
@@ -1503,31 +1561,31 @@ class EntryResource(CustomOperationResourceMixin,
                         html_value = html_renderer(repr_value)
                     html_renderings[repr_name] = html_value
             elif media_type == self.XHTML_TYPE:
-                repr_name, repr_value = self.unmarshallFieldToHTML(
-                    name, field)
+                repr_name, repr_value = self.unmarshallFieldToHTML(name, field)
             else:
                 raise AssertionError(
-                        "Cannot create data structure for media type %s"
-                        % media_type)
+                    "Cannot create data structure for media type %s"
+                    % media_type
+                )
             data[repr_name] = repr_value
             unmarshalled_field_values[name] = repr_value
 
         if len(html_renderings) > 0:
-            data['lp_html'] = html_renderings
+            data["lp_html"] = html_renderings
         elif media_type == self.JSON_PLUS_XHTML_TYPE:
             # The client requested application/json;include=lp_html,
             # but there's no HTML to deliver. Set the Content-Type to
             # regular application/json.
-            self.request.response.setHeader('Content-Type', self.JSON_TYPE)
+            self.request.response.setHeader("Content-Type", self.JSON_TYPE)
         etag = self.getETag(media_type, unmarshalled_field_values)
-        data['http_etag'] = etag
+        data["http_etag"] = etag
         return data
 
     def toXHTML(self):
         """Represent this resource as an XHTML document."""
         view = getMultiAdapter(
-            (self.context, self.request),
-            name="lazr.restful.EntryResource")
+            (self.context, self.request), name="lazr.restful.EntryResource"
+        )
         return view()
 
     def processAsJSONHash(self, media_type, representation):
@@ -1550,13 +1608,13 @@ class EntryResource(CustomOperationResourceMixin,
             return value, error
         if not isinstance(value, dict):
             self.request.response.setStatus(400)
-            return None, 'Expected a JSON hash.'
+            return None, "Expected a JSON hash."
         return value, None
 
     def do_GET(self):
         """Render an appropriate representation of the entry."""
         # Handle a custom operation, probably a search.
-        operation_name = self.request.form.pop('ws.op', None)
+        operation_name = self.request.form.pop("ws.op", None)
         if operation_name is not None:
             result = self.handleCustomGET(operation_name)
             if isinstance(result, (bytes, six.text_type)):
@@ -1572,8 +1630,8 @@ class EntryResource(CustomOperationResourceMixin,
                 # The conditional GET succeeded. Serve nothing.
                 return b""
             else:
-                self.request.response.setHeader('Content-Type', media_type)
-                return self._representation(media_type).encode('UTF-8')
+                self.request.response.setHeader("Content-Type", media_type)
+                return self._representation(media_type).encode("UTF-8")
 
     def do_PUT(self, media_type, representation):
         """Modify the entry's state to match the given representation.
@@ -1595,18 +1653,23 @@ class EntryResource(CustomOperationResourceMixin,
             if not self.isModifiableField(field, True):
                 continue
             field = field.bind(self.context)
-            marshaller = getMultiAdapter((field, self.request),
-                                         IFieldMarshaller)
+            marshaller = getMultiAdapter(
+                (field, self.request), IFieldMarshaller
+            )
             repr_name = marshaller.representation_name
-            if (changeset.get(repr_name) is None
-                and getattr(self.entry, name) is not None):
+            if (
+                changeset.get(repr_name) is None
+                and getattr(self.entry, name) is not None
+            ):
                 # This entry has a value for the attribute, but the
                 # entity-body of the PUT request didn't make any assertion
                 # about the attribute. The resource's behavior under HTTP
                 # is undefined; we choose to send an error.
                 self.request.response.setStatus(400)
-                return ("You didn't specify a value for the attribute '%s'."
-                        % repr_name)
+                return (
+                    "You didn't specify a value for the attribute '%s'."
+                    % repr_name
+                )
 
         return self.applyChanges(changeset, media_type)
 
@@ -1630,9 +1693,12 @@ class EntryResource(CustomOperationResourceMixin,
     def type_url(self):
         """The URL to the resource type for this resource."""
         return "%s#%s" % (
-            absoluteURL(self.request.publication.getApplication(
-                    self.request), self.request),
-            self.adapter_utility.singular_type)
+            absoluteURL(
+                self.request.publication.getApplication(self.request),
+                self.request,
+            ),
+            self.adapter_utility.singular_type,
+        )
 
     @property
     def adapter_utility(self):
@@ -1653,8 +1719,9 @@ class EntryResource(CustomOperationResourceMixin,
                 # database hits.
                 try:
                     tagged_values = field.getTaggedValue(
-                        'lazr.restful.exported')
-                    original_name = tagged_values['original_name']
+                        "lazr.restful.exported"
+                    )
+                    original_name = tagged_values["original_name"]
                 except KeyError:
                     # This field has no tagged values, or is missing
                     # the 'original_name' value. Its entry class was
@@ -1700,8 +1767,9 @@ class EntryResource(CustomOperationResourceMixin,
         directly modified from external clients, but they might change
         as side effects of other changes.
         """
-        if (ICollectionField.providedBy(field)
-            or field.__name__.startswith('_')):
+        if ICollectionField.providedBy(field) or field.__name__.startswith(
+            "_"
+        ):
             return False
         if field.readonly:
             return not is_external_client
@@ -1718,20 +1786,26 @@ class EntryResource(CustomOperationResourceMixin,
                 representation = None
             else:
                 representation = cache.get(
-                    self.context, media_type, self.request.version)
+                    self.context, media_type, self.request.version
+                )
 
             redacted_fields = self.redacted_fields
             if representation is None:
                 # Either there is no active cache, or the representation
                 # wasn't in the cache.
                 representation = simplejson.dumps(
-                    self, cls=ResourceJSONEncoder, media_type=media_type)
+                    self, cls=ResourceJSONEncoder, media_type=media_type
+                )
                 # If there's an active cache, and this representation
                 # doesn't contain any redactions, store it in the
                 # cache.
                 if cache is not None and len(redacted_fields) == 0:
-                    cache.set(self.context, self.JSON_TYPE,
-                              self.request.version, representation)
+                    cache.set(
+                        self.context,
+                        self.JSON_TYPE,
+                        self.request.version,
+                        representation,
+                    )
             else:
                 # We have a representation, but we might not be able
                 # to use it as-is.
@@ -1760,8 +1834,9 @@ class EntryResource(CustomOperationResourceMixin,
             return self.toXHTML()
         else:
             raise AssertionError(
-                    "No representation implementation for media type %s"
-                    % media_type)
+                "No representation implementation for media type %s"
+                % media_type
+            )
 
     @property
     def _representation_cache(self):
@@ -1778,9 +1853,9 @@ class EntryResource(CustomOperationResourceMixin,
 
 
 @implementer(ICollectionResource)
-class CollectionResource(BatchingResourceMixin,
-                         CustomOperationResourceMixin,
-                         ReadOnlyResource):
+class CollectionResource(
+    BatchingResourceMixin, CustomOperationResourceMixin, ReadOnlyResource
+):
     """A resource that serves a list of entry resources."""
 
     def __init__(self, context, request):
@@ -1794,7 +1869,7 @@ class CollectionResource(BatchingResourceMixin,
     def do_GET(self):
         """Fetch a collection and render it as JSON."""
         # Handle a custom operation, probably a search.
-        operation_name = self.request.form.pop('ws.op', None)
+        operation_name = self.request.form.pop("ws.op", None)
         if operation_name is not None:
             result = self.handleCustomGET(operation_name)
             if isinstance(result, (bytes, six.text_type)):
@@ -1812,12 +1887,12 @@ class CollectionResource(BatchingResourceMixin,
             media_type = self.getPreferredSupportedContentType()
             if media_type in [self.DEPRECATED_WADL_TYPE, self.WADL_TYPE]:
                 result = self.toWADL().encode("utf-8")
-                self.request.response.setHeader('Content-Type', media_type)
+                self.request.response.setHeader("Content-Type", media_type)
                 return result
 
-            result = self.batch(entries) + '}'
+            result = self.batch(entries) + "}"
 
-        self.request.response.setHeader('Content-type', self.JSON_TYPE)
+        self.request.response.setHeader("Content-type", self.JSON_TYPE)
         return result
 
     def batch(self, entries=None, request=None):
@@ -1831,8 +1906,7 @@ class CollectionResource(BatchingResourceMixin,
         if request is None:
             request = self.request
         result = super(CollectionResource, self).batch(entries, request)
-        result += (
-            ', "resource_type_link" : ' + simplejson.dumps(self.type_url))
+        result += ', "resource_type_link" : ' + simplejson.dumps(self.type_url)
         return result
 
     @property
@@ -1844,13 +1918,15 @@ class CollectionResource(BatchingResourceMixin,
             # entry the collection holds.
             schema = self.context.relationship.value_type.schema
             adapter = EntryAdapterUtility.forSchemaInterface(
-                schema, self.request)
+                schema, self.request
+            )
             return adapter.entry_page_type_link
         else:
             # Top-level collection.
             schema = self.collection.entry_schema
             adapter = EntryAdapterUtility.forEntryInterface(
-                schema, self.request)
+                schema, self.request
+            )
             return adapter.collection_type_link
 
 
@@ -1859,7 +1935,7 @@ class ServiceRootResource(HTTPResource):
     """A resource that responds to GET by describing the service."""
 
     # A preparsed template file for WADL representations of the root.
-    WADL_TEMPLATE = LazrPageTemplateFile('templates/wadl-root.pt')
+    WADL_TEMPLATE = LazrPageTemplateFile("templates/wadl-root.pt")
 
     def __init__(self):
         """Initialize the resource.
@@ -1887,7 +1963,7 @@ class ServiceRootResource(HTTPResource):
         itself changes.
         """
         revno = getUtility(IWebServiceConfiguration).code_revision
-        return [revno.encode('utf-8')]
+        return [revno.encode("utf-8")]
 
     def __call__(self, REQUEST=None):
         """Handle a GET request."""
@@ -1902,8 +1978,8 @@ class ServiceRootResource(HTTPResource):
 
     def setCachingHeaders(self):
         "How long should the client cache this service root?"
-        user_agent = self.request.getHeader('User-Agent', '')
-        if user_agent.startswith('Python-httplib2'):
+        user_agent = self.request.getHeader("User-Agent", "")
+        if user_agent.startswith("Python-httplib2"):
             # XXX leonardr 20100412
             # bug=http://code.google.com/p/httplib2/issues/detail?id=97
             #
@@ -1921,10 +1997,11 @@ class ServiceRootResource(HTTPResource):
             max_age = caching_policy[0]
         if max_age > 0:
             self.request.response.setHeader(
-                'Cache-Control', 'max-age=%d' % max_age)
+                "Cache-Control", "max-age=%d" % max_age
+            )
             # Also set the Date header so that client-side caches will
             # have something to work from.
-            self.request.response.setHeader('Date', formatdate(time.time()))
+            self.request.response.setHeader("Date", formatdate(time.time()))
 
     def do_GET(self):
         """Describe the capabilities of the web service."""
@@ -1940,7 +2017,7 @@ class ServiceRootResource(HTTPResource):
             # resources.
             result = simplejson.dumps(self, cls=ResourceJSONEncoder)
 
-        self.request.response.setHeader('Content-Type', media_type)
+        self.request.response.setHeader("Content-Type", media_type)
         return result.encode("utf-8")
 
     def toWADL(self):
@@ -1951,15 +2028,17 @@ class ServiceRootResource(HTTPResource):
         singular_names = {}
         plural_names = {}
 
-        # Determine the name of the earliest version. We'll be using this later.
+        # Determine the name of the earliest version.
+        # We'll be using this later.
         config = getUtility(IWebServiceConfiguration)
         earliest_version = config.active_versions[0]
 
         for registration in sorted(site_manager.registeredAdapters()):
             provided = registration.provided
             if IInterface.providedBy(provided):
-                if (provided.isOrExtends(IEntry)
-                    and IEntry.implementedBy(registration.factory)):
+                if provided.isOrExtends(IEntry) and IEntry.implementedBy(
+                    registration.factory
+                ):
                     # The implementedBy check is necessary because
                     # some IEntry adapters aren't classes with
                     # schemas; they're functions. We can ignore these
@@ -1971,8 +2050,10 @@ class ServiceRootResource(HTTPResource):
                     # registration for every web service version.
                     schema, version_marker = registration.required
 
-                    if (version_marker is IWebServiceClientRequest
-                        and self.request.version != earliest_version):
+                    if (
+                        version_marker is IWebServiceClientRequest
+                        and self.request.version != earliest_version
+                    ):
                         # We are generating WADL for some version
                         # other than the earliest version, and this is
                         # a registration for the earliest version. We
@@ -1992,37 +2073,47 @@ class ServiceRootResource(HTTPResource):
                     # Make sure that no other entry class is using this
                     # class's singular or plural names.
                     adapter = EntryAdapterUtility.forSchemaInterface(
-                        schema, self.request)
+                        schema, self.request
+                    )
 
                     singular = adapter.singular_type
-                    assert singular not in singular_names, (
-                        "Both %s and %s expose the singular name '%s'."
-                        % (singular_names[singular].__name__,
-                           schema.__name__, singular))
+                    assert (
+                        singular not in singular_names
+                    ), "Both %s and %s expose the singular name '%s'." % (
+                        singular_names[singular].__name__,
+                        schema.__name__,
+                        singular,
+                    )
                     singular_names[singular] = schema
 
                     plural = adapter.plural_type
-                    assert plural not in plural_names, (
-                        "Both %s and %s expose the plural name '%s'."
-                        % (plural_names[plural].__name__,
-                           schema.__name__, plural))
+                    assert (
+                        plural not in plural_names
+                    ), "Both %s and %s expose the plural name '%s'." % (
+                        plural_names[plural].__name__,
+                        schema.__name__,
+                        plural,
+                    )
                     plural_names[plural] = schema
 
                     entry_classes.append(registration.factory)
-                elif (provided.isOrExtends(ICollection)
-                      and ICollection.implementedBy(registration.factory)
-                      and not IScopedCollection.implementedBy(
-                        registration.factory)):
+                elif (
+                    provided.isOrExtends(ICollection)
+                    and ICollection.implementedBy(registration.factory)
+                    and not IScopedCollection.implementedBy(
+                        registration.factory
+                    )
+                ):
                     # See comment above re: implementedBy check.
                     # We omit IScopedCollection because those are handled
                     # by the entry classes.
                     collection_classes.append(registration.factory)
 
         namespace = self.WADL_TEMPLATE.pt_getContext()
-        namespace['service'] = self
-        namespace['request'] = self.request
-        namespace['entries'] = sorted_named_things(entry_classes)
-        namespace['collections'] = sorted_named_things(collection_classes)
+        namespace["service"] = self
+        namespace["request"] = self.request
+        namespace["entries"] = sorted_named_things(entry_classes)
+        namespace["collections"] = sorted_named_things(collection_classes)
         return self.WADL_TEMPLATE.pt_render(namespace)
 
     def toDataForJSON(self, media_type):
@@ -2035,13 +2126,14 @@ class ServiceRootResource(HTTPResource):
         type_url = "%s#%s" % (
             absoluteURL(
                 self.request.publication.getApplication(self.request),
-                self.request),
-            "service-root")
-        data_for_json = {'resource_type_link': type_url}
+                self.request,
+            ),
+            "service-root",
+        )
+        data_for_json = {"resource_type_link": type_url}
         publications = self.getTopLevelPublications()
         for link_name, publication in publications.items():
-            data_for_json[link_name] = absoluteURL(publication,
-                                                   self.request)
+            data_for_json[link_name] = absoluteURL(publication, self.request)
         return data_for_json
 
     def getTopLevelPublications(self):
@@ -2055,8 +2147,9 @@ class ServiceRootResource(HTTPResource):
                 # XXX sinzui 2008-09-29 bug=276079:
                 # Top-level collections need a marker interface
                 # so that so top-level utilities are explicit.
-                if (provided.isOrExtends(ICollection)
-                     and ICollection.implementedBy(registration.factory)):
+                if provided.isOrExtends(
+                    ICollection
+                ) and ICollection.implementedBy(registration.factory):
                     try:
                         utility = getUtility(registration.required[0])
                     except ComponentLookupError:
@@ -2067,12 +2160,13 @@ class ServiceRootResource(HTTPResource):
                         # It's not a top-level resource.
                         continue
                     adapter = EntryAdapterUtility.forEntryInterface(
-                        entry_schema, self.request)
-                    link_name = ("%s_collection_link" % adapter.plural_type)
+                        entry_schema, self.request
+                    )
+                    link_name = "%s_collection_link" % adapter.plural_type
                     top_level_resources[link_name] = utility
         # Now, collect the top-level entries.
         for utility in getAllUtilitiesRegisteredFor(ITopLevelEntryLink):
-            link_name = ("%s_link" % utility.link_name)
+            link_name = "%s_link" % utility.link_name
             top_level_resources[link_name] = utility
 
         return top_level_resources
@@ -2083,9 +2177,12 @@ class ServiceRootResource(HTTPResource):
         adapter = self.adapter_utility
 
         return "%s#%s" % (
-            absoluteURL(self.request.publication.getApplication(
-                    self.request), self.request),
-            adapter.singular_type)
+            absoluteURL(
+                self.request.publication.getApplication(self.request),
+                self.request,
+            ),
+            adapter.singular_type,
+        )
 
 
 @implementer(IEntry)
@@ -2132,10 +2229,13 @@ class ScopedCollection:
         # corresponding entry schema (IFooEntry).
         model_schema = self.relationship.value_type.schema
         request_interface = getUtility(
-            IWebServiceVersion,
-            name=self.request.version)
-        return getGlobalSiteManager().adapters.lookup(
-            (model_schema, request_interface), IEntry).schema
+            IWebServiceVersion, name=self.request.version
+        )
+        return (
+            getGlobalSiteManager()
+            .adapters.lookup((model_schema, request_interface), IEntry)
+            .schema
+        )
 
     def find(self):
         """See `ICollection`."""
@@ -2143,12 +2243,12 @@ class ScopedCollection:
 
 
 class RESTUtilityBase:
-
     def _service_root_url(self):
         """Return the URL to the service root."""
         request = get_current_web_service_request()
-        return absoluteURL(request.publication.getApplication(request),
-                           request)
+        return absoluteURL(
+            request.publication.getApplication(request), request
+        )
 
 
 class UnknownEntryAdapter(Exception):
@@ -2157,13 +2257,15 @@ class UnknownEntryAdapter(Exception):
     def __init__(self, adapted_interface_name, version):
         self.adapted_interface_name = adapted_interface_name
         self.version = version
-        self.whence = ''
+        self.whence = ""
 
     def __str__(self):
-        message = ("No IEntry adapter found for %s (web service version: %s)."
-            % (self.adapted_interface_name, self.version))
+        message = (
+            "No IEntry adapter found for %s (web service version: %s)."
+            % (self.adapted_interface_name, self.version)
+        )
         if self.whence:
-            message += '  ' + self.whence
+            message += "  " + self.whence
         return message
 
 
@@ -2182,11 +2284,15 @@ class EntryAdapterUtility(RESTUtilityBase):
         subclass of IEntry.
         """
         request_interface = getUtility(
-            IWebServiceVersion, name=request.version)
+            IWebServiceVersion, name=request.version
+        )
         entry_class = getGlobalSiteManager().adapters.lookup(
-            (entry_interface, request_interface), IEntry)
+            (entry_interface, request_interface), IEntry
+        )
         if entry_class is None:
-            raise UnknownEntryAdapter(entry_interface.__name__, request.version)
+            raise UnknownEntryAdapter(
+                entry_interface.__name__, request.version
+            )
         return EntryAdapterUtility(entry_class)
 
     @classmethod
@@ -2199,17 +2305,27 @@ class EntryAdapterUtility(RESTUtilityBase):
         # same IWebServiceVersion interface we find on the 'request'
         # object.
         entry_classes = [
-            registration.factory for registration in registrations
-            if (IInterface.providedBy(registration.provided)
+            registration.factory
+            for registration in registrations
+            if (
+                IInterface.providedBy(registration.provided)
                 and registration.provided.isOrExtends(IEntry)
                 and entry_interface.implementedBy(registration.factory)
-                and registration.required[1].providedBy(request))]
-        assert not len(entry_classes) > 1, (
-            "%s provides more than one IEntry subclass for version %s." %
-            (entry_interface.__name__, request.version))
-        assert not len(entry_classes) < 1, (
-            "%s does not provide any IEntry subclass for version %s." %
-            (entry_interface.__name__, request.version))
+                and registration.required[1].providedBy(request)
+            )
+        ]
+        assert (
+            not len(entry_classes) > 1
+        ), "%s provides more than one IEntry subclass for version %s." % (
+            entry_interface.__name__,
+            request.version,
+        )
+        assert (
+            not len(entry_classes) < 1
+        ), "%s does not provide any IEntry subclass for version %s." % (
+            entry_interface.__name__,
+            request.version,
+        )
         return EntryAdapterUtility(entry_classes[0])
 
     def __init__(self, entry_class):
@@ -2220,13 +2336,15 @@ class EntryAdapterUtility(RESTUtilityBase):
     def entry_interface(self):
         """The IEntry subclass implemented by this entry type."""
         interfaces = implementedBy(self.entry_class)
-        entry_ifaces = [interface for interface in interfaces
-                        if interface.extends(IEntry)]
-        assert len(entry_ifaces) == 1, (
-            "There must be one and only one IEntry implementation "
-            "for %s, found %s" % (
-                self.entry_class,
-                ", ".join(interface.__name__ for interface in entry_ifaces)))
+        entry_ifaces = [
+            interface for interface in interfaces if interface.extends(IEntry)
+        ]
+        assert (
+            len(entry_ifaces) == 1
+        ), "There must be one and only one IEntry implementation " "for %s, found %s" % (
+            self.entry_class,
+            ", ".join(interface.__name__ for interface in entry_ifaces),
+        )
         return entry_ifaces[0]
 
     def _get_tagged_value(self, tag):
@@ -2240,31 +2358,31 @@ class EntryAdapterUtility(RESTUtilityBase):
         # request, we shouldn't publish a web_link for *any* entry.
         web_service_request = get_current_web_service_request()
         website_request = IWebBrowserOriginatingRequest(
-            web_service_request, None)
+            web_service_request, None
+        )
         return website_request is not None and self._get_tagged_value(
-            'publish_web_link')
+            "publish_web_link"
+        )
 
     @property
     def singular_type(self):
         """Return the singular name for this object type."""
-        return self._get_tagged_value('singular')
+        return self._get_tagged_value("singular")
 
     @property
     def plural_type(self):
         """Return the plural name for this object type."""
-        return self._get_tagged_value('plural')
+        return self._get_tagged_value("plural")
 
     @property
     def type_link(self):
         """The URL to the type definition for this kind of entry."""
-        return "%s#%s" % (
-            self._service_root_url(), self.singular_type)
+        return "%s#%s" % (self._service_root_url(), self.singular_type)
 
     @property
     def collection_type_link(self):
         """The definition of a top-level collection of this kind of object."""
-        return "%s#%s" % (
-            self._service_root_url(), self.plural_type)
+        return "%s#%s" % (self._service_root_url(), self.plural_type)
 
     @property
     def entry_page_type(self):
@@ -2274,8 +2392,7 @@ class EntryAdapterUtility(RESTUtilityBase):
     @property
     def entry_page_type_link(self):
         "The URL to the definition of a collection of this kind of object."
-        return "%s#%s" % (
-            self._service_root_url(), self.entry_page_type)
+        return "%s#%s" % (self._service_root_url(), self.entry_page_type)
 
     @property
     def entry_page_representation_id(self):
@@ -2287,13 +2404,13 @@ class EntryAdapterUtility(RESTUtilityBase):
         "The URL to the description of a collection of this kind of object."
         return "%s#%s" % (
             self._service_root_url(),
-            self.entry_page_representation_id)
+            self.entry_page_representation_id,
+        )
 
     @property
     def full_representation_link(self):
         """The URL to the description of the object's full representation."""
-        return "%s#%s-full" % (
-            self._service_root_url(), self.singular_type)
+        return "%s#%s-full" % (self._service_root_url(), self.singular_type)
 
 
 def get_entry_fields_in_write_order(entry):
@@ -2312,7 +2429,7 @@ def get_entry_fields_in_write_order(entry):
     mutator_fields = []
     field_implementations = entry.__class__.__dict__
     for name, field in getFieldsInOrder(entry.schema):
-        if name.startswith('_'):
+        if name.startswith("_"):
             # This field is not part of the web service interface.
             continue
 
@@ -2320,8 +2437,10 @@ def get_entry_fields_in_write_order(entry):
         # Passthrough (but not a direct instance of Passthrough), put
         # it at the end -- it's probably controlled by a mutator.
         implementation = field_implementations[name]
-        if (issubclass(implementation.__class__, Passthrough)
-            and implementation.__class__ is not Passthrough):
+        if (
+            issubclass(implementation.__class__, Passthrough)
+            and implementation.__class__ is not Passthrough
+        ):
             mutator_fields.append((name, field))
         else:
             non_mutator_fields.append((name, field))
diff --git a/src/lazr/restful/debug.py b/src/lazr/restful/debug.py
index 5b2205a..0567455 100644
--- a/src/lazr/restful/debug.py
+++ b/src/lazr/restful/debug.py
@@ -5,10 +5,7 @@
 from __future__ import absolute_import, print_function
 
 __metaclass__ = type
-__all__ = [
-    "debug_proxy",
-    "typename"
-    ]
+__all__ = ["debug_proxy", "typename"]
 
 
 from six import StringIO
@@ -20,7 +17,7 @@ from zope.security.checker import getChecker, Checker, CheckerPublic, Proxy
 def typename(obj):
     """Return the typename of an object."""
     t = type(obj)
-    if t.__module__ in {'__builtin__', 'builtins'}:
+    if t.__module__ in {"__builtin__", "builtins"}:
         return t.__name__
     else:
         return "%s.%s" % (t.__module__, t.__name__)
@@ -39,15 +36,17 @@ def get_permission_mapping(checker):
     permission_to_names = {}
     for name, permission in checker.get_permissions.items():
         if permission is CheckerPublic:
-            permission = 'public'
+            permission = "public"
         permission_to_names.setdefault(permission, []).append(name)
     for name, permission in checker.set_permissions.items():
         if permission is CheckerPublic:
-            permission = 'public'
+            permission = "public"
         set_permission = "%s (set)" % permission
         permission_to_names.setdefault(set_permission, []).append(name)
-    return sorted((permission, sorted(names))
-                   for permission, names in permission_to_names.items())
+    return sorted(
+        (permission, sorted(names))
+        for permission, names in permission_to_names.items()
+    )
 
 
 def security_proxy_formatter(proxy):
@@ -56,7 +55,7 @@ def security_proxy_formatter(proxy):
     output = ["%s (using %s)" % (typename(proxy), typename(checker))]
     if type(checker) is Checker:
         for permission, names in get_permission_mapping(checker):
-            output.append('%s: %s' % (permission, ", ".join(sorted(names))))
+            output.append("%s: %s" % (permission, ", ".join(sorted(names))))
     return "\n    ".join(output)
 
 
diff --git a/src/lazr/restful/declarations.py b/src/lazr/restful/declarations.py
index f1529de..74eb8c5 100644
--- a/src/lazr/restful/declarations.py
+++ b/src/lazr/restful/declarations.py
@@ -6,43 +6,43 @@ from __future__ import absolute_import, print_function
 
 __metaclass__ = type
 __all__ = [
-    'COLLECTION_TYPE',
-    'ENTRY_TYPE',
-    'FIELD_TYPE',
-    'LAZR_WEBSERVICE_ACCESSORS',
-    'LAZR_WEBSERVICE_EXPORTED',
-    'LAZR_WEBSERVICE_MUTATORS',
-    'OPERATION_TYPES',
-    'REQUEST_USER',
-    'accessor_for',
-    'cache_for',
-    'call_with',
-    'collection_default_content',
-    'error_status',
-    'export_as_webservice_collection',
-    'export_as_webservice_entry',
-    'export_destructor_operation',
-    'export_factory_operation',
-    'export_operation_as',
-    'export_read_operation',
-    'export_write_operation',
-    'exported',
-    'exported_as_webservice_collection',
-    'exported_as_webservice_entry',
-    'generate_collection_adapter',
-    'generate_entry_adapters',
-    'generate_entry_interfaces',
-    'generate_operation_adapter',
-    'mutator_for',
-    'operation_for_version',
-    'operation_parameters',
-    'operation_removed_in_version',
-    'operation_returns_entry',
-    'operation_returns_collection_of',
-    'rename_parameters_as',
-    'scoped',
-    'webservice_error',
-    ]
+    "COLLECTION_TYPE",
+    "ENTRY_TYPE",
+    "FIELD_TYPE",
+    "LAZR_WEBSERVICE_ACCESSORS",
+    "LAZR_WEBSERVICE_EXPORTED",
+    "LAZR_WEBSERVICE_MUTATORS",
+    "OPERATION_TYPES",
+    "REQUEST_USER",
+    "accessor_for",
+    "cache_for",
+    "call_with",
+    "collection_default_content",
+    "error_status",
+    "export_as_webservice_collection",
+    "export_as_webservice_entry",
+    "export_destructor_operation",
+    "export_factory_operation",
+    "export_operation_as",
+    "export_read_operation",
+    "export_write_operation",
+    "exported",
+    "exported_as_webservice_collection",
+    "exported_as_webservice_entry",
+    "generate_collection_adapter",
+    "generate_entry_adapters",
+    "generate_entry_interfaces",
+    "generate_operation_adapter",
+    "mutator_for",
+    "operation_for_version",
+    "operation_parameters",
+    "operation_removed_in_version",
+    "operation_returns_entry",
+    "operation_returns_collection_of",
+    "rename_parameters_as",
+    "scoped",
+    "webservice_error",
+]
 
 from collections import OrderedDict
 import copy
@@ -58,12 +58,12 @@ from zope.interface.interfaces import IInterface, IMethod
 from zope.schema import (
     getFields,
     getFieldsInOrder,
-    )
+)
 from zope.schema.interfaces import (
     IField,
     IObject,
     IText,
-    )
+)
 from zope.security.checker import CheckerPublic
 from zope.traversing.browser import absoluteURL
 
@@ -72,7 +72,7 @@ from lazr.delegates import Passthrough
 from lazr.restful.fields import (
     CollectionField,
     Reference,
-    )
+)
 from lazr.restful.interface import copy_field
 from lazr.restful.interfaces import (
     ICollection,
@@ -85,14 +85,14 @@ from lazr.restful.interfaces import (
     IWebServiceVersion,
     LAZR_WEBSERVICE_NAME,
     LAZR_WEBSERVICE_NS,
-    )
+)
 from lazr.restful import (
     Collection,
     Entry,
     EntryAdapterUtility,
     ResourceOperation,
     ObjectLink,
-    )
+)
 from lazr.restful.security import protect_schema
 from lazr.restful.utils import (
     camelcase_to_underscore_separated,
@@ -100,28 +100,34 @@ from lazr.restful.utils import (
     make_identifier_safe,
     VersionedDict,
     VersionedObject,
-    )
-
-LAZR_WEBSERVICE_ACCESSORS = '%s.exported.accessors' % LAZR_WEBSERVICE_NS
-LAZR_WEBSERVICE_EXPORTED = '%s.exported' % LAZR_WEBSERVICE_NS
-LAZR_WEBSERVICE_MUTATORS = '%s.exported.mutators' % LAZR_WEBSERVICE_NS
-COLLECTION_TYPE = 'collection'
-ENTRY_TYPE = 'entry'
-FIELD_TYPE = 'field'
-REMOVED_OPERATION_TYPE = 'removed_operation'
+)
+
+LAZR_WEBSERVICE_ACCESSORS = "%s.exported.accessors" % LAZR_WEBSERVICE_NS
+LAZR_WEBSERVICE_EXPORTED = "%s.exported" % LAZR_WEBSERVICE_NS
+LAZR_WEBSERVICE_MUTATORS = "%s.exported.mutators" % LAZR_WEBSERVICE_NS
+COLLECTION_TYPE = "collection"
+ENTRY_TYPE = "entry"
+FIELD_TYPE = "field"
+REMOVED_OPERATION_TYPE = "removed_operation"
 OPERATION_TYPES = (
-    'destructor', 'factory', 'read_operation', 'write_operation',
-    REMOVED_OPERATION_TYPE)
+    "destructor",
+    "factory",
+    "read_operation",
+    "write_operation",
+    REMOVED_OPERATION_TYPE,
+)
 
 # These are the only valid keys to be found in an entry's
 # version-specific annotation dictionary.
-ENTRY_ANNOTATION_KEYS = set([
-    'contributes_to',
-    'exported',
-    'plural_name',
-    'publish_web_link',
-    'singular_name',
-    ])
+ENTRY_ANNOTATION_KEYS = set(
+    [
+        "contributes_to",
+        "exported",
+        "plural_name",
+        "publish_web_link",
+        "singular_name",
+    ]
+)
 
 
 class REQUEST_USER:
@@ -132,20 +138,23 @@ class REQUEST_USER:
     copy.deepcopy, and we want 'is REQUEST_USER' to succeed on the
     copy.
     """
+
     pass
 
 
 def _check_called_from_interface_def(name):
-    """Make sure that the declaration was used from within a class definition.
+    """
+    Make sure that the declaration was used from within a class definition.
     """
     # 2 is our caller's caller.
     frame = sys._getframe(2)
     f_locals = frame.f_locals
 
     # Try to make sure we were called from a class def.
-    if (f_locals is frame.f_globals) or ('__module__' not in f_locals):
+    if (f_locals is frame.f_globals) or ("__module__" not in f_locals):
         raise TypeError(
-            "%s can only be used from within an interface definition." % name)
+            "%s can only be used from within an interface definition." % name
+        )
 
 
 def _check_interface(name, interface):
@@ -164,10 +173,15 @@ def _get_interface_tags():
     return f_locals.setdefault(TAGGED_DATA, {})
 
 
-def _export_as_webservice_entry(interface,
-                                singular_name=None, plural_name=None,
-                                contributes_to=None, publish_web_link=True,
-                                as_of=None, versioned_annotations=None):
+def _export_as_webservice_entry(
+    interface,
+    singular_name=None,
+    plural_name=None,
+    contributes_to=None,
+    publish_web_link=True,
+    as_of=None,
+    versioned_annotations=None,
+):
     """Tag an interface as exported on the web service as an entry.
 
     This is the core of export_as_webservice_entry and
@@ -180,21 +194,27 @@ def _export_as_webservice_entry(interface,
         # behavior assumes this convention and yields a singular name of
         # "word1_word2".
         my_singular_name = camelcase_to_underscore_separated(
-            interface.__name__[1:])
+            interface.__name__[1:]
+        )
     else:
         my_singular_name = singular_name
 
     # Turn the named arguments into a dictionary for the first exported
     # version.
     initial_version = dict(
-        type=ENTRY_TYPE, singular_name=my_singular_name,
-        plural_name=plural_name, contributes_to=contributes_to,
-        publish_web_link=publish_web_link, exported=True,
-        _as_of_was_used=(as_of is not None))
+        type=ENTRY_TYPE,
+        singular_name=my_singular_name,
+        plural_name=plural_name,
+        contributes_to=contributes_to,
+        publish_web_link=publish_web_link,
+        exported=True,
+        _as_of_was_used=(as_of is not None),
+    )
 
     afterwards = versioned_annotations or []
     for version, annotations in itertools.chain(
-            [(as_of, initial_version)], afterwards):
+        [(as_of, initial_version)], afterwards
+    ):
         annotation_stack.push(version)
 
         for key, value in annotations.items():
@@ -204,14 +224,18 @@ def _export_as_webservice_entry(interface,
                 if key not in ENTRY_ANNOTATION_KEYS:
                     raise ValueError(
                         'Unrecognized annotation for version "%s": '
-                        '"%s"' % (version, key))
+                        '"%s"' % (version, key)
+                    )
             annotation_stack[key] = value
         # If this version provides a singular name but not a plural name,
         # apply the default pluralization rule.
-        if (annotations.get('singular_name') is not None
-                and annotations.get('plural_name') is None):
-            annotation_stack['plural_name'] = (
-                annotations['singular_name'] + 's')
+        if (
+            annotations.get("singular_name") is not None
+            and annotations.get("plural_name") is None
+        ):
+            annotation_stack["plural_name"] = (
+                annotations["singular_name"] + "s"
+            )
 
     # When called from the @exported_as_webservice_entry decorator, this
     # would overwrite any interface annotations made by method decorators;
@@ -227,24 +251,29 @@ def _export_as_webservice_entry(interface,
         tag_stack = field.queryTaggedValue(LAZR_WEBSERVICE_EXPORTED)
         if tag_stack is None or tag_stack.is_empty:
             continue
-        if tag_stack['type'] != FIELD_TYPE:
+        if tag_stack["type"] != FIELD_TYPE:
             continue
         for version, tags in tag_stack.stack:
             # Set 'as' for every version in which the field is published but
             # no 'as' is specified. Also set 'original_name' for every
             # version in which the field is published--this will help with
             # performance optimizations around permission checks.
-            if tags.get('exported') is not False:
-                tags['original_name'] = name
-                if tags.get('as') is None:
-                    tags['as'] = name
+            if tags.get("exported") is not False:
+                tags["original_name"] = name
+                if tags.get("as") is None:
+                    tags["as"] = name
 
     annotate_exported_methods(interface)
 
 
-def export_as_webservice_entry(singular_name=None, plural_name=None,
-                               contributes_to=None, publish_web_link=True,
-                               as_of=None, versioned_annotations=None):
+def export_as_webservice_entry(
+    singular_name=None,
+    plural_name=None,
+    contributes_to=None,
+    publish_web_link=True,
+    as_of=None,
+    versioned_annotations=None,
+):
     """Mark the content interface as exported on the web service as an entry.
 
     If contributes_to is a non-empty sequence of Interfaces, this entry will
@@ -278,15 +307,20 @@ def export_as_webservice_entry(singular_name=None, plural_name=None,
         'plural_name', 'contributes_to', or 'publish_web_link', which
         work just like the corresponding arguments to this method.
     """
-    _check_called_from_interface_def('export_as_webservice_entry()')
+    _check_called_from_interface_def("export_as_webservice_entry()")
 
     def mark_entry(interface):
         """Class advisor that tags the interface once it is created."""
-        _check_interface('export_as_webservice_entry()', interface)
+        _check_interface("export_as_webservice_entry()", interface)
         _export_as_webservice_entry(
-            interface, singular_name=singular_name, plural_name=plural_name,
-            contributes_to=contributes_to, publish_web_link=publish_web_link,
-            as_of=as_of, versioned_annotations=versioned_annotations)
+            interface,
+            singular_name=singular_name,
+            plural_name=plural_name,
+            contributes_to=contributes_to,
+            publish_web_link=publish_web_link,
+            as_of=as_of,
+            versioned_annotations=versioned_annotations,
+        )
         return interface
 
     addClassAdvisor(mark_entry)
@@ -323,9 +357,15 @@ class exported_as_webservice_entry:
         work just like the corresponding arguments to this method.
     """
 
-    def __init__(self, singular_name=None, plural_name=None,
-                 contributes_to=None, publish_web_link=True,
-                 as_of=None, versioned_annotations=None):
+    def __init__(
+        self,
+        singular_name=None,
+        plural_name=None,
+        contributes_to=None,
+        publish_web_link=True,
+        as_of=None,
+        versioned_annotations=None,
+    ):
         self.singular_name = singular_name
         self.plural_name = plural_name
         self.contributes_to = contributes_to
@@ -334,13 +374,16 @@ class exported_as_webservice_entry:
         self.versioned_annotations = versioned_annotations
 
     def __call__(self, interface):
-        _check_interface('exported_as_webservice_entry()', interface)
+        _check_interface("exported_as_webservice_entry()", interface)
         _export_as_webservice_entry(
             interface,
-            singular_name=self.singular_name, plural_name=self.plural_name,
+            singular_name=self.singular_name,
+            plural_name=self.plural_name,
             contributes_to=self.contributes_to,
             publish_web_link=self.publish_web_link,
-            as_of=self.as_of, versioned_annotations=self.versioned_annotations)
+            as_of=self.as_of,
+            versioned_annotations=self.versioned_annotations,
+        )
         return interface
 
 
@@ -378,37 +421,47 @@ def exported(field, *versioned_annotations, **kwparams):
     # describing the different ways this field is exposed in different
     # versions.
     annotation_stack = VersionedDict()
-    first_version_name = kwparams.pop('as_of', None)
+    first_version_name = kwparams.pop("as_of", None)
     annotation_stack.push(first_version_name)
-    annotation_stack['type'] = FIELD_TYPE
+    annotation_stack["type"] = FIELD_TYPE
 
     if first_version_name is not None:
         # The user explicitly said to start publishing this field in a
         # particular version.
-        annotation_stack['_as_of_was_used'] = True
-        annotation_stack['exported'] = True
+        annotation_stack["_as_of_was_used"] = True
+        annotation_stack["exported"] = True
 
-    annotation_key_for_argument_key = {'exported_as' : 'as',
-                                       'exported' : 'exported',
-                                       'readonly' : 'readonly'}
+    annotation_key_for_argument_key = {
+        "exported_as": "as",
+        "exported": "exported",
+        "readonly": "readonly",
+    }
 
     # If keyword parameters are present, they define the field's
     # behavior for the first exposed version. Incorporate them into
     # the VersionedDict.
     for (key, annotation_key) in annotation_key_for_argument_key.items():
         if key in kwparams:
-            if (key == "exported" and kwparams[key] is False
-                and first_version_name is not None):
+            if (
+                key == "exported"
+                and kwparams[key] is False
+                and first_version_name is not None
+            ):
                 raise ValueError(
-                    ("as_of=%s says to export %s, but exported=False "
-                     "says not to.") % (
-                        first_version_name, field.__class__.__name__))
+                    (
+                        "as_of=%s says to export %s, but exported=False "
+                        "says not to."
+                    )
+                    % (first_version_name, field.__class__.__name__)
+                )
             annotation_stack[annotation_key] = kwparams.pop(key)
 
     # If any keywords are left over, raise an exception.
     if len(kwparams) > 0:
-        raise TypeError("exported got an unexpected keyword "
-                        "argument '%s'" % list(kwparams)[0])
+        raise TypeError(
+            "exported got an unexpected keyword "
+            "argument '%s'" % list(kwparams)[0]
+        )
 
     # Now incorporate the list of named dicts into the VersionedDict.
     for version, annotations in reversed(versioned_annotations):
@@ -418,10 +471,13 @@ def exported(field, *versioned_annotations, **kwparams):
         # recognized annotations.
         for key in annotations:
             if key not in annotation_key_for_argument_key:
-                raise ValueError('Unrecognized annotation for version "%s": '
-                                 '"%s"' % (version, key))
-            annotation_stack[annotation_key_for_argument_key[key]] = (
-                annotations[key])
+                raise ValueError(
+                    'Unrecognized annotation for version "%s": '
+                    '"%s"' % (version, key)
+                )
+            annotation_stack[
+                annotation_key_for_argument_key[key]
+            ] = annotations[key]
 
     # Now we can annotate the field object with the VersionedDict.
     field.setTaggedValue(LAZR_WEBSERVICE_EXPORTED, annotation_stack)
@@ -439,10 +495,11 @@ def exported(field, *versioned_annotations, **kwparams):
 def _check_collection_default_content(name, interface):
     """Check that the interface has a method providing the default content."""
     tag = interface.queryTaggedValue(LAZR_WEBSERVICE_EXPORTED, {})
-    if 'collection_default_content' not in tag:
+    if "collection_default_content" not in tag:
         raise TypeError(
-            "%s is missing a method tagged with @collection_default_content." %
-            name)
+            "%s is missing a method tagged with @collection_default_content."
+            % name
+        )
 
 
 def export_as_webservice_collection(entry_schema):
@@ -455,7 +512,7 @@ def export_as_webservice_collection(entry_schema):
     :raises TypeError: if the interface doesn't have a method decorated with
         @collection_default_content.
     """
-    _check_called_from_interface_def('export_as_webservice_collection()')
+    _check_called_from_interface_def("export_as_webservice_collection()")
 
     if not IInterface.providedBy(entry_schema):
         raise TypeError("entry_schema must be an interface.")
@@ -464,13 +521,15 @@ def export_as_webservice_collection(entry_schema):
     # check it.
     tags = _get_interface_tags()
     tags[LAZR_WEBSERVICE_EXPORTED] = dict(
-        type=COLLECTION_TYPE, collection_entry_schema=entry_schema)
+        type=COLLECTION_TYPE, collection_entry_schema=entry_schema
+    )
 
     def mark_collection(interface):
         """Class advisor that tags the interface once it is created."""
-        _check_interface('export_as_webservice_collection()', interface)
+        _check_interface("export_as_webservice_collection()", interface)
         _check_collection_default_content(
-            'export_as_webservice_collection()', interface)
+            "export_as_webservice_collection()", interface
+        )
         annotate_exported_methods(interface)
         return interface
 
@@ -490,15 +549,16 @@ class exported_as_webservice_collection:
         self.entry_schema = entry_schema
 
     def __call__(self, interface):
-        _check_interface('exported_as_webservice_collection()', interface)
+        _check_interface("exported_as_webservice_collection()", interface)
         _check_collection_default_content(
-            'exported_as_webservice_collection()', interface)
+            "exported_as_webservice_collection()", interface
+        )
         tag = interface.queryTaggedValue(LAZR_WEBSERVICE_EXPORTED)
         if tag is None:
             tag = {}
             interface.setTaggedValue(LAZR_WEBSERVICE_EXPORTED, tag)
-        tag['type'] = COLLECTION_TYPE
-        tag['collection_entry_schema'] = self.entry_schema
+        tag["type"] = COLLECTION_TYPE
+        tag["collection_entry_schema"] = self.entry_schema
         annotate_exported_methods(interface)
         return interface
 
@@ -520,7 +580,7 @@ class collection_default_content:
             method. This is to be used when the method has required
             parameters.
         """
-        _check_called_from_interface_def('@collection_default_content')
+        _check_called_from_interface_def("@collection_default_content")
 
         # We used to check that this decorator is being used from within an
         # interface exported as a collection.  However, it isn't possible to
@@ -535,31 +595,36 @@ class collection_default_content:
         # instead.
         tags = _get_interface_tags()
         tag = tags.setdefault(LAZR_WEBSERVICE_EXPORTED, {})
-        if 'type' in tag and tag['type'] != COLLECTION_TYPE:
+        if "type" in tag and tag["type"] != COLLECTION_TYPE:
             raise TypeError(
                 "@collection_default_content can only be used from within an "
-                "interface exported as a collection.")
+                "interface exported as a collection."
+            )
 
         default_content_methods = tag.setdefault(
-            'collection_default_content', {})
+            "collection_default_content", {}
+        )
 
         if version in default_content_methods:
             raise TypeError(
                 "Only one method can be marked with "
-                "@collection_default_content for version '%s'." % (
-                    _version_name(version)))
+                "@collection_default_content for version '%s'."
+                % (_version_name(version))
+            )
         self.version = version
         self.params = params
 
     def __call__(self, f):
         """Annotates the collection with the name of the method to call."""
         tag = _get_interface_tags()[LAZR_WEBSERVICE_EXPORTED]
-        tag['collection_default_content'][self.version] = (
-            f.__name__, self.params)
+        tag["collection_default_content"][self.version] = (
+            f.__name__,
+            self.params,
+        )
         return f
 
 
-WEBSERVICE_ERROR = '__lazr_webservice_error__'
+WEBSERVICE_ERROR = "__lazr_webservice_error__"
 
 
 def webservice_error(status):
@@ -576,10 +641,11 @@ def webservice_error(status):
     f_locals = frame.f_locals
 
     # Try to make sure we were called from a class def.
-    if (f_locals is frame.f_globals) or ('__module__' not in f_locals):
+    if (f_locals is frame.f_globals) or ("__module__" not in f_locals):
         raise TypeError(
             "webservice_error() can only be used from within an exception "
-            "definition.")
+            "definition."
+        )
 
     f_locals[WEBSERVICE_ERROR] = int(status)
 
@@ -608,12 +674,13 @@ def error_status(status):
 
     def func(value):
         if not issubclass(value, Exception):
-            raise TypeError('Annotated value must be an exception class.')
+            raise TypeError("Annotated value must be an exception class.")
         old = getattr(value, WEBSERVICE_ERROR, None)
         if old is not None and old != status:
-            raise ValueError('Exception already has an error status', old)
+            raise ValueError("Exception already has an error status", old)
         setattr(value, WEBSERVICE_ERROR, status)
         return value
+
     return func
 
 
@@ -654,7 +721,7 @@ class _method_annotator:
             # @export_*_operation declaration will modify
             # annotations['type'] in place to signal that it is in
             # fact being published.
-            annotations['type'] = REMOVED_OPERATION_TYPE
+            annotations["type"] = REMOVED_OPERATION_TYPE
             method.__dict__[LAZR_WEBSERVICE_EXPORTED] = annotations
         self.annotate_method(method, annotations)
         return method
@@ -682,57 +749,64 @@ def annotate_exported_methods(interface):
         annotation_stack = method.queryTaggedValue(LAZR_WEBSERVICE_EXPORTED)
         if annotation_stack is None:
             continue
-        if annotation_stack.get('type') is None:
+        if annotation_stack.get("type") is None:
             continue
 
         # Make sure that each version of the web service defines
         # a self-consistent view of this method.
         for version, annotations in annotation_stack.stack:
-            if annotations['type'] == REMOVED_OPERATION_TYPE:
+            if annotations["type"] == REMOVED_OPERATION_TYPE:
                 # The method is published in other versions of the web
                 # service, but not in this one. Don't try to validate this
                 # version's annotations.
                 continue
 
             # Method is exported under its own name by default.
-            if 'as' not in annotations:
-                annotations['as'] = method.__name__
+            if "as" not in annotations:
+                annotations["as"] = method.__name__
 
             # It's possible that call_with, operation_parameters, and/or
             # operation_returns_* weren't used.
-            annotations.setdefault('call_with', {})
-            annotations.setdefault('params', {})
-            annotations.setdefault('return_type', None)
+            annotations.setdefault("call_with", {})
+            annotations.setdefault("params", {})
+            annotations.setdefault("return_type", None)
 
             # Make sure that all parameters exist and that we miss none.
             info = method.getSignatureInfo()
-            defined_params = set(info['optional'])
-            defined_params.update(info['required'])
-            exported_params = set(annotations['params'])
-            exported_params.update(annotations['call_with'])
+            defined_params = set(info["optional"])
+            defined_params.update(info["required"])
+            exported_params = set(annotations["params"])
+            exported_params.update(annotations["call_with"])
             undefined_params = exported_params.difference(defined_params)
-            if undefined_params and info['kwargs'] is None:
+            if undefined_params and info["kwargs"] is None:
                 raise TypeError(
                     'method "%s" doesn\'t have the following exported '
-                    'parameters in version "%s": %s.' % (
-                        method.__name__, _version_name(version),
-                        ", ".join(sorted(undefined_params))))
-            missing_params = set(
-                info['required']).difference(exported_params)
+                    'parameters in version "%s": %s.'
+                    % (
+                        method.__name__,
+                        _version_name(version),
+                        ", ".join(sorted(undefined_params)),
+                    )
+                )
+            missing_params = set(info["required"]).difference(exported_params)
             if missing_params:
                 raise TypeError(
                     'method "%s" is missing definitions for parameter(s) '
-                    'exported in version "%s": %s' % (
-                        method.__name__, _version_name(version),
-                        ", ".join(sorted(missing_params))))
+                    'exported in version "%s": %s'
+                    % (
+                        method.__name__,
+                        _version_name(version),
+                        ", ".join(sorted(missing_params)),
+                    )
+                )
 
-            _update_default_and_required_params(annotations['params'], info)
+            _update_default_and_required_params(annotations["params"], info)
 
 
 def _update_default_and_required_params(params, method_info):
     """Set missing default/required based on the method signature."""
-    optional = method_info['optional']
-    required = method_info['required']
+    optional = method_info["optional"]
+    required = method_info["required"]
     for name, param_def in params.items():
         # If the method parameter is optional and the param didn't have
         # a default, set it to the same as the method.
@@ -743,8 +817,11 @@ def _update_default_and_required_params(params, method_info):
             # zope schema are expected to be unicode, whereas it's
             # really possible that the method's default is a simple
             # string.
-            if (six.PY2 and
-                    isinstance(default, str) and IText.providedBy(param_def)):
+            if (
+                six.PY2
+                and isinstance(default, str)
+                and IText.providedBy(param_def)
+            ):
                 default = unicode(default)  # noqa: F821
             param_def.default = default
             param_def.required = False
@@ -761,12 +838,12 @@ class call_with(_method_annotator):
 
     def __init__(self, **params):
         """Specify fixed values for parameters."""
-        _check_called_from_interface_def('%s()' % self.__class__.__name__)
+        _check_called_from_interface_def("%s()" % self.__class__.__name__)
         self.params = params
 
     def annotate_method(self, method, annotations):
         """See `_method_annotator`."""
-        annotations['call_with'] = self.params
+        annotations["call_with"] = self.params
 
 
 class mutator_for(_method_annotator):
@@ -775,6 +852,7 @@ class mutator_for(_method_annotator):
     The method can be invoked through POST, or by setting a value for
     the given field as part of a PUT or PATCH request.
     """
+
     def __init__(self, field):
         """Specify the field for which this method is a mutator."""
         self.field = field
@@ -786,16 +864,19 @@ class mutator_for(_method_annotator):
         """
 
         if not self.field.readonly:
-            raise TypeError("Only a read-only field can have a mutator "
-                            "method.")
+            raise TypeError(
+                "Only a read-only field can have a mutator " "method."
+            )
 
         # The mutator method must take only one argument, not counting
         # arguments with values fixed by call_with().
         free_params = _free_parameters(method, annotations)
         if len(free_params) != 1:
-            raise TypeError("A mutator method must take one and only one "
-                            "non-fixed argument. %s takes %d." %
-                            (method.__name__, len(free_params)))
+            raise TypeError(
+                "A mutator method must take one and only one "
+                "non-fixed argument. %s takes %d."
+                % (method.__name__, len(free_params))
+            )
 
         # We need to keep mutator annotations in a separate dictionary
         # from the field's main annotations because we're not
@@ -804,13 +885,15 @@ class mutator_for(_method_annotator):
         # version fits into the field's annotations.
         version, method_annotations = annotations.stack[-1]
         mutator_annotations = self.field.queryTaggedValue(
-            LAZR_WEBSERVICE_MUTATORS)
+            LAZR_WEBSERVICE_MUTATORS
+        )
         if version in mutator_annotations:
             raise TypeError(
                 "A field can only have one mutator method for version %s; "
-                "%s makes two." % (_version_name(version), method.__name__ ))
+                "%s makes two." % (_version_name(version), method.__name__)
+            )
         mutator_annotations[version] = (method, dict(method_annotations))
-        method_annotations['is_mutator'] = True
+        method_annotations["is_mutator"] = True
 
 
 class accessor_for(_method_annotator):
@@ -818,6 +901,7 @@ class accessor_for(_method_annotator):
 
     The method can be invoked by accessing the field's URL.
     """
+
     def __init__(self, field):
         """Specify the field for which this method is a mutator."""
         self.field = field
@@ -834,13 +918,15 @@ class accessor_for(_method_annotator):
         # field's annotations.
         version, method_annotations = annotations.stack[-1]
         accessor_annotations = self.field.queryTaggedValue(
-            LAZR_WEBSERVICE_ACCESSORS)
+            LAZR_WEBSERVICE_ACCESSORS
+        )
         if version in accessor_annotations:
             raise TypeError(
                 "A field can only have one accessor method for version %s; "
-                "%s makes two." % (_version_name(version), method.__name__ ))
+                "%s makes two." % (_version_name(version), method.__name__)
+            )
         accessor_annotations[version] = (method, dict(method_annotations))
-        method_annotations['is_accessor'] = True
+        method_annotations["is_accessor"] = True
 
 
 def _free_parameters(method, annotations):
@@ -849,8 +935,9 @@ def _free_parameters(method, annotations):
     Parameters that have values fixed by call_with() are not free.
     """
     signature = fromFunction(method).getSignatureInfo()
-    return (set(signature['required']) -
-               set(annotations.get('call_with', {}).keys()))
+    return set(signature["required"]) - set(
+        annotations.get("call_with", {}).keys()
+    )
 
 
 class operation_for_version(_method_annotator):
@@ -861,8 +948,9 @@ class operation_for_version(_method_annotator):
     their values. Subsequent versions may provide conflicting values,
     but those values will not affect this version.
     """
+
     def __init__(self, version):
-        _check_called_from_interface_def('%s()' % self.__class__.__name__)
+        _check_called_from_interface_def("%s()" % self.__class__.__name__)
         self.version = version
 
     def annotate_method(self, method, annotations):
@@ -881,6 +969,7 @@ class operation_removed_in_version(operation_for_version):
     service, or any subsequent version, unless it's re-published with
     an export_*_operation method.
     """
+
     def annotate_method(self, method, annotations):
         """See `_method_annotator`."""
         # The annotations dict is a VersionedDict. Push a new dict
@@ -891,19 +980,19 @@ class operation_removed_in_version(operation_for_version):
         # We need to set a special 'type' so that lazr.restful can
         # easily distinguish a method that's not present in the latest
         # version from a method that was incompletely annotated.
-        annotations['type'] = REMOVED_OPERATION_TYPE
+        annotations["type"] = REMOVED_OPERATION_TYPE
 
 
 class export_operation_as(_method_annotator):
     """Decorator specifying the name to export the method as."""
 
     def __init__(self, name):
-        _check_called_from_interface_def('%s()' % self.__class__.__name__)
+        _check_called_from_interface_def("%s()" % self.__class__.__name__)
         self.name = name
 
     def annotate_method(self, method, annotations):
         """See `_method_annotator`."""
-        annotations['as'] = self.name
+        annotations["as"] = self.name
 
 
 class rename_parameters_as(_method_annotator):
@@ -911,20 +1000,22 @@ class rename_parameters_as(_method_annotator):
 
     def __init__(self, **params):
         """params is of the form method_parameter_name=webservice_name."""
-        _check_called_from_interface_def('%s()' % self.__class__.__name__)
+        _check_called_from_interface_def("%s()" % self.__class__.__name__)
         self.params = params
 
     def annotate_method(self, method, annotations):
         """See `_method_annotator`."""
-        param_defs = annotations.get('params')
+        param_defs = annotations.get("params")
         if param_defs is None:
             raise TypeError(
-                '"%s" isn\'t exported on the webservice.' % method.__name__)
+                '"%s" isn\'t exported on the webservice.' % method.__name__
+            )
         for name, export_as in self.params.items():
             if name not in param_defs:
                 raise TypeError(
-                    'rename_parameters_as(): no "%s" parameter is exported.' %
-                        name)
+                    'rename_parameters_as(): no "%s" parameter is exported.'
+                    % name
+                )
             param_defs[name].__name__ = export_as
 
 
@@ -934,24 +1025,25 @@ class operation_parameters(_method_annotator):
     The decorator takes a list of `IField` describing the parameters. The name
     of the underlying method parameter is taken from the argument name.
     """
+
     def __init__(self, **params):
         """params is of the form method_parameter_name=Field()."""
-        _check_called_from_interface_def('%s()' % self.__class__.__name__)
+        _check_called_from_interface_def("%s()" % self.__class__.__name__)
         self.params = params
 
     def annotate_method(self, method, annotations):
         """See `_method_annotator`."""
         # It's possible that another decorator already created the params
         # annotation.
-        params = annotations.setdefault('params', {})
+        params = annotations.setdefault("params", {})
         for name, param in self.params.items():
             if not IField.providedBy(param):
                 raise TypeError(
                     'export definition of "%s" in method "%s" must '
-                    'provide IField: %r' % (name, method.__name__, param))
+                    "provide IField: %r" % (name, method.__name__, param)
+                )
             if name in params:
-                raise TypeError(
-                    "'%s' parameter is already defined." % name)
+                raise TypeError("'%s' parameter is already defined." % name)
 
             # By default, parameters are exported under their own name.
             param.__name__ = name
@@ -967,14 +1059,15 @@ class operation_returns_entry(_method_annotator):
     """
 
     def __init__(self, schema):
-        _check_called_from_interface_def('%s()' % self.__class__.__name__)
+        _check_called_from_interface_def("%s()" % self.__class__.__name__)
         if not IInterface.providedBy(schema):
-            raise TypeError('Entry type %s does not provide IInterface.'
-                            % schema)
+            raise TypeError(
+                "Entry type %s does not provide IInterface." % schema
+            )
         self.return_type = Reference(schema=schema)
 
     def annotate_method(self, method, annotations):
-        annotations['return_type'] = self.return_type
+        annotations["return_type"] = self.return_type
 
 
 class operation_returns_collection_of(_method_annotator):
@@ -983,16 +1076,18 @@ class operation_returns_collection_of(_method_annotator):
     The decorator takes one required argument, "schema", an interface that's
     been exported as an entry.
     """
+
     def __init__(self, schema):
-        _check_called_from_interface_def('%s()' % self.__class__.__name__)
+        _check_called_from_interface_def("%s()" % self.__class__.__name__)
         if not IInterface.providedBy(schema):
-            raise TypeError('Collection value type %s does not provide '
-                            'IInterface.' % schema)
-        self.return_type = CollectionField(
-            value_type=Reference(schema=schema))
+            raise TypeError(
+                "Collection value type %s does not provide "
+                "IInterface." % schema
+            )
+        self.return_type = CollectionField(value_type=Reference(schema=schema))
 
     def annotate_method(self, method, annotations):
-        annotations['return_type'] = self.return_type
+        annotations["return_type"] = self.return_type
 
 
 class _export_operation(_method_annotator):
@@ -1002,16 +1097,17 @@ class _export_operation(_method_annotator):
     type = None
 
     def __init__(self):
-        _check_called_from_interface_def('%s()' % self.__class__.__name__)
+        _check_called_from_interface_def("%s()" % self.__class__.__name__)
 
     def annotate_method(self, method, annotations):
         """See `_method_annotator`."""
-        annotations['type'] = self.type
+        annotations["type"] = self.type
 
 
 class export_factory_operation(_export_operation):
     """Decorator marking a method as being a factory on the webservice."""
-    type = 'factory'
+
+    type = "factory"
 
     def __init__(self, interface, field_names):
         """Creates a factory decorator.
@@ -1022,26 +1118,30 @@ class export_factory_operation(_export_operation):
             are used as parameters by this factory.
         """
         # pylint: disable-msg=W0231
-        _check_called_from_interface_def('%s()' % self.__class__.__name__)
+        _check_called_from_interface_def("%s()" % self.__class__.__name__)
         self.interface = interface
         self.params = OrderedDict()
         for name in field_names:
             field = interface.get(name)
             if field is None:
-                raise TypeError("%s doesn't define '%s'." % (
-                                interface.__name__, name))
+                raise TypeError(
+                    "%s doesn't define '%s'." % (interface.__name__, name)
+                )
             if not IField.providedBy(field):
-                raise TypeError("%s.%s doesn't provide IField." % (
-                                interface.__name__, name))
+                raise TypeError(
+                    "%s.%s doesn't provide IField."
+                    % (interface.__name__, name)
+                )
             self.params[name] = copy_field(field)
 
     def annotate_method(self, method, annotations):
         """See `_method_annotator`."""
         super(export_factory_operation, self).annotate_method(
-            method, annotations)
-        annotations['creates'] = self.interface
-        annotations['params'] = self.params
-        annotations['return_type'] = ObjectLink(schema=self.interface)
+            method, annotations
+        )
+        annotations["creates"] = self.interface
+        annotations["params"] = self.params
+        annotations["return_type"] = ObjectLink(schema=self.interface)
 
 
 class cache_for(_method_annotator):
@@ -1051,16 +1151,18 @@ class cache_for(_method_annotator):
         """Specify the duration, in seconds, of the caching resource."""
         if not isinstance(duration, six.integer_types):
             raise TypeError(
-                'Caching duration should be an integer type, not %s' %
-                duration.__class__.__name__)
+                "Caching duration should be an integer type, not %s"
+                % duration.__class__.__name__
+            )
         if duration <= 0:
             raise ValueError(
-                'Caching duration should be a positive number: %s' % duration)
+                "Caching duration should be a positive number: %s" % duration
+            )
         self.duration = duration
 
     def annotate_method(self, method, annotations):
         """See `_method_annotator`."""
-        annotations['cache_for'] = self.duration
+        annotations["cache_for"] = self.duration
 
 
 class scoped(_method_annotator):
@@ -1076,22 +1178,25 @@ class scoped(_method_annotator):
         for scope in scopes:
             if not isinstance(scope, six.string_types):
                 raise TypeError(
-                    'Scope should be a string type, not %s' %
-                    scope.__class__.__name__)
+                    "Scope should be a string type, not %s"
+                    % scope.__class__.__name__
+                )
         self.scopes = scopes
 
     def annotate_method(self, method, annotations):
         """See `_method_annotator`."""
-        annotations['scopes'] = list(self.scopes)
+        annotations["scopes"] = list(self.scopes)
 
 
 class export_read_operation(_export_operation):
     """Decorator marking a method for export as a read operation."""
-    type = 'read_operation'
+
+    type = "read_operation"
 
 
 class export_write_operation(_export_operation):
     """Decorator marking a method for export as a write operation."""
+
     type = "write_operation"
 
 
@@ -1101,6 +1206,7 @@ class export_destructor_operation(_export_operation):
     The method will be invoked when the client sends a DELETE request to
     the entry.
     """
+
     type = "destructor"
 
     def annotate_method(self, method, annotation_stack):
@@ -1111,37 +1217,44 @@ class export_destructor_operation(_export_operation):
         Every version must have a self-consistent set of annotations.
         """
         super(export_destructor_operation, self).annotate_method(
-              method, annotation_stack)
+            method, annotation_stack
+        )
         # The mutator method must take no arguments, not counting
         # arguments with values fixed by call_with().
         for version, annotations in annotation_stack.stack:
-            if annotations['type'] == REMOVED_OPERATION_TYPE:
+            if annotations["type"] == REMOVED_OPERATION_TYPE:
                 continue
             free_params = _free_parameters(method, annotations)
             if len(free_params) != 0:
                 raise TypeError(
                     "A destructor method must take no non-fixed arguments. "
-                    'In version %s, the "%s" method takes %d: "%s".' % (
-                        _version_name(version), method.__name__,
-                        len(free_params), '", "'.join(free_params))
-                        )
+                    'In version %s, the "%s" method takes %d: "%s".'
+                    % (
+                        _version_name(version),
+                        method.__name__,
+                        len(free_params),
+                        '", "'.join(free_params),
+                    )
+                )
 
 
 def _check_tagged_interface(interface, type):
     """Make sure that the interface is exported under the proper type."""
     if not isinstance(interface, InterfaceClass):
-        raise TypeError('not an interface.')
+        raise TypeError("not an interface.")
 
     tag = interface.queryTaggedValue(LAZR_WEBSERVICE_EXPORTED)
     if tag is None:
         raise TypeError(
-            "'%s' isn't tagged for webservice export." % interface.__name__)
-    elif tag['type'] != type:
-        art = 'a'
-        if type == 'entry':
-            art = 'an'
+            "'%s' isn't tagged for webservice export." % interface.__name__
+        )
+    elif tag["type"] != type:
+        art = "a"
+        if type == "entry":
+            art = "an"
         raise TypeError(
-            "'%s' isn't exported as %s %s." % (interface.__name__, art, type))
+            "'%s' isn't exported as %s %s." % (interface.__name__, art, type)
+        )
 
 
 def generate_entry_interfaces(interface, contributors=[], *versions):
@@ -1155,7 +1268,7 @@ def generate_entry_interfaces(interface, contributors=[], *versions):
         as `versions`.
     """
 
-    _check_tagged_interface(interface, 'entry')
+    _check_tagged_interface(interface, "entry")
     versions = list(versions)
 
     # Make sure any given version defines only one destructor method.
@@ -1163,19 +1276,22 @@ def generate_entry_interfaces(interface, contributors=[], *versions):
     for name, method in interface.namesAndDescriptions(True):
         if not IMethod.providedBy(method):
             continue
-        method_annotations = method.queryTaggedValue(
-            LAZR_WEBSERVICE_EXPORTED)
+        method_annotations = method.queryTaggedValue(LAZR_WEBSERVICE_EXPORTED)
         if method_annotations is None:
             continue
         for version, annotations in method_annotations.stack:
-            if annotations.get('type') == export_destructor_operation.type:
+            if annotations.get("type") == export_destructor_operation.type:
                 destructor = destructor_for_version.get(version)
                 if destructor is not None:
                     raise TypeError(
-                        'An entry can only have one destructor method for '
-                        'version %s; %s and %s make two.' % (
-                            _version_name(version), method.__name__,
-                            destructor.__name__))
+                        "An entry can only have one destructor method for "
+                        "version %s; %s and %s make two."
+                        % (
+                            _version_name(version),
+                            method.__name__,
+                            destructor.__name__,
+                        )
+                    )
                 destructor_for_version[version] = method
 
     # Build a data set describing this entry, as it appears in each
@@ -1191,15 +1307,16 @@ def generate_entry_interfaces(interface, contributors=[], *versions):
 
     # If require_explicit_versions is set, make sure the first version
     # to set 'exported' also sets '_as_of_was_used'.
-    _enforce_explicit_version(
-        entry_tags, 'Entry "%s": ' % interface.__name__)
+    _enforce_explicit_version(entry_tags, 'Entry "%s": ' % interface.__name__)
 
     # Make sure there's one set of entry tags for every version of the
     # web service, including versions in which this entry is not
     # published.
     entry_tags.normalize_for_versions(
-        versions, {'type': ENTRY_TYPE, 'exported': False},
-        'Interface "%s": ' % interface.__name__)
+        versions,
+        {"type": ENTRY_TYPE, "exported": False},
+        'Interface "%s": ' % interface.__name__,
+    )
 
     # Next, we'll normalize each published field. A normalized field
     # has a set of annotations for every version in which the entry is
@@ -1212,8 +1329,10 @@ def generate_entry_interfaces(interface, contributors=[], *versions):
             if tag_stack is None:
                 # This field is not published at all.
                 continue
-            error_message_prefix = (
-                'Field "%s" in interface "%s": ' % (name, iface.__name__))
+            error_message_prefix = 'Field "%s" in interface "%s": ' % (
+                name,
+                iface.__name__,
+            )
             _normalize_field_annotations(field, versions, error_message_prefix)
             tags_for_published_fields.append((name, field, tag_stack))
 
@@ -1221,49 +1340,64 @@ def generate_entry_interfaces(interface, contributors=[], *versions):
     entry_tags = interface.queryTaggedValue(LAZR_WEBSERVICE_EXPORTED)
     for version in versions:
         entry_tags_this_version = entry_tags.dict_for_name(version)
-        if entry_tags_this_version.get('exported') is False:
+        if entry_tags_this_version.get("exported") is False:
             # Don't define an entry interface for this version at all.
             continue
         attrs = {}
         for name, field, tag_stack in tags_for_published_fields:
             tags = tag_stack.dict_for_name(version)
-            if tags.get('exported') is False:
+            if tags.get("exported") is False:
                 continue
             mutated_by, mutated_by_annotations = tags.get(
-                'mutator_annotations', (None, {}))
-            readonly = (field.readonly and mutated_by is None)
-            if 'readonly' in tags:
-                publish_as_readonly = tags.get('readonly')
+                "mutator_annotations", (None, {})
+            )
+            readonly = field.readonly and mutated_by is None
+            if "readonly" in tags:
+                publish_as_readonly = tags.get("readonly")
                 if readonly and not publish_as_readonly:
                     raise TypeError(
-                        ("%s.%s is defined as a read-only field, so you "
-                         "can't just declare it to be read-write in "
-                         "the web service: you must define a mutator.") % (
-                            interface.__name__, field.__name__))
+                        (
+                            "%s.%s is defined as a read-only field, so you "
+                            "can't just declare it to be read-write in "
+                            "the web service: you must define a mutator."
+                        )
+                        % (interface.__name__, field.__name__)
+                    )
                 if not readonly and publish_as_readonly:
                     # The field is read-write internally, but the
                     # developer wants it to be read-only through the web
                     # service.
                     readonly = True
-            attrs[tags['as']] = copy_field(
-                field, __name__=tags['as'], readonly=readonly)
+            attrs[tags["as"]] = copy_field(
+                field, __name__=tags["as"], readonly=readonly
+            )
         class_name = _versioned_class_name(
-            "%sEntry" % interface.__name__, version)
+            "%sEntry" % interface.__name__, version
+        )
         entry_interface = InterfaceClass(
-            class_name, bases=(IEntry, ), attrs=attrs,
-            __doc__=interface.__doc__, __module__=interface.__module__)
+            class_name,
+            bases=(IEntry,),
+            attrs=attrs,
+            __doc__=interface.__doc__,
+            __module__=interface.__module__,
+        )
 
         versioned_tag = entry_tags.dict_for_name(version)
-        entry_interface.setTaggedValue(LAZR_WEBSERVICE_NAME, dict(
-            singular=versioned_tag['singular_name'],
-            plural=versioned_tag['plural_name'],
-            publish_web_link=versioned_tag['publish_web_link']))
+        entry_interface.setTaggedValue(
+            LAZR_WEBSERVICE_NAME,
+            dict(
+                singular=versioned_tag["singular_name"],
+                plural=versioned_tag["plural_name"],
+                publish_web_link=versioned_tag["publish_web_link"],
+            ),
+        )
         generated_interfaces.append(VersionedObject(version, entry_interface))
     return generated_interfaces
 
 
 def generate_entry_adapters(
-        content_interface, contributors, webservice_interfaces):
+    content_interface, contributors, webservice_interfaces
+):
     """Create classes adapting from content_interface to webservice_interfaces.
 
     Unlike with generate_collection_adapter and
@@ -1278,7 +1412,7 @@ def generate_entry_adapters(
 
     :param return: A list of 2-tuples (version string, adapter class)
     """
-    _check_tagged_interface(content_interface, 'entry')
+    _check_tagged_interface(content_interface, "entry")
 
     # Go through the fields and build up a picture of what this entry looks
     # like for every version.
@@ -1298,21 +1432,23 @@ def generate_entry_adapters(
 
             # Set '_orig_interfaces' as early as possible as we want that
             # attribute (even if empty) on all adapters.
-            orig_interfaces = adapter_dict.setdefault('_orig_interfaces', {})
+            orig_interfaces = adapter_dict.setdefault("_orig_interfaces", {})
 
             # Figure out the mutator for this version and add it to
             # this version's adapter class dictionary.
-            if tags.get('exported') is False:
+            if tags.get("exported") is False:
                 continue
             mutator, mutator_annotations = tags.get(
-                'mutator_annotations', (None, {}))
+                "mutator_annotations", (None, {})
+            )
             accessor, accessor_annotations = tags.get(
-                'accessor_annotations', (None, {}))
+                "accessor_annotations", (None, {})
+            )
 
             # Always use the field's original_name here as we've combined
             # fields from the content interface with fields of the webservice
             # interfaces (where they may have different names).
-            orig_name = tags['original_name']
+            orig_name = tags["original_name"]
 
             # Some fields may be provided by an adapter of the content class
             # instead of being provided directly by the content class. In
@@ -1325,25 +1461,39 @@ def generate_entry_adapters(
                 if orig_name in contributor:
                     orig_iface = contributor
             assert orig_name in orig_iface, (
-                "Could not find interface where %s is defined" % orig_name)
+                "Could not find interface where %s is defined" % orig_name
+            )
 
             if accessor is not None and mutator is not None:
                 prop = PropertyWithAccessorAndMutator(
-                    orig_name, 'context', accessor,
-                    accessor_annotations, mutator,
-                    mutator_annotations, orig_iface)
+                    orig_name,
+                    "context",
+                    accessor,
+                    accessor_annotations,
+                    mutator,
+                    mutator_annotations,
+                    orig_iface,
+                )
             elif mutator is not None and accessor is None:
                 prop = PropertyWithMutator(
-                    orig_name, 'context', mutator,
-                    mutator_annotations, orig_iface)
+                    orig_name,
+                    "context",
+                    mutator,
+                    mutator_annotations,
+                    orig_iface,
+                )
             elif accessor is not None and mutator is None:
                 prop = PropertyWithAccessor(
-                    orig_name, 'context', accessor,
-                    accessor_annotations, orig_iface)
+                    orig_name,
+                    "context",
+                    accessor,
+                    accessor_annotations,
+                    orig_iface,
+                )
             else:
-                prop = _ScopeChecker(orig_name, 'context', orig_iface)
+                prop = _ScopeChecker(orig_name, "context", orig_iface)
 
-            adapter_dict[tags['as']] = prop
+            adapter_dict[tags["as"]] = prop
 
             # A dict mapping field names to the interfaces where they came
             # from.
@@ -1352,17 +1502,17 @@ def generate_entry_adapters(
     adapters = []
     for version, webservice_interface in webservice_interfaces:
         if not isinstance(webservice_interface, InterfaceClass):
-            raise TypeError('webservice_interface is not an interface.')
+            raise TypeError("webservice_interface is not an interface.")
         class_dict = adapters_by_version.get(version, {})
 
         # If this interface doesn't export a single field/operation,
         # class_dict will be empty, and so we'll add '_orig_interfaces'
         # manually as it should be always available, even if empty.
         if class_dict == {}:
-            class_dict['_orig_interfaces'] = {}
+            class_dict["_orig_interfaces"] = {}
 
-        class_dict['schema'] = webservice_interface
-        class_dict['__doc__'] = webservice_interface.__doc__
+        class_dict["schema"] = webservice_interface
+        class_dict["__doc__"] = webservice_interface.__doc__
         # The webservice interface class name already includes the version
         # string, so there's no reason to add it again to the end
         # of the class name.
@@ -1370,7 +1520,8 @@ def generate_entry_adapters(
         factory = type(classname, (Entry,), class_dict)
         classImplements(factory, webservice_interface)
         protect_schema(
-            factory, webservice_interface, write_permission=CheckerPublic)
+            factory, webservice_interface, write_permission=CheckerPublic
+        )
         adapters.append(VersionedObject(version, factory))
     return adapters
 
@@ -1381,7 +1532,8 @@ def params_with_dereferenced_user(params):
     for name, value in params.items():
         if value is REQUEST_USER:
             params[name] = getUtility(
-                IWebServiceConfiguration).get_request_user()
+                IWebServiceConfiguration
+            ).get_request_user()
     return params
 
 
@@ -1391,7 +1543,8 @@ def _check_request(context, required_scopes):
     See `IWebServiceConfiguration.checkRequest`.
     """
     check_request = getattr(
-        getUtility(IWebServiceConfiguration), 'checkRequest', None)
+        getUtility(IWebServiceConfiguration), "checkRequest", None
+    )
     if check_request is not None:
         check_request(context, required_scopes)
 
@@ -1424,7 +1577,8 @@ class _AccessorWrapper:
     def __get__(self, obj, *args):
         """Call the accessor method to get the value."""
         params = params_with_dereferenced_user(
-            self.accessor_annotations.get('call_with', {}))
+            self.accessor_annotations.get("call_with", {})
+        )
         context = getattr(obj, self.contextvar)
         if self.adaptation is not None:
             context = self.adaptation(context)
@@ -1445,7 +1599,8 @@ class _MutatorWrapper:
     def __set__(self, obj, new_value):
         """Call the mutator method to set the value."""
         params = params_with_dereferenced_user(
-            self.mutator_annotations.get('call_with', {}))
+            self.mutator_annotations.get("call_with", {})
+        )
         context = getattr(obj, self.contextvar)
         if self.adaptation is not None:
             context = self.adaptation(context)
@@ -1459,8 +1614,9 @@ class _MutatorWrapper:
 class PropertyWithAccessor(_AccessorWrapper, _ScopeChecker):
     """A property with a accessor method."""
 
-    def __init__(self, name, context, accessor, accessor_annotations,
-                 adaptation):
+    def __init__(
+        self, name, context, accessor, accessor_annotations, adaptation
+    ):
         super(PropertyWithAccessor, self).__init__(name, context, adaptation)
         self.accessor = accessor.__name__
         self.accessor_annotations = accessor_annotations
@@ -1469,21 +1625,32 @@ class PropertyWithAccessor(_AccessorWrapper, _ScopeChecker):
 class PropertyWithMutator(_MutatorWrapper, _ScopeChecker):
     """A property with a mutator method."""
 
-    def __init__(self, name, context, mutator, mutator_annotations,
-                 adaptation):
+    def __init__(
+        self, name, context, mutator, mutator_annotations, adaptation
+    ):
         super(PropertyWithMutator, self).__init__(name, context, adaptation)
         self.mutator = mutator.__name__
         self.mutator_annotations = mutator_annotations
 
 
-class PropertyWithAccessorAndMutator(_AccessorWrapper, _MutatorWrapper,
-                                     Passthrough):
+class PropertyWithAccessorAndMutator(
+    _AccessorWrapper, _MutatorWrapper, Passthrough
+):
     """A Property with both an accessor an a mutator."""
 
-    def __init__(self, name, context, accessor, accessor_annotations,
-                 mutator, mutator_annotations, adaptation):
+    def __init__(
+        self,
+        name,
+        context,
+        accessor,
+        accessor_annotations,
+        mutator,
+        mutator_annotations,
+        adaptation,
+    ):
         super(PropertyWithAccessorAndMutator, self).__init__(
-            name, context, adaptation)
+            name, context, adaptation
+        )
         self.accessor = accessor.__name__
         self.accessor_annotations = accessor_annotations
         self.mutator = mutator.__name__
@@ -1510,9 +1677,11 @@ class CollectionEntrySchema:
         else:
             request = instance.request
         request_interface = getUtility(
-            IWebServiceVersion, name=request.version)
+            IWebServiceVersion, name=request.version
+        )
         entry_class = getGlobalSiteManager().adapters.lookup(
-            (self.model_schema, request_interface), IEntry)
+            (self.model_schema, request_interface), IEntry
+        )
         if entry_class is None:
             return None
         return EntryAdapterUtility(entry_class).entry_interface
@@ -1534,24 +1703,27 @@ class BaseCollectionAdapter(Collection):
 
 def generate_collection_adapter(interface, version=None):
     """Create a class adapting from interface to ICollection."""
-    _check_tagged_interface(interface, 'collection')
+    _check_tagged_interface(interface, "collection")
 
     tag = interface.getTaggedValue(LAZR_WEBSERVICE_EXPORTED)
-    default_content_by_version = tag['collection_default_content']
-    assert (version in default_content_by_version), (
-        "'%s' isn't tagged for export to web service "
-        "version '%s'." % (interface.__name__, version))
+    default_content_by_version = tag["collection_default_content"]
+    assert (
+        version in default_content_by_version
+    ), "'%s' isn't tagged for export to web service " "version '%s'." % (
+        interface.__name__,
+        version,
+    )
     method_name, params = default_content_by_version[version]
-    entry_schema = tag['collection_entry_schema']
+    entry_schema = tag["collection_entry_schema"]
     class_dict = {
-        'entry_schema' : CollectionEntrySchema(entry_schema),
-        'method_name': method_name,
-        'params': params,
-        '__doc__': interface.__doc__,
-        }
+        "entry_schema": CollectionEntrySchema(entry_schema),
+        "method_name": method_name,
+        "params": params,
+        "__doc__": interface.__doc__,
+    }
     classname = _versioned_class_name(
-        "%sCollectionAdapter" % interface.__name__[1:],
-        version)
+        "%sCollectionAdapter" % interface.__name__[1:], version
+    )
     factory = type(classname, (BaseCollectionAdapter,), class_dict)
 
     protect_schema(factory, ICollection)
@@ -1575,16 +1747,18 @@ class BaseResourceOperationAdapter(ResourceOperation):
         # Handle renames.
         renames = dict(
             (param_def.__name__, orig_name)
-            for orig_name, param_def in self._export_info['params'].items()
-            if param_def.__name__ != orig_name)
+            for orig_name, param_def in self._export_info["params"].items()
+            if param_def.__name__ != orig_name
+        )
         params = OrderedDict()
         for name, value in kwargs.items():
             name = renames.get(name, name)
             params[name] = value
 
         # Handle fixed parameters.
-        params.update(params_with_dereferenced_user(
-                self._export_info['call_with']))
+        params.update(
+            params_with_dereferenced_user(self._export_info["call_with"])
+        )
         return params
 
     def call(self, **kwargs):
@@ -1593,13 +1767,15 @@ class BaseResourceOperationAdapter(ResourceOperation):
 
         # For responses to GET requests, tell the client to cache the
         # response.
-        if (IResourceGETOperation.providedBy(self)
-            and 'cache_for' in self._export_info):
+        if (
+            IResourceGETOperation.providedBy(self)
+            and "cache_for" in self._export_info
+        ):
             self.request.response.setHeader(
-                'Cache-control', 'max-age=%i'
-                % self._export_info['cache_for'])
+                "Cache-control", "max-age=%i" % self._export_info["cache_for"]
+            )
 
-        _check_request(self.context, self._export_info.get('scopes', []))
+        _check_request(self.context, self._export_info.get("scopes", []))
         result = self._getMethod()(**params)
         return self.encodeResult(result)
 
@@ -1617,8 +1793,8 @@ class BaseFactoryResourceOperationAdapter(BaseResourceOperationAdapter):
         result = self._getMethod()(**params)
         response = self.request.response
         response.setStatus(201)
-        response.setHeader('Location', absoluteURL(result, self.request))
-        return u''
+        response.setHeader("Location", absoluteURL(result, self.request))
+        return u""
 
 
 def generate_operation_adapter(method, version=None):
@@ -1635,11 +1811,14 @@ def generate_operation_adapter(method, version=None):
     tag = method.queryTaggedValue(LAZR_WEBSERVICE_EXPORTED)
     if tag is None:
         raise TypeError(
-            "'%s' isn't tagged for webservice export." % method.__name__)
+            "'%s' isn't tagged for webservice export." % method.__name__
+        )
     match = tag.dict_for_name(version)
     if match is None:
-        raise AssertionError("'%s' isn't tagged for export to web service "
-                             "version '%s'" % (method.__name__, version))
+        raise AssertionError(
+            "'%s' isn't tagged for export to web service "
+            "version '%s'" % (method.__name__, version)
+        )
     config = getUtility(IWebServiceConfiguration)
     if version is None:
         # This code path is not currently used except in a test, since
@@ -1652,41 +1831,43 @@ def generate_operation_adapter(method, version=None):
                 'version "%s", but the service configuration requires '
                 "all version declarations to be explicit. You should add "
                 '@operation_for_version("%s") to the bottom of the '
-                'annotation stack.' % (method.__name__, version, version))
+                "annotation stack." % (method.__name__, version, version)
+            )
 
-    bases = (BaseResourceOperationAdapter, )
-    operation_type = match['type']
-    if operation_type == 'read_operation':
-        prefix = 'GET'
+    bases = (BaseResourceOperationAdapter,)
+    operation_type = match["type"]
+    if operation_type == "read_operation":
+        prefix = "GET"
         provides = IResourceGETOperation
-    elif operation_type in ('factory', 'write_operation'):
+    elif operation_type in ("factory", "write_operation"):
         provides = IResourcePOSTOperation
-        prefix = 'POST'
-        if operation_type == 'factory':
+        prefix = "POST"
+        if operation_type == "factory":
             bases = (BaseFactoryResourceOperationAdapter,)
-    elif operation_type == 'destructor':
+    elif operation_type == "destructor":
         provides = IResourceDELETEOperation
-        prefix = 'DELETE'
+        prefix = "DELETE"
     else:
-        raise AssertionError('Unknown method export type: %s' % operation_type)
+        raise AssertionError("Unknown method export type: %s" % operation_type)
 
-    return_type = match['return_type']
-    scopes = match.get('scopes') or []
+    return_type = match["return_type"]
+    scopes = match.get("scopes") or []
 
     name = _versioned_class_name(
-        '%s_%s_%s' % (prefix, method.interface.__name__, match['as']),
-        version)
+        "%s_%s_%s" % (prefix, method.interface.__name__, match["as"]), version
+    )
     class_dict = {
-        'params': tuple(match['params'].values()),
-        'return_type': return_type,
-        'scopes': tuple(scopes),
-        '_orig_iface': method.interface,
-        '_export_info': match,
-        '_method_name': method.__name__,
-        '__doc__': method.__doc__}
-
-    if operation_type == 'write_operation':
-        class_dict['send_modification_event'] = True
+        "params": tuple(match["params"].values()),
+        "return_type": return_type,
+        "scopes": tuple(scopes),
+        "_orig_iface": method.interface,
+        "_export_info": match,
+        "_method_name": method.__name__,
+        "__doc__": method.__doc__,
+    }
+
+    if operation_type == "write_operation":
+        class_dict["send_modification_event"] = True
     factory = type(name, bases, class_dict)
     classImplements(factory, provides)
     protect_schema(factory, provides)
@@ -1694,7 +1875,7 @@ def generate_operation_adapter(method, version=None):
     return factory
 
 
-def _normalize_field_annotations(field, versions, error_prefix=''):
+def _normalize_field_annotations(field, versions, error_prefix=""):
     """Make sure a field has annotations for every published version.
 
     If a field lacks annotations for a given version, it will not show
@@ -1720,8 +1901,11 @@ def _normalize_field_annotations(field, versions, error_prefix=''):
     earliest_version = versions[0]
     stack = versioned_dict.stack
 
-    if (len(stack) >= 2 and stack[0].version is None
-        and stack[1].version == earliest_version):
+    if (
+        len(stack) >= 2
+        and stack[0].version is None
+        and stack[1].version == earliest_version
+    ):
         # The behavior of the earliest version is defined with keyword
         # arguments, but the first explicitly-defined version also
         # refers to the earliest version. We need to consolidate the
@@ -1739,15 +1923,15 @@ def _normalize_field_annotations(field, versions, error_prefix=''):
             if implicit_value == value:
                 # The two values are in sync.
                 continue
-            if key == 'as' and implicit_value == field.__name__:
+            if key == "as" and implicit_value == field.__name__:
                 # The implicit value was set by the system, not by the
                 # user. The later value will simply take precedence.
                 continue
             raise ValueError(
                 error_prefix + 'Annotation "%s" has conflicting values '
                 'for the earliest version: "%s" (from keyword arguments) '
-                'and "%s" (defined explicitly).' % (
-                    key, implicit_value, value))
+                'and "%s" (defined explicitly).' % (key, implicit_value, value)
+            )
         stack[0].object.update(stack[1].object)
         stack.remove(stack[1])
 
@@ -1765,61 +1949,74 @@ def _normalize_field_annotations(field, versions, error_prefix=''):
     # the normal tag stack.
     implicit_earliest_mutator = mutator_annotations.get(None, None)
     explicit_earliest_mutator = mutator_annotations.get(earliest_version, None)
-    if (implicit_earliest_mutator is not None
-        and explicit_earliest_mutator is not None):
+    if (
+        implicit_earliest_mutator is not None
+        and explicit_earliest_mutator is not None
+    ):
         raise ValueError(
             error_prefix + " Both implicit and explicit mutator definitions "
-            "found for earliest version %s." % earliest_version)
+            "found for earliest version %s." % earliest_version
+        )
     earliest_mutator = implicit_earliest_mutator or explicit_earliest_mutator
     if earliest_mutator is not None:
-        stack[0].object['mutator_annotations'] = earliest_mutator
+        stack[0].object["mutator_annotations"] = earliest_mutator
 
     # Make sure there is at most one accessor for the earliest version.
     # If there is one, move it from the accessor-specific dictionary to
     # the normal tag stack.
     implicit_earliest_accessor = accessor_annotations.get(None, None)
     explicit_earliest_accessor = accessor_annotations.get(
-        earliest_version, None)
-    if (implicit_earliest_accessor is not None
-        and explicit_earliest_accessor is not None):
+        earliest_version, None
+    )
+    if (
+        implicit_earliest_accessor is not None
+        and explicit_earliest_accessor is not None
+    ):
         raise ValueError(
             error_prefix + " Both implicit and explicit accessor definitions "
-            "found for earliest version %s." % earliest_version)
+            "found for earliest version %s." % earliest_version
+        )
     earliest_accessor = (
-        implicit_earliest_accessor or explicit_earliest_accessor)
+        implicit_earliest_accessor or explicit_earliest_accessor
+    )
     if earliest_accessor is not None:
-        stack[0].object['accessor_annotations'] = earliest_accessor
+        stack[0].object["accessor_annotations"] = earliest_accessor
 
     # Fill out the stack so that there is one set of tags for each
     # version.
     versioned_dict.normalize_for_versions(
-        versions, dict(exported=False), error_prefix)
+        versions, dict(exported=False), error_prefix
+    )
 
     # Make sure that a mutator defined in version N is inherited in
     # version N+1.
     most_recent_mutator_tags = earliest_mutator
     for version in versions[1:]:
         most_recent_mutator_tags = mutator_annotations.get(
-            version, most_recent_mutator_tags)
+            version, most_recent_mutator_tags
+        )
         # Install a (possibly inherited) mutator for this field in
         # this version.
         if most_recent_mutator_tags is not None:
             tags_for_version = versioned_dict.dict_for_name(version)
-            tags_for_version['mutator_annotations'] = copy.deepcopy(
-                most_recent_mutator_tags)
+            tags_for_version["mutator_annotations"] = copy.deepcopy(
+                most_recent_mutator_tags
+            )
 
     # Make sure that a accessor defined in version N is inherited in
     # version N+1.
     most_recent_accessor_tags = earliest_accessor
     for version in versions[1:]:
         most_recent_accessor_tags = accessor_annotations.get(
-            version, most_recent_accessor_tags)
+            version, most_recent_accessor_tags
+        )
         # Install a (possibly inherited) accessor for this field in
         # this version.
         if most_recent_accessor_tags is not None:
             tags_for_version = versioned_dict.dict_for_name(version)
-            tags_for_version['accessor_annotations'] = copy.deepcopy(
-                most_recent_accessor_tags)
+            tags_for_version["accessor_annotations"] = copy.deepcopy(
+                most_recent_accessor_tags
+            )
 
     return field
 
@@ -1839,12 +2036,13 @@ def _enforce_explicit_version(versioned_dict, error_prefix):
         return
 
     for version, annotations in versioned_dict.stack:
-        if annotations.get('exported', False):
-            if not annotations.get('_as_of_was_used', False):
+        if annotations.get("exported", False):
+            if not annotations.get("_as_of_was_used", False):
                 raise ValueError(
                     error_prefix + "Exported in version %s, but not"
                     " by using as_of. The service configuration"
-                    " requires that you use as_of." % version)
+                    " requires that you use as_of." % version
+                )
             break
 
 
diff --git a/src/lazr/restful/directives/__init__.py b/src/lazr/restful/directives/__init__.py
index c695ea7..4db78d1 100644
--- a/src/lazr/restful/directives/__init__.py
+++ b/src/lazr/restful/directives/__init__.py
@@ -5,9 +5,10 @@
 from __future__ import absolute_import, print_function
 
 __metaclass__ = type
-__all__ = ['request_class',
-           'publication_class',
-           'settings',
+__all__ = [
+    "request_class",
+    "publication_class",
+    "settings",
 ]
 
 import martian
@@ -18,13 +19,21 @@ from zope.traversing.browser import AbsoluteURL
 from zope.traversing.browser.interfaces import IAbsoluteURL
 
 from lazr.restful.interfaces import (
-    IServiceRootResource, IWebServiceClientRequest, IWebServiceConfiguration,
-    IWebServiceLayer)
+    IServiceRootResource,
+    IWebServiceClientRequest,
+    IWebServiceConfiguration,
+    IWebServiceLayer,
+)
 from lazr.restful._resource import (
-    register_versioned_request_utility, ServiceRootResource)
+    register_versioned_request_utility,
+    ServiceRootResource,
+)
 from lazr.restful.simple import (
-    BaseWebServiceConfiguration, Publication, Request,
-    RootResourceAbsoluteURL)
+    BaseWebServiceConfiguration,
+    Publication,
+    Request,
+    RootResourceAbsoluteURL,
+)
 from lazr.restful.utils import make_identifier_safe
 
 
@@ -33,6 +42,7 @@ class request_class(martian.Directive):
 
     The default is lazr.restful.simple.Request.
     """
+
     scope = martian.CLASS
     store = martian.ONCE
     default = Request
@@ -43,6 +53,7 @@ class publication_class(martian.Directive):
 
     The default is lazr.restful.simple.Publication.
     """
+
     scope = martian.CLASS
     store = martian.ONCE
     default = Publication
@@ -69,15 +80,16 @@ class ConfigurationGrokker(martian.ClassGrokker):
     version defined in the configuration, and registers each as an
     IWebServiceVersion utility.
     """
+
     martian.component(BaseWebServiceConfiguration)
     martian.directive(request_class)
     martian.directive(publication_class)
 
-    def execute(self, cls, config, request_class,
-                publication_class, *kw):
+    def execute(self, cls, config, request_class, publication_class, *kw):
         # If implementations of the IWebServiceConfiguration methods are
         # missing, create them from the declarations.
-        if not getattr(cls, 'createRequest', None):
+        if not getattr(cls, "createRequest", None):
+
             def createRequest(self, body_instream, environ):
                 """See `IWebServiceConfiguration`."""
                 request = request_class(body_instream, environ)
@@ -88,11 +100,14 @@ class ConfigurationGrokker(martian.ClassGrokker):
                 # WebServiceRequestTraversal._removeVirtualHostTraversals().
                 request.setPublication(publication_class(None))
                 return request
+
             cls.createRequest = createRequest
 
-        if not getattr(cls, 'get_request_user', None):
+        if not getattr(cls, "get_request_user", None):
+
             def get_request_user(self):
                 return None
+
             cls.get_request_user = get_request_user
 
         # Register as utility.
@@ -102,10 +117,10 @@ class ConfigurationGrokker(martian.ClassGrokker):
 
         # Create and register marker interfaces for request objects.
         superclass = IWebServiceClientRequest
-        for version in (utility.active_versions):
+        for version in utility.active_versions:
             name_part = make_identifier_safe(version)
-            if not name_part.startswith('_'):
-                name_part = '_' + name_part
+            if not name_part.startswith("_"):
+                name_part = "_" + name_part
             classname = "IWebServiceClientRequestVersion" + name_part
             marker_interface = InterfaceClass(classname, (superclass,), {})
             register_versioned_request_utility(marker_interface, version)
@@ -115,6 +130,7 @@ class ConfigurationGrokker(martian.ClassGrokker):
 
 class ServiceRootGrokker(martian.ClassGrokker):
     """Registers your service root as a singleton object."""
+
     martian.component(ServiceRootResource)
 
     def execute(self, cls, config, *kw):
@@ -128,6 +144,7 @@ class RootResourceAbsoluteURLGrokker(martian.ClassGrokker):
     In most cases you can simply create an empty subclass of
     RootResourceAbsoluteURL.
     """
+
     martian.component(RootResourceAbsoluteURL)
 
     def execute(self, cls, config, *kw):
@@ -140,6 +157,7 @@ class location_interface(martian.Directive):
 
     The default is zope.location.interfaces.ILocation
     """
+
     scope = martian.CLASS
     store = martian.ONCE
     default = ILocation
@@ -151,10 +169,12 @@ class AbsoluteURLGrokker(martian.ClassGrokker):
     In most cases you can simply create an empty subclass of
     AbsoluteURL.
     """
+
     martian.component(AbsoluteURL)
     martian.directive(location_interface)
 
     def execute(self, cls, config, location_interface, *kw):
         getSiteManager().registerAdapter(
-            cls, (location_interface, IWebServiceLayer), IAbsoluteURL)
+            cls, (location_interface, IWebServiceLayer), IAbsoluteURL
+        )
         return True
diff --git a/src/lazr/restful/docs/conf.py b/src/lazr/restful/docs/conf.py
index 5a5b367..bd3dea3 100644
--- a/src/lazr/restful/docs/conf.py
+++ b/src/lazr/restful/docs/conf.py
@@ -35,21 +35,21 @@ from lazr.restful 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.restful'
-copyright = u'2004-2019, Canonical Ltd.'
-author = u'LAZR Developers <[e-mail]>'
+project = u"lazr.restful"
+copyright = u"2004-2019, 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
@@ -70,10 +70,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
@@ -84,7 +84,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
@@ -103,9 +103,9 @@ html_static_path = []
 # 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",
     ]
 }
 
@@ -113,7 +113,7 @@ html_sidebars = {
 # -- Options for HTMLHelp output ------------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'lazrrestfuldoc'
+htmlhelp_basename = "lazrrestfuldoc"
 
 
 # -- Options for LaTeX output ---------------------------------------------
@@ -122,15 +122,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',
@@ -140,8 +137,13 @@ latex_elements = {
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, 'lazrrestful.tex', u'lazr.restful Documentation',
-     u'LAZR Developers \\textless{}[e-mail]\\textgreater{}', 'manual'),
+    (
+        master_doc,
+        "lazrrestful.tex",
+        u"lazr.restful Documentation",
+        u"LAZR Developers \\textless{}[e-mail]\\textgreater{}",  # noqa: E501
+        "manual",
+    ),
 ]
 
 
@@ -150,8 +152,7 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    (master_doc, 'lazrrestful', u'lazr.restful Documentation',
-     [author], 1)
+    (master_doc, "lazrrestful", u"lazr.restful Documentation", [author], 1)
 ]
 
 
@@ -161,7 +162,13 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (master_doc, 'lazrrestful', u'lazr.restful Documentation',
-     author, 'lazrrestful', 'One line description of project.',
-     'Miscellaneous'),
+    (
+        master_doc,
+        "lazrrestful",
+        u"lazr.restful Documentation",
+        author,
+        "lazrrestful",
+        "One line description of project.",
+        "Miscellaneous",
+    ),
 ]
diff --git a/src/lazr/restful/error.py b/src/lazr/restful/error.py
index 389c2b8..86cef16 100644
--- a/src/lazr/restful/error.py
+++ b/src/lazr/restful/error.py
@@ -6,14 +6,14 @@ from __future__ import absolute_import, division, print_function
 
 __metaclass__ = type
 __all__ = [
-    'ClientErrorView',
-    'expose',
-    'NotFoundView',
-    'RequestExpiredView',
-    'SystemErrorView',
-    'UnauthorizedView',
-    'WebServiceExceptionView',
-    ]
+    "ClientErrorView",
+    "expose",
+    "NotFoundView",
+    "RequestExpiredView",
+    "SystemErrorView",
+    "UnauthorizedView",
+    "WebServiceExceptionView",
+]
 
 import traceback
 
@@ -28,16 +28,18 @@ except ImportError:
     from zope.interface import Interface
 
     class ISystemErrorView(Interface):
-        """Error views that can classify their contexts as system errors
-        """
+        """Error views that can classify their contexts as system errors"""
 
         def isSystemError():
-            """Return a boolean indicating whether the error is a system error"""
+            """
+            Return a boolean indicating whether the error is a system error
+            """
+
 
 from lazr.restful.interfaces import (
     IWebServiceConfiguration,
     IWebServiceExceptionView,
-    )
+)
 
 
 @implementer(IWebServiceExceptionView)
@@ -55,7 +57,7 @@ class WebServiceExceptionView:
         By default, use the __lazr_webservice_error__ attribute on
         the exception.
         """
-        return getattr(self.context, '__lazr_webservice_error__', 500)
+        return getattr(self.context, "__lazr_webservice_error__", 500)
 
     def isSystemError(self):
         """See `ISystemErrorView`."""
@@ -65,14 +67,13 @@ class WebServiceExceptionView:
         """Generate the HTTP response describing the exception."""
         response = self.request.response
         response.setStatus(self.status)
-        response.setHeader('Content-Type', 'text/plain')
-        if getattr(self.request, 'oopsid', None) is not None:
-            response.setHeader('X-Lazr-OopsId', self.request.oopsid)
+        response.setHeader("Content-Type", "text/plain")
+        if getattr(self.request, "oopsid", None) is not None:
+            response.setHeader("X-Lazr-OopsId", self.request.oopsid)
 
-        show_tracebacks = getUtility(
-            IWebServiceConfiguration).show_tracebacks
+        show_tracebacks = getUtility(IWebServiceConfiguration).show_tracebacks
         server_error = self.status // 100 == 5
-        if (not show_tracebacks and server_error):
+        if not show_tracebacks and server_error:
             # Don't show the exception message; it might contain
             # private information.
             result = [self.context.__class__.__name__]
@@ -81,10 +82,10 @@ class WebServiceExceptionView:
             result = [str(self.context)]
 
         if show_tracebacks and server_error:
-            result.append('\n\n')
+            result.append("\n\n")
             result.append(traceback.format_exc())
 
-        return ''.join(result)
+        return "".join(result)
 
 
 # lazr/restful/configure.zcml registers these classes as adapter
@@ -123,15 +124,18 @@ class RequestExpiredView(WebServiceExceptionView):
 
 
 def expose(exception, status=400):
-    """Tell lazr.restful to deliver details about the exception to the client.
+    """
+    Tell lazr.restful to deliver details about the exception to the client.
     """
     # Since Python lets us raise exception types without instantiating them
     # (like "raise RuntimeError" instead of "raise RuntimeError()", we want to
     # make sure the caller doesn't get confused and try that with us.
     if not isinstance(exception, BaseException):
-        raise ValueError('This function only accepts exception instances. '
-                         'Use the @error_status decorator to publish an '
-                         'exception class as a web service error.')
+        raise ValueError(
+            "This function only accepts exception instances. "
+            "Use the @error_status decorator to publish an "
+            "exception class as a web service error."
+        )
 
     exception.__lazr_webservice_error__ = status
 
diff --git a/src/lazr/restful/example/base/filemanager.py b/src/lazr/restful/example/base/filemanager.py
index 8e03049..fccb0fc 100644
--- a/src/lazr/restful/example/base/filemanager.py
+++ b/src/lazr/restful/example/base/filemanager.py
@@ -5,16 +5,18 @@
 from __future__ import absolute_import, print_function
 
 __metaclass__ = type
-__all__ = ['FileManager',
-           'ManagedFileResource']
+__all__ = ["FileManager", "ManagedFileResource"]
 
 import datetime
+
 # Import SHA in a way compatible with both Python 2.4 and Python 2.6.
 try:
     import hashlib
+
     sha_constructor = hashlib.sha1
 except ImportError:
     import sha
+
     sha_constructor = sha.new
 
 from zope.interface import implementer
@@ -28,7 +30,6 @@ from lazr.restful.utils import get_current_web_service_request
 
 @implementer(IFileManager)
 class FileManager:
-
     def __init__(self):
         """Initialize with an empty list of files."""
         self.files = {}
@@ -43,7 +44,8 @@ class FileManager:
         id = str(self.counter)
         self.counter += 1
         self.files[id] = ManagedFileResource(
-            representation, mediaType, filename, datetime.datetime.now())
+            representation, mediaType, filename, datetime.datetime.now()
+        )
         return id
 
     def delete(self, key):
@@ -56,7 +58,6 @@ grokcore.component.global_utility(FileManager)
 
 
 class ManagedFileResource(ReadOnlyResource):
-
     def __init__(self, representation, mediaType, filename, last_modified):
         """Initialize with a file to be managed."""
         self.representation = representation
@@ -73,16 +74,15 @@ class ManagedFileResource(ReadOnlyResource):
         response = request.response
 
         # Handle a conditional request
-        incoming_etag = request.getHeader('If-None-Match')
+        incoming_etag = request.getHeader("If-None-Match")
         if incoming_etag == self.etag:
             response.setStatus(304)
             return
 
         response.setHeader("Content-Type", self.mediaType)
-        response.setHeader(
-           "Last-Modified", self.last_modified.isoformat())
+        response.setHeader("Last-Modified", self.last_modified.isoformat())
         response.setHeader("ETag", self.etag)
         response.setHeader(
-            "Content-Disposition",
-            'attachment; filename="%s"' % self.filename)
+            "Content-Disposition", 'attachment; filename="%s"' % self.filename
+        )
         return self.representation
diff --git a/src/lazr/restful/example/base/interfaces.py b/src/lazr/restful/example/base/interfaces.py
index afd6b34..b6d7d85 100644
--- a/src/lazr/restful/example/base/interfaces.py
+++ b/src/lazr/restful/example/base/interfaces.py
@@ -6,19 +6,21 @@
 from __future__ import absolute_import, print_function
 
 __metaclass__ = type
-__all__ = ['AlreadyNew',
-           'Cuisine',
-           'ICookbook',
-           'ICookbookSet',
-           'ICookbookSubclass',
-           'IDish',
-           'IDishSet',
-           'IFileManager',
-           'IHasGet',
-           'IFileManagerBackedByteStorage',
-           'IRecipe',
-           'IRecipeSet',
-           'NameAlreadyTaken']
+__all__ = [
+    "AlreadyNew",
+    "Cuisine",
+    "ICookbook",
+    "ICookbookSet",
+    "ICookbookSubclass",
+    "IDish",
+    "IDishSet",
+    "IFileManager",
+    "IHasGet",
+    "IFileManagerBackedByteStorage",
+    "IRecipe",
+    "IRecipeSet",
+    "NameAlreadyTaken",
+]
 
 from zope.interface import Attribute, Interface
 from zope.schema import Bool, Bytes, Choice, Date, Float, Int, TextLine, Text
@@ -41,16 +43,18 @@ from lazr.restful.declarations import (
     operation_returns_collection_of,
     operation_returns_entry,
     webservice_error,
-    )
+)
 
 
 class AlreadyNew(Exception):
     """A cookbook's name prohibits the cheap 'The New' trick."""
+
     webservice_error(400)
 
 
 class NameAlreadyTaken(Exception):
     """The name given for a cookbook is in use by another cookbook."""
+
     webservice_error(409)
 
 
@@ -76,17 +80,22 @@ class Cuisine(EnumeratedType):
 
 class IHasGet(Interface):
     """A marker interface objects that implement traversal with get()."""
+
     def get(name):
         """Traverse to a contained object."""
 
 
-@exported_as_webservice_entry(plural_name='dishes')
+@exported_as_webservice_entry(plural_name="dishes")
 class IDish(ILocation):
     """A dish, annotated for export to the web service."""
+
     name = exported(TextLine(title=u"Name", required=True))
-    recipes = exported(CollectionField(
+    recipes = exported(
+        CollectionField(
             title=u"Recipes in this cookbook",
-            value_type=Reference(schema=Interface)))
+            value_type=Reference(schema=Interface),
+        )
+    )
 
     def removeRecipe(recipe):
         """Remove one of this dish's recipes."""
@@ -95,16 +104,19 @@ class IDish(ILocation):
 @exported_as_webservice_entry()
 class IRecipe(ILocation):
     """A recipe, annotated for export to the web service."""
+
     id = exported(Int(title=u"Unique ID", required=True))
     dish = exported(Reference(title=u"Dish", schema=IDish))
     cookbook = exported(Reference(title=u"Cookbook", schema=Interface))
-    instructions = exported(Text(title=u"How to prepare the recipe",
-                                 required=True))
-    private = exported(Bool(title=u"Whether the public can see this recipe.",
-                       default=False))
+    instructions = exported(
+        Text(title=u"How to prepare the recipe", required=True)
+    )
+    private = exported(
+        Bool(title=u"Whether the public can see this recipe.", default=False)
+    )
     prepared_image = exported(
-        Bytes(0, 5000, title=u"An image of the prepared dish.",
-              readonly=True))
+        Bytes(0, 5000, title=u"An image of the prepared dish.", readonly=True)
+    )
 
     @export_destructor_operation()
     def delete():
@@ -114,41 +126,65 @@ class IRecipe(ILocation):
 @exported_as_webservice_entry()
 class ICookbook(IHasGet, ILocation):
     """A cookbook, annotated for export to the web service."""
+
     name = exported(TextLine(title=u"Name", required=True))
     copyright_date = exported(
-        Date(title=u"Copyright Date",
-             description=u"The copyright date for this work."), readonly=True)
+        Date(
+            title=u"Copyright Date",
+            description=u"The copyright date for this work.",
+        ),
+        readonly=True,
+    )
     description = exported(
-        WhitespaceStrippingTextLine(title=u"Description", required=False))
+        WhitespaceStrippingTextLine(title=u"Description", required=False)
+    )
     revision_number = exported(
-        Int(title=u"A record of the number of times "
-                   "this cookbook has been modified."))
-    confirmed = exported(Bool(
-        title=u"Whether this information has been confirmed",
-        default=False))
-    cuisine = exported(Choice(
-        vocabulary=Cuisine, title=u"Cuisine", required=False, default=None))
+        Int(
+            title=u"A record of the number of times "
+            "this cookbook has been modified."
+        )
+    )
+    confirmed = exported(
+        Bool(
+            title=u"Whether this information has been confirmed", default=False
+        )
+    )
+    cuisine = exported(
+        Choice(
+            vocabulary=Cuisine, title=u"Cuisine", required=False, default=None
+        )
+    )
     last_printing = exported(
-        Date(title=u"Last printing",
-             description=u"The date of this work's most recent printing."))
+        Date(
+            title=u"Last printing",
+            description=u"The date of this work's most recent printing.",
+        )
+    )
     # Don't try this at home! Float is a bad choice for a 'price'
     # field because it's imprecise. Decimal is a better choice. But
     # this is just an example and we need a Float field, so...
     price = exported(Float(title=u"Retail price of the cookbook"))
-    recipes = exported(CollectionField(title=u"Recipes in this cookbook",
-                                       value_type=Reference(schema=IRecipe)))
+    recipes = exported(
+        CollectionField(
+            title=u"Recipes in this cookbook",
+            value_type=Reference(schema=IRecipe),
+        )
+    )
     cover = exported(
-        Bytes(0, 5000, title=u"An image of the cookbook's cover."))
+        Bytes(0, 5000, title=u"An image of the cookbook's cover.")
+    )
 
     @operation_parameters(
-        search=TextLine(title=u"String to search for in recipe name."))
+        search=TextLine(title=u"String to search for in recipe name.")
+    )
     @operation_returns_collection_of(IRecipe)
     @export_read_operation()
     def find_recipes(search):
         """Search for recipes in this cookbook."""
 
     @operation_parameters(
-        dish=Reference(title=u"Dish to search for.", schema=IDish))
+        dish=Reference(title=u"Dish to search for.", schema=IDish)
+    )
     @operation_returns_entry(IRecipe)
     @export_read_operation()
     def find_recipe_for(dish):
@@ -168,8 +204,8 @@ class ICookbook(IHasGet, ILocation):
 
 
 # Resolve dangling references
-IDish['recipes'].value_type.schema = IRecipe
-IRecipe['cookbook'].schema = ICookbook
+IDish["recipes"].value_type.schema = IRecipe
+IRecipe["cookbook"].schema = ICookbook
 
 
 @exported_as_webservice_entry()
@@ -196,26 +232,41 @@ class ICookbookSet(IHasGet):
 
     @operation_parameters(
         search=TextLine(title=u"String to search for in recipe name."),
-        vegetarian=Bool(title=u"Whether or not to limit the search to "
-                        "vegetarian cookbooks.", default=False))
+        vegetarian=Bool(
+            title=u"Whether or not to limit the search to "
+            "vegetarian cookbooks.",
+            default=False,
+        ),
+    )
     @operation_returns_collection_of(IRecipe)
     @export_read_operation()
     def find_recipes(search, vegetarian):
         """Search for recipes across cookbooks."""
 
     @operation_parameters(
-        cuisine=Choice(vocabulary=Cuisine,
-                       title=u"Cuisine to search for in recipe name."))
+        cuisine=Choice(
+            vocabulary=Cuisine, title=u"Cuisine to search for in recipe name."
+        )
+    )
     @operation_returns_collection_of(ICookbook)
     @export_read_operation()
     def find_for_cuisine(cuisine):
         """Search for cookbooks of a given cuisine."""
 
     @export_factory_operation(
-        ICookbook, ['name', 'description', 'cuisine', 'copyright_date',
-                    'last_printing', 'price'])
-    def create(name, description, cuisine, copyright_date, last_printing,
-               price):
+        ICookbook,
+        [
+            "name",
+            "description",
+            "cuisine",
+            "copyright_date",
+            "last_printing",
+            "price",
+        ],
+    )
+    def create(
+        name, description, cuisine, copyright_date, last_printing, price
+    ):
         """Create a new cookbook."""
 
     featured = Attribute("The currently featured cookbook.")
@@ -239,7 +290,8 @@ class IRecipeSet(IHasGet):
         """Return the list of recipes."""
 
     @export_factory_operation(
-        IRecipe, ['id', 'cookbook', 'dish', 'instructions', 'private'])
+        IRecipe, ["id", "cookbook", "dish", "instructions", "private"]
+    )
     def createRecipe(id, cookbook, dish, instructions, private=False):
         """Create a new recipe."""
 
diff --git a/src/lazr/restful/example/base/root.py b/src/lazr/restful/example/base/root.py
index 197d5df..424c971 100644
--- a/src/lazr/restful/example/base/root.py
+++ b/src/lazr/restful/example/base/root.py
@@ -5,11 +5,13 @@
 from __future__ import absolute_import, print_function
 
 __metaclass__ = type
-__all__ = ['Cookbook',
-           'CookbookServiceRootResource',
-           'CookbookSet',
-           'CookbookWebServiceObject',
-           'WebServiceConfiguration']
+__all__ = [
+    "Cookbook",
+    "CookbookServiceRootResource",
+    "CookbookSet",
+    "CookbookWebServiceObject",
+    "WebServiceConfiguration",
+]
 
 from datetime import date
 
@@ -24,11 +26,25 @@ from zope.security.proxy import removeSecurityProxy
 from lazr.restful import directives, ServiceRootResource
 
 from lazr.restful.interfaces import (
-    IByteStorage, IEntry, IServiceRootResource, ITopLevelEntryLink,
-    IWebServiceConfiguration)
+    IByteStorage,
+    IEntry,
+    IServiceRootResource,
+    ITopLevelEntryLink,
+    IWebServiceConfiguration,
+)
 from lazr.restful.example.base.interfaces import (
-    AlreadyNew, Cuisine, ICookbook, ICookbookSet, IDish, IDishSet,
-    IFileManager, IRecipe, IRecipeSet, IHasGet, NameAlreadyTaken)
+    AlreadyNew,
+    Cuisine,
+    ICookbook,
+    ICookbookSet,
+    IDish,
+    IDishSet,
+    IFileManager,
+    IRecipe,
+    IRecipeSet,
+    IHasGet,
+    NameAlreadyTaken,
+)
 from lazr.restful.simple import BaseWebServiceConfiguration
 from lazr.restful.testing.webservice import WebServiceTestPublication
 from lazr.restful.utils import get_current_web_service_request
@@ -40,17 +56,18 @@ class CookbookWebServiceObject:
 
 
 @implementer(IByteStorage, ILocation)
-class SimpleByteStorage(CookbookWebServiceObject,
-                        grokcore.component.MultiAdapter):
+class SimpleByteStorage(
+    CookbookWebServiceObject, grokcore.component.MultiAdapter
+):
     """A simple IByteStorage implementation"""
+
     grokcore.component.adapts(IEntry, IBytes)
     grokcore.component.provides(IByteStorage)
 
     def __init__(self, entry, field):
         self.entry = entry
         self.field = field
-        self.is_stored = getattr(
-            self.entry, field.__name__, None) is not None
+        self.is_stored = getattr(self.entry, field.__name__, None) is not None
         if self.is_stored:
             self.filename = getattr(self.entry, field.__name__).filename
             self.id = getattr(self.entry, field.__name__).id
@@ -72,16 +89,18 @@ class SimpleByteStorage(CookbookWebServiceObject,
         implementation, and 2) the ByteStorage implementation cannot
         change between versions.
         """
-        return 'http://cookbooks.dev/%s/filemanager/%s' % (
+        return "http://cookbooks.dev/%s/filemanager/%s" % (
             getUtility(IWebServiceConfiguration).active_versions[-1],
-            self.id)
+            self.id,
+        )
 
     def createStored(self, mediaType, representation, filename=None):
         self.representation = representation
         if filename is None:
             filename = self.field.__name__
         self.id = getUtility(IFileManager).put(
-            mediaType, representation, filename)
+            mediaType, representation, filename
+        )
         self.filename = filename
         setattr(self.entry, self.field.__name__, self)
 
@@ -93,8 +112,17 @@ class SimpleByteStorage(CookbookWebServiceObject,
 @implementer(ICookbook)
 class Cookbook(CookbookWebServiceObject):
     """An object representing a cookbook"""
-    def __init__(self, name, description, cuisine, copyright_date,
-                 last_printing=None, price=0, confirmed=False):
+
+    def __init__(
+        self,
+        name,
+        description,
+        cuisine,
+        copyright_date,
+        last_printing=None,
+        price=0,
+        confirmed=False,
+    ):
         self.name = name
         self.cuisine = cuisine
         self.description = description
@@ -116,8 +144,7 @@ class Cookbook(CookbookWebServiceObject):
 
     def get(self, name):
         """See `IHasGet`."""
-        match = [recipe for recipe in self.recipes
-                 if recipe.dish.name == name]
+        match = [recipe for recipe in self.recipes if recipe.dish.name == name]
         if len(match) > 0:
             return match[0]
         return None
@@ -135,7 +162,8 @@ class Cookbook(CookbookWebServiceObject):
         if self.name.find("The New ") == 0:
             raise AlreadyNew(
                 "The 'New' trick can't be used on this cookbook "
-                "because its name already starts with 'The New'.")
+                "because its name already starts with 'The New'."
+            )
         self.name = "The New " + self.name
 
     def find_recipe_for(self, dish):
@@ -151,14 +179,14 @@ class Cookbook(CookbookWebServiceObject):
 
     def replace_cover(self, cover):
         entry = getMultiAdapter(
-            (self, get_current_web_service_request()), IEntry)
-        storage = SimpleByteStorage(entry, ICookbook['cover'])
-        storage.createStored('application/octet-stream', cover, 'cover')
+            (self, get_current_web_service_request()), IEntry
+        )
+        storage = SimpleByteStorage(entry, ICookbook["cover"])
+        storage.createStored("application/octet-stream", cover, "cover")
 
 
 @implementer(IDish)
 class Dish(CookbookWebServiceObject):
-
     def __init__(self, name):
         self.name = name
         self.recipes = []
@@ -177,7 +205,6 @@ class Dish(CookbookWebServiceObject):
 
 @implementer(IRecipe)
 class Recipe(CookbookWebServiceObject):
-
     def __init__(self, id, cookbook, dish, instructions, private=False):
         self.id = id
         self.dish = dish
@@ -202,8 +229,9 @@ class Recipe(CookbookWebServiceObject):
 
 # Top-level objects.
 @implementer(ILocation)
-class CookbookTopLevelObject(CookbookWebServiceObject,
-                             grokcore.component.GlobalUtility):
+class CookbookTopLevelObject(
+    CookbookWebServiceObject, grokcore.component.GlobalUtility
+):
     """An object published at the top level of the web service."""
 
     @property
@@ -218,6 +246,7 @@ class CookbookTopLevelObject(CookbookWebServiceObject,
 @implementer(ITopLevelEntryLink)
 class FeaturedCookbookLink(CookbookTopLevelObject):
     """A link to the currently featured cookbook."""
+
     grokcore.component.provides(ITopLevelEntryLink)
 
     @property
@@ -233,6 +262,7 @@ class FeaturedCookbookLink(CookbookTopLevelObject):
 @implementer(ICookbookSet)
 class CookbookSet(CookbookTopLevelObject):
     """The set of all cookbooks."""
+
     grokcore.component.provides(ICookbookSet)
 
     __name__ = "cookbooks"
@@ -267,14 +297,23 @@ class CookbookSet(CookbookTopLevelObject):
                 cookbooks.append(cookbook)
         return cookbooks
 
-    def create(self, name, description, cuisine, copyright_date,
-               last_printing=None, price=0):
+    def create(
+        self,
+        name,
+        description,
+        cuisine,
+        copyright_date,
+        last_printing=None,
+        price=0,
+    ):
         for cookbook in self.cookbooks:
             if cookbook.name == name:
                 raise NameAlreadyTaken(
-                    'A cookbook called "%s" already exists.' % name)
-        cookbook = Cookbook(name, description, cuisine, copyright_date,
-                            last_printing, price)
+                    'A cookbook called "%s" already exists.' % name
+                )
+        cookbook = Cookbook(
+            name, description, cuisine, copyright_date, last_printing, price
+        )