format source using black

177 files changed, 13381 insertions, 7013 deletions

diff --git a/setup.py b/setup.py
index a49dc6a6a..513369094 100644
--- a/setup.py
+++ b/setup.py
@@ -55,46 +55,47 @@ testing_extras = tests_require + [
     'virtualenv',  # for scaffolding tests
 ]
 
-setup(name='pyramid',
-      version='1.10.dev0',
-      description='The Pyramid Web Framework, a Pylons project',
-      long_description=README + '\n\n' + CHANGES,
-      classifiers=[
-          "Development Status :: 6 - Mature",
-          "Intended Audience :: Developers",
-          "Programming Language :: Python",
-          "Programming Language :: Python :: 2.7",
-          "Programming Language :: Python :: 3",
-          "Programming Language :: Python :: 3.4",
-          "Programming Language :: Python :: 3.5",
-          "Programming Language :: Python :: 3.6",
-          "Programming Language :: Python :: 3.7",
-          "Programming Language :: Python :: Implementation :: CPython",
-          "Programming Language :: Python :: Implementation :: PyPy",
-          "Framework :: Pyramid",
-          "Topic :: Internet :: WWW/HTTP",
-          "Topic :: Internet :: WWW/HTTP :: WSGI",
-          "License :: Repoze Public License",
-      ],
-      keywords='web wsgi pylons pyramid',
-      author="Chris McDonough, Agendaless Consulting",
-      author_email="pylons-discuss@googlegroups.com",
-      url="https://trypyramid.com",
-      license="BSD-derived (http://www.repoze.org/LICENSE.txt)",
-      packages=find_packages('src', exclude=['tests']),
-      package_dir={'': 'src'},
-      include_package_data=True,
-      zip_safe=False,
-      python_requires='>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*',
-      install_requires=install_requires,
-      extras_require={
-          ':python_version<"3.2"': ['repoze.lru >= 0.4'],
-          'testing': testing_extras,
-          'docs': docs_extras,
-      },
-      tests_require=tests_require,
-      test_suite="tests",
-      entry_points="""\
+setup(
+    name='pyramid',
+    version='1.10.dev0',
+    description='The Pyramid Web Framework, a Pylons project',
+    long_description=README + '\n\n' + CHANGES,
+    classifiers=[
+        "Development Status :: 6 - Mature",
+        "Intended Audience :: Developers",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.4",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: Implementation :: CPython",
+        "Programming Language :: Python :: Implementation :: PyPy",
+        "Framework :: Pyramid",
+        "Topic :: Internet :: WWW/HTTP",
+        "Topic :: Internet :: WWW/HTTP :: WSGI",
+        "License :: Repoze Public License",
+    ],
+    keywords='web wsgi pylons pyramid',
+    author="Chris McDonough, Agendaless Consulting",
+    author_email="pylons-discuss@googlegroups.com",
+    url="https://trypyramid.com",
+    license="BSD-derived (http://www.repoze.org/LICENSE.txt)",
+    packages=find_packages('src', exclude=['tests']),
+    package_dir={'': 'src'},
+    include_package_data=True,
+    zip_safe=False,
+    python_requires='>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*',
+    install_requires=install_requires,
+    extras_require={
+        ':python_version<"3.2"': ['repoze.lru >= 0.4'],
+        'testing': testing_extras,
+        'docs': docs_extras,
+    },
+    tests_require=tests_require,
+    test_suite="tests",
+    entry_points="""\
         [pyramid.scaffold]
         starter=pyramid.scaffolds:StarterProjectTemplate
         zodb=pyramid.scaffolds:ZODBProjectTemplate
@@ -113,5 +114,5 @@ setup(name='pyramid',
         [paste.server_runner]
         wsgiref = pyramid.scripts.pserve:wsgiref_server_runner
         cherrypy = pyramid.scripts.pserve:cherrypy_server_runner
-      """
-      )
+      """,
+)
diff --git a/src/pyramid/asset.py b/src/pyramid/asset.py
index 9d7a3ee63..0d7575a85 100644
--- a/src/pyramid/asset.py
+++ b/src/pyramid/asset.py
@@ -3,14 +3,12 @@ import pkg_resources
 
 from pyramid.compat import string_types
 
-from pyramid.path import (
-    package_path,
-    package_name,
-    )
+from pyramid.path import package_path, package_name
+
 
 def resolve_asset_spec(spec, pname='__main__'):
     if pname and not isinstance(pname, string_types):
-        pname = pname.__name__ # as package
+        pname = pname.__name__  # as package
     if os.path.isabs(spec):
         return None, spec
     filename = spec
@@ -20,6 +18,7 @@ def resolve_asset_spec(spec, pname='__main__'):
         pname, filename = None, spec
     return pname, filename
 
+
 def asset_spec_from_abspath(abspath, package):
     """ Try to convert an absolute path to a resource in a package to
     a resource specification if possible; otherwise return the
@@ -28,11 +27,14 @@ def asset_spec_from_abspath(abspath, package):
         return abspath
     pp = package_path(package) + os.path.sep
     if abspath.startswith(pp):
-        relpath = abspath[len(pp):]
-        return '%s:%s' % (package_name(package),
-                          relpath.replace(os.path.sep, '/'))
+        relpath = abspath[len(pp) :]
+        return '%s:%s' % (
+            package_name(package),
+            relpath.replace(os.path.sep, '/'),
+        )
     return abspath
 
+
 # bw compat only; use pyramid.path.AssetResolver().resolve(spec).abspath()
 def abspath_from_asset_spec(spec, pname='__main__'):
     if pname is None:
@@ -41,4 +43,3 @@ def abspath_from_asset_spec(spec, pname='__main__'):
     if pname is None:
         return filename
     return pkg_resources.resource_filename(pname, filename)
-
diff --git a/src/pyramid/authentication.py b/src/pyramid/authentication.py
index a9604e336..f4c2b51ef 100644
--- a/src/pyramid/authentication.py
+++ b/src/pyramid/authentication.py
@@ -21,17 +21,11 @@ from pyramid.compat import (
     bytes_,
     ascii_native_,
     native_,
-    )
+)
 
-from pyramid.interfaces import (
-    IAuthenticationPolicy,
-    IDebugLogger,
-    )
+from pyramid.interfaces import IAuthenticationPolicy, IDebugLogger
 
-from pyramid.security import (
-    Authenticated,
-    Everyone,
-    )
+from pyramid.security import Authenticated, Everyone
 
 from pyramid.util import strings_differ
 from pyramid.util import SimpleSerializer
@@ -74,36 +68,41 @@ class CallbackAuthenticationPolicy(object):
             debug and self._log(
                 'call to unauthenticated_userid returned None; returning None',
                 'authenticated_userid',
-                request)
+                request,
+            )
             return None
         if self._clean_principal(userid) is None:
             debug and self._log(
-                ('use of userid %r is disallowed by any built-in Pyramid '
-                 'security policy, returning None' % userid),
+                (
+                    'use of userid %r is disallowed by any built-in Pyramid '
+                    'security policy, returning None' % userid
+                ),
                 'authenticated_userid',
-                request)
+                request,
+            )
             return None
 
         if self.callback is None:
             debug and self._log(
                 'there was no groupfinder callback; returning %r' % (userid,),
                 'authenticated_userid',
-                request)
+                request,
+            )
             return userid
         callback_ok = self.callback(userid, request)
-        if callback_ok is not None: # is not None!
+        if callback_ok is not None:  # is not None!
             debug and self._log(
-                'groupfinder callback returned %r; returning %r' % (
-                    callback_ok, userid),
+                'groupfinder callback returned %r; returning %r'
+                % (callback_ok, userid),
                 'authenticated_userid',
-                request
-                )
+                request,
+            )
             return userid
         debug and self._log(
             'groupfinder callback returned None; returning None',
             'authenticated_userid',
-            request
-            )
+            request,
+        )
 
     def effective_principals(self, request):
         """ A list of effective principals derived from request.
@@ -134,42 +133,45 @@ class CallbackAuthenticationPolicy(object):
 
         if userid is None:
             debug and self._log(
-                'unauthenticated_userid returned %r; returning %r' % (
-                    userid, effective_principals),
+                'unauthenticated_userid returned %r; returning %r'
+                % (userid, effective_principals),
                 'effective_principals',
-                request
-                )
+                request,
+            )
             return effective_principals
 
         if self._clean_principal(userid) is None:
             debug and self._log(
-                ('unauthenticated_userid returned disallowed %r; returning %r '
-                 'as if it was None' % (userid, effective_principals)),
+                (
+                    'unauthenticated_userid returned disallowed %r; returning %r '
+                    'as if it was None' % (userid, effective_principals)
+                ),
                 'effective_principals',
-                request
-                )
+                request,
+            )
             return effective_principals
 
         if self.callback is None:
             debug and self._log(
                 'groupfinder callback is None, so groups is []',
                 'effective_principals',
-                request)
+                request,
+            )
             groups = []
         else:
             groups = self.callback(userid, request)
             debug and self._log(
                 'groupfinder callback returned %r as groups' % (groups,),
                 'effective_principals',
-                request)
+                request,
+            )
 
-        if groups is None: # is None!
+        if groups is None:  # is None!
             debug and self._log(
-                'returning effective principals: %r' % (
-                    effective_principals,),
+                'returning effective principals: %r' % (effective_principals,),
                 'effective_principals',
-                request
-                )
+                request,
+            )
             return effective_principals
 
         effective_principals.append(Authenticated)
@@ -177,10 +179,9 @@ class CallbackAuthenticationPolicy(object):
         effective_principals.extend(groups)
 
         debug and self._log(
-            'returning effective principals: %r' % (
-                effective_principals,),
+            'returning effective principals: %r' % (effective_principals,),
             'effective_principals',
-            request
+            request,
         )
         return effective_principals
 
@@ -241,7 +242,8 @@ class RepozeWho1AuthenticationPolicy(CallbackAuthenticationPolicy):
             self.debug and self._log(
                 'repoze.who identity is None, returning None',
                 'authenticated_userid',
-                request)
+                request,
+            )
             return None
 
         userid = identity['repoze.who.userid']
@@ -250,21 +252,25 @@ class RepozeWho1AuthenticationPolicy(CallbackAuthenticationPolicy):
             self.debug and self._log(
                 'repoze.who.userid is None, returning None' % userid,
                 'authenticated_userid',
-                request)
+                request,
+            )
             return None
 
         if self._clean_principal(userid) is None:
             self.debug and self._log(
-                ('use of userid %r is disallowed by any built-in Pyramid '
-                 'security policy, returning None' % userid),
+                (
+                    'use of userid %r is disallowed by any built-in Pyramid '
+                    'security policy, returning None' % userid
+                ),
                 'authenticated_userid',
-                request)
+                request,
+            )
             return None
 
         if self.callback is None:
             return userid
 
-        if self.callback(identity, request) is not None: # is not None!
+        if self.callback(identity, request) is not None:  # is not None!
             return userid
 
     def unauthenticated_userid(self, request):
@@ -292,11 +298,13 @@ class RepozeWho1AuthenticationPolicy(CallbackAuthenticationPolicy):
 
         if identity is None:
             self.debug and self._log(
-                ('repoze.who identity was None; returning %r' %
-                 effective_principals),
+                (
+                    'repoze.who identity was None; returning %r'
+                    % effective_principals
+                ),
                 'effective_principals',
-                request
-                )
+                request,
+            )
             return effective_principals
 
         if self.callback is None:
@@ -304,33 +312,39 @@ class RepozeWho1AuthenticationPolicy(CallbackAuthenticationPolicy):
         else:
             groups = self.callback(identity, request)
 
-        if groups is None: # is None!
+        if groups is None:  # is None!
             self.debug and self._log(
-                ('security policy groups callback returned None; returning %r' %
-                 effective_principals),
+                (
+                    'security policy groups callback returned None; returning %r'
+                    % effective_principals
+                ),
                 'effective_principals',
-                request
-                )
+                request,
+            )
             return effective_principals
 
         userid = identity['repoze.who.userid']
 
         if userid is None:
             self.debug and self._log(
-                ('repoze.who.userid was None; returning %r' %
-                 effective_principals),
+                (
+                    'repoze.who.userid was None; returning %r'
+                    % effective_principals
+                ),
                 'effective_principals',
-                request
-                )
+                request,
+            )
             return effective_principals
 
         if self._clean_principal(userid) is None:
             self.debug and self._log(
-                ('unauthenticated_userid returned disallowed %r; returning %r '
-                 'as if it was None' % (userid, effective_principals)),
+                (
+                    'unauthenticated_userid returned disallowed %r; returning %r '
+                    'as if it was None' % (userid, effective_principals)
+                ),
                 'effective_principals',
-                request
-                )
+                request,
+            )
             return effective_principals
 
         effective_principals.append(Authenticated)
@@ -367,6 +381,7 @@ class RepozeWho1AuthenticationPolicy(CallbackAuthenticationPolicy):
         identity = self._get_identity(request)
         return identifier.forget(request.environ, identity)
 
+
 @implementer(IAuthenticationPolicy)
 class RemoteUserAuthenticationPolicy(CallbackAuthenticationPolicy):
     """ A :app:`Pyramid` :term:`authentication policy` which
@@ -419,6 +434,7 @@ class RemoteUserAuthenticationPolicy(CallbackAuthenticationPolicy):
         be done somewhere else or in a subclass."""
         return []
 
+
 @implementer(IAuthenticationPolicy)
 class AuthTktAuthenticationPolicy(CallbackAuthenticationPolicy):
     """A :app:`Pyramid` :term:`authentication policy` which
@@ -586,24 +602,25 @@ class AuthTktAuthenticationPolicy(CallbackAuthenticationPolicy):
 
     """
 
-    def __init__(self,
-                 secret,
-                 callback=None,
-                 cookie_name='auth_tkt',
-                 secure=False,
-                 include_ip=False,
-                 timeout=None,
-                 reissue_time=None,
-                 max_age=None,
-                 path="/",
-                 http_only=False,
-                 wild_domain=True,
-                 debug=False,
-                 hashalg='sha512',
-                 parent_domain=False,
-                 domain=None,
-                 samesite='Lax',
-                 ):
+    def __init__(
+        self,
+        secret,
+        callback=None,
+        cookie_name='auth_tkt',
+        secure=False,
+        include_ip=False,
+        timeout=None,
+        reissue_time=None,
+        max_age=None,
+        path="/",
+        http_only=False,
+        wild_domain=True,
+        debug=False,
+        hashalg='sha512',
+        parent_domain=False,
+        domain=None,
+        samesite='Lax',
+    ):
         self.cookie = AuthTktCookieHelper(
             secret,
             cookie_name=cookie_name,
@@ -619,7 +636,7 @@ class AuthTktAuthenticationPolicy(CallbackAuthenticationPolicy):
             parent_domain=parent_domain,
             domain=domain,
             samesite=samesite,
-            )
+        )
         self.callback = callback
         self.debug = debug
 
@@ -643,12 +660,15 @@ class AuthTktAuthenticationPolicy(CallbackAuthenticationPolicy):
         """ A list of headers which will delete appropriate cookies."""
         return self.cookie.forget(request)
 
+
 def b64encode(v):
     return base64.b64encode(bytes_(v)).strip().replace(b'\n', b'')
 
+
 def b64decode(v):
     return base64.b64decode(bytes_(v))
 
+
 # this class licensed under the MIT license (stolen from Paste)
 class AuthTicket(object):
     """
@@ -670,9 +690,18 @@ class AuthTicket(object):
 
     """
 
-    def __init__(self, secret, userid, ip, tokens=(), user_data='',
-                 time=None, cookie_name='auth_tkt', secure=False,
-                 hashalg='md5'):
+    def __init__(
+        self,
+        secret,
+        userid,
+        ip,
+        tokens=(),
+        user_data='',
+        time=None,
+        cookie_name='auth_tkt',
+        secure=False,
+        hashalg='md5',
+    ):
         self.secret = secret
         self.userid = userid
         self.ip = ip
@@ -688,17 +717,27 @@ class AuthTicket(object):
 
     def digest(self):
         return calculate_digest(
-            self.ip, self.time, self.secret, self.userid, self.tokens,
-            self.user_data, self.hashalg)
+            self.ip,
+            self.time,
+            self.secret,
+            self.userid,
+            self.tokens,
+            self.user_data,
+            self.hashalg,
+        )
 
     def cookie_value(self):
-        v = '%s%08x%s!' % (self.digest(), int(self.time),
-                           url_quote(self.userid))
+        v = '%s%08x%s!' % (
+            self.digest(),
+            int(self.time),
+            url_quote(self.userid),
+        )
         if self.tokens:
             v += self.tokens + '!'
         v += self.user_data
         return v
 
+
 # this class licensed under the MIT license (stolen from Paste)
 class BadTicket(Exception):
     """
@@ -706,10 +745,12 @@ class BadTicket(Exception):
     determine what the expected digest should have been, expected is set.
     This should not be shown by default, but can be useful for debugging.
     """
+
     def __init__(self, msg, expected=None):
         self.expected = expected
         Exception.__init__(self, msg)
 
+
 # this function licensed under the MIT license (stolen from Paste)
 def parse_ticket(secret, ticket, ip, hashalg='md5'):
     """
@@ -722,37 +763,41 @@ def parse_ticket(secret, ticket, ip, hashalg='md5'):
     digest_size = hashlib.new(hashalg).digest_size * 2
     digest = ticket[:digest_size]
     try:
-        timestamp = int(ticket[digest_size:digest_size + 8], 16)
+        timestamp = int(ticket[digest_size : digest_size + 8], 16)
     except ValueError as e:
         raise BadTicket('Timestamp is not a hex integer: %s' % e)
     try:
-        userid, data = ticket[digest_size + 8:].split('!', 1)
+        userid, data = ticket[digest_size + 8 :].split('!', 1)
     except ValueError:
         raise BadTicket('userid is not followed by !')
     userid = url_unquote(userid)
     if '!' in data:
         tokens, user_data = data.split('!', 1)
-    else: # pragma: no cover (never generated)
+    else:  # pragma: no cover (never generated)
         # @@: Is this the right order?
         tokens = ''
         user_data = data
 
-    expected = calculate_digest(ip, timestamp, secret,
-                                userid, tokens, user_data, hashalg)
+    expected = calculate_digest(
+        ip, timestamp, secret, userid, tokens, user_data, hashalg
+    )
 
     # Avoid timing attacks (see
     # http://seb.dbzteam.org/crypto/python-oauth-timing-hmac.pdf)
     if strings_differ(expected, digest):
-        raise BadTicket('Digest signature is not correct',
-                        expected=(expected, digest))
+        raise BadTicket(
+            'Digest signature is not correct', expected=(expected, digest)
+        )
 
     tokens = tokens.split(',')
 
     return (timestamp, userid, tokens, user_data)
 
+
 # this function licensed under the MIT license (stolen from Paste)
-def calculate_digest(ip, timestamp, secret, userid, tokens, user_data,
-                     hashalg='md5'):
+def calculate_digest(
+    ip, timestamp, secret, userid, tokens, user_data, hashalg='md5'
+):
     secret = bytes_(secret, 'utf-8')
     userid = bytes_(userid, 'utf-8')
     tokens = bytes_(tokens, 'utf-8')
@@ -767,24 +812,29 @@ def calculate_digest(ip, timestamp, secret, userid, tokens, user_data,
         # encode_ip_timestamp not required, left in for backwards compatibility
         ip_timestamp = encode_ip_timestamp(ip, timestamp)
 
-    hash_obj.update(ip_timestamp + secret + userid + b'\0' +
-            tokens + b'\0' + user_data)
+    hash_obj.update(
+        ip_timestamp + secret + userid + b'\0' + tokens + b'\0' + user_data
+    )
     digest = hash_obj.hexdigest()
     hash_obj2 = hashlib.new(hashalg)
     hash_obj2.update(bytes_(digest) + secret)
     return hash_obj2.hexdigest()
 
+
 # this function licensed under the MIT license (stolen from Paste)
 def encode_ip_timestamp(ip, timestamp):
     ip_chars = ''.join(map(chr, map(int, ip.split('.'))))
     t = int(timestamp)
-    ts = ((t & 0xff000000) >> 24,
-          (t & 0xff0000) >> 16,
-          (t & 0xff00) >> 8,
-          t & 0xff)
+    ts = (
+        (t & 0xFF000000) >> 24,
+        (t & 0xFF0000) >> 16,
+        (t & 0xFF00) >> 8,
+        t & 0xFF,
+    )
     ts_chars = ''.join(map(chr, ts))
     return bytes_(ip_chars + ts_chars)
 
+
 class AuthTktCookieHelper(object):
     """
     A helper class for use in third-party authentication policy
@@ -792,41 +842,43 @@ class AuthTktCookieHelper(object):
     :class:`pyramid.authentication.AuthTktAuthenticationPolicy` for the
     meanings of the constructor arguments.
     """
-    parse_ticket = staticmethod(parse_ticket) # for tests
-    AuthTicket = AuthTicket # for tests
-    BadTicket = BadTicket # for tests
-    now = None # for tests
+
+    parse_ticket = staticmethod(parse_ticket)  # for tests
+    AuthTicket = AuthTicket  # for tests
+    BadTicket = BadTicket  # for tests
+    now = None  # for tests
 
     userid_type_decoders = {
-        'int':int,
-        'unicode':lambda x: utf_8_decode(x)[0], # bw compat for old cookies
+        'int': int,
+        'unicode': lambda x: utf_8_decode(x)[0],  # bw compat for old cookies
         'b64unicode': lambda x: utf_8_decode(b64decode(x))[0],
         'b64str': lambda x: b64decode(x),
-        }
+    }
 
     userid_type_encoders = {
         int: ('int', str),
         long: ('int', str),
         text_type: ('b64unicode', lambda x: b64encode(utf_8_encode(x)[0])),
         binary_type: ('b64str', lambda x: b64encode(x)),
-        }
-
-    def __init__(self,
-                 secret,
-                 cookie_name='auth_tkt',
-                 secure=False,
-                 include_ip=False,
-                 timeout=None,
-                 reissue_time=None,
-                 max_age=None,
-                 http_only=False,
-                 path="/",
-                 wild_domain=True,
-                 hashalg='md5',
-                 parent_domain=False,
-                 domain=None,
-                 samesite='Lax',
-                 ):
+    }
+
+    def __init__(
+        self,
+        secret,
+        cookie_name='auth_tkt',
+        secure=False,
+        include_ip=False,
+        timeout=None,
+        reissue_time=None,
+        max_age=None,
+        http_only=False,
+        path="/",
+        wild_domain=True,
+        hashalg='md5',
+        parent_domain=False,
+        domain=None,
+        samesite='Lax',
+    ):
 
         serializer = SimpleSerializer()
 
@@ -845,7 +897,9 @@ class AuthTktCookieHelper(object):
         self.secure = secure
         self.include_ip = include_ip
         self.timeout = timeout if timeout is None else int(timeout)
-        self.reissue_time = reissue_time if reissue_time is None else int(reissue_time)
+        self.reissue_time = (
+            reissue_time if reissue_time is None else int(reissue_time)
+        )
         self.max_age = max_age if max_age is None else int(max_age)
         self.wild_domain = wild_domain
         self.parent_domain = parent_domain
@@ -893,16 +947,17 @@ class AuthTktCookieHelper(object):
 
         try:
             timestamp, userid, tokens, user_data = self.parse_ticket(
-                self.secret, cookie, remote_addr, self.hashalg)
+                self.secret, cookie, remote_addr, self.hashalg
+            )
         except self.BadTicket:
             return None
 
-        now = self.now # service tests
+        now = self.now  # service tests
 
         if now is None:
             now = time_mod.time()
 
-        if self.timeout and ( (timestamp + self.timeout) < now ):
+        if self.timeout and ((timestamp + self.timeout) < now):
             # the auth_tkt data has expired
             return None
 
@@ -910,7 +965,7 @@ class AuthTktCookieHelper(object):
         user_data_info = user_data.split('|')
         for datum in filter(None, user_data_info):
             if datum.startswith(userid_typename):
-                userid_type = datum[len(userid_typename):]
+                userid_type = datum[len(userid_typename) :]
                 decoder = self.userid_type_decoders.get(userid_type)
                 if decoder:
                     userid = decoder(userid)
@@ -918,15 +973,18 @@ class AuthTktCookieHelper(object):
         reissue = self.reissue_time is not None
 
         if reissue and not hasattr(request, '_authtkt_reissued'):
-            if ( (now - timestamp) > self.reissue_time ):
+            if (now - timestamp) > self.reissue_time:
                 # See https://github.com/Pylons/pyramid/issues#issue/108
                 tokens = list(filter(None, tokens))
-                headers = self.remember(request, userid, max_age=self.max_age,
-                                        tokens=tokens)
+                headers = self.remember(
+                    request, userid, max_age=self.max_age, tokens=tokens
+                )
+
                 def reissue_authtkt(request, response):
                     if not hasattr(request, '_authtkt_reissue_revoked'):
                         for k, v in headers:
                             response.headerlist.append((k, v))
+
                 request.add_response_callback(reissue_authtkt)
                 request._authtkt_reissued = True
 
@@ -987,7 +1045,8 @@ class AuthTktCookieHelper(object):
                 "AuthTktAuthenticationPolicy. Explicitly converting to string "
                 "and storing as base64. Subsequent requests will receive a "
                 "string as the userid, it will not be decoded back to the type "
-                "provided.".format(type(userid)), RuntimeWarning
+                "provided.".format(type(userid)),
+                RuntimeWarning,
             )
             encoding, encoder = self.userid_type_encoders.get(text_type)
             userid = str(userid)
@@ -1018,12 +1077,13 @@ class AuthTktCookieHelper(object):
             user_data=user_data,
             cookie_name=self.cookie_name,
             secure=self.secure,
-            hashalg=self.hashalg
-            )
+            hashalg=self.hashalg,
+        )
 
         cookie_value = ticket.cookie_value()
         return self._get_cookies(request, cookie_value, max_age)
 
+
 @implementer(IAuthenticationPolicy)
 class SessionAuthenticationPolicy(CallbackAuthenticationPolicy):
     """ A :app:`Pyramid` authentication policy which gets its data from the
@@ -1123,6 +1183,7 @@ class BasicAuthAuthenticationPolicy(CallbackAuthenticationPolicy):
                 return response
             return HTTPForbidden()
     """
+
     def __init__(self, check, realm='Realm', debug=False):
         self.check = check
         self.realm = realm
@@ -1158,7 +1219,8 @@ class BasicAuthAuthenticationPolicy(CallbackAuthenticationPolicy):
 
 
 HTTPBasicCredentials = namedtuple(
-    'HTTPBasicCredentials', ['username', 'password'])
+    'HTTPBasicCredentials', ['username', 'password']
+)
 
 
 def extract_http_basic_credentials(request):
@@ -1183,7 +1245,7 @@ def extract_http_basic_credentials(request):
 
     try:
         authbytes = b64decode(auth.strip())
-    except (TypeError, binascii.Error): # can't decode
+    except (TypeError, binascii.Error):  # can't decode
         return None
 
     # try utf-8 first, then latin-1; see discussion in
@@ -1195,7 +1257,7 @@ def extract_http_basic_credentials(request):
 
     try:
         username, password = auth.split(':', 1)
-    except ValueError: # not enough values to unpack
+    except ValueError:  # not enough values to unpack
         return None
 
     return HTTPBasicCredentials(username, password)
diff --git a/src/pyramid/authorization.py b/src/pyramid/authorization.py
index 4845762ef..974748765 100644
--- a/src/pyramid/authorization.py
+++ b/src/pyramid/authorization.py
@@ -6,13 +6,8 @@ from pyramid.location import lineage
 
 from pyramid.compat import is_nonstr_iter
 
-from pyramid.security import (
-    ACLAllowed,
-    ACLDenied,
-    Allow,
-    Deny,
-    Everyone,
-    )
+from pyramid.security import ACLAllowed, ACLDenied, Allow, Deny, Everyone
+
 
 @implementer(IAuthorizationPolicy)
 class ACLAuthorizationPolicy(object):
@@ -90,20 +85,19 @@ class ACLAuthorizationPolicy(object):
                         ace_permissions = [ace_permissions]
                     if permission in ace_permissions:
                         if ace_action == Allow:
-                            return ACLAllowed(ace, acl, permission,
-                                              principals, location)
+                            return ACLAllowed(
+                                ace, acl, permission, principals, location
+                            )
                         else:
-                            return ACLDenied(ace, acl, permission,
-                                             principals, location)
+                            return ACLDenied(
+                                ace, acl, permission, principals, location
+                            )
 
         # default deny (if no ACL in lineage at all, or if none of the
         # principals were mentioned in any ACE we found)
         return ACLDenied(
-            '<default deny>',
-            acl,
-            permission,
-            principals,
-            context)
+            '<default deny>', acl, permission, principals, context
+        )
 
     def principals_allowed_by_permission(self, context, permission):
         """ Return the set of principals explicitly granted the
@@ -132,14 +126,14 @@ class ACLAuthorizationPolicy(object):
                     if ace_principal not in denied_here:
                         allowed_here.add(ace_principal)
                 if (ace_action == Deny) and (permission in ace_permissions):
-                        denied_here.add(ace_principal)
-                        if ace_principal == Everyone:
-                            # clear the entire allowed set, as we've hit a
-                            # deny of Everyone ala (Deny, Everyone, ALL)
-                            allowed = set()
-                            break
-                        elif ace_principal in allowed:
-                            allowed.remove(ace_principal)
+                    denied_here.add(ace_principal)
+                    if ace_principal == Everyone:
+                        # clear the entire allowed set, as we've hit a
+                        # deny of Everyone ala (Deny, Everyone, ALL)
+                        allowed = set()
+                        break
+                    elif ace_principal in allowed:
+                        allowed.remove(ace_principal)
 
             allowed.update(allowed_here)
 
diff --git a/src/pyramid/compat.py b/src/pyramid/compat.py
index a7f9c1287..4df279e94 100644
--- a/src/pyramid/compat.py
+++ b/src/pyramid/compat.py
@@ -7,6 +7,7 @@ WIN = platform.system() == 'Windows'
 
 try:  # pragma: no cover
     import __pypy__
+
     PYPY = True
 except:  # pragma: no cover
     __pypy__ = None
@@ -27,20 +28,21 @@ PY2 = sys.version_info[0] == 2
 PY3 = sys.version_info[0] == 3
 
 if PY2:
-    string_types = basestring,
+    string_types = (basestring,)
     integer_types = (int, long)
     class_types = (type, types.ClassType)
     text_type = unicode
     binary_type = str
     long = long
 else:
-    string_types = str,
-    integer_types = int,
-    class_types = type,
+    string_types = (str,)
+    integer_types = (int,)
+    class_types = (type,)
     text_type = str
     binary_type = bytes
     long = int
 
+
 def text_(s, encoding='latin-1', errors='strict'):
     """ If ``s`` is an instance of ``binary_type``, return
     ``s.decode(encoding, errors)``, otherwise return ``s``"""
@@ -48,6 +50,7 @@ def text_(s, encoding='latin-1', errors='strict'):
         return s.decode(encoding, errors)
     return s
 
+
 def bytes_(s, encoding='latin-1', errors='strict'):
     """ If ``s`` is an instance of ``text_type``, return
     ``s.encode(encoding, errors)``, otherwise return ``s``"""
@@ -55,17 +58,23 @@ def bytes_(s, encoding='latin-1', errors='strict'):
         return s.encode(encoding, errors)
     return s
 
+
 if PY2:
+
     def ascii_native_(s):
         if isinstance(s, text_type):
             s = s.encode('ascii')
         return str(s)
+
+
 else:
+
     def ascii_native_(s):
         if isinstance(s, text_type):
             s = s.encode('ascii')
         return str(s, 'ascii', 'strict')
 
+
 ascii_native_.__doc__ = """
 Python 3: If ``s`` is an instance of ``text_type``, return
 ``s.encode('ascii')``, otherwise return ``str(s, 'ascii', 'strict')``
@@ -76,13 +85,17 @@ Python 2: If ``s`` is an instance of ``text_type``, return
 
 
 if PY2:
+
     def native_(s, encoding='latin-1', errors='strict'):
         """ If ``s`` is an instance of ``text_type``, return
         ``s.encode(encoding, errors)``, otherwise return ``str(s)``"""
         if isinstance(s, text_type):
             return s.encode(encoding, errors)
         return str(s)
+
+
 else:
+
     def native_(s, encoding='latin-1', errors='strict'):
         """ If ``s`` is an instance of ``text_type``, return
         ``s``, otherwise return ``str(s, encoding, errors)``"""
@@ -90,6 +103,7 @@ else:
             return s
         return str(s, encoding, errors)
 
+
 native_.__doc__ = """
 Python 3: If ``s`` is an instance of ``text_type``, return ``s``, otherwise
 return ``str(s, encoding, errors)``
@@ -106,25 +120,34 @@ if PY2:
     from urllib import urlencode as url_encode
     from urllib2 import urlopen as url_open
 
-    def url_unquote_text(v, encoding='utf-8', errors='replace'): # pragma: no cover
+    def url_unquote_text(
+        v, encoding='utf-8', errors='replace'
+    ):  # pragma: no cover
         v = url_unquote(v)
         return v.decode(encoding, errors)
 
-    def url_unquote_native(v, encoding='utf-8', errors='replace'): # pragma: no cover
+    def url_unquote_native(
+        v, encoding='utf-8', errors='replace'
+    ):  # pragma: no cover
         return native_(url_unquote_text(v, encoding, errors))
+
+
 else:
     from urllib import parse
+
     urlparse = parse
     from urllib.parse import quote as url_quote
     from urllib.parse import quote_plus as url_quote_plus
     from urllib.parse import unquote as url_unquote
     from urllib.parse import urlencode as url_encode
     from urllib.request import urlopen as url_open
+
     url_unquote_text = url_unquote
     url_unquote_native = url_unquote
 
 
 if PY2:  # pragma: no cover
+
     def exec_(code, globs=None, locs=None):
         """Execute code in a namespace."""
         if globs is None:
@@ -137,12 +160,15 @@ if PY2:  # pragma: no cover
             locs = globs
         exec("""exec code in globs, locs""")
 
-    exec_("""def reraise(tp, value, tb=None):
+    exec_(
+        """def reraise(tp, value, tb=None):
     raise tp, value, tb
-""")
+"""
+    )
 
 else:  # pragma: no cover
     import builtins
+
     exec_ = getattr(builtins, "exec")
 
     def reraise(tp, value, tb=None):
@@ -156,6 +182,7 @@ else:  # pragma: no cover
 
 
 if PY2:  # pragma: no cover
+
     def iteritems_(d):
         return d.iteritems()
 
@@ -164,7 +191,10 @@ if PY2:  # pragma: no cover
 
     def iterkeys_(d):
         return d.iterkeys()
+
+
 else:  # pragma: no cover
+
     def iteritems_(d):
         return d.items()
 
@@ -178,18 +208,25 @@ else:  # pragma: no cover
 if PY2:
     map_ = map
 else:
+
     def map_(*arg):
         return list(map(*arg))
 
+
 if PY2:
+
     def is_nonstr_iter(v):
         return hasattr(v, '__iter__')
+
+
 else:
+
     def is_nonstr_iter(v):
         if isinstance(v, str):
             return False
         return hasattr(v, '__iter__')
 
+
 if PY2:
     im_func = 'im_func'
     im_self = 'im_self'
@@ -227,21 +264,27 @@ else:
 import json
 
 if PY2:
+
     def decode_path_info(path):
         return path.decode('utf-8')
+
+
 else:
     # see PEP 3333 for why we encode WSGI PATH_INFO to latin-1 before
     # decoding it to utf-8
     def decode_path_info(path):
         return path.encode('latin-1').decode('utf-8')
 
+
 if PY2:
     from urlparse import unquote as unquote_to_bytes
 
     def unquote_bytes_to_wsgi(bytestring):
         return unquote_to_bytes(bytestring)
+
+
 else:
-    # see PEP 3333 for why we decode the path to latin-1 
+    # see PEP 3333 for why we decode the path to latin-1
     from urllib.parse import unquote_to_bytes
 
     def unquote_bytes_to_wsgi(bytestring):
@@ -251,6 +294,7 @@ else:
 def is_bound_method(ob):
     return inspect.ismethod(ob) and getattr(ob, im_self, None) is not None
 
+
 # support annotations and keyword-only arguments in PY3
 if PY2:
     from inspect import getargspec
@@ -262,6 +306,7 @@ if PY2:
 else:
     from itertools import zip_longest
 
+
 def is_unbound_method(fn):
     """
     This consistently verifies that the callable is bound to a
diff --git a/src/pyramid/config/__init__.py b/src/pyramid/config/__init__.py
index 2f4e133f0..ab5edfefe 100644
--- a/src/pyramid/config/__init__.py
+++ b/src/pyramid/config/__init__.py
@@ -17,17 +17,13 @@ from pyramid.interfaces import (
     PHASE1_CONFIG,
     PHASE2_CONFIG,
     PHASE3_CONFIG,
-    )
+)
 
 from pyramid.asset import resolve_asset_spec
 
 from pyramid.authorization import ACLAuthorizationPolicy
 
-from pyramid.compat import (
-    text_,
-    reraise,
-    string_types,
-    )
+from pyramid.compat import text_, reraise, string_types
 
 from pyramid.events import ApplicationCreated
 
@@ -35,21 +31,13 @@ from pyramid.exceptions import (
     ConfigurationConflictError,
     ConfigurationError,
     ConfigurationExecutionError,
-    )
+)
 
 from pyramid.httpexceptions import default_exceptionresponse_view
 
-from pyramid.path import (
-    caller_package,
-    package_of,
-    )
+from pyramid.path import caller_package, package_of
 
-from pyramid.registry import (
-    Introspectable,
-    Introspector,
-    Registry,
-    undefer,
-    )
+from pyramid.registry import Introspectable, Introspector, Registry, undefer
 
 from pyramid.router import Router
 
@@ -57,17 +45,9 @@ from pyramid.settings import aslist
 
 from pyramid.threadlocal import manager
 
-from pyramid.util import (
-    WeakOrderedSet,
-    object_description,
-    )
+from pyramid.util import WeakOrderedSet, object_description
 
-from pyramid.config.util import (
-    ActionInfo,
-    PredicateList,
-    action_method,
-    not_,
-)
+from pyramid.config.util import ActionInfo, PredicateList, action_method, not_
 
 from pyramid.config.adapters import AdaptersConfiguratorMixin
 from pyramid.config.assets import AssetsConfiguratorMixin
@@ -94,6 +74,7 @@ PHASE1_CONFIG = PHASE1_CONFIG  # api
 PHASE2_CONFIG = PHASE2_CONFIG  # api
 PHASE3_CONFIG = PHASE3_CONFIG  # api
 
+
 class Configurator(
     TestingConfiguratorMixin,
     TweensConfiguratorMixin,
@@ -107,7 +88,7 @@ class Configurator(
     SettingsConfiguratorMixin,
     FactoriesConfiguratorMixin,
     AdaptersConfiguratorMixin,
-    ):
+):
     """
     A Configurator is used to configure a :app:`Pyramid`
     :term:`application registry`.
@@ -284,8 +265,9 @@ class Configurator(
        ``with``-statement to make threadlocal configuration available for
        further configuration with an implicit commit.
     """
-    manager = manager # for testing injection
-    venusian = venusian # for testing injection
+
+    manager = manager  # for testing injection
+    venusian = venusian  # for testing injection
     _ainfo = None
     basepath = None
     includepath = ()
@@ -294,27 +276,28 @@ class Configurator(
     introspectable = Introspectable
     inspect = inspect
 
-    def __init__(self,
-                 registry=None,
-                 package=None,
-                 settings=None,
-                 root_factory=None,
-                 authentication_policy=None,
-                 authorization_policy=None,
-                 renderers=None,
-                 debug_logger=None,
-                 locale_negotiator=None,
-                 request_factory=None,
-                 response_factory=None,
-                 default_permission=None,
-                 session_factory=None,
-                 default_view_mapper=None,
-                 autocommit=False,
-                 exceptionresponse_view=default_exceptionresponse_view,
-                 route_prefix=None,
-                 introspection=True,
-                 root_package=None,
-                 ):
+    def __init__(
+        self,
+        registry=None,
+        package=None,
+        settings=None,
+        root_factory=None,
+        authentication_policy=None,
+        authorization_policy=None,
+        renderers=None,
+        debug_logger=None,
+        locale_negotiator=None,
+        request_factory=None,
+        response_factory=None,
+        default_permission=None,
+        session_factory=None,
+        default_view_mapper=None,
+        autocommit=False,
+        exceptionresponse_view=default_exceptionresponse_view,
+        route_prefix=None,
+        introspection=True,
+        root_package=None,
+    ):
         if package is None:
             package = caller_package()
         if root_package is None:
@@ -345,23 +328,24 @@ class Configurator(
                 session_factory=session_factory,
                 default_view_mapper=default_view_mapper,
                 exceptionresponse_view=exceptionresponse_view,
-                )
+            )
 
-    def setup_registry(self,
-                       settings=None,
-                       root_factory=None,
-                       authentication_policy=None,
-                       authorization_policy=None,
-                       renderers=None,
-                       debug_logger=None,
-                       locale_negotiator=None,
-                       request_factory=None,
-                       response_factory=None,
-                       default_permission=None,
-                       session_factory=None,
-                       default_view_mapper=None,
-                       exceptionresponse_view=default_exceptionresponse_view,
-                       ):
+    def setup_registry(
+        self,
+        settings=None,
+        root_factory=None,
+        authentication_policy=None,
+        authorization_policy=None,
+        renderers=None,
+        debug_logger=None,
+        locale_negotiator=None,
+        request_factory=None,
+        response_factory=None,
+        default_permission=None,
+        session_factory=None,
+        default_view_mapper=None,
+        exceptionresponse_view=default_exceptionresponse_view,
+    ):
         """ When you pass a non-``None`` ``registry`` argument to the
         :term:`Configurator` constructor, no initial setup is performed
         against the registry.  This is because the registry you pass in may
@@ -404,7 +388,9 @@ class Configurator(
         if exceptionresponse_view is not None:
             exceptionresponse_view = self.maybe_dotted(exceptionresponse_view)
             self.add_view(exceptionresponse_view, context=IExceptionResponse)
-            self.add_view(exceptionresponse_view,context=WebobWSGIHTTPException)
+            self.add_view(
+                exceptionresponse_view, context=WebobWSGIHTTPException
+            )
 
         # commit below because:
         #
@@ -424,7 +410,7 @@ class Configurator(
         # automatic conflict resolution.
 
         if authentication_policy and not authorization_policy:
-            authorization_policy = ACLAuthorizationPolicy() # default
+            authorization_policy = ACLAuthorizationPolicy()  # default
 
         if authorization_policy:
             self.set_authorization_policy(authorization_policy)
@@ -468,7 +454,7 @@ class Configurator(
     def _make_spec(self, path_or_spec):
         package, filename = resolve_asset_spec(path_or_spec, self.package_name)
         if package is None:
-            return filename # absolute filename
+            return filename  # absolute filename
         return '%s:%s' % (package, filename)
 
     def _fix_registry(self):
@@ -480,38 +466,55 @@ class Configurator(
         _registry = self.registry
 
         if not hasattr(_registry, 'notify'):
+
             def notify(*events):
-                [ _ for _ in _registry.subscribers(events, None) ]
+                [_ for _ in _registry.subscribers(events, None)]
+
             _registry.notify = notify
 
         if not hasattr(_registry, 'has_listeners'):
             _registry.has_listeners = True
 
         if not hasattr(_registry, 'queryAdapterOrSelf'):
+
             def queryAdapterOrSelf(object, interface, default=None):
                 if not interface.providedBy(object):
-                    return _registry.queryAdapter(object, interface,
-                                                  default=default)
+                    return _registry.queryAdapter(
+                        object, interface, default=default
+                    )
                 return object
+
             _registry.queryAdapterOrSelf = queryAdapterOrSelf
 
         if not hasattr(_registry, 'registerSelfAdapter'):
-            def registerSelfAdapter(required=None, provided=None,
-                                    name=empty, info=empty, event=True):
-                return _registry.registerAdapter(lambda x: x,
-                                                 required=required,
-                                                 provided=provided, name=name,
-                                                 info=info, event=event)
+
+            def registerSelfAdapter(
+                required=None,
+                provided=None,
+                name=empty,
+                info=empty,
+                event=True,
+            ):
+                return _registry.registerAdapter(
+                    lambda x: x,
+                    required=required,
+                    provided=provided,
+                    name=name,
+                    info=info,
+                    event=event,
+                )
+
             _registry.registerSelfAdapter = registerSelfAdapter
 
         if not hasattr(_registry, '_lock'):
             _registry._lock = threading.Lock()
 
         if not hasattr(_registry, '_clear_view_lookup_cache'):
+
             def _clear_view_lookup_cache():
                 _registry._view_lookup_cache = {}
-            _registry._clear_view_lookup_cache = _clear_view_lookup_cache
 
+            _registry._clear_view_lookup_cache = _clear_view_lookup_cache
 
     # API
 
@@ -530,7 +533,7 @@ class Configurator(
 
     introspector = property(
         _get_introspector, _set_introspector, _del_introspector
-        )
+    )
 
     def get_predlist(self, name):
         predlist = self.registry.queryUtility(IPredicateList, name=name)
@@ -539,30 +542,41 @@ class Configurator(
             self.registry.registerUtility(predlist, IPredicateList, name=name)
         return predlist
 
-
-    def _add_predicate(self, type, name, factory, weighs_more_than=None,
-                       weighs_less_than=None):
+    def _add_predicate(
+        self, type, name, factory, weighs_more_than=None, weighs_less_than=None
+    ):
         factory = self.maybe_dotted(factory)
         discriminator = ('%s option' % type, name)
         intr = self.introspectable(
             '%s predicates' % type,
             discriminator,
             '%s predicate named %s' % (type, name),
-            '%s predicate' % type)
+            '%s predicate' % type,
+        )
         intr['name'] = name
         intr['factory'] = factory
         intr['weighs_more_than'] = weighs_more_than
         intr['weighs_less_than'] = weighs_less_than
+
         def register():
             predlist = self.get_predlist(type)
-            predlist.add(name, factory, weighs_more_than=weighs_more_than,
-                         weighs_less_than=weighs_less_than)
-        self.action(discriminator, register, introspectables=(intr,),
-                    order=PHASE1_CONFIG) # must be registered early
+            predlist.add(
+                name,
+                factory,
+                weighs_more_than=weighs_more_than,
+                weighs_less_than=weighs_less_than,
+            )
+
+        self.action(
+            discriminator,
+            register,
+            introspectables=(intr,),
+            order=PHASE1_CONFIG,
+        )  # must be registered early
 
     @property
     def action_info(self):
-        info = self.info # usually a ZCML action (ParserInfo) if self.info
+        info = self.info  # usually a ZCML action (ParserInfo) if self.info
         if not info:
             # Try to provide more accurate info for conflict reports
             if self._ainfo:
@@ -571,8 +585,16 @@ class Configurator(
                 info = ActionInfo(None, 0, '', '')
         return info
 
-    def action(self, discriminator, callable=None, args=(), kw=None, order=0,
-               introspectables=(), **extra):
+    def action(
+        self,
+        discriminator,
+        callable=None,
+        args=(),
+        kw=None,
+        order=0,
+        introspectables=(),
+        **extra
+    ):
         """ Register an action which will be executed when
         :meth:`pyramid.config.Configurator.commit` is called (or executed
         immediately if ``autocommit`` is ``True``).
@@ -607,7 +629,7 @@ class Configurator(
         """
         # catch nonhashable discriminators here; most unit tests use
         # autocommit=False, which won't catch unhashable discriminators
-        assert hash(discriminator) 
+        assert hash(discriminator)
 
         if kw is None:
             kw = {}
@@ -645,8 +667,8 @@ class Configurator(
                     info=action_info,
                     includepath=self.includepath,
                     introspectables=introspectables,
-                    )
                 )
+            )
             self.action_state.action(**action)
 
     def _get_action_state(self):
@@ -663,7 +685,7 @@ class Configurator(
 
     action_state = property(_get_action_state, _set_action_state)
 
-    _ctx = action_state # bw compat
+    _ctx = action_state  # bw compat
 
     def commit(self):
         """
@@ -687,7 +709,7 @@ class Configurator(
             self.action_state.execute_actions(introspector=self.introspector)
         finally:
             self.end()
-        self.action_state = ActionState() # old actions have been processed
+        self.action_state = ActionState()  # old actions have been processed
 
     def include(self, callable, route_prefix=None):
         """Include a configuration callable, to support imperative
@@ -800,17 +822,18 @@ class Configurator(
                 c = getattr(module, 'includeme')
             except AttributeError:
                 raise ConfigurationError(
-                    "module %r has no attribute 'includeme'" % (module.__name__)
-                    )
-                                                       
+                    "module %r has no attribute 'includeme'"
+                    % (module.__name__)
+                )
+
         spec = module.__name__ + ':' + c.__name__
         sourcefile = self.inspect.getsourcefile(c)
 
         if sourcefile is None:
             raise ConfigurationError(
                 'No source file for module %r (.py file must exist, '
-                'refusing to use orphan .pyc or .pyo file).' % module.__name__)
-            
+                'refusing to use orphan .pyc or .pyo file).' % module.__name__
+            )
 
         if action_state.processSpec(spec):
             with self.route_prefix_context(route_prefix):
@@ -820,7 +843,7 @@ class Configurator(
                     root_package=self.root_package,
                     autocommit=self.autocommit,
                     route_prefix=self.route_prefix,
-                    )
+                )
                 configurator.basepath = os.path.dirname(sourcefile)
                 configurator.includepath = self.includepath + (spec,)
 
@@ -886,7 +909,7 @@ class Configurator(
             autocommit=self.autocommit,
             route_prefix=self.route_prefix,
             introspection=self.introspection,
-            )
+        )
         configurator.basepath = self.basepath
         configurator.includepath = self.includepath
         configurator.info = self.info
@@ -914,7 +937,7 @@ class Configurator(
             return relative_spec
         return self._make_spec(relative_spec)
 
-    absolute_resource_spec = absolute_asset_spec # b/w compat forever
+    absolute_resource_spec = absolute_asset_spec  # b/w compat forever
 
     def begin(self, request=_marker):
         """ Indicate that application or test configuration has begun.
@@ -940,7 +963,7 @@ class Configurator(
                 request = current['request']
             else:
                 request = None
-        self.manager.push({'registry':self.registry, 'request':request})
+        self.manager.push({'registry': self.registry, 'request': request})
 
     def end(self):
         """ Indicate that application or test configuration has ended.
@@ -961,8 +984,9 @@ class Configurator(
             self.commit()
 
     # this is *not* an action method (uses caller_package)
-    def scan(self, package=None, categories=None, onerror=None, ignore=None,
-             **kw):
+    def scan(
+        self, package=None, categories=None, onerror=None, ignore=None, **kw
+    ):
         """Scan a Python package and any of its subpackages for objects
         marked with :term:`configuration decoration` such as
         :class:`pyramid.view.view_config`.  Any decorated object found will
@@ -1021,7 +1045,7 @@ class Configurator(
 
         """
         package = self.maybe_dotted(package)
-        if package is None: # pragma: no cover
+        if package is None:  # pragma: no cover
             package = caller_package()
 
         ctorkw = {'config': self}
@@ -1029,8 +1053,9 @@ class Configurator(
 
         scanner = self.venusian.Scanner(**ctorkw)
 
-        scanner.scan(package, categories=categories, onerror=onerror,
-                     ignore=ignore)
+        scanner.scan(
+            package, categories=categories, onerror=onerror, ignore=ignore
+        )
 
     def make_wsgi_app(self):
         """ Commits any pending configuration statements, sends a
@@ -1079,8 +1104,18 @@ class ActionState(object):
         self._seen_files.add(spec)
         return True
 
-    def action(self, discriminator, callable=None, args=(), kw=None, order=0,
-               includepath=(), info=None, introspectables=(), **extra):
+    def action(
+        self,
+        discriminator,
+        callable=None,
+        args=(),
+        kw=None,
+        order=0,
+        includepath=(),
+        info=None,
+        introspectables=(),
+        **extra
+    ):
         """Add an action with the given discriminator, callable and arguments
         """
         if kw is None:
@@ -1096,8 +1131,8 @@ class ActionState(object):
                 info=info,
                 order=order,
                 introspectables=introspectables,
-                )
             )
+        )
         self.actions.append(action)
 
     def execute_actions(self, clear=True, introspector=None):
@@ -1179,8 +1214,7 @@ class ActionState(object):
                 if self.actions:
                     all_actions.extend(self.actions)
                     action_iter = resolveConflicts(
-                        self.actions,
-                        state=conflict_state,
+                        self.actions, state=conflict_state
                     )
                     self.actions = []
 
@@ -1203,9 +1237,11 @@ class ActionState(object):
                 except Exception:
                     t, v, tb = sys.exc_info()
                     try:
-                        reraise(ConfigurationExecutionError,
-                                ConfigurationExecutionError(t, v, info),
-                                tb)
+                        reraise(
+                            ConfigurationExecutionError,
+                            ConfigurationExecutionError(t, v, info),
+                            tb,
+                        )
                     finally:
                         del t, v, tb
 
@@ -1290,9 +1326,12 @@ def resolveConflicts(actions, state=None):
 
         # error out if we went backward in order
         if state.min_order is not None and order < state.min_order:
-            r = ['Actions were added to order={0} after execution had moved '
-                 'on to order={1}. Conflicting actions: '
-                 .format(order, state.min_order)]
+            r = [
+                'Actions were added to order={0} after execution had moved '
+                'on to order={1}. Conflicting actions: '.format(
+                    order, state.min_order
+                )
+            ]
             for i, action in actiongroup:
                 for line in str(action['info']).rstrip().split('\n'):
                     r.append("  " + line)
@@ -1348,8 +1387,10 @@ def resolveConflicts(actions, state=None):
                 # if the new action conflicts with the resolved action then
                 # note the conflict, otherwise drop the action as it's
                 # effectively overriden by the previous action
-                if (includepath[:len(basepath)] != basepath or
-                        includepath == basepath):
+                if (
+                    includepath[: len(basepath)] != basepath
+                    or includepath == basepath
+                ):
                     L = conflicts.setdefault(discriminator, [baseinfo])
                     L.append(action['info'])
 
@@ -1360,8 +1401,10 @@ def resolveConflicts(actions, state=None):
             for _, action in rest:
                 includepath = action['includepath']
                 # Test whether path is a prefix of opath
-                if (includepath[:len(basepath)] != basepath or  # not a prefix
-                        includepath == basepath):
+                if (
+                    includepath[: len(basepath)] != basepath
+                    or includepath == basepath  # not a prefix
+                ):
                     L = conflicts.setdefault(discriminator, [baseinfo])
                     L.append(action['info'])
 
@@ -1389,8 +1432,14 @@ def normalize_actions(actions):
 
 
 def expand_action_tuple(
-    discriminator, callable=None, args=(), kw=None, includepath=(),
-    info=None, order=0, introspectables=(),
+    discriminator,
+    callable=None,
+    args=(),
+    kw=None,
+    includepath=(),
+    info=None,
+    order=0,
+    introspectables=(),
 ):
     if kw is None:
         kw = {}
@@ -1403,7 +1452,7 @@ def expand_action_tuple(
         info=info,
         order=order,
         introspectables=introspectables,
-        )
+    )
 
 
 global_registries = WeakOrderedSet()
diff --git a/src/pyramid/config/adapters.py b/src/pyramid/config/adapters.py
index 945faa3c6..e5668c40e 100644
--- a/src/pyramid/config/adapters.py
+++ b/src/pyramid/config/adapters.py
@@ -4,11 +4,7 @@ from functools import update_wrapper
 
 from zope.interface import Interface
 
-from pyramid.interfaces import (
-    IResponse,
-    ITraverser,
-    IResourceURL,
-    )
+from pyramid.interfaces import IResponse, ITraverser, IResourceURL
 
 from pyramid.util import takes_one_arg
 
@@ -53,33 +49,33 @@ class AdaptersConfiguratorMixin(object):
             predlist = self.get_predlist('subscriber')
             order, preds, phash = predlist.make(self, **predicates)
 
-            derived_predicates = [ self._derive_predicate(p) for p in preds ]
+            derived_predicates = [self._derive_predicate(p) for p in preds]
             derived_subscriber = self._derive_subscriber(
-                subscriber,
-                derived_predicates,
-                )
+                subscriber, derived_predicates
+            )
 
             intr.update(
-                {'phash':phash,
-                 'order':order,
-                 'predicates':preds,
-                 'derived_predicates':derived_predicates,
-                 'derived_subscriber':derived_subscriber,
-                 }
-                )
+                {
+                    'phash': phash,
+                    'order': order,
+                    'predicates': preds,
+                    'derived_predicates': derived_predicates,
+                    'derived_subscriber': derived_subscriber,
+                }
+            )
 
             self.registry.registerHandler(derived_subscriber, iface)
-            
+
         intr = self.introspectable(
             'subscribers',
             id(subscriber),
             self.object_description(subscriber),
-            'subscriber'
-            )
-        
+            'subscriber',
+        )
+
         intr['subscriber'] = subscriber
         intr['interfaces'] = iface
-        
+
         self.action(None, register, introspectables=(intr,))
         return subscriber
 
@@ -87,8 +83,10 @@ class AdaptersConfiguratorMixin(object):
         derived_predicate = predicate
 
         if eventonly(predicate):
+
             def derived_predicate(*arg):
                 return predicate(arg[0])
+
             # seems pointless to try to fix __doc__, __module__, etc as
             # predicate will invariably be an instance
 
@@ -98,8 +96,10 @@ class AdaptersConfiguratorMixin(object):
         derived_subscriber = subscriber
 
         if eventonly(subscriber):
+
             def derived_subscriber(*arg):
                 return subscriber(arg[0])
+
             if hasattr(subscriber, '__name__'):
                 update_wrapper(derived_subscriber, subscriber)
 
@@ -132,10 +132,11 @@ class AdaptersConfiguratorMixin(object):
             update_wrapper(subscriber_wrapper, subscriber)
 
         return subscriber_wrapper
-        
+
     @action_method
-    def add_subscriber_predicate(self, name, factory, weighs_more_than=None,
-                                 weighs_less_than=None):
+    def add_subscriber_predicate(
+        self, name, factory, weighs_more_than=None, weighs_less_than=None
+    ):
         """
         .. versionadded:: 1.4
 
@@ -159,8 +160,8 @@ class AdaptersConfiguratorMixin(object):
             name,
             factory,
             weighs_more_than=weighs_more_than,
-            weighs_less_than=weighs_less_than
-            )
+            weighs_less_than=weighs_less_than,
+        )
 
     @action_method
     def add_response_adapter(self, adapter, type_or_iface):
@@ -178,18 +179,21 @@ class AdaptersConfiguratorMixin(object):
         See :ref:`using_iresponse` for more information."""
         adapter = self.maybe_dotted(adapter)
         type_or_iface = self.maybe_dotted(type_or_iface)
+
         def register():
             reg = self.registry
             if adapter is None:
                 reg.registerSelfAdapter((type_or_iface,), IResponse)
             else:
                 reg.registerAdapter(adapter, (type_or_iface,), IResponse)
+
         discriminator = (IResponse, type_or_iface)
         intr = self.introspectable(
             'response adapters',
             discriminator,
             self.object_description(adapter),
-            'response adapter')
+            'response adapter',
+        )
         intr['adapter'] = adapter
         intr['type'] = type_or_iface
         self.action(discriminator, register, introspectables=(intr,))
@@ -255,17 +259,19 @@ class AdaptersConfiguratorMixin(object):
         """
         iface = self.maybe_dotted(iface)
         adapter = self.maybe_dotted(adapter)
+
         def register(iface=iface):
             if iface is None:
                 iface = Interface
             self.registry.registerAdapter(adapter, (iface,), ITraverser)
+
         discriminator = ('traverser', iface)
         intr = self.introspectable(
-            'traversers', 
+            'traversers',
             discriminator,
             'traverser for %r' % iface,
             'traverser',
-            )
+        )
         intr['adapter'] = adapter
         intr['iface'] = iface
         self.action(discriminator, register, introspectables=(intr,))
@@ -303,24 +309,25 @@ class AdaptersConfiguratorMixin(object):
         """
         adapter = self.maybe_dotted(adapter)
         resource_iface = self.maybe_dotted(resource_iface)
+
         def register(resource_iface=resource_iface):
             if resource_iface is None:
                 resource_iface = Interface
             self.registry.registerAdapter(
-                adapter,
-                (resource_iface, Interface),
-                IResourceURL,
-                )
+                adapter, (resource_iface, Interface), IResourceURL
+            )
+
         discriminator = ('resource url adapter', resource_iface)
         intr = self.introspectable(
-            'resource url adapters', 
+            'resource url adapters',
             discriminator,
             'resource url adapter for resource iface %r' % resource_iface,
             'resource url adapter',
-            )
+        )
         intr['adapter'] = adapter
         intr['resource_iface'] = resource_iface
         self.action(discriminator, register, introspectables=(intr,))
 
+
 def eventonly(callee):
     return takes_one_arg(callee, argname='event')
diff --git a/src/pyramid/config/assets.py b/src/pyramid/config/assets.py
index b9536df42..fd8b2ee49 100644
--- a/src/pyramid/config/assets.py
+++ b/src/pyramid/config/assets.py
@@ -4,16 +4,14 @@ import sys
 
 from zope.interface import implementer
 
-from pyramid.interfaces import (
-    IPackageOverrides,
-    PHASE1_CONFIG,
-)
+from pyramid.interfaces import IPackageOverrides, PHASE1_CONFIG
 
 from pyramid.exceptions import ConfigurationError
 from pyramid.threadlocal import get_current_registry
 
 from pyramid.config.util import action_method
 
+
 class OverrideProvider(pkg_resources.DefaultProvider):
     def __init__(self, module):
         pkg_resources.DefaultProvider.__init__(self, module)
@@ -35,7 +33,8 @@ class OverrideProvider(pkg_resources.DefaultProvider):
             if filename is not None:
                 return filename
         return pkg_resources.DefaultProvider.get_resource_filename(
-            self, manager, resource_name)
+            self, manager, resource_name
+        )
 
     def get_resource_stream(self, manager, resource_name):
         """ Return a readable file-like object for resource_name."""
@@ -45,7 +44,8 @@ class OverrideProvider(pkg_resources.DefaultProvider):
             if stream is not None:
                 return stream
         return pkg_resources.DefaultProvider.get_resource_stream(
-            self, manager, resource_name)
+            self, manager, resource_name
+        )
 
     def get_resource_string(self, manager, resource_name):
         """ Return a string containing the contents of resource_name."""
@@ -55,7 +55,8 @@ class OverrideProvider(pkg_resources.DefaultProvider):
             if string is not None:
                 return string
         return pkg_resources.DefaultProvider.get_resource_string(
-            self, manager, resource_name)
+            self, manager, resource_name
+        )
 
     def has_resource(self, resource_name):
         overrides = self._get_overrides()
@@ -63,8 +64,7 @@ class OverrideProvider(pkg_resources.DefaultProvider):
             result = overrides.has_resource(resource_name)
             if result is not None:
                 return result
-        return pkg_resources.DefaultProvider.has_resource(
-            self, resource_name)
+        return pkg_resources.DefaultProvider.has_resource(self, resource_name)
 
     def resource_isdir(self, resource_name):
         overrides = self._get_overrides()
@@ -73,7 +73,8 @@ class OverrideProvider(pkg_resources.DefaultProvider):
             if result is not None:
                 return result
         return pkg_resources.DefaultProvider.resource_isdir(
-            self, resource_name)
+            self, resource_name
+        )
 
     def resource_listdir(self, resource_name):
         overrides = self._get_overrides()
@@ -82,7 +83,8 @@ class OverrideProvider(pkg_resources.DefaultProvider):
             if result is not None:
                 return result
         return pkg_resources.DefaultProvider.resource_listdir(
-            self, resource_name)
+            self, resource_name
+        )
 
 
 @implementer(IPackageOverrides)
@@ -193,9 +195,10 @@ class DirectoryOverride:
 
     def __call__(self, resource_name):
         if resource_name.startswith(self.path):
-            new_path = resource_name[self.pathlen:]
+            new_path = resource_name[self.pathlen :]
             return self.source, new_path
 
+
 class FileOverride:
     def __init__(self, path, source):
         self.path = path
@@ -215,6 +218,7 @@ class PackageAssetSource(object):
     the empty string, as returned by the ``FileOverride``.
 
     """
+
     def __init__(self, package, prefix):
         self.package = package
         if hasattr(package, '__name__'):
@@ -262,6 +266,7 @@ class FSAssetSource(object):
     An asset source relative to a path in the filesystem.
 
     """
+
     def __init__(self, prefix):
         self.prefix = prefix
 
@@ -305,14 +310,16 @@ class FSAssetSource(object):
 
 
 class AssetsConfiguratorMixin(object):
-    def _override(self, package, path, override_source,
-                  PackageOverrides=PackageOverrides):
+    def _override(
+        self, package, path, override_source, PackageOverrides=PackageOverrides
+    ):
         pkg_name = package.__name__
         override = self.registry.queryUtility(IPackageOverrides, name=pkg_name)
         if override is None:
             override = PackageOverrides(package)
-            self.registry.registerUtility(override, IPackageOverrides,
-                                          name=pkg_name)
+            self.registry.registerUtility(
+                override, IPackageOverrides, name=pkg_name
+            )
         override.insert(path, override_source)
 
     @action_method
@@ -331,7 +338,8 @@ class AssetsConfiguratorMixin(object):
         information about asset overrides."""
         if to_override == override_with:
             raise ConfigurationError(
-                'You cannot override an asset with itself')
+                'You cannot override an asset with itself'
+            )
 
         package = to_override
         path = ''
@@ -346,7 +354,8 @@ class AssetsConfiguratorMixin(object):
             if not os.path.exists(override_with):
                 raise ConfigurationError(
                     'Cannot override asset with an absolute path that does '
-                    'not exist')
+                    'not exist'
+                )
             override_isdir = os.path.isdir(override_with)
             override_package = None
             override_prefix = override_with
@@ -360,22 +369,23 @@ class AssetsConfiguratorMixin(object):
             to_package = sys.modules[override_package]
             override_source = PackageAssetSource(to_package, override_prefix)
 
-            override_isdir = (
-                override_prefix == '' or
-                override_with.endswith('/')
+            override_isdir = override_prefix == '' or override_with.endswith(
+                '/'
             )
 
         if overridden_isdir and (not override_isdir):
             raise ConfigurationError(
                 'A directory cannot be overridden with a file (put a '
-                'slash at the end of override_with if necessary)')
+                'slash at the end of override_with if necessary)'
+            )
 
         if (not overridden_isdir) and override_isdir:
             raise ConfigurationError(
                 'A file cannot be overridden with a directory (put a '
-                'slash at the end of to_override if necessary)')
+                'slash at the end of to_override if necessary)'
+            )
 
-        override = _override or self._override # test jig
+        override = _override or self._override  # test jig
 
         def register():
             __import__(package)
@@ -387,10 +397,11 @@ class AssetsConfiguratorMixin(object):
             (package, override_package, path, override_prefix),
             '%s -> %s' % (to_override, override_with),
             'asset override',
-            )
+        )
         intr['to_override'] = to_override
         intr['override_with'] = override_with
-        self.action(None, register, introspectables=(intr,),
-                    order=PHASE1_CONFIG)
+        self.action(
+            None, register, introspectables=(intr,), order=PHASE1_CONFIG
+        )
 
-    override_resource = override_asset # bw compat
+    override_resource = override_asset  # bw compat
diff --git a/src/pyramid/config/factories.py b/src/pyramid/config/factories.py
index 52248269d..2ec1558a6 100644
--- a/src/pyramid/config/factories.py
+++ b/src/pyramid/config/factories.py
@@ -8,18 +8,16 @@ from pyramid.interfaces import (
     IRequestExtensions,
     IRootFactory,
     ISessionFactory,
-    )
+)
 
 from pyramid.router import default_execution_policy
 from pyramid.traversal import DefaultRootFactory
 
-from pyramid.util import (
-    get_callable_name,
-    InstancePropertyHelper,
-    )
+from pyramid.util import get_callable_name, InstancePropertyHelper
 
 from pyramid.config.util import action_method
 
+
 class FactoriesConfiguratorMixin(object):
     @action_method
     def set_root_factory(self, factory):
@@ -41,10 +39,12 @@ class FactoriesConfiguratorMixin(object):
             self.registry.registerUtility(factory, IRootFactory)
             self.registry.registerUtility(factory, IDefaultRootFactory)  # b/c
 
-        intr = self.introspectable('root factories',
-                                   None,
-                                   self.object_description(factory),
-                                   'root factory')
+        intr = self.introspectable(
+            'root factories',
+            None,
+            self.object_description(factory),
+            'root factory',
+        )
         intr['factory'] = factory
         self.action(IRootFactory, register, introspectables=(intr,))
 
@@ -67,9 +67,13 @@ class FactoriesConfiguratorMixin(object):
 
         def register():
             self.registry.registerUtility(factory, ISessionFactory)
-        intr = self.introspectable('session factory', None,
-                                   self.object_description(factory),
-                                   'session factory')
+
+        intr = self.introspectable(
+            'session factory',
+            None,
+            self.object_description(factory),
+            'session factory',
+        )
         intr['factory'] = factory
         self.action(ISessionFactory, register, introspectables=(intr,))
 
@@ -97,9 +101,13 @@ class FactoriesConfiguratorMixin(object):
 
         def register():
             self.registry.registerUtility(factory, IRequestFactory)
-        intr = self.introspectable('request factory', None,
-                                   self.object_description(factory),
-                                   'request factory')
+
+        intr = self.introspectable(
+            'request factory',
+            None,
+            self.object_description(factory),
+            'request factory',
+        )
         intr['factory'] = factory
         self.action(IRequestFactory, register, introspectables=(intr,))
 
@@ -122,18 +130,19 @@ class FactoriesConfiguratorMixin(object):
         def register():
             self.registry.registerUtility(factory, IResponseFactory)
 
-        intr = self.introspectable('response factory', None,
-                                   self.object_description(factory),
-                                   'response factory')
+        intr = self.introspectable(
+            'response factory',
+            None,
+            self.object_description(factory),
+            'response factory',
+        )
         intr['factory'] = factory
         self.action(IResponseFactory, register, introspectables=(intr,))
 
     @action_method
-    def add_request_method(self,
-                           callable=None,
-                           name=None,
-                           property=False,
-                           reify=False):
+    def add_request_method(
+        self, callable=None, name=None, property=False, reify=False
+    ):
         """ Add a property or method to the request object.
 
         When adding a method to the request, ``callable`` may be any
@@ -177,7 +186,8 @@ class FactoriesConfiguratorMixin(object):
         property = property or reify
         if property:
             name, callable = InstancePropertyHelper.make_property(
-                callable, name=name, reify=reify)
+                callable, name=name, reify=reify
+            )
         elif name is None:
             name = callable.__name__
         else:
@@ -196,23 +206,31 @@ class FactoriesConfiguratorMixin(object):
         if callable is None:
             self.action(('request extensions', name), None)
         elif property:
-            intr = self.introspectable('request extensions', name,
-                                       self.object_description(callable),
-                                       'request property')
+            intr = self.introspectable(
+                'request extensions',
+                name,
+                self.object_description(callable),
+                'request property',
+            )
             intr['callable'] = callable
             intr['property'] = True
             intr['reify'] = reify
-            self.action(('request extensions', name), register,
-                        introspectables=(intr,))
+            self.action(
+                ('request extensions', name), register, introspectables=(intr,)
+            )
         else:
-            intr = self.introspectable('request extensions', name,
-                                       self.object_description(callable),
-                                       'request method')
+            intr = self.introspectable(
+                'request extensions',
+                name,
+                self.object_description(callable),
+                'request method',
+            )
             intr['callable'] = callable
             intr['property'] = False
             intr['reify'] = False
-            self.action(('request extensions', name), register,
-                        introspectables=(intr,))
+            self.action(
+                ('request extensions', name), register, introspectables=(intr,)
+            )
 
     @action_method
     def set_execution_policy(self, policy):
@@ -231,9 +249,12 @@ class FactoriesConfiguratorMixin(object):
         def register():
             self.registry.registerUtility(policy, IExecutionPolicy)
 
-        intr = self.introspectable('execution policy', None,
-                                   self.object_description(policy),
-                                   'execution policy')
+        intr = self.introspectable(
+            'execution policy',
+            None,
+            self.object_description(policy),
+            'execution policy',
+        )
         intr['policy'] = policy
         self.action(IExecutionPolicy, register, introspectables=(intr,))
 
diff --git a/src/pyramid/config/i18n.py b/src/pyramid/config/i18n.py
index 5dabe2845..6e7334448 100644
--- a/src/pyramid/config/i18n.py
+++ b/src/pyramid/config/i18n.py
@@ -1,13 +1,11 @@
-from pyramid.interfaces import (
-    ILocaleNegotiator,
-    ITranslationDirectories,
-    )
+from pyramid.interfaces import ILocaleNegotiator, ITranslationDirectories
 
 from pyramid.exceptions import ConfigurationError
 from pyramid.path import AssetResolver
 
 from pyramid.config.util import action_method
 
+
 class I18NConfiguratorMixin(object):
     @action_method
     def set_locale_negotiator(self, negotiator):
@@ -30,11 +28,16 @@ class I18NConfiguratorMixin(object):
            :class:`pyramid.config.Configurator` constructor can be used to
            achieve the same purpose.
         """
+
         def register():
             self._set_locale_negotiator(negotiator)
-        intr = self.introspectable('locale negotiator', None,
-                                   self.object_description(negotiator),
-                                   'locale negotiator')
+
+        intr = self.introspectable(
+            'locale negotiator',
+            None,
+            self.object_description(negotiator),
+            'locale negotiator',
+        )
         intr['negotiator'] = negotiator
         self.action(ILocaleNegotiator, register, introspectables=(intr,))
 
@@ -97,10 +100,15 @@ class I18NConfiguratorMixin(object):
                 asset = resolver.resolve(spec)
                 directory = asset.abspath()
                 if not asset.isdir():
-                    raise ConfigurationError('"%s" is not a directory' %
-                                            directory)
-                intr = self.introspectable('translation directories', directory,
-                                        spec, 'translation directory')
+                    raise ConfigurationError(
+                        '"%s" is not a directory' % directory
+                    )
+                intr = self.introspectable(
+                    'translation directories',
+                    directory,
+                    spec,
+                    'translation directory',
+                )
                 intr['directory'] = directory
                 intr['spec'] = spec
                 introspectables.append(intr)
@@ -117,4 +125,3 @@ class I18NConfiguratorMixin(object):
                     tdirs.insert(0, directory)
 
         self.action(None, register, introspectables=introspectables)
-
diff --git a/src/pyramid/config/predicates.py b/src/pyramid/config/predicates.py
index bda763161..cdbf68ca4 100644
--- a/src/pyramid/config/predicates.py
+++ b/src/pyramid/config/predicates.py
@@ -1,2 +1,3 @@
 import zope.deprecation
+
 zope.deprecation.moved('pyramid.predicates', 'Pyramid 1.10')
diff --git a/src/pyramid/config/rendering.py b/src/pyramid/config/rendering.py
index 0d55c41e8..948199636 100644
--- a/src/pyramid/config/rendering.py
+++ b/src/pyramid/config/rendering.py
@@ -1,7 +1,4 @@
-from pyramid.interfaces import (
-    IRendererFactory,
-    PHASE1_CONFIG,
-    )
+from pyramid.interfaces import IRendererFactory, PHASE1_CONFIG
 
 from pyramid import renderers
 from pyramid.config.util import action_method
@@ -9,13 +6,14 @@ from pyramid.config.util import action_method
 DEFAULT_RENDERERS = (
     ('json', renderers.json_renderer_factory),
     ('string', renderers.string_renderer_factory),
-    )
+)
+
 
 class RenderingConfiguratorMixin(object):
     def add_default_renderers(self):
         for name, renderer in DEFAULT_RENDERERS:
             self.add_renderer(name, renderer)
-    
+
     @action_method
     def add_renderer(self, name, factory):
         """
@@ -36,16 +34,23 @@ class RenderingConfiguratorMixin(object):
         # as a name
         if not name:
             name = ''
+
         def register():
             self.registry.registerUtility(factory, IRendererFactory, name=name)
-        intr = self.introspectable('renderer factories',
-                                   name,
-                                   self.object_description(factory),
-                                   'renderer factory')
+
+        intr = self.introspectable(
+            'renderer factories',
+            name,
+            self.object_description(factory),
+            'renderer factory',
+        )
         intr['factory'] = factory
         intr['name'] = name
         # we need to register renderers early (in phase 1) because they are
         # used during view configuration (which happens in phase 3)
-        self.action((IRendererFactory, name), register, order=PHASE1_CONFIG,
-                    introspectables=(intr,))
-
+        self.action(
+            (IRendererFactory, name),
+            register,
+            order=PHASE1_CONFIG,
+            introspectables=(intr,),
+        )
diff --git a/src/pyramid/config/routes.py b/src/pyramid/config/routes.py
index 5d05429a7..46b8921cd 100644
--- a/src/pyramid/config/routes.py
+++ b/src/pyramid/config/routes.py
@@ -7,16 +7,13 @@ from pyramid.interfaces import (
     IRouteRequest,
     IRoutesMapper,
     PHASE2_CONFIG,
-    )
+)
 
 from pyramid.exceptions import ConfigurationError
 from pyramid.request import route_request_iface
 from pyramid.urldispatch import RoutesMapper
 
-from pyramid.util import (
-    as_sorted_tuple,
-    is_nonstr_iter,
-)
+from pyramid.util import as_sorted_tuple, is_nonstr_iter
 
 import pyramid.predicates
 
@@ -26,26 +23,29 @@ from pyramid.config.util import (
     predvalseq,
 )
 
+
 class RoutesConfiguratorMixin(object):
     @action_method
-    def add_route(self,
-                  name,
-                  pattern=None,
-                  factory=None,
-                  for_=None,
-                  header=None,
-                  xhr=None,
-                  accept=None,
-                  path_info=None,
-                  request_method=None,
-                  request_param=None,
-                  traverse=None,
-                  custom_predicates=(),
-                  use_global_views=False,
-                  path=None,
-                  pregenerator=None,
-                  static=False,
-                  **predicates):
+    def add_route(
+        self,
+        name,
+        pattern=None,
+        factory=None,
+        for_=None,
+        header=None,
+        xhr=None,
+        accept=None,
+        path_info=None,
+        request_method=None,
+        request_param=None,
+        traverse=None,
+        custom_predicates=(),
+        use_global_views=False,
+        path=None,
+        pregenerator=None,
+        static=False,
+        **predicates
+    ):
         """ Add a :term:`route configuration` to the current
         configuration state, as well as possibly a :term:`view
         configuration` to be used to specify a :term:`view callable`
@@ -297,27 +297,31 @@ class RoutesConfiguratorMixin(object):
         """
         if custom_predicates:
             warnings.warn(
-                ('The "custom_predicates" argument to Configurator.add_route '
-                 'is deprecated as of Pyramid 1.5.  Use '
-                 '"config.add_route_predicate" and use the registered '
-                 'route predicate as a predicate argument to add_route '
-                 'instead. See "Adding A Third Party View, Route, or '
-                 'Subscriber Predicate" in the "Hooks" chapter of the '
-                 'documentation for more information.'),
+                (
+                    'The "custom_predicates" argument to Configurator.add_route '
+                    'is deprecated as of Pyramid 1.5.  Use '
+                    '"config.add_route_predicate" and use the registered '
+                    'route predicate as a predicate argument to add_route '
+                    'instead. See "Adding A Third Party View, Route, or '
+                    'Subscriber Predicate" in the "Hooks" chapter of the '
+                    'documentation for more information.'
+                ),
                 DeprecationWarning,
-                stacklevel=3
-                )
+                stacklevel=3,
+            )
 
         if accept is not None:
             if not is_nonstr_iter(accept):
                 if '*' in accept:
                     warnings.warn(
-                        ('Passing a media range to the "accept" argument of '
-                         'Configurator.add_route is deprecated as of Pyramid '
-                         '1.10. Use a list of explicit media types.'),
+                        (
+                            'Passing a media range to the "accept" argument of '
+                            'Configurator.add_route is deprecated as of Pyramid '
+                            '1.10. Use a list of explicit media types.'
+                        ),
                         DeprecationWarning,
                         stacklevel=3,
-                        )
+                    )
                 # XXX switch this to False when range support is dropped
                 accept = [normalize_accept_offer(accept, allow_range=True)]
 
@@ -347,15 +351,16 @@ class RoutesConfiguratorMixin(object):
             pattern = parsed.path
 
             original_pregenerator = pregenerator
+
             def external_url_pregenerator(request, elements, kw):
                 if '_app_url' in kw:
                     raise ValueError(
                         'You cannot generate a path to an external route '
                         'pattern via request.route_path nor pass an _app_url '
                         'to request.route_url when generating a URL for an '
-                        'external route pattern (pattern was "%s") ' %
-                        (pattern,)
-                        )
+                        'external route pattern (pattern was "%s") '
+                        % (pattern,)
+                    )
                 if '_scheme' in kw:
                     scheme = kw['_scheme']
                 elif parsed.scheme:
@@ -365,8 +370,7 @@ class RoutesConfiguratorMixin(object):
                 kw['_app_url'] = '{0}://{1}'.format(scheme, parsed.netloc)
 
                 if original_pregenerator:
-                    elements, kw = original_pregenerator(
-                        request, elements, kw)
+                    elements, kw = original_pregenerator(request, elements, kw)
                 return elements, kw
 
             pregenerator = external_url_pregenerator
@@ -379,10 +383,9 @@ class RoutesConfiguratorMixin(object):
 
         introspectables = []
 
-        intr = self.introspectable('routes',
-                                   name,
-                                   '%s (pattern: %r)' % (name, pattern),
-                                   'route')
+        intr = self.introspectable(
+            'routes', name, '%s (pattern: %r)' % (name, pattern), 'route'
+        )
         intr['name'] = name
         intr['pattern'] = pattern
         intr['factory'] = factory
@@ -404,17 +407,21 @@ class RoutesConfiguratorMixin(object):
         introspectables.append(intr)
 
         if factory:
-            factory_intr = self.introspectable('root factories',
-                                               name,
-                                               self.object_description(factory),
-                                               'root factory')
+            factory_intr = self.introspectable(
+                'root factories',
+                name,
+                self.object_description(factory),
+                'root factory',
+            )
             factory_intr['factory'] = factory
             factory_intr['route_name'] = name
             factory_intr.relate('routes', name)
             introspectables.append(factory_intr)
 
         def register_route_request_iface():
-            request_iface = self.registry.queryUtility(IRouteRequest, name=name)
+            request_iface = self.registry.queryUtility(
+                IRouteRequest, name=name
+            )
             if request_iface is None:
                 if use_global_views:
                     bases = (IRequest,)
@@ -422,7 +429,8 @@ class RoutesConfiguratorMixin(object):
                     bases = ()
                 request_iface = route_request_iface(name, bases)
                 self.registry.registerUtility(
-                    request_iface, IRouteRequest, name=name)
+                    request_iface, IRouteRequest, name=name
+                )
 
         def register_connect():
             pvals = predicates.copy()
@@ -436,15 +444,19 @@ class RoutesConfiguratorMixin(object):
                     accept=accept,
                     traverse=traverse,
                     custom=predvalseq(custom_predicates),
-                    )
                 )
+            )
 
             predlist = self.get_predlist('route')
             _, preds, _ = predlist.make(self, **pvals)
             route = mapper.connect(
-                name, pattern, factory, predicates=preds,
-                pregenerator=pregenerator, static=static
-                )
+                name,
+                pattern,
+                factory,
+                predicates=preds,
+                pregenerator=pregenerator,
+                static=static,
+            )
             intr['object'] = route
             return route
 
@@ -455,12 +467,17 @@ class RoutesConfiguratorMixin(object):
 
         # But IRouteRequest interfaces must be registered before we begin to
         # process view registrations (in phase 3)
-        self.action(('route', name), register_route_request_iface,
-                    order=PHASE2_CONFIG, introspectables=introspectables)
+        self.action(
+            ('route', name),
+            register_route_request_iface,
+            order=PHASE2_CONFIG,
+            introspectables=introspectables,
+        )
 
     @action_method
-    def add_route_predicate(self, name, factory, weighs_more_than=None,
-                            weighs_less_than=None):
+    def add_route_predicate(
+        self, name, factory, weighs_more_than=None, weighs_less_than=None
+    ):
         """ Adds a route predicate factory.  The view predicate can later be
         named as a keyword argument to
         :meth:`pyramid.config.Configurator.add_route`.
@@ -481,8 +498,8 @@ class RoutesConfiguratorMixin(object):
             name,
             factory,
             weighs_more_than=weighs_more_than,
-            weighs_less_than=weighs_less_than
-            )
+            weighs_less_than=weighs_less_than,
+        )
 
     def add_default_route_predicates(self):
         p = pyramid.predicates
@@ -496,7 +513,7 @@ class RoutesConfiguratorMixin(object):
             ('effective_principals', p.EffectivePrincipalsPredicate),
             ('custom', p.CustomPredicate),
             ('traverse', p.TraversePredicate),
-            ):
+        ):
             self.add_route_predicate(name, factory)
 
     def get_routes_mapper(self):
@@ -541,8 +558,7 @@ class RoutesConfiguratorMixin(object):
             old_route_prefix = ''
 
         route_prefix = '{}/{}'.format(
-            old_route_prefix.rstrip('/'),
-            route_prefix.lstrip('/'),
+            old_route_prefix.rstrip('/'), route_prefix.lstrip('/')
         )
 
         route_prefix = route_prefix.strip('/')
diff --git a/src/pyramid/config/security.py b/src/pyramid/config/security.py
index c7afbcf4e..3b55c41d7 100644
--- a/src/pyramid/config/security.py
+++ b/src/pyramid/config/security.py
@@ -8,7 +8,7 @@ from pyramid.interfaces import (
     IDefaultPermission,
     PHASE1_CONFIG,
     PHASE2_CONFIG,
-    )
+)
 
 from pyramid.csrf import LegacySessionCSRFStoragePolicy
 from pyramid.exceptions import ConfigurationError
@@ -16,8 +16,8 @@ from pyramid.util import as_sorted_tuple
 
 from pyramid.config.util import action_method
 
-class SecurityConfiguratorMixin(object):
 
+class SecurityConfiguratorMixin(object):
     def add_default_security(self):
         self.set_csrf_storage_policy(LegacySessionCSRFStoragePolicy())
 
@@ -35,20 +35,30 @@ class SecurityConfiguratorMixin(object):
            achieve the same purpose.
 
         """
+
         def register():
             self._set_authentication_policy(policy)
             if self.registry.queryUtility(IAuthorizationPolicy) is None:
                 raise ConfigurationError(
                     'Cannot configure an authentication policy without '
                     'also configuring an authorization policy '
-                    '(use the set_authorization_policy method)')
-        intr = self.introspectable('authentication policy', None,
-                                   self.object_description(policy),
-                                   'authentication policy')
+                    '(use the set_authorization_policy method)'
+                )
+
+        intr = self.introspectable(
+            'authentication policy',
+            None,
+            self.object_description(policy),
+            'authentication policy',
+        )
         intr['policy'] = policy
         # authentication policy used by view config (phase 3)
-        self.action(IAuthenticationPolicy, register, order=PHASE2_CONFIG,
-                    introspectables=(intr,))
+        self.action(
+            IAuthenticationPolicy,
+            register,
+            order=PHASE2_CONFIG,
+            introspectables=(intr,),
+        )
 
     def _set_authentication_policy(self, policy):
         policy = self.maybe_dotted(policy)
@@ -67,8 +77,10 @@ class SecurityConfiguratorMixin(object):
            :class:`pyramid.config.Configurator` constructor can be used to
            achieve the same purpose.
         """
+
         def register():
             self._set_authorization_policy(policy)
+
         def ensure():
             if self.autocommit:
                 return
@@ -76,16 +88,24 @@ class SecurityConfiguratorMixin(object):
                 raise ConfigurationError(
                     'Cannot configure an authorization policy without '
                     'also configuring an authentication policy '
-                    '(use the set_authorization_policy method)')
+                    '(use the set_authorization_policy method)'
+                )
 
-        intr = self.introspectable('authorization policy', None,
-                                   self.object_description(policy),
-                                   'authorization policy')
+        intr = self.introspectable(
+            'authorization policy',
+            None,
+            self.object_description(policy),
+            'authorization policy',
+        )
         intr['policy'] = policy
         # authorization policy used by view config (phase 3) and
         # authentication policy (phase 2)
-        self.action(IAuthorizationPolicy, register, order=PHASE1_CONFIG,
-                    introspectables=(intr,))
+        self.action(
+            IAuthorizationPolicy,
+            register,
+            order=PHASE1_CONFIG,
+            introspectables=(intr,),
+        )
         self.action(None, ensure)
 
     def _set_authorization_policy(self, policy):
@@ -133,21 +153,25 @@ class SecurityConfiguratorMixin(object):
            :class:`pyramid.config.Configurator` constructor can be used to
            achieve the same purpose.
         """
+
         def register():
             self.registry.registerUtility(permission, IDefaultPermission)
-        intr = self.introspectable('default permission',
-                                   None,
-                                   permission,
-                                   'default permission')
+
+        intr = self.introspectable(
+            'default permission', None, permission, 'default permission'
+        )
         intr['value'] = permission
-        perm_intr = self.introspectable('permissions',
-                                        permission,
-                                        permission,
-                                        'permission')
+        perm_intr = self.introspectable(
+            'permissions', permission, permission, 'permission'
+        )
         perm_intr['value'] = permission
         # default permission used during view registration (phase 3)
-        self.action(IDefaultPermission, register, order=PHASE1_CONFIG,
-                    introspectables=(intr, perm_intr,))
+        self.action(
+            IDefaultPermission,
+            register,
+            order=PHASE1_CONFIG,
+            introspectables=(intr, perm_intr),
+        )
 
     def add_permission(self, permission_name):
         """
@@ -161,11 +185,8 @@ class SecurityConfiguratorMixin(object):
           config.add_permission('view')
         """
         intr = self.introspectable(
-            'permissions',
-            permission_name,
-            permission_name,
-            'permission'
-            )
+            'permissions', permission_name, permission_name, 'permission'
+        )
         intr['value'] = permission_name
         self.action(None, introspectables=(intr,))
 
@@ -217,22 +238,30 @@ class SecurityConfiguratorMixin(object):
 
         """
         options = DefaultCSRFOptions(
-            require_csrf, token, header, safe_methods, callback,
+            require_csrf, token, header, safe_methods, callback
         )
+
         def register():
             self.registry.registerUtility(options, IDefaultCSRFOptions)
-        intr = self.introspectable('default csrf view options',
-                                   None,
-                                   options,
-                                   'default csrf view options')
+
+        intr = self.introspectable(
+            'default csrf view options',
+            None,
+            options,
+            'default csrf view options',
+        )
         intr['require_csrf'] = require_csrf
         intr['token'] = token
         intr['header'] = header
         intr['safe_methods'] = as_sorted_tuple(safe_methods)
         intr['callback'] = callback
 
-        self.action(IDefaultCSRFOptions, register, order=PHASE1_CONFIG,
-                    introspectables=(intr,))
+        self.action(
+            IDefaultCSRFOptions,
+            register,
+            order=PHASE1_CONFIG,
+            introspectables=(intr,),
+        )
 
     @action_method
     def set_csrf_storage_policy(self, policy):
@@ -245,12 +274,13 @@ class SecurityConfiguratorMixin(object):
         how to generate and persist CSRF tokens.
 
         """
+
         def register():
             self.registry.registerUtility(policy, ICSRFStoragePolicy)
-        intr = self.introspectable('csrf storage policy',
-                                   None,
-                                   policy,
-                                   'csrf storage policy')
+
+        intr = self.introspectable(
+            'csrf storage policy', None, policy, 'csrf storage policy'
+        )
         intr['policy'] = policy
         self.action(ICSRFStoragePolicy, register, introspectables=(intr,))
 
diff --git a/src/pyramid/config/settings.py b/src/pyramid/config/settings.py
index 11a1f7d8c..07b469c29 100644
--- a/src/pyramid/config/settings.py
+++ b/src/pyramid/config/settings.py
@@ -2,6 +2,7 @@ import os
 
 from pyramid.settings import asbool, aslist
 
+
 class SettingsConfiguratorMixin(object):
     def _set_settings(self, mapping):
         if mapping is None:
@@ -60,11 +61,13 @@ def Settings(d=None, _environ_=os.environ, **kw):
     d.update(**kw)
 
     eget = _environ_.get
+
     def expand_key(key):
         keys = [key]
         if not key.startswith('pyramid.'):
             keys.append('pyramid.' + key)
         return keys
+
     def S(settings_key, env_key=None, type_=str, default=False):
         value = default
         keys = expand_key(settings_key)
@@ -74,6 +77,7 @@ def Settings(d=None, _environ_=os.environ, **kw):
             value = eget(env_key, value)
         value = type_(value)
         d.update({k: value for k in keys})
+
     def O(settings_key, override_key):  # noqa: E743
         for key in expand_key(settings_key):
             d[key] = d[key] or d[override_key]
diff --git a/src/pyramid/config/testing.py b/src/pyramid/config/testing.py
index 1daf5cdeb..1655df52c 100644
--- a/src/pyramid/config/testing.py
+++ b/src/pyramid/config/testing.py
@@ -5,22 +5,25 @@ from pyramid.interfaces import (
     IAuthorizationPolicy,
     IAuthenticationPolicy,
     IRendererFactory,
-    )
+)
 
 from pyramid.renderers import RendererHelper
 
-from pyramid.traversal import (
-    decode_path_info,
-    split_path_info,
-    )
+from pyramid.traversal import decode_path_info, split_path_info
 
 from pyramid.config.util import action_method
 
+
 class TestingConfiguratorMixin(object):
     # testing API
-    def testing_securitypolicy(self, userid=None, groupids=(),
-                               permissive=True, remember_result=None,
-                               forget_result=None):
+    def testing_securitypolicy(
+        self,
+        userid=None,
+        groupids=(),
+        permissive=True,
+        remember_result=None,
+        forget_result=None,
+    ):
         """Unit/integration testing helper: Registers a pair of faux
         :app:`Pyramid` security policies: a :term:`authentication
         policy` and a :term:`authorization policy`.
@@ -64,9 +67,10 @@ class TestingConfiguratorMixin(object):
            The ``forget_result`` argument.
         """
         from pyramid.testing import DummySecurityPolicy
+
         policy = DummySecurityPolicy(
             userid, groupids, permissive, remember_result, forget_result
-            )
+        )
         self.registry.registerUtility(policy, IAuthorizationPolicy)
         self.registry.registerUtility(policy, IAuthenticationPolicy)
         return policy
@@ -85,6 +89,7 @@ class TestingConfiguratorMixin(object):
         :func:`pyramid.traversal.find_resource` is called with an
         equivalent path string or tuple.
         """
+
         class DummyTraverserFactory:
             def __init__(self, context):
                 self.context = context
@@ -93,14 +98,22 @@ class TestingConfiguratorMixin(object):
                 path = decode_path_info(request.environ['PATH_INFO'])
                 ob = resources[path]
                 traversed = split_path_info(path)
-                return {'context':ob, 'view_name':'','subpath':(),
-                        'traversed':traversed, 'virtual_root':ob,
-                        'virtual_root_path':(), 'root':ob}
-        self.registry.registerAdapter(DummyTraverserFactory, (Interface,),
-                                      ITraverser)
+                return {
+                    'context': ob,
+                    'view_name': '',
+                    'subpath': (),
+                    'traversed': traversed,
+                    'virtual_root': ob,
+                    'virtual_root_path': (),
+                    'root': ob,
+                }
+
+        self.registry.registerAdapter(
+            DummyTraverserFactory, (Interface,), ITraverser
+        )
         return resources
 
-    testing_models = testing_resources # b/w compat
+    testing_models = testing_resources  # b/w compat
 
     @action_method
     def testing_add_subscriber(self, event_iface=None):
@@ -122,8 +135,10 @@ class TestingConfiguratorMixin(object):
         """
         event_iface = self.maybe_dotted(event_iface)
         L = []
+
         def subscriber(*event):
             L.extend(event)
+
         self.add_subscriber(subscriber, event_iface)
         return L
 
@@ -149,19 +164,22 @@ class TestingConfiguratorMixin(object):
 
         """
         from pyramid.testing import DummyRendererFactory
+
         helper = RendererHelper(name=path, registry=self.registry)
-        factory = self.registry.queryUtility(IRendererFactory, name=helper.type)
+        factory = self.registry.queryUtility(
+            IRendererFactory, name=helper.type
+        )
         if not isinstance(factory, DummyRendererFactory):
             factory = DummyRendererFactory(helper.type, factory)
-            self.registry.registerUtility(factory, IRendererFactory,
-                                          name=helper.type)
+            self.registry.registerUtility(
+                factory, IRendererFactory, name=helper.type
+            )
 
         from pyramid.testing import DummyTemplateRenderer
+
         if renderer is None:
             renderer = DummyTemplateRenderer()
         factory.add(path, renderer)
         return renderer
 
     testing_add_template = testing_add_renderer
-
-
diff --git a/src/pyramid/config/tweens.py b/src/pyramid/config/tweens.py
index 8bf21cf71..a90008784 100644
--- a/src/pyramid/config/tweens.py
+++ b/src/pyramid/config/tweens.py
@@ -2,26 +2,17 @@ from zope.interface import implementer
 
 from pyramid.interfaces import ITweens
 
-from pyramid.compat import (
-    string_types,
-    is_nonstr_iter,
-    )
+from pyramid.compat import string_types, is_nonstr_iter
 
 from pyramid.exceptions import ConfigurationError
 
-from pyramid.tweens import (
-    MAIN,
-    INGRESS,
-    EXCVIEW,
-    )
+from pyramid.tweens import MAIN, INGRESS, EXCVIEW
 
-from pyramid.util import (
-    is_string_or_iterable,
-    TopologicalSorter,
-    )
+from pyramid.util import is_string_or_iterable, TopologicalSorter
 
 from pyramid.config.util import action_method
 
+
 class TweensConfiguratorMixin(object):
     def add_tween(self, tween_factory, under=None, over=None):
         """
@@ -104,8 +95,9 @@ class TweensConfiguratorMixin(object):
         For more information, see :ref:`registering_tweens`.
 
         """
-        return self._add_tween(tween_factory, under=under, over=over,
-                               explicit=False)
+        return self._add_tween(
+            tween_factory, under=under, over=over, explicit=False
+        )
 
     def add_default_tweens(self):
         self.add_tween(EXCVIEW)
@@ -116,8 +108,9 @@ class TweensConfiguratorMixin(object):
         if not isinstance(tween_factory, string_types):
             raise ConfigurationError(
                 'The "tween_factory" argument to add_tween must be a '
-                'dotted name to a globally importable object, not %r' %
-                tween_factory)
+                'dotted name to a globally importable object, not %r'
+                % tween_factory
+            )
 
         name = tween_factory
 
@@ -130,7 +123,8 @@ class TweensConfiguratorMixin(object):
             if p is not None:
                 if not is_string_or_iterable(p):
                     raise ConfigurationError(
-                        '"%s" must be a string or iterable, not %s' % (t, p))
+                        '"%s" must be a string or iterable, not %s' % (t, p)
+                    )
 
         if over is INGRESS or is_nonstr_iter(over) and INGRESS in over:
             raise ConfigurationError('%s cannot be over INGRESS' % name)
@@ -150,15 +144,16 @@ class TweensConfiguratorMixin(object):
             if explicit:
                 tweens.add_explicit(name, tween_factory)
             else:
-                tweens.add_implicit(name, tween_factory, under=under, over=over)
+                tweens.add_implicit(
+                    name, tween_factory, under=under, over=over
+                )
 
         discriminator = ('tween', name, explicit)
         tween_type = explicit and 'explicit' or 'implicit'
 
-        intr = self.introspectable('tweens',
-                                   discriminator,
-                                   name,
-                                   '%s tween' % tween_type)
+        intr = self.introspectable(
+            'tweens', discriminator, name, '%s tween' % tween_type
+        )
         intr['name'] = name
         intr['factory'] = tween_factory
         intr['type'] = tween_type
@@ -167,6 +162,7 @@ class TweensConfiguratorMixin(object):
         introspectables.append(intr)
         self.action(discriminator, register, introspectables=introspectables)
 
+
 @implementer(ITweens)
 class Tweens(object):
     def __init__(self):
@@ -174,7 +170,8 @@ class Tweens(object):
             default_before=None,
             default_after=INGRESS,
             first=INGRESS,
-            last=MAIN)
+            last=MAIN,
+        )
         self.explicit = []
 
     def add_explicit(self, name, factory):
diff --git a/src/pyramid/config/util.py b/src/pyramid/config/util.py
index 05d810f6f..627b78b6f 100644
--- a/src/pyramid/config/util.py
+++ b/src/pyramid/config/util.py
@@ -4,23 +4,18 @@ import traceback
 from webob.acceptparse import Accept
 from zope.interface import implementer
 
-from pyramid.compat import (
-    bytes_,
-    is_nonstr_iter
-)
+from pyramid.compat import bytes_, is_nonstr_iter
 from pyramid.interfaces import IActionInfo
 
 from pyramid.exceptions import ConfigurationError
 from pyramid.predicates import Notted
 from pyramid.registry import predvalseq
-from pyramid.util import (
-    TopologicalSorter,
-    takes_one_arg,
-)
+from pyramid.util import TopologicalSorter, takes_one_arg
 
 TopologicalSorter = TopologicalSorter  # support bw-compat imports
 takes_one_arg = takes_one_arg  # support bw-compat imports
 
+
 @implementer(IActionInfo)
 class ActionInfo(object):
     def __init__(self, file, line, function, src):
@@ -34,10 +29,12 @@ class ActionInfo(object):
         src = '\n'.join('    %s' % x for x in srclines)
         return 'Line %s of file %s:\n%s' % (self.line, self.file, src)
 
+
 def action_method(wrapped):
     """ Wrapper to provide the right conflict info report data when a method
     that calls Configurator.action calls another that does the same.  Not a
     documented API but used by some external systems."""
+
     def wrapper(self, *arg, **kw):
         if self._ainfo is None:
             self._ainfo = []
@@ -55,10 +52,10 @@ def action_method(wrapped):
                 # extra stack frame. This should no longer be necessary in
                 # Python 3.5.1
                 last_frame = ActionInfo(*f[-1])
-                if last_frame.function == 'extract_stack': # pragma: no cover
+                if last_frame.function == 'extract_stack':  # pragma: no cover
                     f.pop()
                 info = ActionInfo(*f[-backframes])
-            except Exception: # pragma: no cover
+            except Exception:  # pragma: no cover
                 info = ActionInfo(None, 0, '', '')
         self._ainfo.append(info)
         try:
@@ -112,6 +109,7 @@ class not_(object):
 
     .. versionadded:: 1.5
     """
+
     def __init__(self, value):
         self.value = value
 
@@ -119,8 +117,8 @@ class not_(object):
 # under = after
 # over = before
 
-class PredicateList(object):
 
+class PredicateList(object):
     def __init__(self):
         self.sorter = TopologicalSorter()
         self.last_added = None
@@ -133,11 +131,8 @@ class PredicateList(object):
         ##     weighs_less_than = LAST
         self.last_added = name
         self.sorter.add(
-            name,
-            factory,
-            after=weighs_more_than,
-            before=weighs_less_than,
-            )
+            name, factory, after=weighs_more_than, before=weighs_less_than
+        )
 
     def names(self):
         # Return the list of valid predicate names.
@@ -161,7 +156,7 @@ class PredicateList(object):
         preds = []
         for n, (name, predicate_factory) in enumerate(ordered):
             vals = kw.pop(name, None)
-            if vals is None: # XXX should this be a sentinel other than None?
+            if vals is None:  # XXX should this be a sentinel other than None?
                 continue
             if not isinstance(vals, predvalseq):
                 vals = (vals,)
@@ -183,8 +178,9 @@ class PredicateList(object):
                 preds.append(pred)
         if kw:
             from difflib import get_close_matches
+
             closest = []
-            names = [ name for name, _ in ordered ]
+            names = [name for name, _ in ordered]
             for name in kw:
                 closest.extend(get_close_matches(name, names, 3))
 
@@ -266,8 +262,7 @@ def sort_accept_offers(offers, order=None):
         parsed = Accept.parse_offer(value)
 
         type_w = find_order_index(
-            parsed.type + '/' + parsed.subtype,
-            max_weight,
+            parsed.type + '/' + parsed.subtype, max_weight
         )
 
         if parsed.params:
diff --git a/src/pyramid/config/views.py b/src/pyramid/config/views.py
index e6baa7c17..277b207fd 100644
--- a/src/pyramid/config/views.py
+++ b/src/pyramid/config/views.py
@@ -6,11 +6,7 @@ import os
 import warnings
 
 from webob.acceptparse import Accept
-from zope.interface import (
-    Interface,
-    implementedBy,
-    implementer,
-    )
+from zope.interface import Interface, implementedBy, implementer
 from zope.interface.interfaces import IInterface
 
 from pyramid.interfaces import (
@@ -31,7 +27,7 @@ from pyramid.interfaces import (
     IViewDeriverInfo,
     IViewMapperFactory,
     PHASE1_CONFIG,
-    )
+)
 
 from pyramid import renderers
 
@@ -42,20 +38,17 @@ from pyramid.compat import (
     url_quote,
     WIN,
     is_nonstr_iter,
-    )
+)
 
 from pyramid.decorator import reify
 
-from pyramid.exceptions import (
-    ConfigurationError,
-    PredicateMismatch,
-    )
+from pyramid.exceptions import ConfigurationError, PredicateMismatch
 
 from pyramid.httpexceptions import (
     HTTPForbidden,
     HTTPNotFound,
     default_exceptionresponse_view,
-    )
+)
 
 from pyramid.registry import Deferred
 
@@ -66,10 +59,7 @@ from pyramid.url import parse_url_overrides
 
 from pyramid.view import AppendSlashNotFoundViewFactory
 
-from pyramid.util import (
-    as_sorted_tuple,
-    TopologicalSorter,
-    )
+from pyramid.util import as_sorted_tuple, TopologicalSorter
 
 import pyramid.predicates
 import pyramid.viewderivers
@@ -91,19 +81,19 @@ from pyramid.config.util import (
     normalize_accept_offer,
     predvalseq,
     sort_accept_offers,
-    )
+)
 
 urljoin = urlparse.urljoin
 url_parse = urlparse.urlparse
 
-DefaultViewMapper = DefaultViewMapper # bw-compat
-preserve_view_attrs = preserve_view_attrs # bw-compat
-requestonly = requestonly # bw-compat
-view_description = view_description # bw-compat
+DefaultViewMapper = DefaultViewMapper  # bw-compat
+preserve_view_attrs = preserve_view_attrs  # bw-compat
+requestonly = requestonly  # bw-compat
+view_description = view_description  # bw-compat
+
 
 @implementer(IMultiView)
 class MultiView(object):
-
     def __init__(self, name):
         self.name = name
         self.media_views = {}
@@ -181,21 +171,22 @@ class MultiView(object):
                 continue
         raise PredicateMismatch(self.name)
 
+
 def attr_wrapped_view(view, info):
-    accept, order, phash = (info.options.get('accept', None),
-                            getattr(info, 'order', MAX_ORDER),
-                            getattr(info, 'phash', DEFAULT_PHASH))
+    accept, order, phash = (
+        info.options.get('accept', None),
+        getattr(info, 'order', MAX_ORDER),
+        getattr(info, 'phash', DEFAULT_PHASH),
+    )
     # this is a little silly but we don't want to decorate the original
     # function with attributes that indicate accept, order, and phash,
     # so we use a wrapper
-    if (
-        (accept is None) and
-        (order == MAX_ORDER) and
-        (phash == DEFAULT_PHASH)
-    ):
-        return view # defaults
+    if (accept is None) and (order == MAX_ORDER) and (phash == DEFAULT_PHASH):
+        return view  # defaults
+
     def attr_view(context, request):
         return view(context, request)
+
     attr_view.__accept__ = accept
     attr_view.__order__ = order
     attr_view.__phash__ = phash
@@ -203,31 +194,38 @@ def attr_wrapped_view(view, info):
     attr_view.__permission__ = info.options.get('permission')
     return attr_view
 
+
 attr_wrapped_view.options = ('accept', 'attr', 'permission')
 
+
 def predicated_view(view, info):
     preds = info.predicates
     if not preds:
         return view
+
     def predicate_wrapper(context, request):
         for predicate in preds:
             if not predicate(context, request):
                 view_name = getattr(view, '__name__', view)
                 raise PredicateMismatch(
-                    'predicate mismatch for view %s (%s)' % (
-                        view_name, predicate.text()))
+                    'predicate mismatch for view %s (%s)'
+                    % (view_name, predicate.text())
+                )
         return view(context, request)
+
     def checker(context, request):
-        return all((predicate(context, request) for predicate in
-                    preds))
+        return all((predicate(context, request) for predicate in preds))
+
     predicate_wrapper.__predicated__ = checker
     predicate_wrapper.__predicates__ = preds
     return predicate_wrapper
 
+
 def viewdefaults(wrapped):
     """ Decorator for add_view-like methods which takes into account
     __view_defaults__ attached to view it is passed.  Not a documented API but
     used by some external systems."""
+
     def wrapper(self, *arg, **kw):
         defaults = {}
         if arg:
@@ -238,19 +236,23 @@ def viewdefaults(wrapped):
         if inspect.isclass(view):
             defaults = getattr(view, '__view_defaults__', {}).copy()
         if '_backframes' not in kw:
-            kw['_backframes'] = 1 # for action_method
+            kw['_backframes'] = 1  # for action_method
         defaults.update(kw)
         return wrapped(self, *arg, **defaults)
+
     return functools.wraps(wrapped)(wrapper)
 
+
 def combine_decorators(*decorators):
     def decorated(view_callable):
         # reversed() allows a more natural ordering in the api
         for decorator in reversed(decorators):
             view_callable = decorator(view_callable)
         return view_callable
+
     return decorated
 
+
 class ViewsConfiguratorMixin(object):
     @viewdefaults
     @action_method
@@ -281,7 +283,8 @@ class ViewsConfiguratorMixin(object):
         check_csrf=None,
         require_csrf=None,
         exception_only=False,
-        **view_options):
+        **view_options
+    ):
         """ Add a :term:`view configuration` to the current
         configuration state.  Arguments to ``add_view`` are broken
         down below into *predicate* arguments and *non-predicate*
@@ -804,42 +807,48 @@ class ViewsConfiguratorMixin(object):
         """
         if custom_predicates:
             warnings.warn(
-                ('The "custom_predicates" argument to Configurator.add_view '
-                 'is deprecated as of Pyramid 1.5.  Use '
-                 '"config.add_view_predicate" and use the registered '
-                 'view predicate as a predicate argument to add_view instead. '
-                 'See "Adding A Third Party View, Route, or Subscriber '
-                 'Predicate" in the "Hooks" chapter of the documentation '
-                 'for more information.'),
+                (
+                    'The "custom_predicates" argument to Configurator.add_view '
+                    'is deprecated as of Pyramid 1.5.  Use '
+                    '"config.add_view_predicate" and use the registered '
+                    'view predicate as a predicate argument to add_view instead. '
+                    'See "Adding A Third Party View, Route, or Subscriber '
+                    'Predicate" in the "Hooks" chapter of the documentation '
+                    'for more information.'
+                ),
                 DeprecationWarning,
                 stacklevel=4,
-                )
+            )
 
         if check_csrf is not None:
             warnings.warn(
-                ('The "check_csrf" argument to Configurator.add_view is '
-                 'deprecated as of Pyramid 1.7. Use the "require_csrf" option '
-                 'instead or see "Checking CSRF Tokens Automatically" in the '
-                 '"Sessions" chapter of the documentation for more '
-                 'information.'),
+                (
+                    'The "check_csrf" argument to Configurator.add_view is '
+                    'deprecated as of Pyramid 1.7. Use the "require_csrf" option '
+                    'instead or see "Checking CSRF Tokens Automatically" in the '
+                    '"Sessions" chapter of the documentation for more '
+                    'information.'
+                ),
                 DeprecationWarning,
                 stacklevel=4,
-                )
+            )
 
         if accept is not None:
             if is_nonstr_iter(accept):
                 raise ConfigurationError(
-                    'A list is not supported in the "accept" view predicate.',
+                    'A list is not supported in the "accept" view predicate.'
                 )
             if '*' in accept:
                 warnings.warn(
-                    ('Passing a media range to the "accept" argument of '
-                     'Configurator.add_view is deprecated as of Pyramid 1.10. '
-                     'Use explicit media types to avoid ambiguities in '
-                     'content negotiation that may impact your users.'),
+                    (
+                        'Passing a media range to the "accept" argument of '
+                        'Configurator.add_view is deprecated as of Pyramid 1.10. '
+                        'Use explicit media types to avoid ambiguities in '
+                        'content negotiation that may impact your users.'
+                    ),
                     DeprecationWarning,
                     stacklevel=4,
-                    )
+                )
             # XXX when media ranges are gone, switch allow_range=False
             accept = normalize_accept_offer(accept, allow_range=True)
 
@@ -856,17 +865,21 @@ class ViewsConfiguratorMixin(object):
 
         if not view:
             if renderer:
+
                 def view(context, request):
                     return {}
+
             else:
-                raise ConfigurationError('"view" was not specified and '
-                                         'no "renderer" specified')
+                raise ConfigurationError(
+                    '"view" was not specified and ' 'no "renderer" specified'
+                )
 
         if request_type is not None:
             request_type = self.maybe_dotted(request_type)
             if not IInterface.providedBy(request_type):
                 raise ConfigurationError(
-                    'request_type must be an interface, not %s' % request_type)
+                    'request_type must be an interface, not %s' % request_type
+                )
 
         if context is None:
             context = for_
@@ -875,7 +888,8 @@ class ViewsConfiguratorMixin(object):
         if exception_only and not isexc:
             raise ConfigurationError(
                 'view "context" must be an exception type when '
-                '"exception_only" is True')
+                '"exception_only" is True'
+            )
 
         r_context = context
         if r_context is None:
@@ -885,24 +899,26 @@ class ViewsConfiguratorMixin(object):
 
         if isinstance(renderer, string_types):
             renderer = renderers.RendererHelper(
-                name=renderer, package=self.package,
-                registry=self.registry)
+                name=renderer, package=self.package, registry=self.registry
+            )
 
         introspectables = []
         ovals = view_options.copy()
-        ovals.update(dict(
-            xhr=xhr,
-            request_method=request_method,
-            path_info=path_info,
-            request_param=request_param,
-            header=header,
-            accept=accept,
-            containment=containment,
-            request_type=request_type,
-            match_param=match_param,
-            check_csrf=check_csrf,
-            custom=predvalseq(custom_predicates),
-        ))
+        ovals.update(
+            dict(
+                xhr=xhr,
+                request_method=request_method,
+                path_info=path_info,
+                request_param=request_param,
+                header=header,
+                accept=accept,
+                containment=containment,
+                request_type=request_type,
+                match_param=match_param,
+                check_csrf=check_csrf,
+                custom=predvalseq(custom_predicates),
+            )
+        )
 
         def discrim_func():
             # We need to defer the discriminator until we know what the phash
@@ -924,80 +940,82 @@ class ViewsConfiguratorMixin(object):
 
             order, preds, phash = predlist.make(self, **pvals)
 
-            view_intr.update({
-                'phash': phash,
-                'order': order,
-                'predicates': preds,
-                })
+            view_intr.update(
+                {'phash': phash, 'order': order, 'predicates': preds}
+            )
             return ('view', context, name, route_name, phash)
 
         discriminator = Deferred(discrim_func)
 
         if inspect.isclass(view) and attr:
             view_desc = 'method %r of %s' % (
-                attr, self.object_description(view))
+                attr,
+                self.object_description(view),
+            )
         else:
             view_desc = self.object_description(view)
 
         tmpl_intr = None
 
-        view_intr = self.introspectable('views',
-                                        discriminator,
-                                        view_desc,
-                                        'view')
-        view_intr.update(dict(
-            name=name,
-            context=context,
-            exception_only=exception_only,
-            containment=containment,
-            request_param=request_param,
-            request_methods=request_method,
-            route_name=route_name,
-            attr=attr,
-            xhr=xhr,
-            accept=accept,
-            header=header,
-            path_info=path_info,
-            match_param=match_param,
-            check_csrf=check_csrf,
-            http_cache=http_cache,
-            require_csrf=require_csrf,
-            callable=view,
-            mapper=mapper,
-            decorator=decorator,
-        ))
+        view_intr = self.introspectable(
+            'views', discriminator, view_desc, 'view'
+        )
+        view_intr.update(
+            dict(
+                name=name,
+                context=context,
+                exception_only=exception_only,
+                containment=containment,
+                request_param=request_param,
+                request_methods=request_method,
+                route_name=route_name,
+                attr=attr,
+                xhr=xhr,
+                accept=accept,
+                header=header,
+                path_info=path_info,
+                match_param=match_param,
+                check_csrf=check_csrf,
+                http_cache=http_cache,
+                require_csrf=require_csrf,
+                callable=view,
+                mapper=mapper,
+                decorator=decorator,
+            )
+        )
         view_intr.update(view_options)
         introspectables.append(view_intr)
 
         def register(permission=permission, renderer=renderer):
             request_iface = IRequest
             if route_name is not None:
-                request_iface = self.registry.queryUtility(IRouteRequest,
-                                                           name=route_name)
+                request_iface = self.registry.queryUtility(
+                    IRouteRequest, name=route_name
+                )
                 if request_iface is None:
                     # route configuration should have already happened in
                     # phase 2
                     raise ConfigurationError(
-                        'No route named %s found for view registration' %
-                        route_name)
+                        'No route named %s found for view registration'
+                        % route_name
+                    )
 
             if renderer is None:
                 # use default renderer if one exists (reg'd in phase 1)
                 if self.registry.queryUtility(IRendererFactory) is not None:
                     renderer = renderers.RendererHelper(
-                        name=None,
-                        package=self.package,
-                        registry=self.registry
-                        )
+                        name=None, package=self.package, registry=self.registry
+                    )
 
             renderer_type = getattr(renderer, 'type', None)
             intrspc = self.introspector
             if (
-                renderer_type is not None and
-                tmpl_intr is not None and
-                intrspc is not None and
-                intrspc.get('renderer factories', renderer_type) is not None
-                ):
+                renderer_type is not None
+                and tmpl_intr is not None
+                and intrspc is not None
+                and intrspc.get('renderer factories', renderer_type)
+                is not None
+            ):
                 # allow failure of registered template factories to be deferred
                 # until view execution, like other bad renderer factories; if
                 # we tried to relate this to an existing renderer factory
@@ -1013,8 +1031,9 @@ class ViewsConfiguratorMixin(object):
                 register_view(IViewClassifier, request_iface, derived_view)
             if isexc:
                 derived_exc_view = derive_view(True, renderer)
-                register_view(IExceptionViewClassifier, request_iface,
-                              derived_exc_view)
+                register_view(
+                    IExceptionViewClassifier, request_iface, derived_exc_view
+                )
 
                 if exception_only:
                     derived_view = derived_exc_view
@@ -1085,8 +1104,8 @@ class ViewsConfiguratorMixin(object):
 
             for view_type in (IView, ISecuredView, IMultiView):
                 old_view = registered(
-                    (classifier, request_iface, r_context),
-                    view_type, name)
+                    (classifier, request_iface, r_context), view_type, name
+                )
                 if old_view is not None:
                     break
 
@@ -1109,8 +1128,8 @@ class ViewsConfiguratorMixin(object):
                     derived_view,
                     (classifier, request_iface, context),
                     view_iface,
-                    name
-                    )
+                    name,
+                )
 
             else:
                 # - A view or multiview was already registered for this
@@ -1136,32 +1155,33 @@ class ViewsConfiguratorMixin(object):
                     # unregister any existing views
                     self.registry.adapters.unregister(
                         (classifier, request_iface, r_context),
-                        view_type, name=name)
+                        view_type,
+                        name=name,
+                    )
                 self.registry.registerAdapter(
                     multiview,
                     (classifier, request_iface, context),
-                    IMultiView, name=name)
+                    IMultiView,
+                    name=name,
+                )
 
         if mapper:
             mapper_intr = self.introspectable(
                 'view mappers',
                 discriminator,
                 'view mapper for %s' % view_desc,
-                'view mapper'
-                )
+                'view mapper',
+            )
             mapper_intr['mapper'] = mapper
             mapper_intr.relate('views', discriminator)
             introspectables.append(mapper_intr)
         if route_name:
-            view_intr.relate('routes', route_name) # see add_route
+            view_intr.relate('routes', route_name)  # see add_route
         if renderer is not None and renderer.name and '.' in renderer.name:
             # the renderer is a template
             tmpl_intr = self.introspectable(
-                'templates',
-                discriminator,
-                renderer.name,
-                'template'
-                )
+                'templates', discriminator, renderer.name, 'template'
+            )
             tmpl_intr.relate('views', discriminator)
             tmpl_intr['name'] = renderer.name
             tmpl_intr['type'] = renderer.type
@@ -1170,11 +1190,8 @@ class ViewsConfiguratorMixin(object):
         if permission is not None:
             # if a permission exists, register a permission introspectable
             perm_intr = self.introspectable(
-                'permissions',
-                permission,
-                permission,
-                'permission'
-                )
+                'permissions', permission, permission, 'permission'
+            )
             perm_intr['value'] = permission
             perm_intr.relate('views', discriminator)
             introspectables.append(perm_intr)
@@ -1192,8 +1209,10 @@ class ViewsConfiguratorMixin(object):
 
     def _apply_view_derivers(self, info):
         # These derivers are not really derivers and so have fixed order
-        outer_derivers = [('attr_wrapped_view', attr_wrapped_view),
-                          ('predicated_view', predicated_view)]
+        outer_derivers = [
+            ('attr_wrapped_view', attr_wrapped_view),
+            ('predicated_view', predicated_view),
+        ]
 
         view = info.original_view
         derivers = self.registry.getUtility(IViewDerivers)
@@ -1202,8 +1221,9 @@ class ViewsConfiguratorMixin(object):
         return view
 
     @action_method
-    def add_view_predicate(self, name, factory, weighs_more_than=None,
-                           weighs_less_than=None):
+    def add_view_predicate(
+        self, name, factory, weighs_more_than=None, weighs_less_than=None
+    ):
         """
         .. versionadded:: 1.4
 
@@ -1226,8 +1246,8 @@ class ViewsConfiguratorMixin(object):
             name,
             factory,
             weighs_more_than=weighs_more_than,
-            weighs_less_than=weighs_less_than
-            )
+            weighs_less_than=weighs_less_than,
+        )
 
     def add_default_view_predicates(self):
         p = pyramid.predicates
@@ -1245,7 +1265,7 @@ class ViewsConfiguratorMixin(object):
             ('physical_path', p.PhysicalPathPredicate),
             ('effective_principals', p.EffectivePrincipalsPredicate),
             ('custom', p.CustomPredicate),
-            ):
+        ):
             self.add_view_predicate(name, factory)
 
     def add_default_accept_view_order(self):
@@ -1261,10 +1281,7 @@ class ViewsConfiguratorMixin(object):
 
     @action_method
     def add_accept_view_order(
-        self,
-        value,
-        weighs_more_than=None,
-        weighs_less_than=None,
+        self, value, weighs_more_than=None, weighs_less_than=None
     ):
         """
         Specify an ordering preference for the ``accept`` view option used
@@ -1293,19 +1310,22 @@ class ViewsConfiguratorMixin(object):
         .. versionadded:: 1.10
 
         """
+
         def check_type(than):
             than_type, than_subtype, than_params = Accept.parse_offer(than)
             # text/plain vs text/html;charset=utf8
             if bool(offer_params) ^ bool(than_params):
                 raise ConfigurationError(
                     'cannot compare a media type with params to one without '
-                    'params')
+                    'params'
+                )
             # text/plain;charset=utf8 vs text/html;charset=utf8
             if offer_params and (
                 offer_subtype != than_subtype or offer_type != than_type
             ):
                 raise ConfigurationError(
-                    'cannot compare params across different media types')
+                    'cannot compare params across different media types'
+                )
 
         def normalize_types(thans):
             thans = [normalize_accept_offer(than) for than in thans]
@@ -1328,25 +1348,27 @@ class ViewsConfiguratorMixin(object):
 
         discriminator = ('accept view order', value)
         intr = self.introspectable(
-            'accept view order',
-            value,
-            value,
-            'accept view order')
+            'accept view order', value, value, 'accept view order'
+        )
         intr['value'] = value
         intr['weighs_more_than'] = weighs_more_than
         intr['weighs_less_than'] = weighs_less_than
+
         def register():
             sorter = self.registry.queryUtility(IAcceptOrder)
             if sorter is None:
                 sorter = TopologicalSorter()
                 self.registry.registerUtility(sorter, IAcceptOrder)
             sorter.add(
-                value, value,
-                before=weighs_more_than,
-                after=weighs_less_than,
+                value, value, before=weighs_more_than, after=weighs_less_than
             )
-        self.action(discriminator, register, introspectables=(intr,),
-                    order=PHASE1_CONFIG) # must be registered before add_view
+
+        self.action(
+            discriminator,
+            register,
+            introspectables=(intr,),
+            order=PHASE1_CONFIG,
+        )  # must be registered before add_view
 
     @action_method
     def add_view_deriver(self, deriver, name=None, under=None, over=None):
@@ -1390,8 +1412,9 @@ class ViewsConfiguratorMixin(object):
             name = deriver.__name__
 
         if name in (INGRESS, VIEW):
-            raise ConfigurationError('%s is a reserved view deriver name'
-                                     % name)
+            raise ConfigurationError(
+                '%s is a reserved view deriver name' % name
+            )
 
         if under is None:
             under = 'decorated_view'
@@ -1415,15 +1438,12 @@ class ViewsConfiguratorMixin(object):
             raise ConfigurationError('%s cannot be under "mapped_view"' % name)
 
         discriminator = ('view deriver', name)
-        intr = self.introspectable(
-            'view derivers',
-            name,
-            name,
-            'view deriver')
+        intr = self.introspectable('view derivers', name, name, 'view deriver')
         intr['name'] = name
         intr['deriver'] = deriver
         intr['under'] = under
         intr['over'] = over
+
         def register():
             derivers = self.registry.queryUtility(IViewDerivers)
             if derivers is None:
@@ -1435,8 +1455,13 @@ class ViewsConfiguratorMixin(object):
                 )
                 self.registry.registerUtility(derivers, IViewDerivers)
             derivers.add(name, deriver, before=over, after=under)
-        self.action(discriminator, register, introspectables=(intr,),
-                    order=PHASE1_CONFIG) # must be registered before add_view
+
+        self.action(
+            discriminator,
+            register,
+            introspectables=(intr,),
+            order=PHASE1_CONFIG,
+        )  # must be registered before add_view
 
     def add_default_view_derivers(self):
         d = pyramid.viewderivers
@@ -1450,12 +1475,7 @@ class ViewsConfiguratorMixin(object):
         ]
         last = INGRESS
         for name, deriver in derivers:
-            self.add_view_deriver(
-                deriver,
-                name=name,
-                under=last,
-                over=VIEW,
-            )
+            self.add_view_deriver(deriver, name=name, under=last, over=VIEW)
             last = name
 
         # leave the csrf_view loosely coupled to the rest of the pipeline
@@ -1547,26 +1567,39 @@ class ViewsConfiguratorMixin(object):
         return self._derive_view(view, attr=attr, renderer=renderer)
 
     # b/w compat
-    def _derive_view(self, view, permission=None, predicates=(),
-                     attr=None, renderer=None, wrapper_viewname=None,
-                     viewname=None, accept=None, order=MAX_ORDER,
-                     phash=DEFAULT_PHASH, decorator=None, route_name=None,
-                     mapper=None, http_cache=None, context=None,
-                     require_csrf=None, exception_only=False,
-                     extra_options=None):
+    def _derive_view(
+        self,
+        view,
+        permission=None,
+        predicates=(),
+        attr=None,
+        renderer=None,
+        wrapper_viewname=None,
+        viewname=None,
+        accept=None,
+        order=MAX_ORDER,
+        phash=DEFAULT_PHASH,
+        decorator=None,
+        route_name=None,
+        mapper=None,
+        http_cache=None,
+        context=None,
+        require_csrf=None,
+        exception_only=False,
+        extra_options=None,
+    ):
         view = self.maybe_dotted(view)
         mapper = self.maybe_dotted(mapper)
         if isinstance(renderer, string_types):
             renderer = renderers.RendererHelper(
-                name=renderer, package=self.package,
-                registry=self.registry)
+                name=renderer, package=self.package, registry=self.registry
+            )
         if renderer is None:
             # use default renderer if one exists
             if self.registry.queryUtility(IRendererFactory) is not None:
                 renderer = renderers.RendererHelper(
-                    name=None,
-                    package=self.package,
-                    registry=self.registry)
+                    name=None, package=self.package, registry=self.registry
+                )
 
         options = dict(
             view=view,
@@ -1581,7 +1614,7 @@ class ViewsConfiguratorMixin(object):
             decorator=decorator,
             http_cache=http_cache,
             require_csrf=require_csrf,
-            route_name=route_name
+            route_name=route_name,
         )
         if extra_options:
             options.update(extra_options)
@@ -1624,7 +1657,7 @@ class ViewsConfiguratorMixin(object):
         mapper=None,
         match_param=None,
         **view_options
-        ):
+    ):
         """ Add a forbidden view to the current configuration state.  The
         view will be called when Pyramid or application code raises a
         :exc:`pyramid.httpexceptions.HTTPForbidden` exception and the set of
@@ -1658,13 +1691,18 @@ class ViewsConfiguratorMixin(object):
            The view is created using ``exception_only=True``.
         """
         for arg in (
-            'name', 'permission', 'context', 'for_', 'require_csrf',
+            'name',
+            'permission',
+            'context',
+            'for_',
+            'require_csrf',
             'exception_only',
         ):
             if arg in view_options:
                 raise ConfigurationError(
                     '%s may not be used as an argument to add_forbidden_view'
-                    % (arg,))
+                    % (arg,)
+                )
 
         if view is None:
             view = default_exceptionresponse_view
@@ -1691,11 +1729,11 @@ class ViewsConfiguratorMixin(object):
             require_csrf=False,
             attr=attr,
             renderer=renderer,
-            )
+        )
         settings.update(view_options)
         return self.add_view(**settings)
 
-    set_forbidden_view = add_forbidden_view # deprecated sorta-bw-compat alias
+    set_forbidden_view = add_forbidden_view  # deprecated sorta-bw-compat alias
 
     @viewdefaults
     @action_method
@@ -1720,7 +1758,7 @@ class ViewsConfiguratorMixin(object):
         match_param=None,
         append_slash=False,
         **view_options
-        ):
+    ):
         """ Add a default :term:`Not Found View` to the current configuration
         state. The view will be called when Pyramid or application code raises
         an :exc:`pyramid.httpexceptions.HTTPNotFound` exception (e.g., when a
@@ -1794,13 +1832,18 @@ class ViewsConfiguratorMixin(object):
 
         """
         for arg in (
-            'name', 'permission', 'context', 'for_', 'require_csrf',
+            'name',
+            'permission',
+            'context',
+            'for_',
+            'require_csrf',
             'exception_only',
         ):
             if arg in view_options:
                 raise ConfigurationError(
                     '%s may not be used as an argument to add_notfound_view'
-                    % (arg,))
+                    % (arg,)
+                )
 
         if view is None:
             view = default_exceptionresponse_view
@@ -1825,13 +1868,13 @@ class ViewsConfiguratorMixin(object):
             route_name=route_name,
             permission=NO_PERMISSION_REQUIRED,
             require_csrf=False,
-            )
+        )
         settings.update(view_options)
         if append_slash:
             view = self._derive_view(view, attr=attr, renderer=renderer)
             if IResponse.implementedBy(append_slash):
                 view = AppendSlashNotFoundViewFactory(
-                    view, redirect_class=append_slash,
+                    view, redirect_class=append_slash
                 )
             else:
                 view = AppendSlashNotFoundViewFactory(view)
@@ -1841,7 +1884,7 @@ class ViewsConfiguratorMixin(object):
             settings['renderer'] = renderer
         return self.add_view(**settings)
 
-    set_notfound_view = add_notfound_view # deprecated sorta-bw-compat alias
+    set_notfound_view = add_notfound_view  # deprecated sorta-bw-compat alias
 
     @viewdefaults
     @action_method
@@ -1851,7 +1894,7 @@ class ViewsConfiguratorMixin(object):
         context=None,
         # force all other arguments to be specified as key=value
         **view_options
-        ):
+    ):
         """ Add an :term:`exception view` for the specified ``exception`` to
         the current configuration state. The view will be called when Pyramid
         or application code raises the given exception.
@@ -1867,21 +1910,28 @@ class ViewsConfiguratorMixin(object):
         .. versionadded:: 1.8
         """
         for arg in (
-            'name', 'for_', 'exception_only', 'require_csrf', 'permission',
+            'name',
+            'for_',
+            'exception_only',
+            'require_csrf',
+            'permission',
         ):
             if arg in view_options:
                 raise ConfigurationError(
                     '%s may not be used as an argument to add_exception_view'
-                    % (arg,))
+                    % (arg,)
+                )
         if context is None:
             context = Exception
-        view_options.update(dict(
-            view=view,
-            context=context,
-            exception_only=True,
-            permission=NO_PERMISSION_REQUIRED,
-            require_csrf=False,
-        ))
+        view_options.update(
+            dict(
+                view=view,
+                context=context,
+                exception_only=True,
+                permission=NO_PERMISSION_REQUIRED,
+                require_csrf=False,
+            )
+        )
         return self.add_view(**view_options)
 
     @action_method
@@ -1909,17 +1959,25 @@ class ViewsConfiguratorMixin(object):
            can be used to achieve the same purpose.
         """
         mapper = self.maybe_dotted(mapper)
+
         def register():
             self.registry.registerUtility(mapper, IViewMapperFactory)
+
         # IViewMapperFactory is looked up as the result of view config
         # in phase 3
-        intr = self.introspectable('view mappers',
-                                   IViewMapperFactory,
-                                   self.object_description(mapper),
-                                   'default view mapper')
+        intr = self.introspectable(
+            'view mappers',
+            IViewMapperFactory,
+            self.object_description(mapper),
+            'default view mapper',
+        )
         intr['mapper'] = mapper
-        self.action(IViewMapperFactory, register, order=PHASE1_CONFIG,
-                    introspectables=(intr,))
+        self.action(
+            IViewMapperFactory,
+            register,
+            order=PHASE1_CONFIG,
+            introspectables=(intr,),
+        )
 
     @action_method
     def add_static_view(self, name, path, **kw):
@@ -2054,14 +2112,15 @@ class ViewsConfiguratorMixin(object):
             self.registry.registerUtility(info, IStaticURLInfo)
         return info
 
+
 def isexception(o):
     if IInterface.providedBy(o):
         if IException.isEqualOrExtendedBy(o):
             return True
-    return (
-        isinstance(o, Exception) or
-        (inspect.isclass(o) and (issubclass(o, Exception)))
-        )
+    return isinstance(o, Exception) or (
+        inspect.isclass(o) and (issubclass(o, Exception))
+    )
+
 
 def runtime_exc_view(view, excview):
     # create a view callable which can pretend to be both a normal view
@@ -2094,6 +2153,7 @@ def runtime_exc_view(view, excview):
             fn = getattr(selected_view, attr, None)
             if fn is not None:
                 return fn(context, request)
+
         return wrapper
 
     # these methods are dynamic per-request and should dispatch to their
@@ -2104,16 +2164,12 @@ def runtime_exc_view(view, excview):
     wrapper_view.__predicates__ = wrap_fn('__predicates__')
     return wrapper_view
 
+
 @implementer(IViewDeriverInfo)
 class ViewDeriverInfo(object):
-    def __init__(self,
-                 view,
-                 registry,
-                 package,
-                 predicates,
-                 exception_only,
-                 options,
-                 ):
+    def __init__(
+        self, view, registry, package, predicates, exception_only, options
+    ):
         self.original_view = view
         self.registry = registry
         self.package = package
@@ -2125,6 +2181,7 @@ class ViewDeriverInfo(object):
     def settings(self):
         return self.registry.settings
 
+
 @implementer(IStaticURLInfo)
 class StaticURLInfo(object):
     def __init__(self):
@@ -2134,12 +2191,13 @@ class StaticURLInfo(object):
     def generate(self, path, request, **kw):
         for (url, spec, route_name) in self.registrations:
             if path.startswith(spec):
-                subpath = path[len(spec):]
-                if WIN: # pragma: no cover
-                    subpath = subpath.replace('\\', '/') # windows
+                subpath = path[len(spec) :]
+                if WIN:  # pragma: no cover
+                    subpath = subpath.replace('\\', '/')  # windows
                 if self.cache_busters:
                     subpath, kw = self._bust_asset_path(
-                        request, spec, subpath, kw)
+                        request, spec, subpath, kw
+                    )
                 if url is None:
                     kw['subpath'] = subpath
                     return request.route_url(route_name, **kw)
@@ -2147,8 +2205,11 @@ class StaticURLInfo(object):
                     app_url, qs, anchor = parse_url_overrides(request, kw)
                     parsed = url_parse(url)
                     if not parsed.scheme:
-                        url = urlparse.urlunparse(parsed._replace(
-                            scheme=request.environ['wsgi.url_scheme']))
+                        url = urlparse.urlunparse(
+                            parsed._replace(
+                                scheme=request.environ['wsgi.url_scheme']
+                            )
+                        )
                     subpath = url_quote(subpath)
                     result = urljoin(url, subpath)
                     return result + qs + anchor
@@ -2161,7 +2222,7 @@ class StaticURLInfo(object):
         # appending a slash here if the spec doesn't have one is
         # required for proper prefix matching done in ``generate``
         # (``subpath = path[len(spec):]``).
-        if os.path.isabs(spec): # FBO windows
+        if os.path.isabs(spec):  # FBO windows
             sep = os.sep
         else:
             sep = '/'
@@ -2189,8 +2250,9 @@ class StaticURLInfo(object):
             cache_max_age = extra.pop('cache_max_age', None)
 
             # create a view
-            view = static_view(spec, cache_max_age=cache_max_age,
-                               use_subpath=True)
+            view = static_view(
+                spec, cache_max_age=cache_max_age, use_subpath=True
+            )
 
             # Mutate extra to allow factory, etc to be passed through here.
             # Treat permission specially because we'd like to default to
@@ -2207,7 +2269,7 @@ class StaticURLInfo(object):
 
             # register a route using the computed view, permission, and
             # pattern, plus any extras passed to us via add_static_view
-            pattern = "%s*subpath" % name # name already ends with slash
+            pattern = "%s*subpath" % name  # name already ends with slash
             if config.route_prefix:
                 route_name = '__%s/%s' % (config.route_prefix, name)
             else:
@@ -2233,10 +2295,9 @@ class StaticURLInfo(object):
             # url, spec, route_name
             registrations.append((url, spec, route_name))
 
-        intr = config.introspectable('static views',
-                                     name,
-                                     'static view for %r' % name,
-                                     'static view')
+        intr = config.introspectable(
+            'static views', name, 'static view for %r' % name, 'static view'
+        )
         intr['name'] = name
         intr['spec'] = spec
 
@@ -2245,7 +2306,7 @@ class StaticURLInfo(object):
     def add_cache_buster(self, config, spec, cachebust, explicit=False):
         # ensure the spec always has a trailing slash as we only support
         # adding cache busters to folders, not files
-        if os.path.isabs(spec): # FBO windows
+        if os.path.isabs(spec):  # FBO windows
             sep = os.sep
         else:
             sep = '/'
@@ -2282,10 +2343,9 @@ class StaticURLInfo(object):
 
             cache_busters.insert(new_idx, (spec, cachebust, explicit))
 
-        intr = config.introspectable('cache busters',
-                                     spec,
-                                     'cache buster for %r' % spec,
-                                     'cache buster')
+        intr = config.introspectable(
+            'cache busters', spec, 'cache buster for %r' % spec, 'cache buster'
+        )
         intr['cachebust'] = cachebust
         intr['path'] = spec
         intr['explicit'] = explicit
@@ -2318,9 +2378,8 @@ class StaticURLInfo(object):
         kw['pathspec'] = pathspec
         kw['rawspec'] = rawspec
         for spec_, cachebust, explicit in reversed(self.cache_busters):
-            if (
-                (explicit and rawspec.startswith(spec_)) or
-                (not explicit and pathspec.startswith(spec_))
+            if (explicit and rawspec.startswith(spec_)) or (
+                not explicit and pathspec.startswith(spec_)
             ):
                 subpath, kw = cachebust(request, subpath, kw)
                 break
diff --git a/src/pyramid/config/zca.py b/src/pyramid/config/zca.py
index bcd5c31e3..7bf637632 100644
--- a/src/pyramid/config/zca.py
+++ b/src/pyramid/config/zca.py
@@ -1,5 +1,6 @@
 from pyramid.threadlocal import get_current_registry
 
+
 class ZCAConfiguratorMixin(object):
     def hook_zca(self):
         """ Call :func:`zope.component.getSiteManager.sethook` with the
@@ -10,11 +11,12 @@ class ZCAConfiguratorMixin(object):
         :app:`Pyramid` :term:`application registry` rather than the Zope
         'global' registry."""
         from zope.component import getSiteManager
+
         getSiteManager.sethook(get_current_registry)
 
     def unhook_zca(self):
         """ Call :func:`zope.component.getSiteManager.reset` to undo the
         action of :meth:`pyramid.config.Configurator.hook_zca`."""
         from zope.component import getSiteManager
-        getSiteManager.reset()
 
+        getSiteManager.reset()
diff --git a/src/pyramid/csrf.py b/src/pyramid/csrf.py
index da171d9af..582d6a641 100644
--- a/src/pyramid/csrf.py
+++ b/src/pyramid/csrf.py
@@ -4,22 +4,11 @@ from webob.cookies import CookieProfile
 from zope.interface import implementer
 
 
-from pyramid.compat import (
-    bytes_,
-    urlparse,
-    text_,
-)
-from pyramid.exceptions import (
-    BadCSRFOrigin,
-    BadCSRFToken,
-)
+from pyramid.compat import bytes_, urlparse, text_
+from pyramid.exceptions import BadCSRFOrigin, BadCSRFToken
 from pyramid.interfaces import ICSRFStoragePolicy
 from pyramid.settings import aslist
-from pyramid.util import (
-    SimpleSerializer,
-    is_same_domain,
-    strings_differ
-)
+from pyramid.util import SimpleSerializer, is_same_domain, strings_differ
 
 
 @implementer(ICSRFStoragePolicy)
@@ -37,6 +26,7 @@ class LegacySessionCSRFStoragePolicy(object):
     .. versionadded:: 1.9
 
     """
+
     def new_csrf_token(self, request):
         """ Sets a new CSRF token into the session and returns it. """
         return request.session.new_csrf_token()
@@ -50,7 +40,8 @@ class LegacySessionCSRFStoragePolicy(object):
         """ Returns ``True`` if the ``supplied_token`` is valid."""
         expected_token = self.get_csrf_token(request)
         return not strings_differ(
-            bytes_(expected_token), bytes_(supplied_token))
+            bytes_(expected_token), bytes_(supplied_token)
+        )
 
 
 @implementer(ICSRFStoragePolicy)
@@ -68,6 +59,7 @@ class SessionCSRFStoragePolicy(object):
     .. versionadded:: 1.9
 
     """
+
     _token_factory = staticmethod(lambda: text_(uuid.uuid4().hex))
 
     def __init__(self, key='_csrft_'):
@@ -91,7 +83,8 @@ class SessionCSRFStoragePolicy(object):
         """ Returns ``True`` if the ``supplied_token`` is valid."""
         expected_token = self.get_csrf_token(request)
         return not strings_differ(
-            bytes_(expected_token), bytes_(supplied_token))
+            bytes_(expected_token), bytes_(supplied_token)
+        )
 
 
 @implementer(ICSRFStoragePolicy)
@@ -111,10 +104,19 @@ class CookieCSRFStoragePolicy(object):
        Added the ``samesite`` option and made the default ``'Lax'``.
 
     """
+
     _token_factory = staticmethod(lambda: text_(uuid.uuid4().hex))
 
-    def __init__(self, cookie_name='csrf_token', secure=False, httponly=False,
-                 domain=None, max_age=None, path='/', samesite='Lax'):
+    def __init__(
+        self,
+        cookie_name='csrf_token',
+        secure=False,
+        httponly=False,
+        domain=None,
+        max_age=None,
+        path='/',
+        samesite='Lax',
+    ):
         serializer = SimpleSerializer()
         self.cookie_profile = CookieProfile(
             cookie_name=cookie_name,
@@ -132,11 +134,10 @@ class CookieCSRFStoragePolicy(object):
         """ Sets a new CSRF token into the request and returns it. """
         token = self._token_factory()
         request.cookies[self.cookie_name] = token
+
         def set_cookie(request, response):
-            self.cookie_profile.set_cookies(
-                response,
-                token,
-            )
+            self.cookie_profile.set_cookies(response, token)
+
         request.add_response_callback(set_cookie)
         return token
 
@@ -153,7 +154,8 @@ class CookieCSRFStoragePolicy(object):
         """ Returns ``True`` if the ``supplied_token`` is valid."""
         expected_token = self.get_csrf_token(request)
         return not strings_differ(
-            bytes_(expected_token), bytes_(supplied_token))
+            bytes_(expected_token), bytes_(supplied_token)
+        )
 
 
 def get_csrf_token(request):
@@ -182,10 +184,9 @@ def new_csrf_token(request):
     return csrf.new_csrf_token(request)
 
 
-def check_csrf_token(request,
-                     token='csrf_token',
-                     header='X-CSRF-Token',
-                     raises=True):
+def check_csrf_token(
+    request, token='csrf_token', header='X-CSRF-Token', raises=True
+):
     """ Check the CSRF token returned by the
     :class:`pyramid.interfaces.ICSRFStoragePolicy` implementation against the
     value in ``request.POST.get(token)`` (if a POST request) or
@@ -267,6 +268,7 @@ def check_csrf_origin(request, trusted_origins=None, raises=True):
        Moved from :mod:`pyramid.session` to :mod:`pyramid.csrf`
 
     """
+
     def _fail(reason):
         if raises:
             raise BadCSRFOrigin(reason)
@@ -315,7 +317,8 @@ def check_csrf_origin(request, trusted_origins=None, raises=True):
         if trusted_origins is None:
             trusted_origins = aslist(
                 request.registry.settings.get(
-                    "pyramid.csrf_trusted_origins", [])
+                    "pyramid.csrf_trusted_origins", []
+                )
             )
 
         if request.host_port not in set(["80", "443"]):
@@ -325,8 +328,9 @@ def check_csrf_origin(request, trusted_origins=None, raises=True):
 
         # Actually check to see if the request's origin matches any of our
         # trusted origins.
-        if not any(is_same_domain(originp.netloc, host)
-                   for host in trusted_origins):
+        if not any(
+            is_same_domain(originp.netloc, host) for host in trusted_origins
+        ):
             reason = (
                 "Referer checking failed - {0} does not match any trusted "
                 "origins."
diff --git a/src/pyramid/decorator.py b/src/pyramid/decorator.py
index 065a3feed..89cbb0f6e 100644
--- a/src/pyramid/decorator.py
+++ b/src/pyramid/decorator.py
@@ -32,6 +32,7 @@ class reify(object):
         >>> f.jammy
         2
     """
+
     def __init__(self, wrapped):
         self.wrapped = wrapped
         update_wrapper(self, wrapped)
@@ -42,4 +43,3 @@ class reify(object):
         val = self.wrapped(inst)
         setattr(inst, self.wrapped.__name__, val)
         return val
-
diff --git a/src/pyramid/encode.py b/src/pyramid/encode.py
index 73ff14e62..2cf2247da 100644
--- a/src/pyramid/encode.py
+++ b/src/pyramid/encode.py
@@ -4,9 +4,10 @@ from pyramid.compat import (
     is_nonstr_iter,
     url_quote as _url_quote,
     url_quote_plus as _quote_plus,
-    )
+)
 
-def url_quote(val, safe=''): # bw compat api
+
+def url_quote(val, safe=''):  # bw compat api
     cls = val.__class__
     if cls is text_type:
         val = val.encode('utf-8')
@@ -14,6 +15,7 @@ def url_quote(val, safe=''): # bw compat api
         val = str(val).encode('utf-8')
     return _url_quote(val, safe=safe)
 
+
 # bw compat api (dnr)
 def quote_plus(val, safe=''):
     cls = val.__class__
@@ -23,6 +25,7 @@ def quote_plus(val, safe=''):
         val = str(val).encode('utf-8')
     return _quote_plus(val, safe=safe)
 
+
 def urlencode(query, doseq=True, quote_via=quote_plus):
     """
     An alternate implementation of Python's stdlib
diff --git a/src/pyramid/events.py b/src/pyramid/events.py
index 93fc127a1..fb3730f63 100644
--- a/src/pyramid/events.py
+++ b/src/pyramid/events.py
@@ -1,9 +1,6 @@
 import venusian
 
-from zope.interface import (
-    implementer,
-    Interface
-    )
+from zope.interface import implementer, Interface
 
 from pyramid.interfaces import (
     IContextFound,
@@ -12,7 +9,8 @@ from pyramid.interfaces import (
     IApplicationCreated,
     IBeforeRender,
     IBeforeTraversal,
-    )
+)
+
 
 class subscriber(object):
     """ Decorator activated via a :term:`scan` which treats the function
@@ -89,7 +87,8 @@ class subscriber(object):
        Added the ``_depth`` and ``_category`` arguments.
 
     """
-    venusian = venusian # for unit testing
+
+    venusian = venusian  # for unit testing
 
     def __init__(self, *ifaces, **predicates):
         self.ifaces = ifaces
@@ -103,10 +102,15 @@ class subscriber(object):
             config.add_subscriber(wrapped, iface, **self.predicates)
 
     def __call__(self, wrapped):
-        self.venusian.attach(wrapped, self.register, category=self.category,
-                             depth=self.depth + 1)
+        self.venusian.attach(
+            wrapped,
+            self.register,
+            category=self.category,
+            depth=self.depth + 1,
+        )
         return wrapped
 
+
 @implementer(INewRequest)
 class NewRequest(object):
     """ An instance of this class is emitted as an :term:`event`
@@ -114,9 +118,11 @@ class NewRequest(object):
     event instance has an attribute, ``request``, which is a
     :term:`request` object.  This event class implements the
     :class:`pyramid.interfaces.INewRequest` interface."""
+
     def __init__(self, request):
         self.request = request
 
+
 @implementer(INewResponse)
 class NewResponse(object):
     """ An instance of this class is emitted as an :term:`event`
@@ -149,10 +155,12 @@ class NewResponse(object):
        almost purely for symmetry with the
        :class:`pyramid.interfaces.INewRequest` event.
     """
+
     def __init__(self, request, response):
         self.request = request
         self.response = response
 
+
 @implementer(IBeforeTraversal)
 class BeforeTraversal(object):
     """
@@ -173,6 +181,7 @@ class BeforeTraversal(object):
     def __init__(self, request):
         self.request = request
 
+
 @implementer(IContextFound)
 class ContextFound(object):
     """ An instance of this class is emitted as an :term:`event` after
@@ -194,10 +203,13 @@ class ContextFound(object):
        As of :app:`Pyramid` 1.0, for backwards compatibility purposes, this
        event may also be imported as :class:`pyramid.events.AfterTraversal`.
     """
+
     def __init__(self, request):
         self.request = request
 
-AfterTraversal = ContextFound # b/c as of 1.0
+
+AfterTraversal = ContextFound  # b/c as of 1.0
+
 
 @implementer(IApplicationCreated)
 class ApplicationCreated(object):
@@ -214,11 +226,14 @@ class ApplicationCreated(object):
        :class:`pyramid.events.WSGIApplicationCreatedEvent`.  This was the name
        of the event class before :app:`Pyramid` 1.0.
     """
+
     def __init__(self, app):
         self.app = app
         self.object = app
 
-WSGIApplicationCreatedEvent = ApplicationCreated # b/c (as of 1.0)
+
+WSGIApplicationCreatedEvent = ApplicationCreated  # b/c (as of 1.0)
+
 
 @implementer(IBeforeRender)
 class BeforeRender(dict):
@@ -283,7 +298,7 @@ class BeforeRender(dict):
 
         See also :class:`pyramid.interfaces.IBeforeRender`.
     """
+
     def __init__(self, system, rendering_val=None):
         dict.__init__(self, system)
         self.rendering_val = rendering_val
-
diff --git a/src/pyramid/exceptions.py b/src/pyramid/exceptions.py
index c95922eb0..9a7054731 100644
--- a/src/pyramid/exceptions.py
+++ b/src/pyramid/exceptions.py
@@ -1,11 +1,7 @@
-from pyramid.httpexceptions import (
-    HTTPBadRequest,
-    HTTPNotFound,
-    HTTPForbidden,
-    )
+from pyramid.httpexceptions import HTTPBadRequest, HTTPNotFound, HTTPForbidden
 
-NotFound = HTTPNotFound # bw compat
-Forbidden = HTTPForbidden # bw compat
+NotFound = HTTPNotFound  # bw compat
+Forbidden = HTTPForbidden  # bw compat
 
 CR = '\n'
 
@@ -15,6 +11,7 @@ class BadCSRFOrigin(HTTPBadRequest):
     This exception indicates the request has failed cross-site request forgery
     origin validation.
     """
+
     title = "Bad CSRF Origin"
     explanation = (
         "Access is denied. This server can not verify that the origin or "
@@ -29,6 +26,7 @@ class BadCSRFToken(HTTPBadRequest):
     This exception indicates the request has failed cross-site request
     forgery token validation.
     """
+
     title = 'Bad CSRF Token'
     explanation = (
         'Access is denied.  This server can not verify that your cross-site '
@@ -36,7 +34,9 @@ class BadCSRFToken(HTTPBadRequest):
         'supplied the wrong cross-site request forgery token or your session '
         'no longer exists.  This may be due to session timeout or because '
         'browser is not supplying the credentials required, as can happen '
-        'when the browser has cookies turned off.')
+        'when the browser has cookies turned off.'
+    )
+
 
 class PredicateMismatch(HTTPNotFound):
     """
@@ -65,6 +65,7 @@ class PredicateMismatch(HTTPNotFound):
     exception view.
     """
 
+
 class URLDecodeError(UnicodeDecodeError):
     """
     This exception is raised when :app:`Pyramid` cannot
@@ -76,10 +77,12 @@ class URLDecodeError(UnicodeDecodeError):
     decoded.
     """
 
+
 class ConfigurationError(Exception):
     """ Raised when inappropriate input values are supplied to an API
     method of a :term:`Configurator`"""
 
+
 class ConfigurationConflictError(ConfigurationError):
     """ Raised when a configuration conflict is detected during action
     processing"""
@@ -91,7 +94,7 @@ class ConfigurationConflictError(ConfigurationError):
         r = ["Conflicting configuration actions"]
         items = sorted(self._conflicts.items())
         for discriminator, infos in items:
-            r.append("  For: %s" % (discriminator, ))
+            r.append("  For: %s" % (discriminator,))
             for info in infos:
                 for line in str(info).rstrip().split(CR):
                     r.append("    " + line)
@@ -113,6 +116,7 @@ class ConfigurationExecutionError(ConfigurationError):
 class CyclicDependencyError(Exception):
     """ The exception raised when the Pyramid topological sorter detects a
     cyclic dependency."""
+
     def __init__(self, cycles):
         self.cycles = cycles
 
diff --git a/src/pyramid/httpexceptions.py b/src/pyramid/httpexceptions.py
index bef8420b1..359601399 100644
--- a/src/pyramid/httpexceptions.py
+++ b/src/pyramid/httpexceptions.py
@@ -137,16 +137,12 @@ from zope.interface import implementer
 from webob import html_escape as _html_escape
 from webob.acceptparse import create_accept_header
 
-from pyramid.compat import (
-    class_types,
-    text_type,
-    binary_type,
-    text_,
-    )
+from pyramid.compat import class_types, text_type, binary_type, text_
 
 from pyramid.interfaces import IExceptionResponse
 from pyramid.response import Response
 
+
 def _no_escape(value):
     if value is None:
         return ''
@@ -159,6 +155,7 @@ def _no_escape(value):
             value = text_type(value)
     return value
 
+
 @implementer(IExceptionResponse)
 class HTTPException(Response, Exception):
 
@@ -195,18 +192,23 @@ class HTTPException(Response, Exception):
     code = 520
     title = 'Unknown Error'
     explanation = ''
-    body_template_obj = Template('''\
+    body_template_obj = Template(
+        '''\
 ${explanation}${br}${br}
 ${detail}
 ${html_comment}
-''')
+'''
+    )
 
-    plain_template_obj = Template('''\
+    plain_template_obj = Template(
+        '''\
 ${status}
 
-${body}''')
+${body}'''
+    )
 
-    html_template_obj = Template('''\
+    html_template_obj = Template(
+        '''\
 <html>
  <head>
   <title>${status}</title>
@@ -215,13 +217,21 @@ ${body}''')
   <h1>${status}</h1>
   ${body}
  </body>
-</html>''')
+</html>'''
+    )
 
     ## Set this to True for responses that should have no request body
     empty_body = False
 
-    def __init__(self, detail=None, headers=None, comment=None,
-                 body_template=None, json_formatter=None, **kw):
+    def __init__(
+        self,
+        detail=None,
+        headers=None,
+        comment=None,
+        body_template=None,
+        json_formatter=None,
+        **kw
+    ):
         status = '%s %s' % (self.code, self.title)
         Response.__init__(self, status=status, **kw)
         Exception.__init__(self, detail)
@@ -243,9 +253,7 @@ ${body}''')
         return str(self.detail) if self.detail else self.explanation
 
     def _json_formatter(self, status, body, title, environ):
-        return {'message': body,
-                'code': status,
-                'title': self.title}
+        return {'message': body, 'code': status, 'title': self.title}
 
     def prepare(self, environ):
         if not self.has_body and not self.empty_body:
@@ -255,7 +263,9 @@ ${body}''')
             accept = create_accept_header(accept_value)
             # Attempt to match text/html or application/json, if those don't
             # match, we will fall through to defaulting to text/plain
-            acceptable = accept.acceptable_offers(['text/html', 'application/json'])
+            acceptable = accept.acceptable_offers(
+                ['text/html', 'application/json']
+            )
             acceptable = [offer[0] for offer in acceptable] + ['text/plain']
             match = acceptable[0]
 
@@ -281,8 +291,10 @@ ${body}''')
                     def substitute(self, status, body):
                         jsonbody = self.excobj._json_formatter(
                             status=status,
-                            body=body, title=self.excobj.title,
-                            environ=environ)
+                            body=body,
+                            title=self.excobj.title,
+                            environ=environ,
+                        )
                         return json.dumps(jsonbody)
 
                 page_template = JsonPageTemplate(self)
@@ -299,7 +311,7 @@ ${body}''')
                 'detail': escape(self.detail or ''),
                 'comment': escape(comment),
                 'html_comment': html_comment,
-                }
+            }
             body_tmpl = self.body_template_obj
             if HTTPException.body_template_obj is not body_tmpl:
                 # Custom template; add headers to args
@@ -324,7 +336,7 @@ ${body}''')
         # bw compat only
         return self
 
-    exception = wsgi_response # bw compat only
+    exception = wsgi_response  # bw compat only
 
     def __call__(self, environ, start_response):
         # differences from webob.exc.WSGIHTTPException
@@ -337,7 +349,9 @@ ${body}''')
         self.prepare(environ)
         return Response.__call__(self, environ, start_response)
 
-WSGIHTTPException = HTTPException # b/c post 1.5
+
+WSGIHTTPException = HTTPException  # b/c post 1.5
+
 
 class HTTPError(HTTPException):
     """
@@ -347,6 +361,7 @@ class HTTPError(HTTPException):
     and that any work in progress should not be committed.
     """
 
+
 class HTTPRedirection(HTTPException):
     """
     base class for exceptions with status codes in the 300s (redirections)
@@ -357,16 +372,19 @@ class HTTPRedirection(HTTPException):
     condition.
     """
 
+
 class HTTPSuccessful(HTTPException):
     """
     Base class for exceptions with status codes in the 200s (successful
     responses)
     """
 
+
 ############################################################
 ## 2xx success
 ############################################################
 
+
 class HTTPOk(HTTPSuccessful):
     """
     subclass of :class:`~HTTPSuccessful`
@@ -375,9 +393,11 @@ class HTTPOk(HTTPSuccessful):
 
     code: 200, title: OK
     """
+
     code = 200
     title = 'OK'
 
+
 class HTTPCreated(HTTPSuccessful):
     """
     subclass of :class:`~HTTPSuccessful`
@@ -387,9 +407,11 @@ class HTTPCreated(HTTPSuccessful):
 
     code: 201, title: Created
     """
+
     code = 201
     title = 'Created'
 
+
 class HTTPAccepted(HTTPSuccessful):
     """
     subclass of :class:`~HTTPSuccessful`
@@ -399,10 +421,12 @@ class HTTPAccepted(HTTPSuccessful):
 
     code: 202, title: Accepted
     """
+
     code = 202
     title = 'Accepted'
     explanation = 'The request is accepted for processing.'
 
+
 class HTTPNonAuthoritativeInformation(HTTPSuccessful):
     """
     subclass of :class:`~HTTPSuccessful`
@@ -413,9 +437,11 @@ class HTTPNonAuthoritativeInformation(HTTPSuccessful):
 
     code: 203, title: Non-Authoritative Information
     """
+
     code = 203
     title = 'Non-Authoritative Information'
 
+
 class HTTPNoContent(HTTPSuccessful):
     """
     subclass of :class:`~HTTPSuccessful`
@@ -426,10 +452,12 @@ class HTTPNoContent(HTTPSuccessful):
 
     code: 204, title: No Content
     """
+
     code = 204
     title = 'No Content'
     empty_body = True
 
+
 class HTTPResetContent(HTTPSuccessful):
     """
     subclass of :class:`~HTTPSuccessful`
@@ -440,10 +468,12 @@ class HTTPResetContent(HTTPSuccessful):
 
     code: 205, title: Reset Content
     """
+
     code = 205
     title = 'Reset Content'
     empty_body = True
 
+
 class HTTPPartialContent(HTTPSuccessful):
     """
     subclass of :class:`~HTTPSuccessful`
@@ -453,15 +483,18 @@ class HTTPPartialContent(HTTPSuccessful):
 
     code: 206, title: Partial Content
     """
+
     code = 206
     title = 'Partial Content'
 
+
 ## FIXME: add 207 Multi-Status (but it's complicated)
 
 ############################################################
 ## 3xx redirection
 ############################################################
 
+
 class _HTTPMove(HTTPRedirection):
     """
     redirections which require a Location field
@@ -472,6 +505,7 @@ class _HTTPMove(HTTPRedirection):
 
     You must provide a ``location`` keyword argument.
     """
+
     # differences from webob.exc._HTTPMove:
     #
     # - ${location} isn't wrapped in an <a> tag in body
@@ -486,18 +520,33 @@ class _HTTPMove(HTTPRedirection):
     # - ``add_slash`` argument is no longer accepted:  code that passes
     #   add_slash argument to the constructor will receive an exception.
     explanation = 'The resource has been moved to'
-    body_template_obj = Template('''\
+    body_template_obj = Template(
+        '''\
 ${explanation} ${location}; you should be redirected automatically.
 ${detail}
-${html_comment}''')
+${html_comment}'''
+    )
 
-    def __init__(self, location='', detail=None, headers=None, comment=None,
-                 body_template=None, **kw):
+    def __init__(
+        self,
+        location='',
+        detail=None,
+        headers=None,
+        comment=None,
+        body_template=None,
+        **kw
+    ):
         if location is None:
             raise ValueError("HTTP redirects need a location to redirect to.")
         super(_HTTPMove, self).__init__(
-            detail=detail, headers=headers, comment=comment,
-            body_template=body_template, location=location, **kw)
+            detail=detail,
+            headers=headers,
+            comment=comment,
+            body_template=body_template,
+            location=location,
+            **kw
+        )
+
 
 class HTTPMultipleChoices(_HTTPMove):
     """
@@ -511,9 +560,11 @@ class HTTPMultipleChoices(_HTTPMove):
 
     code: 300, title: Multiple Choices
     """
+
     code = 300
     title = 'Multiple Choices'
 
+
 class HTTPMovedPermanently(_HTTPMove):
     """
     subclass of :class:`~_HTTPMove`
@@ -524,9 +575,11 @@ class HTTPMovedPermanently(_HTTPMove):
 
     code: 301, title: Moved Permanently
     """
+
     code = 301
     title = 'Moved Permanently'
 
+
 class HTTPFound(_HTTPMove):
     """
     subclass of :class:`~_HTTPMove`
@@ -536,10 +589,12 @@ class HTTPFound(_HTTPMove):
 
     code: 302, title: Found
     """
+
     code = 302
     title = 'Found'
     explanation = 'The resource was found at'
 
+
 # This one is safe after a POST (the redirected location will be
 # retrieved with GET):
 class HTTPSeeOther(_HTTPMove):
@@ -552,9 +607,11 @@ class HTTPSeeOther(_HTTPMove):
 
     code: 303, title: See Other
     """
+
     code = 303
     title = 'See Other'
 
+
 class HTTPNotModified(HTTPRedirection):
     """
     subclass of :class:`~HTTPRedirection`
@@ -565,11 +622,13 @@ class HTTPNotModified(HTTPRedirection):
 
     code: 304, title: Not Modified
     """
+
     # FIXME: this should include a date or etag header
     code = 304
     title = 'Not Modified'
     empty_body = True
 
+
 class HTTPUseProxy(_HTTPMove):
     """
     subclass of :class:`~_HTTPMove`
@@ -579,11 +638,12 @@ class HTTPUseProxy(_HTTPMove):
 
     code: 305, title: Use Proxy
     """
+
     # Not a move, but looks a little like one
     code = 305
     title = 'Use Proxy'
-    explanation = (
-        'The resource must be accessed through a proxy located at')
+    explanation = 'The resource must be accessed through a proxy located at'
+
 
 class HTTPTemporaryRedirect(_HTTPMove):
     """
@@ -594,9 +654,11 @@ class HTTPTemporaryRedirect(_HTTPMove):
 
     code: 307, title: Temporary Redirect
     """
+
     code = 307
     title = 'Temporary Redirect'
 
+
 class HTTPPermanentRedirect(_HTTPMove):
     """
     subclass of :class:`~_HTTPMove`
@@ -607,13 +669,16 @@ class HTTPPermanentRedirect(_HTTPMove):
 
     code: 308, title: Permanent Redirect
     """
+
     code = 308
     title = 'Permanent Redirect'
 
+
 ############################################################
 ## 4xx client error
 ############################################################
 
+
 class HTTPClientError(HTTPError):
     """
     base class for the 400s, where the client is in error
@@ -623,9 +688,11 @@ class HTTPClientError(HTTPError):
     a bug.  A server-side traceback is not warranted.  Unless specialized,
     this is a '400 Bad Request'
     """
+
     code = 400
     title = 'Bad Request'
 
+
 class HTTPBadRequest(HTTPClientError):
     """
     subclass of :class:`~HTTPClientError`
@@ -635,8 +702,12 @@ class HTTPBadRequest(HTTPClientError):
 
     code: 400, title: Bad Request
     """
-    explanation = ('The server could not comply with the request since '
-                   'it is either malformed or otherwise incorrect.')
+
+    explanation = (
+        'The server could not comply with the request since '
+        'it is either malformed or otherwise incorrect.'
+    )
+
 
 class HTTPUnauthorized(HTTPClientError):
     """
@@ -646,13 +717,16 @@ class HTTPUnauthorized(HTTPClientError):
 
     code: 401, title: Unauthorized
     """
+
     code = 401
     title = 'Unauthorized'
     explanation = (
         'This server could not verify that you are authorized to '
         'access the document you requested.  Either you supplied the '
         'wrong credentials (e.g., bad password), or your browser '
-        'does not understand how to supply the credentials required.')
+        'does not understand how to supply the credentials required.'
+    )
+
 
 class HTTPPaymentRequired(HTTPClientError):
     """
@@ -660,9 +734,11 @@ class HTTPPaymentRequired(HTTPClientError):
 
     code: 402, title: Payment Required
     """
+
     code = 402
     title = 'Payment Required'
-    explanation = ('Access was denied for financial reasons.')
+    explanation = 'Access was denied for financial reasons.'
+
 
 class HTTPForbidden(HTTPClientError):
     """
@@ -693,6 +769,7 @@ class HTTPForbidden(HTTPClientError):
     exception as necessary to provide extended information in an error
     report shown to a user.
     """
+
     # differences from webob.exc.HTTPForbidden:
     #
     # - accepts a ``result`` keyword argument
@@ -705,14 +782,28 @@ class HTTPForbidden(HTTPClientError):
     #
     code = 403
     title = 'Forbidden'
-    explanation = ('Access was denied to this resource.')
-    def __init__(self, detail=None, headers=None, comment=None,
-                 body_template=None, result=None, **kw):
-        HTTPClientError.__init__(self, detail=detail, headers=headers,
-                                 comment=comment, body_template=body_template,
-                                 **kw)
+    explanation = 'Access was denied to this resource.'
+
+    def __init__(
+        self,
+        detail=None,
+        headers=None,
+        comment=None,
+        body_template=None,
+        result=None,
+        **kw
+    ):
+        HTTPClientError.__init__(
+            self,
+            detail=detail,
+            headers=headers,
+            comment=comment,
+            body_template=body_template,
+            **kw
+        )
         self.result = result
 
+
 class HTTPNotFound(HTTPClientError):
     """
     subclass of :class:`~HTTPClientError`
@@ -732,9 +823,11 @@ class HTTPNotFound(HTTPClientError):
     string will be available as the ``message`` attribute of this exception,
     for availability to the :term:`Not Found View`.
     """
+
     code = 404
     title = 'Not Found'
-    explanation = ('The resource could not be found.')
+    explanation = 'The resource could not be found.'
+
 
 class HTTPMethodNotAllowed(HTTPClientError):
     """
@@ -745,14 +838,18 @@ class HTTPMethodNotAllowed(HTTPClientError):
 
     code: 405, title: Method Not Allowed
     """
+
     # differences from webob.exc.HTTPMethodNotAllowed:
     #
     # - body_template_obj uses ${br} instead of <br />
     code = 405
     title = 'Method Not Allowed'
-    body_template_obj = Template('''\
+    body_template_obj = Template(
+        '''\
 The method ${REQUEST_METHOD} is not allowed for this resource. ${br}${br}
-${detail}''')
+${detail}'''
+    )
+
 
 class HTTPNotAcceptable(HTTPClientError):
     """
@@ -765,12 +862,14 @@ class HTTPNotAcceptable(HTTPClientError):
 
     code: 406, title: Not Acceptable
     """
+
     # differences from webob.exc.HTTPNotAcceptable:
     #
     # - "template" attribute left off (useless, bug in webob?)
     code = 406
     title = 'Not Acceptable'
 
+
 class HTTPProxyAuthenticationRequired(HTTPClientError):
     """
     subclass of :class:`~HTTPClientError`
@@ -780,9 +879,11 @@ class HTTPProxyAuthenticationRequired(HTTPClientError):
 
     code: 407, title: Proxy Authentication Required
     """
+
     code = 407
     title = 'Proxy Authentication Required'
-    explanation = ('Authentication with a local proxy is needed.')
+    explanation = 'Authentication with a local proxy is needed.'
+
 
 class HTTPRequestTimeout(HTTPClientError):
     """
@@ -793,10 +894,14 @@ class HTTPRequestTimeout(HTTPClientError):
 
     code: 408, title: Request Timeout
     """
+
     code = 408
     title = 'Request Timeout'
-    explanation = ('The server has waited too long for the request to '
-                   'be sent by the client.')
+    explanation = (
+        'The server has waited too long for the request to '
+        'be sent by the client.'
+    )
+
 
 class HTTPConflict(HTTPClientError):
     """
@@ -807,10 +912,13 @@ class HTTPConflict(HTTPClientError):
 
     code: 409, title: Conflict
     """
+
     code = 409
     title = 'Conflict'
-    explanation = ('There was a conflict when trying to complete '
-                   'your request.')
+    explanation = (
+        'There was a conflict when trying to complete ' 'your request.'
+    )
+
 
 class HTTPGone(HTTPClientError):
     """
@@ -821,10 +929,14 @@ class HTTPGone(HTTPClientError):
 
     code: 410, title: Gone
     """
+
     code = 410
     title = 'Gone'
-    explanation = ('This resource is no longer available.  No forwarding '
-                   'address is given.')
+    explanation = (
+        'This resource is no longer available.  No forwarding '
+        'address is given.'
+    )
+
 
 class HTTPLengthRequired(HTTPClientError):
     """
@@ -835,9 +947,11 @@ class HTTPLengthRequired(HTTPClientError):
 
     code: 411, title: Length Required
     """
+
     code = 411
     title = 'Length Required'
-    explanation = ('Content-Length header required.')
+    explanation = 'Content-Length header required.'
+
 
 class HTTPPreconditionFailed(HTTPClientError):
     """
@@ -849,9 +963,11 @@ class HTTPPreconditionFailed(HTTPClientError):
 
     code: 412, title: Precondition Failed
     """
+
     code = 412
     title = 'Precondition Failed'
-    explanation = ('Request precondition failed.')
+    explanation = 'Request precondition failed.'
+
 
 class HTTPRequestEntityTooLarge(HTTPClientError):
     """
@@ -863,9 +979,11 @@ class HTTPRequestEntityTooLarge(HTTPClientError):
 
     code: 413, title: Request Entity Too Large
     """
+
     code = 413
     title = 'Request Entity Too Large'
-    explanation = ('The body of your request was too large for this server.')
+    explanation = 'The body of your request was too large for this server.'
+
 
 class HTTPRequestURITooLong(HTTPClientError):
     """
@@ -877,9 +995,11 @@ class HTTPRequestURITooLong(HTTPClientError):
 
     code: 414, title: Request-URI Too Long
     """
+
     code = 414
     title = 'Request-URI Too Long'
-    explanation = ('The request URI was too long for this server.')
+    explanation = 'The request URI was too long for this server.'
+
 
 class HTTPUnsupportedMediaType(HTTPClientError):
     """
@@ -891,12 +1011,14 @@ class HTTPUnsupportedMediaType(HTTPClientError):
 
     code: 415, title: Unsupported Media Type
     """
+
     # differences from webob.exc.HTTPUnsupportedMediaType:
     #
     # - "template_obj" attribute left off (useless, bug in webob?)
     code = 415
     title = 'Unsupported Media Type'
 
+
 class HTTPRequestRangeNotSatisfiable(HTTPClientError):
     """
     subclass of :class:`~HTTPClientError`
@@ -909,9 +1031,11 @@ class HTTPRequestRangeNotSatisfiable(HTTPClientError):
 
     code: 416, title: Request Range Not Satisfiable
     """
+
     code = 416
     title = 'Request Range Not Satisfiable'
-    explanation = ('The Range requested is not available.')
+    explanation = 'The Range requested is not available.'
+
 
 class HTTPExpectationFailed(HTTPClientError):
     """
@@ -922,9 +1046,11 @@ class HTTPExpectationFailed(HTTPClientError):
 
     code: 417, title: Expectation Failed
     """
+
     code = 417
     title = 'Expectation Failed'
-    explanation = ('Expectation failed.')
+    explanation = 'Expectation failed.'
+
 
 class HTTPUnprocessableEntity(HTTPClientError):
     """
@@ -940,11 +1066,13 @@ class HTTPUnprocessableEntity(HTTPClientError):
 
     code: 422, title: Unprocessable Entity
     """
+
     ## Note: from WebDAV
     code = 422
     title = 'Unprocessable Entity'
     explanation = 'Unable to process the contained instructions'
 
+
 class HTTPLocked(HTTPClientError):
     """
     subclass of :class:`~HTTPClientError`
@@ -953,10 +1081,12 @@ class HTTPLocked(HTTPClientError):
 
     code: 423, title: Locked
     """
+
     ## Note: from WebDAV
     code = 423
     title = 'Locked'
-    explanation = ('The resource is locked')
+    explanation = 'The resource is locked'
+
 
 class HTTPFailedDependency(HTTPClientError):
     """
@@ -967,12 +1097,15 @@ class HTTPFailedDependency(HTTPClientError):
 
     code: 424, title: Failed Dependency
     """
+
     ## Note: from WebDAV
     code = 424
     title = 'Failed Dependency'
     explanation = (
         'The method could not be performed because the requested '
-        'action dependended on another action and that action failed')
+        'action dependended on another action and that action failed'
+    )
+
 
 class HTTPPreconditionRequired(HTTPClientError):
     """
@@ -991,10 +1124,11 @@ class HTTPPreconditionRequired(HTTPClientError):
 
     code: 428, title: Precondition Required
     """
+
     code = 428
     title = 'Precondition Required'
-    explanation = (
-        'The origin server requires the request to be conditional.')
+    explanation = 'The origin server requires the request to be conditional.'
+
 
 class HTTPTooManyRequests(HTTPClientError):
     """
@@ -1007,11 +1141,14 @@ class HTTPTooManyRequests(HTTPClientError):
 
     code: 429, title: Too Many Requests
     """
+
     code = 429
     title = 'Too Many Requests'
     explanation = (
         'The action could not be performed because there were too '
-        'many requests by the client.')
+        'many requests by the client.'
+    )
+
 
 class HTTPRequestHeaderFieldsTooLarge(HTTPClientError):
     """
@@ -1025,10 +1162,11 @@ class HTTPRequestHeaderFieldsTooLarge(HTTPClientError):
 
     code: 431, title: Request Header Fields Too Large
     """
+
     code = 431
     title = 'Request Header Fields Too Large'
-    explanation = (
-        'The requests header fields were too large.')
+    explanation = 'The requests header fields were too large.'
+
 
 ############################################################
 ## 5xx Server Error
@@ -1041,6 +1179,7 @@ class HTTPRequestHeaderFieldsTooLarge(HTTPClientError):
 #  agents SHOULD display any included entity to the user. These response
 #  codes are applicable to any request method.
 
+
 class HTTPServerError(HTTPError):
     """
     base class for the 500s, where the server is in-error
@@ -1048,9 +1187,11 @@ class HTTPServerError(HTTPError):
     This is an error condition in which the server is presumed to be
     in-error.  Unless specialized, this is a '500 Internal Server Error'.
     """
+
     code = 500
     title = 'Internal Server Error'
 
+
 class HTTPInternalServerError(HTTPServerError):
     """
     subclass of :class:`~HTTPServerError`
@@ -1060,9 +1201,12 @@ class HTTPInternalServerError(HTTPServerError):
 
     code: 500, title: Internal Server Error
     """
+
     explanation = (
         'The server has either erred or is incapable of performing '
-        'the requested operation.')
+        'the requested operation.'
+    )
+
 
 class HTTPNotImplemented(HTTPServerError):
     """
@@ -1073,12 +1217,14 @@ class HTTPNotImplemented(HTTPServerError):
 
     code: 501, title: Not Implemented
     """
+
     # differences from webob.exc.HTTPNotAcceptable:
     #
     # - "template" attr left off (useless, bug in webob?)
     code = 501
     title = 'Not Implemented'
 
+
 class HTTPBadGateway(HTTPServerError):
     """
     subclass of :class:`~HTTPServerError`
@@ -1089,9 +1235,11 @@ class HTTPBadGateway(HTTPServerError):
 
     code: 502, title: Bad Gateway
     """
+
     code = 502
     title = 'Bad Gateway'
-    explanation = ('Bad gateway.')
+    explanation = 'Bad gateway.'
+
 
 class HTTPServiceUnavailable(HTTPServerError):
     """
@@ -1102,10 +1250,14 @@ class HTTPServiceUnavailable(HTTPServerError):
 
     code: 503, title: Service Unavailable
     """
+
     code = 503
     title = 'Service Unavailable'
-    explanation = ('The server is currently unavailable. '
-                   'Please try again at a later time.')
+    explanation = (
+        'The server is currently unavailable. '
+        'Please try again at a later time.'
+    )
+
 
 class HTTPGatewayTimeout(HTTPServerError):
     """
@@ -1118,9 +1270,11 @@ class HTTPGatewayTimeout(HTTPServerError):
 
     code: 504, title: Gateway Timeout
     """
+
     code = 504
     title = 'Gateway Timeout'
-    explanation = ('The gateway has timed out.')
+    explanation = 'The gateway has timed out.'
+
 
 class HTTPVersionNotSupported(HTTPServerError):
     """
@@ -1132,9 +1286,11 @@ class HTTPVersionNotSupported(HTTPServerError):
 
     code: 505, title: HTTP Version Not Supported
     """
+
     code = 505
     title = 'HTTP Version Not Supported'
-    explanation = ('The HTTP version is not supported.')
+    explanation = 'The HTTP version is not supported.'
+
 
 class HTTPInsufficientStorage(HTTPServerError):
     """
@@ -1145,9 +1301,11 @@ class HTTPInsufficientStorage(HTTPServerError):
 
     code: 507, title: Insufficient Storage
     """
+
     code = 507
     title = 'Insufficient Storage'
-    explanation = ('There was not enough space to save the resource')
+    explanation = 'There was not enough space to save the resource'
+
 
 def exception_response(status_code, **kw):
     """Creates an HTTP exception based on a status code. Example::
@@ -1159,22 +1317,24 @@ def exception_response(status_code, **kw):
     exc = status_map[status_code](**kw)
     return exc
 
+
 def default_exceptionresponse_view(context, request):
     if not isinstance(context, Exception):
         # backwards compat for an exception response view registered via
         # config.set_notfound_view or config.set_forbidden_view
         # instead of as a proper exception view
         context = request.exception or context
-    return context # assumed to be an IResponse
+    return context  # assumed to be an IResponse
+
 
 status_map = {}
 code = None
 for name, value in list(globals().items()):
     if (
-            isinstance(value, class_types) and
-            issubclass(value, HTTPException) and
-            value not in {HTTPClientError, HTTPServerError} and
-            not name.startswith('_')
+        isinstance(value, class_types)
+        and issubclass(value, HTTPException)
+        and value not in {HTTPClientError, HTTPServerError}
+        and not name.startswith('_')
     ):
         code = getattr(value, 'code', None)
         if code:
diff --git a/src/pyramid/i18n.py b/src/pyramid/i18n.py
index 1d11adfe3..9f5f898be 100644
--- a/src/pyramid/i18n.py
+++ b/src/pyramid/i18n.py
@@ -4,9 +4,9 @@ import os
 from translationstring import (
     Translator,
     Pluralizer,
-    TranslationString, # API
-    TranslationStringFactory, # API
-    )
+    TranslationString,  # API
+    TranslationStringFactory,  # API
+)
 
 from pyramid.compat import PY2
 from pyramid.decorator import reify
@@ -15,7 +15,7 @@ from pyramid.interfaces import (
     ILocalizer,
     ITranslationDirectories,
     ILocaleNegotiator,
-    )
+)
 
 from pyramid.threadlocal import get_current_registry
 
@@ -24,6 +24,7 @@ TranslationStringFactory = TranslationStringFactory  # PyFlakes
 
 DEFAULT_PLURAL = lambda n: int(n != 1)
 
+
 class Localizer(object):
     """
     An object providing translation and pluralizations related to
@@ -31,6 +32,7 @@ class Localizer(object):
     :class:`pyramid.i18n.Localizer` object is created using the
     :func:`pyramid.i18n.get_localizer` function.
     """
+
     def __init__(self, locale_name, translations):
         self.locale_name = locale_name
         self.translations = translations
@@ -112,8 +114,9 @@ class Localizer(object):
         """
         if self.pluralizer is None:
             self.pluralizer = Pluralizer(self.translations)
-        return self.pluralizer(singular, plural, n, domain=domain,
-                               mapping=mapping)
+        return self.pluralizer(
+            singular, plural, n, domain=domain, mapping=mapping
+        )
 
 
 def default_locale_negotiator(request):
@@ -142,6 +145,7 @@ def default_locale_negotiator(request):
             locale_name = request.cookies.get(name)
     return locale_name
 
+
 def negotiate_locale_name(request):
     """ Negotiate and return the :term:`locale name` associated with
     the current request."""
@@ -149,8 +153,9 @@ def negotiate_locale_name(request):
         registry = request.registry
     except AttributeError:
         registry = get_current_registry()
-    negotiator = registry.queryUtility(ILocaleNegotiator,
-                                       default=default_locale_negotiator)
+    negotiator = registry.queryUtility(
+        ILocaleNegotiator, default=default_locale_negotiator
+    )
     locale_name = negotiator(request)
 
     if locale_name is None:
@@ -159,6 +164,7 @@ def negotiate_locale_name(request):
 
     return locale_name
 
+
 def get_locale_name(request):
     """
     .. deprecated:: 1.5
@@ -167,6 +173,7 @@ def get_locale_name(request):
     """
     return request.locale_name
 
+
 def make_localizer(current_locale_name, translation_directories):
     """ Create a :class:`pyramid.i18n.Localizer` object
     corresponding to the provided locale name from the 
@@ -199,16 +206,17 @@ def make_localizer(current_locale_name, translation_directories):
             if not os.path.isdir(os.path.realpath(messages_dir)):
                 continue
             for mofile in os.listdir(messages_dir):
-                mopath = os.path.realpath(os.path.join(messages_dir,
-                                                       mofile))
+                mopath = os.path.realpath(os.path.join(messages_dir, mofile))
                 if mofile.endswith('.mo') and os.path.isfile(mopath):
                     with open(mopath, 'rb') as mofp:
                         domain = mofile[:-3]
                         dtrans = Translations(mofp, domain)
                         translations.add(dtrans)
 
-    return Localizer(locale_name=current_locale_name,
-                          translations=translations)
+    return Localizer(
+        locale_name=current_locale_name, translations=translations
+    )
+
 
 def get_localizer(request):
     """
@@ -219,6 +227,7 @@ def get_localizer(request):
     """
     return request.localizer
 
+
 class Translations(gettext.GNUTranslations, object):
     """An extended translation catalog class (ripped off from Babel) """
 
@@ -272,8 +281,10 @@ class Translations(gettext.GNUTranslations, object):
             return cls(fileobj=fp, domain=domain)
 
     def __repr__(self):
-        return '<%s: "%s">' % (type(self).__name__,
-                               self._info.get('project-id-version'))
+        return '<%s: "%s">' % (
+            type(self).__name__,
+            self._info.get('project-id-version'),
+        )
 
     def add(self, translations, merge=True):
         """Add the given translations to the catalog.
@@ -331,13 +342,13 @@ class Translations(gettext.GNUTranslations, object):
         domain.
         """
         return self._domains.get(domain, self).gettext(message)
-    
+
     def ldgettext(self, domain, message):
         """Like ``lgettext()``, but look the message up in the specified 
         domain.
-        """ 
+        """
         return self._domains.get(domain, self).lgettext(message)
-    
+
     def dugettext(self, domain, message):
         """Like ``ugettext()``, but look the message up in the specified
         domain.
@@ -346,29 +357,32 @@ class Translations(gettext.GNUTranslations, object):
             return self._domains.get(domain, self).ugettext(message)
         else:
             return self._domains.get(domain, self).gettext(message)
-    
+
     def dngettext(self, domain, singular, plural, num):
         """Like ``ngettext()``, but look the message up in the specified
         domain.
         """
         return self._domains.get(domain, self).ngettext(singular, plural, num)
-    
+
     def ldngettext(self, domain, singular, plural, num):
         """Like ``lngettext()``, but look the message up in the specified
         domain.
         """
         return self._domains.get(domain, self).lngettext(singular, plural, num)
-    
+
     def dungettext(self, domain, singular, plural, num):
         """Like ``ungettext()`` but look the message up in the specified
         domain.
         """
         if PY2:
             return self._domains.get(domain, self).ungettext(
-                singular, plural, num)
+                singular, plural, num
+            )
         else:
             return self._domains.get(domain, self).ngettext(
-                singular, plural, num)
+                singular, plural, num
+            )
+
 
 class LocalizerRequestMixin(object):
     @reify
@@ -384,8 +398,9 @@ class LocalizerRequestMixin(object):
             tdirs = registry.queryUtility(ITranslationDirectories, default=[])
             localizer = make_localizer(current_locale_name, tdirs)
 
-            registry.registerUtility(localizer, ILocalizer,
-                                     name=current_locale_name)
+            registry.registerUtility(
+                localizer, ILocalizer, name=current_locale_name
+            )
 
         return localizer
 
@@ -393,5 +408,3 @@ class LocalizerRequestMixin(object):
     def locale_name(self):
         locale_name = negotiate_locale_name(self)
         return locale_name
-        
-    
diff --git a/src/pyramid/interfaces.py b/src/pyramid/interfaces.py
index 4df5593f8..26a9d7025 100644
--- a/src/pyramid/interfaces.py
+++ b/src/pyramid/interfaces.py
@@ -1,14 +1,12 @@
 from zope.deprecation import deprecated
 
-from zope.interface import (
-    Attribute,
-    Interface,
-    )
+from zope.interface import Attribute, Interface
 
 from pyramid.compat import PY2
 
 # public API interfaces
 
+
 class IContextFound(Interface):
     """ An event type that is emitted after :app:`Pyramid` finds a
     :term:`context` object but before it calls any view code.  See the
@@ -21,32 +19,41 @@ class IContextFound(Interface):
        :app:`Pyramid` before 1.0, this event interface can also be
        imported as :class:`pyramid.interfaces.IAfterTraversal`.
     """
+
     request = Attribute('The request object')
 
+
 IAfterTraversal = IContextFound
 
+
 class IBeforeTraversal(Interface):
     """
     An event type that is emitted after :app:`Pyramid` attempted to find a
     route but before it calls any traversal or view code. See the documentation
     attached to :class:`pyramid.events.Routefound` for more information.
     """
+
     request = Attribute('The request object')
 
+
 class INewRequest(Interface):
     """ An event type that is emitted whenever :app:`Pyramid`
     begins to process a new request.  See the documentation attached
     to :class:`pyramid.events.NewRequest` for more information."""
+
     request = Attribute('The request object')
 
+
 class INewResponse(Interface):
     """ An event type that is emitted whenever any :app:`Pyramid`
     view returns a response. See the
     documentation attached to :class:`pyramid.events.NewResponse`
     for more information."""
+
     request = Attribute('The request object')
     response = Attribute('The response object')
 
+
 class IApplicationCreated(Interface):
     """ Event issued when the
     :meth:`pyramid.config.Configurator.make_wsgi_app` method
@@ -60,9 +67,12 @@ class IApplicationCreated(Interface):
        versions before 1.0, this interface can also be imported as
        :class:`pyramid.interfaces.IWSGIApplicationCreatedEvent`.
     """
+
     app = Attribute("Created application")
 
-IWSGIApplicationCreatedEvent = IApplicationCreated # b /c
+
+IWSGIApplicationCreatedEvent = IApplicationCreated  # b /c
+
 
 class IResponse(Interface):
     """ Represents a WSGI response using the WebOb response interface.
@@ -74,7 +84,8 @@ class IResponse(Interface):
     :mod:`pyramid.httpexceptions`."""
 
     RequestClass = Attribute(
-        """ Alias for :class:`pyramid.request.Request` """)
+        """ Alias for :class:`pyramid.request.Request` """
+    )
 
     def __call__(environ, start_response):
         """ :term:`WSGI` call interface, should call the start_response
@@ -82,21 +93,25 @@ class IResponse(Interface):
 
     accept_ranges = Attribute(
         """Gets and sets and deletes the Accept-Ranges header. For more
-        information on Accept-Ranges see RFC 2616, section 14.5""")
+        information on Accept-Ranges see RFC 2616, section 14.5"""
+    )
 
     age = Attribute(
         """Gets and sets and deletes the Age header. Converts using int.
-        For more information on Age see RFC 2616, section 14.6.""")
+        For more information on Age see RFC 2616, section 14.6."""
+    )
 
     allow = Attribute(
         """Gets and sets and deletes the Allow header. Converts using
-        list. For more information on Allow see RFC 2616, Section 14.7.""")
+        list. For more information on Allow see RFC 2616, Section 14.7."""
+    )
 
     app_iter = Attribute(
         """Returns the app_iter of the response.
 
         If body was set, this will create an app_iter from that body
-        (a single-item list)""")
+        (a single-item list)"""
+    )
 
     def app_iter_range(start, stop):
         """ Return a new app_iter built from the response app_iter that
@@ -104,21 +119,24 @@ class IResponse(Interface):
 
     body = Attribute(
         """The body of the response, as a str. This will read in the entire
-        app_iter if necessary.""")
+        app_iter if necessary."""
+    )
 
     body_file = Attribute(
         """A file-like object that can be used to write to the body. If you
-        passed in a list app_iter, that app_iter will be modified by writes.""")
+        passed in a list app_iter, that app_iter will be modified by writes."""
+    )
 
     cache_control = Attribute(
-        """Get/set/modify the Cache-Control header (RFC 2616 section 14.9)""")
+        """Get/set/modify the Cache-Control header (RFC 2616 section 14.9)"""
+    )
 
     cache_expires = Attribute(
         """ Get/set the Cache-Control and Expires headers. This sets the
-            response to expire in the number of seconds passed when set. """)
+            response to expire in the number of seconds passed when set. """
+    )
 
-    charset = Attribute(
-        """Get/set the charset (in the Content-Type)""")
+    charset = Attribute("""Get/set the charset (in the Content-Type)""")
 
     def conditional_response_app(environ, start_response):
         """ Like the normal __call__ interface, but checks conditional
@@ -133,52 +151,62 @@ class IResponse(Interface):
     content_disposition = Attribute(
         """Gets and sets and deletes the Content-Disposition header.
         For more information on Content-Disposition see RFC 2616 section
-        19.5.1.""")
+        19.5.1."""
+    )
 
     content_encoding = Attribute(
         """Gets and sets and deletes the Content-Encoding header.  For more
-        information about Content-Encoding see RFC 2616 section 14.11.""")
+        information about Content-Encoding see RFC 2616 section 14.11."""
+    )
 
     content_language = Attribute(
         """Gets and sets and deletes the Content-Language header. Converts
         using list.  For more information about Content-Language see RFC 2616
-        section 14.12.""")
+        section 14.12."""
+    )
 
     content_length = Attribute(
         """Gets and sets and deletes the Content-Length header. For more
         information on Content-Length see RFC 2616 section 14.17.
-        Converts using int. """)
+        Converts using int. """
+    )
 
     content_location = Attribute(
         """Gets and sets and deletes the Content-Location header. For more
-        information on Content-Location see RFC 2616 section 14.14.""")
+        information on Content-Location see RFC 2616 section 14.14."""
+    )
 
     content_md5 = Attribute(
         """Gets and sets and deletes the Content-MD5 header. For more
-        information on Content-MD5 see RFC 2616 section 14.14.""")
+        information on Content-MD5 see RFC 2616 section 14.14."""
+    )
 
     content_range = Attribute(
         """Gets and sets and deletes the Content-Range header. For more
         information on Content-Range see section 14.16. Converts using
-        ContentRange object.""")
+        ContentRange object."""
+    )
 
     content_type = Attribute(
         """Get/set the Content-Type header (or None), without the charset
         or any parameters. If you include parameters (or ; at all) when
         setting the content_type, any existing parameters will be deleted;
-        otherwise they will be preserved.""")
+        otherwise they will be preserved."""
+    )
 
     content_type_params = Attribute(
         """A dictionary of all the parameters in the content type.  This is
         not a view, set to change, modifications of the dict would not
-        be applied otherwise.""")
+        be applied otherwise."""
+    )
 
     def copy():
         """ Makes a copy of the response and returns the copy. """
 
     date = Attribute(
         """Gets and sets and deletes the Date header. For more information on
-        Date see RFC 2616 section 14.18. Converts using HTTP date.""")
+        Date see RFC 2616 section 14.18. Converts using HTTP date."""
+    )
 
     def delete_cookie(name, path='/', domain=None):
         """ Delete a cookie from the client. Note that path and domain must
@@ -191,31 +219,34 @@ class IResponse(Interface):
 
     environ = Attribute(
         """Get/set the request environ associated with this response,
-        if any.""")
+        if any."""
+    )
 
     etag = Attribute(
         """ Gets and sets and deletes the ETag header. For more information
-        on ETag see RFC 2616 section 14.19. Converts using Entity tag.""")
+        on ETag see RFC 2616 section 14.19. Converts using Entity tag."""
+    )
 
     expires = Attribute(
         """ Gets and sets and deletes the Expires header. For more
         information on Expires see RFC 2616 section 14.21. Converts using
-        HTTP date.""")
+        HTTP date."""
+    )
 
-    headerlist = Attribute(
-        """ The list of response headers. """)
+    headerlist = Attribute(""" The list of response headers. """)
 
-    headers = Attribute(
-        """ The headers in a dictionary-like object """)
+    headers = Attribute(""" The headers in a dictionary-like object """)
 
     last_modified = Attribute(
         """ Gets and sets and deletes the Last-Modified header. For more
         information on Last-Modified see RFC 2616 section 14.29. Converts
-        using HTTP date.""")
+        using HTTP date."""
+    )
 
     location = Attribute(
         """ Gets and sets and deletes the Location header. For more
-        information on Location see RFC 2616 section 14.30.""")
+        information on Location see RFC 2616 section 14.30."""
+    )
 
     def md5_etag(body=None, set_content_md5=False):
         """ Generate an etag for the response object using an MD5 hash of the
@@ -230,34 +261,46 @@ class IResponse(Interface):
 
     pragma = Attribute(
         """ Gets and sets and deletes the Pragma header. For more information
-        on Pragma see RFC 2616 section 14.32. """)
+        on Pragma see RFC 2616 section 14.32. """
+    )
 
     request = Attribute(
-        """ Return the request associated with this response if any. """)
+        """ Return the request associated with this response if any. """
+    )
 
     retry_after = Attribute(
         """ Gets and sets and deletes the Retry-After header. For more
         information on Retry-After see RFC 2616 section 14.37. Converts
-        using HTTP date or delta seconds.""")
+        using HTTP date or delta seconds."""
+    )
 
     server = Attribute(
         """ Gets and sets and deletes the Server header. For more information
-        on Server see RFC216 section 14.38. """)
+        on Server see RFC216 section 14.38. """
+    )
 
-    def set_cookie(name, value='', max_age=None, path='/', domain=None,
-                   secure=False, httponly=False, comment=None, expires=None,
-                   overwrite=False):
+    def set_cookie(
+        name,
+        value='',
+        max_age=None,
+        path='/',
+        domain=None,
+        secure=False,
+        httponly=False,
+        comment=None,
+        expires=None,
+        overwrite=False,
+    ):
         """ Set (add) a cookie for the response """
 
-    status = Attribute(
-        """ The status string. """)
+    status = Attribute(""" The status string. """)
 
-    status_int = Attribute(
-        """ The status as an integer """)
+    status_int = Attribute(""" The status as an integer """)
 
     unicode_body = Attribute(
         """ Get/set the unicode value of the body (using the charset of
-        the Content-Type)""")
+        the Content-Type)"""
+    )
 
     def unset_cookie(name, strict=True):
         """ Unset a cookie with the given name (remove it from the
@@ -265,16 +308,20 @@ class IResponse(Interface):
 
     vary = Attribute(
         """Gets and sets and deletes the Vary header. For more information
-        on Vary see section 14.44. Converts using list.""")
+        on Vary see section 14.44. Converts using list."""
+    )
 
     www_authenticate = Attribute(
         """ Gets and sets and deletes the WWW-Authenticate header. For more
         information on WWW-Authenticate see RFC 2616 section 14.47. Converts
-        using 'parse_auth' and 'serialize_auth'. """)
+        using 'parse_auth' and 'serialize_auth'. """
+    )
+
 
-class IException(Interface): # not an API
+class IException(Interface):  # not an API
     """ An interface representing a generic exception """
 
+
 class IExceptionResponse(IException, IResponse):
     """ An interface representing a WSGI response which is also an exception
     object.  Register an exception view using this interface as a ``context``
@@ -283,9 +330,11 @@ class IExceptionResponse(IException, IResponse):
     :class:`pyramid.response.Response`, including
     :class:`pyramid.httpexceptions.HTTPNotFound` and
     :class:`pyramid.httpexceptions.HTTPForbidden`)."""
+
     def prepare(environ):
         """ Prepares the response for being called as a WSGI application """
 
+
 class IDict(Interface):
     # Documentation-only interface
 
@@ -354,6 +403,7 @@ class IDict(Interface):
     def clear():
         """ Clear all values from the dictionary """
 
+
 class IBeforeRender(IDict):
     """
     Subscribers to this event may introspect and modify the set of
@@ -373,26 +423,37 @@ class IBeforeRender(IDict):
 
         See also :ref:`beforerender_event`.
     """
-    rendering_val = Attribute('The value returned by a view or passed to a '
-                              '``render`` method for this rendering. '
-                              'This feature is new in Pyramid 1.2.')
+
+    rendering_val = Attribute(
+        'The value returned by a view or passed to a '
+        '``render`` method for this rendering. '
+        'This feature is new in Pyramid 1.2.'
+    )
+
 
 class IRendererInfo(Interface):
     """ An object implementing this interface is passed to every
     :term:`renderer factory` constructor as its only argument (conventionally
     named ``info``)"""
+
     name = Attribute('The value passed by the user as the renderer name')
-    package = Attribute('The "current package" when the renderer '
-                        'configuration statement was found')
+    package = Attribute(
+        'The "current package" when the renderer '
+        'configuration statement was found'
+    )
     type = Attribute('The renderer type name')
-    registry = Attribute('The "current" application registry when the '
-                         'renderer was created')
-    settings = Attribute('The deployment settings dictionary related '
-                         'to the current application')
+    registry = Attribute(
+        'The "current" application registry when the ' 'renderer was created'
+    )
+    settings = Attribute(
+        'The deployment settings dictionary related '
+        'to the current application'
+    )
 
     def clone():
         """ Return a shallow copy that does not share any mutable state."""
 
+
 class IRendererFactory(Interface):
     def __call__(info):
         """ Return an object that implements
@@ -400,6 +461,7 @@ class IRendererFactory(Interface):
         object that implements :class:`pyramid.interfaces.IRendererInfo`.
         """
 
+
 class IRenderer(Interface):
     def __call__(value, system):
         """ Call the renderer with the result of the
@@ -413,6 +475,7 @@ class IRenderer(Interface):
         view), and ``request`` (the request object passed to the
         view)."""
 
+
 class ITemplateRenderer(IRenderer):
     def implementation():
         """ Return the object that the underlying templating system
@@ -420,12 +483,14 @@ class ITemplateRenderer(IRenderer):
         accepts arbitrary keyword arguments and returns a string or
         unicode object """
 
+
 deprecated(
     'ITemplateRenderer',
     'As of Pyramid 1.5 the, "pyramid.interfaces.ITemplateRenderer" interface '
     'is scheduled to be removed. It was used by the Mako and Chameleon '
-    'renderers which have been split into their own packages.'
-    )
+    'renderers which have been split into their own packages.',
+)
+
 
 class IViewMapper(Interface):
     def __call__(self, object):
@@ -435,6 +500,7 @@ class IViewMapper(Interface):
         object.  An IViewMapper is returned by
         :class:`pyramid.interfaces.IViewMapperFactory`."""
 
+
 class IViewMapperFactory(Interface):
     def __call__(self, **kw):
         """
@@ -448,6 +514,7 @@ class IViewMapperFactory(Interface):
         invocation signatures and response values.
         """
 
+
 class IAuthenticationPolicy(Interface):
     """ An object representing a Pyramid authentication policy. """
 
@@ -500,8 +567,10 @@ class IAuthenticationPolicy(Interface):
 
         """
 
+
 class IAuthorizationPolicy(Interface):
     """ An object representing a Pyramid authorization policy. """
+
     def permits(context, principals, permission):
         """ Return an instance of :class:`pyramid.security.Allowed` if any
         of the ``principals`` is allowed the ``permission`` in the current
@@ -518,7 +587,8 @@ class IAuthorizationPolicy(Interface):
         ``pyramid.security.principals_allowed_by_permission`` API is
         used."""
 
-class IMultiDict(IDict): # docs-only interface
+
+class IMultiDict(IDict):  # docs-only interface
     """
     An ordered dictionary that can have multiple values for each key. A
     multidict adds the methods ``getall``, ``getone``, ``mixed``, ``extend``,
@@ -556,36 +626,46 @@ class IMultiDict(IDict): # docs-only interface
         dictionary. This is similar to the kind of dictionary often used to
         represent the variables in a web request. """
 
+
 # internal interfaces
 
+
 class IRequest(Interface):
     """ Request type interface attached to all request objects """
 
+
 class ITweens(Interface):
     """ Marker interface for utility registration representing the ordered
     set of a configuration's tween factories"""
 
+
 class IRequestHandler(Interface):
     """ """
+
     def __call__(self, request):
         """ Must return a tuple of IReqest, IResponse or raise an exception.
         The ``request`` argument will be an instance of an object that
         provides IRequest."""
 
-IRequest.combined = IRequest # for exception view lookups
+
+IRequest.combined = IRequest  # for exception view lookups
+
 
 class IRequestExtensions(Interface):
     """ Marker interface for storing request extensions (properties and
     methods) which will be added to the request object."""
+
     descriptors = Attribute(
-        """A list of descriptors that will be added to each request.""")
-    methods = Attribute(
-        """A list of methods to be added to each request.""")
+        """A list of descriptors that will be added to each request."""
+    )
+    methods = Attribute("""A list of methods to be added to each request.""")
+
 
 class IRouteRequest(Interface):
     """ *internal only* interface used as in a utility lookup to find
     route-specific interfaces.  Not an API."""
 
+
 class IAcceptOrder(Interface):
     """
     Marker interface for a list of accept headers with the most important
@@ -593,8 +673,10 @@ class IAcceptOrder(Interface):
 
     """
 
+
 class IStaticURLInfo(Interface):
     """ A policy for generating URLs to static assets """
+
     def add(config, name, spec, **extra):
         """ Add a new static info registration """
 
@@ -604,15 +686,19 @@ class IStaticURLInfo(Interface):
     def add_cache_buster(config, spec, cache_buster):
         """ Add a new cache buster to a particular set of assets """
 
+
 class IResponseFactory(Interface):
     """ A utility which generates a response """
+
     def __call__(request):
         """ Return a response object implementing IResponse,
         e.g. :class:`pyramid.response.Response`). It should handle the
         case when ``request`` is ``None``."""
 
+
 class IRequestFactory(Interface):
     """ A utility which generates a request """
+
     def __call__(environ):
         """ Return an instance of ``pyramid.request.Request``"""
 
@@ -620,18 +706,23 @@ class IRequestFactory(Interface):
         """ Return an empty request object (see
         :meth:`pyramid.request.Request.blank`)"""
 
+
 class IViewClassifier(Interface):
     """ *Internal only* marker interface for views."""
 
+
 class IExceptionViewClassifier(Interface):
     """ *Internal only* marker interface for exception views."""
 
+
 class IView(Interface):
     def __call__(context, request):
         """ Must return an object that implements IResponse. """
 
+
 class ISecuredView(IView):
     """ *Internal only* interface.  Not an API. """
+
     def __call_permissive__(context, request):
         """ Guaranteed-permissive version of __call__ """
 
@@ -639,21 +730,26 @@ class ISecuredView(IView):
         """ Return True if view execution will be permitted using the
         context and request, False otherwise"""
 
+
 class IMultiView(ISecuredView):
     """ *internal only*.  A multiview is a secured view that is a
     collection of other views.  Each of the views is associated with
     zero or more predicates.  Not an API."""
+
     def add(view, predicates, order, accept=None, phash=None):
         """ Add a view to the multiview. """
 
+
 class IRootFactory(Interface):
     def __call__(request):
         """ Return a root object based on the request """
 
+
 class IDefaultRootFactory(Interface):
     def __call__(request):
         """ Return the *default* root object for an application """
 
+
 class ITraverser(Interface):
     def __call__(request):
         """ Return a dictionary with (at least) the keys ``root``,
@@ -678,21 +774,26 @@ class ITraverser(Interface):
         as attributes of the ``request`` object by the :term:`router`.
         """
 
-ITraverserFactory = ITraverser # b / c for 1.0 code
+
+ITraverserFactory = ITraverser  # b / c for 1.0 code
+
 
 class IViewPermission(Interface):
     def __call__(context, request):
         """ Return True if the permission allows, return False if it denies.
         """
 
+
 class IRouter(Interface):
     """
     WSGI application which routes requests to 'view' code based on
     a view registry.
 
     """
+
     registry = Attribute(
-        """Component architecture registry local to this application.""")
+        """Component architecture registry local to this application."""
+    )
 
     def request_context(environ):
         """
@@ -734,6 +835,7 @@ class IRouter(Interface):
 
         """
 
+
 class IExecutionPolicy(Interface):
     def __call__(environ, router):
         """
@@ -762,22 +864,28 @@ class IExecutionPolicy(Interface):
                         return request.invoke_exception_view(reraise=True)
         """
 
+
 class ISettings(IDict):
     """ Runtime settings utility for pyramid; represents the
     deployment settings for the application.  Implements a mapping
     interface."""
 
+
 # this interface, even if it becomes unused within Pyramid, is
 # imported by other packages (such as traversalwrapper)
 class ILocation(Interface):
     """Objects that have a structural location"""
+
     __parent__ = Attribute("The parent in the location hierarchy")
     __name__ = Attribute("The name within the parent")
 
+
 class IDebugLogger(Interface):
     """ Interface representing a PEP 282 logger """
 
-ILogger = IDebugLogger # b/c
+
+ILogger = IDebugLogger  # b/c
+
 
 class IRoutePregenerator(Interface):
     def __call__(request, elements, kw):
@@ -804,21 +912,27 @@ class IRoutePregenerator(Interface):
 
         """
 
+
 class IRoute(Interface):
     """ Interface representing the type of object returned from
     ``IRoutesMapper.get_route``"""
+
     name = Attribute('The route name')
     pattern = Attribute('The route pattern')
     factory = Attribute(
         'The :term:`root factory` used by the :app:`Pyramid` router '
-        'when this route matches (or ``None``)')
+        'when this route matches (or ``None``)'
+    )
     predicates = Attribute(
         'A sequence of :term:`route predicate` objects used to '
         'determine if a request matches this route or not after '
-        'basic pattern matching has been completed.')
-    pregenerator = Attribute('This attribute should either be ``None`` or '
-                             'a callable object implementing the '
-                             '``IRoutePregenerator`` interface')
+        'basic pattern matching has been completed.'
+    )
+    pregenerator = Attribute(
+        'This attribute should either be ``None`` or '
+        'a callable object implementing the '
+        '``IRoutePregenerator`` interface'
+    )
 
     def match(path):
         """
@@ -831,14 +945,17 @@ class IRoute(Interface):
         If the ``path`` passed to this function cannot be matched by
         the ``pattern`` of this route, return ``None``.
         """
+
     def generate(kw):
         """
         Generate a URL based on filling in the dynamic segment markers
         in the pattern using the ``kw`` dictionary provided.
         """
 
+
 class IRoutesMapper(Interface):
     """ Interface representing a Routes ``Mapper`` object """
+
     def get_routes():
         """ Return a sequence of Route objects registered in the mapper.
         Static routes will not be returned in this sequence."""
@@ -850,8 +967,14 @@ class IRoutesMapper(Interface):
         """ Returns an ``IRoute`` object if a route with the name ``name``
         was registered, otherwise return ``None``."""
 
-    def connect(name, pattern, factory=None, predicates=(), pregenerator=None,
-                static=True):
+    def connect(
+        name,
+        pattern,
+        factory=None,
+        predicates=(),
+        pregenerator=None,
+        static=True,
+    ):
         """ Add a new route. """
 
     def generate(name, kw):
@@ -865,23 +988,26 @@ class IRoutesMapper(Interface):
         ``match`` key will be the matchdict or ``None`` if no route
         matched.  Static routes will not be considered for matching.  """
 
+
 class IResourceURL(Interface):
     virtual_path = Attribute(
         'The virtual url path of the resource as a string.'
-        )
+    )
     physical_path = Attribute(
         'The physical url path of the resource as a string.'
-        )
+    )
     virtual_path_tuple = Attribute(
         'The virtual url path of the resource as a tuple.  (New in 1.5)'
-        )
+    )
     physical_path_tuple = Attribute(
         'The physical url path of the resource as a tuple. (New in 1.5)'
-        )
+    )
+
 
 class IPEP302Loader(Interface):
     """ See http://www.python.org/dev/peps/pep-0302/#id30.
     """
+
     def get_data(path):
         """ Retrieve data for and arbitrary "files" from storage backend.
 
@@ -924,43 +1050,54 @@ class IPEP302Loader(Interface):
 class IPackageOverrides(IPEP302Loader):
     """ Utility for pkg_resources overrides """
 
+
 # VH_ROOT_KEY is an interface; its imported from other packages (e.g.
 # traversalwrapper)
 VH_ROOT_KEY = 'HTTP_X_VHM_ROOT'
 
+
 class ILocalizer(Interface):
     """ Localizer for a specific language """
 
+
 class ILocaleNegotiator(Interface):
     def __call__(request):
         """ Return a locale name """
 
+
 class ITranslationDirectories(Interface):
     """ A list object representing all known translation directories
     for an application"""
 
+
 class IDefaultPermission(Interface):
     """ A string object representing the default permission to be used
     for all view configurations which do not explicitly declare their
     own."""
 
+
 class IDefaultCSRFOptions(Interface):
     """ An object representing the default CSRF settings to be used for
     all view configurations which do not explicitly declare their own."""
+
     require_csrf = Attribute(
         'Boolean attribute. If ``True``, then CSRF checks will be enabled by '
-        'default for the view unless overridden.')
+        'default for the view unless overridden.'
+    )
     token = Attribute('The key to be matched in the body of the request.')
     header = Attribute('The header to be matched with the CSRF token.')
     safe_methods = Attribute('A set of safe methods that skip CSRF checks.')
     callback = Attribute('A callback to disable CSRF checks per-request.')
 
+
 class ISessionFactory(Interface):
     """ An interface representing a factory which accepts a request object and
     returns an ISession object """
+
     def __call__(request):
         """ Return an ISession object """
 
+
 class ISession(IDict):
     """ An interface representing a session (a web session object,
     usually accessed via ``request.session``.
@@ -1158,16 +1295,21 @@ class IIntrospectable(Interface):
 
     title = Attribute('Text title describing this introspectable')
     type_name = Attribute('Text type name describing this introspectable')
-    order = Attribute('integer order in which registered with introspector '
-                      '(managed by introspector, usually)')
+    order = Attribute(
+        'integer order in which registered with introspector '
+        '(managed by introspector, usually)'
+    )
     category_name = Attribute('introspection category name')
-    discriminator = Attribute('introspectable discriminator (within category) '
-                              '(must be hashable)')
+    discriminator = Attribute(
+        'introspectable discriminator (within category) ' '(must be hashable)'
+    )
     discriminator_hash = Attribute('an integer hash of the discriminator')
-    action_info = Attribute('An IActionInfo object representing the caller '
-                            'that invoked the creation of this introspectable '
-                            '(usually a sentinel until updated during '
-                            'self.register)')
+    action_info = Attribute(
+        'An IActionInfo object representing the caller '
+        'that invoked the creation of this introspectable '
+        '(usually a sentinel until updated during '
+        'self.register)'
+    )
 
     def relate(category_name, discriminator):
         """ Indicate an intent to relate this IIntrospectable with another
@@ -1209,19 +1351,22 @@ class IIntrospectable(Interface):
           return hash((self.category_name,) + (self.discriminator,))
         """
 
+
 class IActionInfo(Interface):
     """ Class which provides code introspection capability associated with an
     action.  The ParserInfo class used by ZCML implements the same interface."""
-    file = Attribute(
-        'Filename of action-invoking code as a string')
+
+    file = Attribute('Filename of action-invoking code as a string')
     line = Attribute(
         'Starting line number in file (as an integer) of action-invoking code.'
-        'This will be ``None`` if the value could not be determined.')
+        'This will be ``None`` if the value could not be determined.'
+    )
 
     def __str__():
         """ Return a representation of the action information (including
         source code from file, if possible) """
 
+
 class IAssetDescriptor(Interface):
     """
     Describes an :term:`asset`.
@@ -1260,19 +1405,24 @@ class IAssetDescriptor(Interface):
         Returns True if asset exists, otherwise returns False.
         """
 
+
 class IJSONAdapter(Interface):
     """
     Marker interface for objects that can convert an arbitrary object
     into a JSON-serializable primitive.
     """
 
+
 class IPredicateList(Interface):
     """ Interface representing a predicate list """
 
+
 class IViewDeriver(Interface):
-    options = Attribute('A list of supported options to be passed to '
-                        ':meth:`pyramid.config.Configurator.add_view`. '
-                        'This attribute is optional.')
+    options = Attribute(
+        'A list of supported options to be passed to '
+        ':meth:`pyramid.config.Configurator.add_view`. '
+        'This attribute is optional.'
+    )
 
     def __call__(view, info):
         """
@@ -1285,24 +1435,35 @@ class IViewDeriver(Interface):
 
         """
 
+
 class IViewDeriverInfo(Interface):
     """ An object implementing this interface is passed to every
     :term:`view deriver` during configuration."""
-    registry = Attribute('The "current" application registry where the '
-                         'view was created')
-    package = Attribute('The "current package" where the view '
-                        'configuration statement was found')
-    settings = Attribute('The deployment settings dictionary related '
-                         'to the current application')
-    options = Attribute('The view options passed to the view, including any '
-                        'default values that were not overriden')
+
+    registry = Attribute(
+        'The "current" application registry where the ' 'view was created'
+    )
+    package = Attribute(
+        'The "current package" where the view '
+        'configuration statement was found'
+    )
+    settings = Attribute(
+        'The deployment settings dictionary related '
+        'to the current application'
+    )
+    options = Attribute(
+        'The view options passed to the view, including any '
+        'default values that were not overriden'
+    )
     predicates = Attribute('The list of predicates active on the view')
     original_view = Attribute('The original view object being wrapped')
     exception_only = Attribute('The view will only be invoked for exceptions')
 
+
 class IViewDerivers(Interface):
     """ Interface for view derivers list """
 
+
 class ICacheBuster(Interface):
     """
     A cache buster modifies the URL generation machinery for
@@ -1310,6 +1471,7 @@ class ICacheBuster(Interface):
 
     .. versionadded:: 1.6
     """
+
     def __call__(request, subpath, kw):
         """
         Modifies a subpath and/or keyword arguments from which a static asset
@@ -1344,6 +1506,7 @@ class ICacheBuster(Interface):
         ``config.override_asset('myapp:static/foo.png', 'themepkg:bar.png')``.
         """
 
+
 # configuration phases: a lower phase number means the actions associated
 # with this phase will be executed earlier than those with later phase
 # numbers.  The default phase number is 0, FTR.
diff --git a/src/pyramid/location.py b/src/pyramid/location.py
index 4124895a5..b8542d1b9 100644
--- a/src/pyramid/location.py
+++ b/src/pyramid/location.py
@@ -12,6 +12,7 @@
 #
 ##############################################################################
 
+
 def inside(resource1, resource2):
     """Is ``resource1`` 'inside' ``resource2``?  Return ``True`` if so, else
     ``False``.
@@ -28,6 +29,7 @@ def inside(resource1, resource2):
 
     return False
 
+
 def lineage(resource):
     """
     Return a generator representing the :term:`lineage` of the
@@ -63,4 +65,3 @@ def lineage(resource):
             resource = resource.__parent__
         except AttributeError:
             resource = None
-
diff --git a/src/pyramid/paster.py b/src/pyramid/paster.py
index f7544f0c5..eda479476 100644
--- a/src/pyramid/paster.py
+++ b/src/pyramid/paster.py
@@ -1,6 +1,7 @@
 from pyramid.scripting import prepare
 from pyramid.scripts.common import get_config_loader
 
+
 def setup_logging(config_uri, global_conf=None):
     """
     Set up Python logging with the filename specified via ``config_uri``
@@ -11,6 +12,7 @@ def setup_logging(config_uri, global_conf=None):
     loader = get_config_loader(config_uri)
     loader.setup_logging(global_conf)
 
+
 def get_app(config_uri, name=None, options=None):
     """ Return the WSGI application named ``name`` in the PasteDeploy
     config file specified by ``config_uri``.
@@ -27,6 +29,7 @@ def get_app(config_uri, name=None, options=None):
     loader = get_config_loader(config_uri)
     return loader.get_wsgi_app(name, options)
 
+
 def get_appsettings(config_uri, name=None, options=None):
     """ Return a dictionary representing the key/value pairs in an ``app``
     section within the file represented by ``config_uri``.
@@ -43,6 +46,7 @@ def get_appsettings(config_uri, name=None, options=None):
     loader = get_config_loader(config_uri)
     return loader.get_wsgi_app_settings(name, options)
 
+
 def bootstrap(config_uri, request=None, options=None):
     """ Load a WSGI application from the PasteDeploy config file specified
     by ``config_uri``. The environment will be configured as if it is
@@ -108,4 +112,3 @@ def bootstrap(config_uri, request=None, options=None):
     env = prepare(request)
     env['app'] = app
     return env
-
diff --git a/src/pyramid/path.py b/src/pyramid/path.py
index 3fac7e940..c70be99db 100644
--- a/src/pyramid/path.py
+++ b/src/pyramid/path.py
@@ -9,9 +9,13 @@ from pyramid.interfaces import IAssetDescriptor
 
 from pyramid.compat import string_types
 
-ignore_types = [ imp.C_EXTENSION, imp.C_BUILTIN ]
-init_names = [ '__init__%s' % x[0] for x in imp.get_suffixes() if
-               x[0] and x[2] not in ignore_types ]
+ignore_types = [imp.C_EXTENSION, imp.C_BUILTIN]
+init_names = [
+    '__init__%s' % x[0]
+    for x in imp.get_suffixes()
+    if x[0] and x[2] not in ignore_types
+]
+
 
 def caller_path(path, level=2):
     if not os.path.isabs(path):
@@ -20,12 +24,14 @@ def caller_path(path, level=2):
         path = os.path.join(prefix, path)
     return path
 
+
 def caller_module(level=2, sys=sys):
     module_globals = sys._getframe(level).f_globals
     module_name = module_globals.get('__name__') or '__main__'
     module = sys.modules[module_name]
     return module
 
+
 def package_name(pkg_or_module):
     """ If this function is passed a module, return the dotted Python
     package name of the package in which the module lives.  If this
@@ -45,23 +51,26 @@ def package_name(pkg_or_module):
         return pkg_name
     return pkg_name.rsplit('.', 1)[0]
 
+
 def package_of(pkg_or_module):
     """ Return the package of a module or return the package itself """
     pkg_name = package_name(pkg_or_module)
     __import__(pkg_name)
     return sys.modules[pkg_name]
 
+
 def caller_package(level=2, caller_module=caller_module):
     # caller_module in arglist for tests
     module = caller_module(level + 1)
     f = getattr(module, '__file__', '')
-    if (('__init__.py' in f) or ('__init__$py' in f)): # empty at >>>
+    if ('__init__.py' in f) or ('__init__$py' in f):  # empty at >>>
         # Module is a package
         return module
     # Go up one level to get package
     package_name = module.__name__.rsplit('.', 1)[0]
     return sys.modules[package_name]
 
+
 def package_path(package):
     # computing the abspath is actually kinda expensive so we memoize
     # the result
@@ -78,12 +87,15 @@ def package_path(package):
             pass
     return prefix
 
+
 class _CALLER_PACKAGE(object):
-    def __repr__(self): # pragma: no cover (for docs)
+    def __repr__(self):  # pragma: no cover (for docs)
         return 'pyramid.path.CALLER_PACKAGE'
 
+
 CALLER_PACKAGE = _CALLER_PACKAGE()
 
+
 class Resolver(object):
     def __init__(self, package=CALLER_PACKAGE):
         if package in (None, CALLER_PACKAGE):
@@ -95,7 +107,7 @@ class Resolver(object):
                 except ImportError:
                     raise ValueError(
                         'The dotted name %r cannot be imported' % (package,)
-                        )
+                    )
                 package = sys.modules[package]
             self.package = package_of(package)
 
@@ -164,6 +176,7 @@ class AssetResolver(Resolver):
     to the :meth:`~pyramid.path.AssetResolver.resolve` method, the resulting
     absolute asset spec would be ``xml.minidom:template.pt``.
     """
+
     def resolve(self, spec):
         """
         Resolve the asset spec named as ``spec`` to an object that has the
@@ -208,6 +221,7 @@ class AssetResolver(Resolver):
                 )
         return PkgResourcesAssetDescriptor(package_name, path)
 
+
 class DottedNameResolver(Resolver):
     """ A class used to resolve a :term:`dotted Python name` to a package or
     module object.
@@ -258,6 +272,7 @@ class DottedNameResolver(Resolver):
     :meth:`~pyramid.path.DottedNameResolver.resolve` method, the resulting
     import would be for ``xml.minidom``.
     """
+
     def resolve(self, dotted):
         """
         This method resolves a dotted name reference to a global Python
@@ -332,7 +347,7 @@ class DottedNameResolver(Resolver):
             if not package:
                 raise ValueError(
                     'relative name %r irresolveable without package' % (value,)
-                    )
+                )
             if value in ['.', ':']:
                 value = package.__name__
             else:
@@ -348,7 +363,7 @@ class DottedNameResolver(Resolver):
 
     def _zope_dottedname_style(self, value, package):
         """ package.module.attr style """
-        module = getattr(package, '__name__', None) # package may be None
+        module = getattr(package, '__name__', None)  # package may be None
         if not module:
             module = None
         if value == '.':
@@ -364,7 +379,7 @@ class DottedNameResolver(Resolver):
                     raise ValueError(
                         'relative name %r irresolveable without '
                         'package' % (value,)
-                        )
+                    )
                 module = module.split('.')
                 name.pop(0)
                 while not name[0]:
@@ -380,10 +395,11 @@ class DottedNameResolver(Resolver):
                 found = getattr(found, n)
             except AttributeError:
                 __import__(used)
-                found = getattr(found, n) # pragma: no cover
+                found = getattr(found, n)  # pragma: no cover
 
         return found
 
+
 @implementer(IAssetDescriptor)
 class PkgResourcesAssetDescriptor(object):
     pkg_resources = pkg_resources
@@ -397,7 +413,8 @@ class PkgResourcesAssetDescriptor(object):
 
     def abspath(self):
         return os.path.abspath(
-            self.pkg_resources.resource_filename(self.pkg_name, self.path))
+            self.pkg_resources.resource_filename(self.pkg_name, self.path)
+        )
 
     def stream(self):
         return self.pkg_resources.resource_stream(self.pkg_name, self.path)
@@ -411,9 +428,9 @@ class PkgResourcesAssetDescriptor(object):
     def exists(self):
         return self.pkg_resources.resource_exists(self.pkg_name, self.path)
 
+
 @implementer(IAssetDescriptor)
 class FSAssetDescriptor(object):
-
     def __init__(self, path):
         self.path = os.path.abspath(path)
 
diff --git a/src/pyramid/predicates.py b/src/pyramid/predicates.py
index 97edae8a0..b95dfd9be 100644
--- a/src/pyramid/predicates.py
+++ b/src/pyramid/predicates.py
@@ -8,17 +8,15 @@ from pyramid.csrf import check_csrf_token
 from pyramid.traversal import (
     find_interface,
     traversal_path,
-    resource_path_tuple
-    )
+    resource_path_tuple,
+)
 
 from pyramid.urldispatch import _compile_route
-from pyramid.util import (
-    as_sorted_tuple,
-    object_description,
-)
+from pyramid.util import as_sorted_tuple, object_description
 
 _marker = object()
 
+
 class XHRPredicate(object):
     def __init__(self, val, config):
         self.val = bool(val)
@@ -31,6 +29,7 @@ class XHRPredicate(object):
     def __call__(self, context, request):
         return bool(request.is_xhr) is self.val
 
+
 class RequestMethodPredicate(object):
     def __init__(self, val, config):
         request_method = as_sorted_tuple(val)
@@ -47,6 +46,7 @@ class RequestMethodPredicate(object):
     def __call__(self, context, request):
         return request.method in self.val
 
+
 class PathInfoPredicate(object):
     def __init__(self, val, config):
         self.orig = val
@@ -63,7 +63,8 @@ class PathInfoPredicate(object):
 
     def __call__(self, context, request):
         return self.val.match(request.upath_info) is not None
-    
+
+
 class RequestParamPredicate(object):
     def __init__(self, val, config):
         val = as_sorted_tuple(val)
@@ -85,7 +86,7 @@ class RequestParamPredicate(object):
 
     def text(self):
         return 'request_param %s' % ','.join(
-            ['%s=%s' % (x,y) if y else x for x, y in self.reqs]
+            ['%s=%s' % (x, y) if y else x for x, y in self.reqs]
         )
 
     phash = text
@@ -99,6 +100,7 @@ class RequestParamPredicate(object):
                 return False
         return True
 
+
 class HeaderPredicate(object):
     def __init__(self, val, config):
         name = val
@@ -129,6 +131,7 @@ class HeaderPredicate(object):
             return False
         return self.val.match(val) is not None
 
+
 class AcceptPredicate(object):
     _is_using_deprecated_ranges = False
 
@@ -151,6 +154,7 @@ class AcceptPredicate(object):
             return self.values[0] in request.accept
         return bool(request.accept.acceptable_offers(self.values))
 
+
 class ContainmentPredicate(object):
     def __init__(self, val, config):
         self.val = config.maybe_dotted(val)
@@ -163,7 +167,8 @@ class ContainmentPredicate(object):
     def __call__(self, context, request):
         ctx = getattr(request, 'context', context)
         return find_interface(ctx, self.val) is not None
-    
+
+
 class RequestTypePredicate(object):
     def __init__(self, val, config):
         self.val = val
@@ -175,18 +180,19 @@ class RequestTypePredicate(object):
 
     def __call__(self, context, request):
         return self.val.providedBy(request)
-    
+
+
 class MatchParamPredicate(object):
     def __init__(self, val, config):
         val = as_sorted_tuple(val)
         self.val = val
-        reqs = [ p.split('=', 1) for p in val ]
-        self.reqs = [ (x.strip(), y.strip()) for x, y in reqs ]
+        reqs = [p.split('=', 1) for p in val]
+        self.reqs = [(x.strip(), y.strip()) for x, y in reqs]
 
     def text(self):
         return 'match_param %s' % ','.join(
-            ['%s=%s' % (x,y) for x, y in self.reqs]
-            )
+            ['%s=%s' % (x, y) for x, y in self.reqs]
+        )
 
     phash = text
 
@@ -198,7 +204,8 @@ class MatchParamPredicate(object):
             if request.matchdict.get(k) != v:
                 return False
         return True
-    
+
+
 class CustomPredicate(object):
     def __init__(self, func, config):
         self.func = func
@@ -207,8 +214,8 @@ class CustomPredicate(object):
         return getattr(
             self.func,
             '__text__',
-            'custom predicate: %s' % object_description(self.func)
-            )
+            'custom predicate: %s' % object_description(self.func),
+        )
 
     def phash(self):
         # using hash() here rather than id() is intentional: we
@@ -221,8 +228,8 @@ class CustomPredicate(object):
 
     def __call__(self, context, request):
         return self.func(context, request)
-    
-    
+
+
 class TraversePredicate(object):
     # Can only be used as a *route* "predicate"; it adds 'traverse' to the
     # matchdict if it's specified in the routing args.  This causes the
@@ -231,7 +238,7 @@ class TraversePredicate(object):
     def __init__(self, val, config):
         _, self.tgenerate = _compile_route(val)
         self.val = val
-        
+
     def text(self):
         return 'traverse matchdict pseudo-predicate'
 
@@ -252,10 +259,11 @@ class TraversePredicate(object):
         # return True.
         return True
 
+
 class CheckCSRFTokenPredicate(object):
 
-    check_csrf_token = staticmethod(check_csrf_token) # testing
-    
+    check_csrf_token = staticmethod(check_csrf_token)  # testing
+
     def __init__(self, val, config):
         self.val = val
 
@@ -272,6 +280,7 @@ class CheckCSRFTokenPredicate(object):
             return self.check_csrf_token(request, val, raises=False)
         return True
 
+
 class PhysicalPathPredicate(object):
     def __init__(self, val, config):
         if is_nonstr_iter(val):
@@ -290,6 +299,7 @@ class PhysicalPathPredicate(object):
             return resource_path_tuple(context) == self.val
         return False
 
+
 class EffectivePrincipalsPredicate(object):
     def __init__(self, val, config):
         if is_nonstr_iter(val):
@@ -310,6 +320,7 @@ class EffectivePrincipalsPredicate(object):
                 return True
         return False
 
+
 class Notted(object):
     def __init__(self, predicate):
         self.predicate = predicate
diff --git a/src/pyramid/registry.py b/src/pyramid/registry.py
index a741c495e..c24125830 100644
--- a/src/pyramid/registry.py
+++ b/src/pyramid/registry.py
@@ -7,19 +7,13 @@ from zope.interface.registry import Components
 from pyramid.compat import text_
 from pyramid.decorator import reify
 
-from pyramid.interfaces import (
-    IIntrospector,
-    IIntrospectable,
-    ISettings,
-)
+from pyramid.interfaces import IIntrospector, IIntrospectable, ISettings
 
-from pyramid.path import (
-    CALLER_PACKAGE,
-    caller_package,
-)
+from pyramid.path import CALLER_PACKAGE, caller_package
 
 empty = text_('')
 
+
 class Registry(Components, dict):
     """ A registry object is an :term:`application registry`.
 
@@ -82,13 +76,19 @@ class Registry(Components, dict):
         self.has_listeners = True
         return result
 
-    def registerSelfAdapter(self, required=None, provided=None, name=empty,
-                            info=empty, event=True):
+    def registerSelfAdapter(
+        self, required=None, provided=None, name=empty, info=empty, event=True
+    ):
         # registerAdapter analogue which always returns the object itself
         # when required is matched
-        return self.registerAdapter(lambda x: x, required=required,
-                                    provided=provided, name=name,
-                                    info=info, event=event)
+        return self.registerAdapter(
+            lambda x: x,
+            required=required,
+            provided=provided,
+            name=name,
+            info=info,
+            event=event,
+        )
 
     def queryAdapterOrSelf(self, object, interface, default=None):
         # queryAdapter analogue which returns the object if it implements
@@ -106,7 +106,7 @@ class Registry(Components, dict):
     def notify(self, *events):
         if self.has_listeners:
             # iterating over subscribers assures they get executed
-            [ _ for _ in self.subscribers(events, None) ]
+            [_ for _ in self.subscribers(events, None)]
 
     # backwards compatibility for code that wants to look up a settings
     # object via ``registry.getUtility(ISettings)``
@@ -119,6 +119,7 @@ class Registry(Components, dict):
 
     settings = property(_get_settings, _set_settings)
 
+
 @implementer(IIntrospector)
 class Introspector(object):
     def __init__(self):
@@ -147,16 +148,19 @@ class Introspector(object):
         values = category.values()
         values = sorted(set(values), key=sort_key)
         return [
-            {'introspectable': intr,
-             'related': self.related(intr)}
+            {'introspectable': intr, 'related': self.related(intr)}
             for intr in values
         ]
 
     def categorized(self, sort_key=None):
         L = []
         for category_name in self.categories():
-            L.append((category_name, self.get_category(category_name,
-                                                       sort_key=sort_key)))
+            L.append(
+                (
+                    category_name,
+                    self.get_category(category_name, sort_key=sort_key),
+                )
+            )
         return L
 
     def categories(self):
@@ -186,7 +190,7 @@ class Introspector(object):
 
     def relate(self, *pairs):
         introspectables = self._get_intrs_by_pairs(pairs)
-        relatable = ((x,y) for x in introspectables for y in introspectables)
+        relatable = ((x, y) for x in introspectables for y in introspectables)
         for x, y in relatable:
             L = self._refs.setdefault(x, [])
             if x is not y and y not in L:
@@ -194,7 +198,7 @@ class Introspector(object):
 
     def unrelate(self, *pairs):
         introspectables = self._get_intrs_by_pairs(pairs)
-        relatable = ((x,y) for x in introspectables for y in introspectables)
+        relatable = ((x, y) for x in introspectables for y in introspectables)
         for x, y in relatable:
             L = self._refs.get(x, [])
             if y in L:
@@ -207,11 +211,12 @@ class Introspector(object):
             raise KeyError((category_name, discriminator))
         return self._refs.get(intr, [])
 
+
 @implementer(IIntrospectable)
 class Introspectable(dict):
 
-    order = 0 # mutated by introspector.add
-    action_info = None # mutated by self.register
+    order = 0  # mutated by introspector.add
+    action_info = None  # mutated by self.register
 
     def __init__(self, category_name, discriminator, title, type_name):
         self.category_name = category_name
@@ -240,14 +245,16 @@ class Introspectable(dict):
 
     def __repr__(self):
         self._assert_resolved()
-        return '<%s category %r, discriminator %r>' % (self.__class__.__name__,
-                                                       self.category_name,
-                                                       self.discriminator)
+        return '<%s category %r, discriminator %r>' % (
+            self.__class__.__name__,
+            self.category_name,
+            self.discriminator,
+        )
 
     def __nonzero__(self):
         return True
 
-    __bool__ = __nonzero__ # py3
+    __bool__ = __nonzero__  # py3
 
     def register(self, introspector, action_info):
         self.discriminator = undefer(self.discriminator)
@@ -261,8 +268,9 @@ class Introspectable(dict):
                 method = introspector.unrelate
             method(
                 (self.category_name, self.discriminator),
-                (category_name, discriminator)
-                )
+                (category_name, discriminator),
+            )
+
 
 class Deferred(object):
     """ Can be used by a third-party configuration extender to wrap a
@@ -270,6 +278,7 @@ class Deferred(object):
     discriminator cannot be computed because it relies on unresolved values.
     The function should accept no arguments and should return a hashable
     discriminator."""
+
     def __init__(self, func):
         self.func = func
 
@@ -282,6 +291,7 @@ class Deferred(object):
     def resolve(self):
         return self.value
 
+
 def undefer(v):
     """ Function which accepts an object and returns it unless it is a
     :class:`pyramid.registry.Deferred` instance.  If it is an instance of
@@ -291,7 +301,9 @@ def undefer(v):
         v = v.resolve()
     return v
 
+
 class predvalseq(tuple):
     """ A subtype of tuple used to represent a sequence of predicate values """
 
+
 global_registry = Registry('global')
diff --git a/src/pyramid/renderers.py b/src/pyramid/renderers.py
index d1c85b371..a8e3ec16f 100644
--- a/src/pyramid/renderers.py
+++ b/src/pyramid/renderers.py
@@ -3,22 +3,12 @@ import json
 import os
 import re
 
-from zope.interface import (
-    implementer,
-    providedBy,
-    )
+from zope.interface import implementer, providedBy
 from zope.interface.registry import Components
 
-from pyramid.interfaces import (
-    IJSONAdapter,
-    IRendererFactory,
-    IRendererInfo,
-    )
+from pyramid.interfaces import IJSONAdapter, IRendererFactory, IRendererInfo
 
-from pyramid.compat import (
-    string_types,
-    text_type,
-    )
+from pyramid.compat import string_types, text_type
 
 from pyramid.csrf import get_csrf_token
 from pyramid.decorator import reify
@@ -35,6 +25,7 @@ from pyramid.util import hide_attrs
 
 # API
 
+
 def render(renderer_name, value, request=None, package=None):
     """ Using the renderer ``renderer_name`` (a template
     or a static renderer), render the value (or set of values) present
@@ -76,19 +67,19 @@ def render(renderer_name, value, request=None, package=None):
         registry = None
     if package is None:
         package = caller_package()
-    helper = RendererHelper(name=renderer_name, package=package,
-                            registry=registry)
+    helper = RendererHelper(
+        name=renderer_name, package=package, registry=registry
+    )
 
     with hide_attrs(request, 'response'):
         result = helper.render(value, None, request=request)
 
     return result
 
-def render_to_response(renderer_name,
-                       value,
-                       request=None,
-                       package=None,
-                       response=None):
+
+def render_to_response(
+    renderer_name, value, request=None, package=None, response=None
+):
     """ Using the renderer ``renderer_name`` (a template
     or a static renderer), render the value (or set of values) using
     the result of the renderer's ``__call__`` method (usually a string
@@ -137,8 +128,9 @@ def render_to_response(renderer_name,
         registry = None
     if package is None:
         package = caller_package()
-    helper = RendererHelper(name=renderer_name, package=package,
-                            registry=registry)
+    helper = RendererHelper(
+        name=renderer_name, package=package, registry=registry
+    )
 
     with hide_attrs(request, 'response'):
         if response is not None:
@@ -147,6 +139,7 @@ def render_to_response(renderer_name,
 
     return result
 
+
 def get_renderer(renderer_name, package=None, registry=None):
     """ Return the renderer object for the renderer ``renderer_name``.
 
@@ -165,12 +158,15 @@ def get_renderer(renderer_name, package=None, registry=None):
     """
     if package is None:
         package = caller_package()
-    helper = RendererHelper(name=renderer_name, package=package,
-                            registry=registry)
+    helper = RendererHelper(
+        name=renderer_name, package=package, registry=registry
+    )
     return helper.renderer
 
+
 # concrete renderer factory implementations (also API)
 
+
 def string_renderer_factory(info):
     def _render(value, system):
         if not isinstance(value, string_types):
@@ -182,10 +178,13 @@ def string_renderer_factory(info):
             if ct == response.default_content_type:
                 response.content_type = 'text/plain'
         return value
+
     return _render
 
+
 _marker = object()
 
+
 class JSON(object):
     """ Renderer that returns a JSON-encoded string.
 
@@ -265,13 +264,15 @@ class JSON(object):
         instances of the ``Foo`` class when they're encountered in your view
         results."""
 
-        self.components.registerAdapter(adapter, (type_or_iface,),
-                                        IJSONAdapter)
+        self.components.registerAdapter(
+            adapter, (type_or_iface,), IJSONAdapter
+        )
 
     def __call__(self, info):
         """ Returns a plain JSON-encoded string with content-type
         ``application/json``. The content-type may be overridden by
         setting ``request.response.content_type``."""
+
         def _render(value, system):
             request = system.get('request')
             if request is not None:
@@ -290,17 +291,21 @@ class JSON(object):
                 return obj.__json__(request)
             obj_iface = providedBy(obj)
             adapters = self.components.adapters
-            result = adapters.lookup((obj_iface,), IJSONAdapter,
-                                     default=_marker)
+            result = adapters.lookup(
+                (obj_iface,), IJSONAdapter, default=_marker
+            )
             if result is _marker:
                 raise TypeError('%r is not JSON serializable' % (obj,))
             return result(obj, request)
+
         return default
 
-json_renderer_factory = JSON() # bw compat
+
+json_renderer_factory = JSON()  # bw compat
 
 JSONP_VALID_CALLBACK = re.compile(r"^[$a-z_][$0-9a-z_\.\[\]]+[^.]$", re.I)
 
+
 class JSONP(JSON):
     """ `JSONP <https://en.wikipedia.org/wiki/JSONP>`_ renderer factory helper
     which implements a hybrid json/jsonp renderer.  JSONP is useful for
@@ -373,6 +378,7 @@ class JSONP(JSON):
         ``application/javascript`` if query parameter matching
         ``self.param_name`` is present in request.GET; otherwise returns
         plain-JSON encoded string with content-type ``application/json``"""
+
         def _render(value, system):
             request = system.get('request')
             default = self._make_default(request)
@@ -384,7 +390,9 @@ class JSONP(JSON):
 
                 if callback is not None:
                     if not JSONP_VALID_CALLBACK.match(callback):
-                        raise HTTPBadRequest('Invalid JSONP callback function name.')
+                        raise HTTPBadRequest(
+                            'Invalid JSONP callback function name.'
+                        )
 
                     ct = 'application/javascript'
                     body = '/**/{0}({1});'.format(callback, val)
@@ -392,8 +400,10 @@ class JSONP(JSON):
                 if response.content_type == response.default_content_type:
                     response.content_type = ct
             return body
+
         return _render
 
+
 @implementer(IRendererInfo)
 class RendererHelper(object):
     def __init__(self, name=None, package=None, registry=None):
@@ -422,36 +432,36 @@ class RendererHelper(object):
     def renderer(self):
         factory = self.registry.queryUtility(IRendererFactory, name=self.type)
         if factory is None:
-            raise ValueError(
-                'No such renderer factory %s' % str(self.type))
+            raise ValueError('No such renderer factory %s' % str(self.type))
         return factory(self)
 
     def get_renderer(self):
         return self.renderer
 
     def render_view(self, request, response, view, context):
-        system = {'view':view,
-                  'renderer_name':self.name, # b/c
-                  'renderer_info':self,
-                  'context':context,
-                  'request':request,
-                  'req':request,
-                  'get_csrf_token':partial(get_csrf_token, request),
-                  }
+        system = {
+            'view': view,
+            'renderer_name': self.name,  # b/c
+            'renderer_info': self,
+            'context': context,
+            'request': request,
+            'req': request,
+            'get_csrf_token': partial(get_csrf_token, request),
+        }
         return self.render_to_response(response, system, request=request)
 
     def render(self, value, system_values, request=None):
         renderer = self.renderer
         if system_values is None:
             system_values = {
-                'view':None,
-                'renderer_name':self.name, # b/c
-                'renderer_info':self,
-                'context':getattr(request, 'context', None),
-                'request':request,
-                'req':request,
-                'get_csrf_token':partial(get_csrf_token, request),
-                }
+                'view': None,
+                'renderer_name': self.name,  # b/c
+                'renderer_info': self,
+                'context': getattr(request, 'context', None),
+                'request': request,
+                'req': request,
+                'get_csrf_token': partial(get_csrf_token, request),
+            }
 
         system_values = BeforeRender(system_values, value)
 
@@ -495,12 +505,14 @@ class RendererHelper(object):
             registry = self.registry
         return self.__class__(name=name, package=package, registry=registry)
 
+
 class NullRendererHelper(RendererHelper):
     """ Special renderer helper that has render_* methods which simply return
     the value they are fed rather than converting them to response objects;
     useful for testing purposes and special case view configuration
     registrations that want to use the view configuration machinery but do
     not want actual rendering to happen ."""
+
     def __init__(self, name=None, package=None, registry=None):
         # we override the initializer to avoid calling get_current_registry
         # (it will return a reference to the global registry when this
@@ -526,4 +538,5 @@ class NullRendererHelper(RendererHelper):
     def clone(self, name=None, package=None, registry=None):
         return self
 
+
 null_renderer = NullRendererHelper()
diff --git a/src/pyramid/request.py b/src/pyramid/request.py
index 201f1d648..907b4477f 100644
--- a/src/pyramid/request.py
+++ b/src/pyramid/request.py
@@ -11,32 +11,23 @@ from pyramid.interfaces import (
     IRequestExtensions,
     IResponse,
     ISessionFactory,
-    )
+)
 
-from pyramid.compat import (
-    text_,
-    bytes_,
-    native_,
-    iteritems_,
-    )
+from pyramid.compat import text_, bytes_, native_, iteritems_
 
 from pyramid.decorator import reify
 from pyramid.i18n import LocalizerRequestMixin
 from pyramid.response import Response, _get_response_factory
-from pyramid.security import (
-    AuthenticationAPIMixin,
-    AuthorizationAPIMixin,
-    )
+from pyramid.security import AuthenticationAPIMixin, AuthorizationAPIMixin
 from pyramid.url import URLMethodsMixin
-from pyramid.util import (
-    InstancePropertyHelper,
-    InstancePropertyMixin,
-)
+from pyramid.util import InstancePropertyHelper, InstancePropertyMixin
 from pyramid.view import ViewMethodsMixin
 
+
 class TemplateContext(object):
     pass
 
+
 class CallbackMethodsMixin(object):
     @reify
     def finished_callbacks(self):
@@ -146,6 +137,7 @@ class CallbackMethodsMixin(object):
             callback = callbacks.popleft()
             callback(self)
 
+
 @implementer(IRequest)
 class Request(
     BaseRequest,
@@ -156,7 +148,7 @@ class Request(
     AuthenticationAPIMixin,
     AuthorizationAPIMixin,
     ViewMethodsMixin,
-    ):
+):
     """
     A subclass of the :term:`WebOb` Request class.  An instance of
     this class is created by the :term:`router` and is provided to a
@@ -177,6 +169,7 @@ class Request(
     release of this :app:`Pyramid` version.  See
     https://webob.org/ for further information.
     """
+
     exception = None
     exc_info = None
     matchdict = None
@@ -201,7 +194,8 @@ class Request(
         if factory is None:
             raise AttributeError(
                 'No session factory registered '
-                '(see the Sessions chapter of the Pyramid documentation)')
+                '(see the Sessions chapter of the Pyramid documentation)'
+            )
         return factory(self)
 
     @reify
@@ -244,13 +238,17 @@ def route_request_iface(name, bases=()):
     # zope.interface.interface.Element.__init__ and
     # https://github.com/Pylons/pyramid/issues/232; as a result, always pass
     # __doc__ to the InterfaceClass constructor.
-    iface = InterfaceClass('%s_IRequest' % name, bases=bases,
-                           __doc__="route_request_iface-generated interface")
+    iface = InterfaceClass(
+        '%s_IRequest' % name,
+        bases=bases,
+        __doc__="route_request_iface-generated interface",
+    )
     # for exception view lookups
     iface.combined = InterfaceClass(
         '%s_combined_IRequest' % name,
         bases=(iface, IRequest),
-        __doc__='route_request_iface-generated combined interface')
+        __doc__='route_request_iface-generated combined interface',
+    )
     return iface
 
 
@@ -258,8 +256,10 @@ def add_global_response_headers(request, headerlist):
     def add_headers(request, response):
         for k, v in headerlist:
             response.headerlist.append((k, v))
+
     request.add_response_callback(add_headers)
 
+
 def call_app_with_subpath_as_path_info(request, app):
     # Copy the request.  Use the source request's subpath (if it exists) as
     # the new request's PATH_INFO.  Set the request copy's SCRIPT_NAME to the
@@ -280,11 +280,12 @@ def call_app_with_subpath_as_path_info(request, app):
     new_script_name = ''
 
     # compute new_path_info
-    new_path_info = '/' + '/'.join([native_(x.encode('utf-8'), 'latin-1')
-                                    for x in subpath])
+    new_path_info = '/' + '/'.join(
+        [native_(x.encode('utf-8'), 'latin-1') for x in subpath]
+    )
 
-    if new_path_info != '/': # don't want a sole double-slash
-        if path_info != '/': # if orig path_info is '/', we're already done
+    if new_path_info != '/':  # don't want a sole double-slash
+        if path_info != '/':  # if orig path_info is '/', we're already done
             if path_info.endswith('/'):
                 # readd trailing slash stripped by subpath (traversal)
                 # conversion
@@ -314,6 +315,7 @@ def call_app_with_subpath_as_path_info(request, app):
 
     return new_request.get_response(app)
 
+
 def apply_request_extensions(request, extensions=None):
     """Apply request extensions (methods and properties) to an instance of
     :class:`pyramid.interfaces.IRequest`. This method is dependent on the
@@ -331,4 +333,5 @@ def apply_request_extensions(request, extensions=None):
             setattr(request, name, method)
 
         InstancePropertyHelper.apply_properties(
-            request, extensions.descriptors)
+            request, extensions.descriptors
+        )
diff --git a/src/pyramid/resource.py b/src/pyramid/resource.py
index 986c75e37..1454114fd 100644
--- a/src/pyramid/resource.py
+++ b/src/pyramid/resource.py
@@ -1,5 +1,6 @@
 """ Backwards compatibility shim module (forever). """
-from pyramid.asset import * # b/w compat
+from pyramid.asset import *  # b/w compat
+
 resolve_resource_spec = resolve_asset_spec
 resource_spec_from_abspath = asset_spec_from_abspath
 abspath_from_resource_spec = abspath_from_asset_spec
diff --git a/src/pyramid/response.py b/src/pyramid/response.py
index 1e2546ed0..38f9fa1ce 100644
--- a/src/pyramid/response.py
+++ b/src/pyramid/response.py
@@ -1,8 +1,5 @@
 import mimetypes
-from os.path import (
-    getmtime,
-    getsize,
-    )
+from os.path import getmtime, getsize
 
 import venusian
 
@@ -18,17 +15,20 @@ def init_mimetypes(mimetypes):
         return True
     return False
 
+
 # See http://bugs.python.org/issue5853 which is a recursion bug
 # that seems to effect Python 2.6, Python 2.6.1, and 2.6.2 (a fix
 # has been applied on the Python 2 trunk).
 init_mimetypes(mimetypes)
 
-_BLOCK_SIZE = 4096 * 64 # 256K
+_BLOCK_SIZE = 4096 * 64  # 256K
+
 
 @implementer(IResponse)
 class Response(_Response):
     pass
 
+
 class FileResponse(Response):
     """
     A Response object that can be used to serve a static file from disk
@@ -51,14 +51,21 @@ class FileResponse(Response):
     binary file.  This argument will be ignored if you also leave
     ``content-type`` as ``None``.
     """
-    def __init__(self, path, request=None, cache_max_age=None,
-                 content_type=None, content_encoding=None):
+
+    def __init__(
+        self,
+        path,
+        request=None,
+        cache_max_age=None,
+        content_type=None,
+        content_encoding=None,
+    ):
         if content_type is None:
             content_type, content_encoding = _guess_type(path)
         super(FileResponse, self).__init__(
             conditional_response=True,
             content_type=content_type,
-            content_encoding=content_encoding
+            content_encoding=content_encoding,
         )
         self.last_modified = getmtime(path)
         content_length = getsize(path)
@@ -76,6 +83,7 @@ class FileResponse(Response):
         if cache_max_age is not None:
             self.cache_expires = cache_max_age
 
+
 class FileIter(object):
     """ A fixed-block-size iterator for use as a WSGI app_iter.
 
@@ -84,6 +92,7 @@ class FileIter(object):
 
     ``block_size`` is an optional block size for iteration.
     """
+
     def __init__(self, file, block_size=_BLOCK_SIZE):
         self.file = file
         self.block_size = block_size
@@ -97,7 +106,7 @@ class FileIter(object):
             raise StopIteration
         return val
 
-    __next__ = next # py3
+    __next__ = next  # py3
 
     def close(self):
         self.file.close()
@@ -166,7 +175,8 @@ class response_adapter(object):
        Added the ``_depth`` and ``_category`` arguments.
 
     """
-    venusian = venusian # for unit testing
+
+    venusian = venusian  # for unit testing
 
     def __init__(self, *types_or_ifaces, **kwargs):
         self.types_or_ifaces = types_or_ifaces
@@ -180,8 +190,12 @@ class response_adapter(object):
             config.add_response_adapter(wrapped, type_or_iface, **self.kwargs)
 
     def __call__(self, wrapped):
-        self.venusian.attach(wrapped, self.register, category=self.category,
-                             depth=self.depth + 1)
+        self.venusian.attach(
+            wrapped,
+            self.register,
+            category=self.category,
+            depth=self.depth + 1,
+        )
         return wrapped
 
 
@@ -190,18 +204,14 @@ def _get_response_factory(registry):
     `pyramid.interfaces.IResponseFactory`.
     """
     response_factory = registry.queryUtility(
-        IResponseFactory,
-        default=lambda r: Response()
+        IResponseFactory, default=lambda r: Response()
     )
 
     return response_factory
 
 
 def _guess_type(path):
-    content_type, content_encoding = mimetypes.guess_type(
-        path,
-        strict=False
-        )
+    content_type, content_encoding = mimetypes.guess_type(path, strict=False)
     if content_type is None:
         content_type = 'application/octet-stream'
     # str-ifying content_type is a workaround for a bug in Python 2.7.7
diff --git a/src/pyramid/router.py b/src/pyramid/router.py
index 49b7b601b..19641aecd 100644
--- a/src/pyramid/router.py
+++ b/src/pyramid/router.py
@@ -1,7 +1,4 @@
-from zope.interface import (
-    implementer,
-    providedBy,
-    )
+from zope.interface import implementer, providedBy
 
 from pyramid.interfaces import (
     IDebugLogger,
@@ -15,14 +12,14 @@ from pyramid.interfaces import (
     IRoutesMapper,
     ITraverser,
     ITweens,
-    )
+)
 
 from pyramid.events import (
     ContextFound,
     NewRequest,
     NewResponse,
     BeforeTraversal,
-    )
+)
 
 from pyramid.httpexceptions import HTTPNotFound
 from pyramid.request import Request
@@ -30,10 +27,8 @@ from pyramid.view import _call_view
 from pyramid.request import apply_request_extensions
 from pyramid.threadlocal import RequestContext
 
-from pyramid.traversal import (
-    DefaultRootFactory,
-    ResourceTreeTraverser,
-    )
+from pyramid.traversal import DefaultRootFactory, ResourceTreeTraverser
+
 
 @implementer(IRouter)
 class Router(object):
@@ -49,12 +44,13 @@ class Router(object):
         self.request_factory = q(IRequestFactory, default=Request)
         self.request_extensions = q(IRequestExtensions)
         self.execution_policy = q(
-            IExecutionPolicy, default=default_execution_policy)
+            IExecutionPolicy, default=default_execution_policy
+        )
         self.orig_handle_request = self.handle_request
         tweens = q(ITweens)
         if tweens is not None:
             self.handle_request = tweens(self.handle_request, registry)
-        self.root_policy = self.root_factory # b/w compat
+        self.root_policy = self.root_factory  # b/w compat
         self.registry = registry
         settings = registry.settings
         if settings is not None:
@@ -82,8 +78,7 @@ class Router(object):
             match, route = info['match'], info['route']
             if route is None:
                 if debug_routematch:
-                    msg = ('no route matched for url %s' %
-                           request.url)
+                    msg = 'no route matched for url %s' % request.url
                     logger and logger.debug(msg)
             else:
                 attrs['matchdict'] = match
@@ -96,20 +91,21 @@ class Router(object):
                         'path_info: %r, '
                         'pattern: %r, '
                         'matchdict: %r, '
-                        'predicates: %r' % (
+                        'predicates: %r'
+                        % (
                             request.url,
                             route.name,
                             request.path_info,
                             route.pattern,
                             match,
-                            ', '.join([p.text() for p in route.predicates]))
+                            ', '.join([p.text() for p in route.predicates]),
                         )
+                    )
                     logger and logger.debug(msg)
 
                 request.request_iface = registry.queryUtility(
-                    IRouteRequest,
-                    name=route.name,
-                    default=IRequest)
+                    IRouteRequest, name=route.name, default=IRequest
+                )
 
                 root_factory = route.factory or self.root_factory
 
@@ -137,8 +133,8 @@ class Router(object):
             tdict['subpath'],
             tdict['traversed'],
             tdict['virtual_root'],
-            tdict['virtual_root_path']
-            )
+            tdict['virtual_root_path'],
+        )
 
         attrs.update(tdict)
 
@@ -149,12 +145,8 @@ class Router(object):
         # find a view callable
         context_iface = providedBy(context)
         response = _call_view(
-            registry,
-            request,
-            context,
-            context_iface,
-            view_name
-            )
+            registry, request, context, context_iface, view_name
+        )
 
         if response is None:
             if self.debug_notfound:
@@ -162,11 +154,19 @@ class Router(object):
                     'debug_notfound of url %s; path_info: %r, '
                     'context: %r, view_name: %r, subpath: %r, '
                     'traversed: %r, root: %r, vroot: %r, '
-                    'vroot_path: %r' % (
-                        request.url, request.path_info, context,
-                        view_name, subpath, traversed, root, vroot,
-                        vroot_path)
+                    'vroot_path: %r'
+                    % (
+                        request.url,
+                        request.path_info,
+                        context,
+                        view_name,
+                        subpath,
+                        traversed,
+                        root,
+                        vroot,
+                        vroot_path,
                     )
+                )
                 logger and logger.debug(msg)
             else:
                 msg = request.path_info
@@ -270,6 +270,7 @@ class Router(object):
         response = self.execution_policy(environ, self)
         return response(environ, start_response)
 
+
 def default_execution_policy(environ, router):
     with router.request_context(environ) as request:
         try:
diff --git a/src/pyramid/scaffolds/__init__.py b/src/pyramid/scaffolds/__init__.py
index 71a220e22..95c51a2d8 100644
--- a/src/pyramid/scaffolds/__init__.py
+++ b/src/pyramid/scaffolds/__init__.py
@@ -6,11 +6,13 @@ from pyramid.compat import native_
 
 from pyramid.scaffolds.template import Template  # API
 
+
 class PyramidTemplate(Template):
     """
      A class that can be used as a base class for Pyramid scaffolding
      templates.
     """
+
     def pre(self, command, output_dir, vars):
         """ Overrides :meth:`pyramid.scaffolds.template.Template.pre`, adding
         several variables to the default variables list (including
@@ -26,7 +28,7 @@ class PyramidTemplate(Template):
         vars['package_logger'] = package_logger
         return Template.pre(self, command, output_dir, vars)
 
-    def post(self, command, output_dir, vars): # pragma: no cover
+    def post(self, command, output_dir, vars):  # pragma: no cover
         """ Overrides :meth:`pyramid.scaffolds.template.Template.post`, to
         print "Welcome to Pyramid.  Sorry for the convenience." after a
         successful scaffolding rendering."""
@@ -42,24 +44,29 @@ class PyramidTemplate(Template):
 
             Welcome to Pyramid.  Sorry for the convenience.
             %(separator)s
-        """ % {'separator': separator})
+        """
+            % {'separator': separator}
+        )
 
         self.out(msg)
         return Template.post(self, command, output_dir, vars)
 
-    def out(self, msg): # pragma: no cover (replaceable testing hook)
+    def out(self, msg):  # pragma: no cover (replaceable testing hook)
         print(msg)
 
+
 class StarterProjectTemplate(PyramidTemplate):
     _template_dir = 'starter'
     summary = 'Pyramid starter project using URL dispatch and Jinja2'
 
+
 class ZODBProjectTemplate(PyramidTemplate):
     _template_dir = 'zodb'
     summary = 'Pyramid project using ZODB, traversal, and Chameleon'
 
+
 class AlchemyProjectTemplate(PyramidTemplate):
     _template_dir = 'alchemy'
     summary = (
-        'Pyramid project using SQLAlchemy, SQLite, URL dispatch, and '
-        'Jinja2')
+        'Pyramid project using SQLAlchemy, SQLite, URL dispatch, and ' 'Jinja2'
+    )
diff --git a/src/pyramid/scaffolds/copydir.py b/src/pyramid/scaffolds/copydir.py
index 0914bb0d4..31e8dfb9e 100644
--- a/src/pyramid/scaffolds/copydir.py
+++ b/src/pyramid/scaffolds/copydir.py
@@ -11,7 +11,7 @@ from pyramid.compat import (
     native_,
     url_quote as compat_url_quote,
     escape,
-    )
+)
 
 fsenc = sys.getfilesystemencoding()
 
@@ -22,9 +22,20 @@ class SkipTemplate(Exception):
     Raise this exception during the substitution of your template
     """
 
-def copy_dir(source, dest, vars, verbosity, simulate, indent=0,
-             sub_vars=True, interactive=False, overwrite=True,
-             template_renderer=None, out_=sys.stdout):
+
+def copy_dir(
+    source,
+    dest,
+    vars,
+    verbosity,
+    simulate,
+    indent=0,
+    sub_vars=True,
+    interactive=False,
+    overwrite=True,
+    template_renderer=None,
+    out_=sys.stdout,
+):
     """
     Copies the ``source`` directory to the ``dest`` directory.
 
@@ -49,10 +60,12 @@ def copy_dir(source, dest, vars, verbosity, simulate, indent=0,
     ``template_renderer(content_as_string, vars_as_dict,
     filename=filename)``.
     """
+
     def out(msg):
         out_.write(msg)
         out_.write('\n')
         out_.flush()
+
     # This allows you to use a leading +dot+ in filenames which would
     # otherwise be skipped because leading dots make the file hidden:
     vars.setdefault('dot', '.')
@@ -80,7 +93,7 @@ def copy_dir(source, dest, vars, verbosity, simulate, indent=0,
             if verbosity >= 2:
                 reason = pad + reason % {'filename': full}
                 out(reason)
-            continue # pragma: no cover
+            continue  # pragma: no cover
         if sub_vars:
             dest_full = os.path.join(dest, substitute_filename(name, vars))
         sub_file = False
@@ -90,18 +103,36 @@ def copy_dir(source, dest, vars, verbosity, simulate, indent=0,
         if use_pkg_resources and pkg_resources.resource_isdir(source[0], full):
             if verbosity:
                 out('%sRecursing into %s' % (pad, os.path.basename(full)))
-            copy_dir((source[0], full), dest_full, vars, verbosity, simulate,
-                     indent=indent + 1, sub_vars=sub_vars,
-                     interactive=interactive, overwrite=overwrite,
-                     template_renderer=template_renderer, out_=out_)
+            copy_dir(
+                (source[0], full),
+                dest_full,
+                vars,
+                verbosity,
+                simulate,
+                indent=indent + 1,
+                sub_vars=sub_vars,
+                interactive=interactive,
+                overwrite=overwrite,
+                template_renderer=template_renderer,
+                out_=out_,
+            )
             continue
         elif not use_pkg_resources and os.path.isdir(full):
             if verbosity:
                 out('%sRecursing into %s' % (pad, os.path.basename(full)))
-            copy_dir(full, dest_full, vars, verbosity, simulate,
-                     indent=indent + 1, sub_vars=sub_vars,
-                     interactive=interactive, overwrite=overwrite,
-                     template_renderer=template_renderer, out_=out_)
+            copy_dir(
+                full,
+                dest_full,
+                vars,
+                verbosity,
+                simulate,
+                indent=indent + 1,
+                sub_vars=sub_vars,
+                interactive=interactive,
+                overwrite=overwrite,
+                template_renderer=template_renderer,
+                out_=out_,
+            )
             continue
         elif use_pkg_resources:
             content = pkg_resources.resource_string(source[0], full)
@@ -111,12 +142,14 @@ def copy_dir(source, dest, vars, verbosity, simulate, indent=0,
         if sub_file:
             try:
                 content = substitute_content(
-                    content, vars, filename=full,
-                    template_renderer=template_renderer
-                    )
-            except SkipTemplate: 
-                continue # pragma: no cover
-            if content is None:  
+                    content,
+                    vars,
+                    filename=full,
+                    template_renderer=template_renderer,
+                )
+            except SkipTemplate:
+                continue  # pragma: no cover
+            if content is None:
                 continue  # pragma: no cover
         already_exists = os.path.exists(dest_full)
         if already_exists:
@@ -124,27 +157,33 @@ def copy_dir(source, dest, vars, verbosity, simulate, indent=0,
                 old_content = f.read()
             if old_content == content:
                 if verbosity:
-                    out('%s%s already exists (same content)' %
-                          (pad, dest_full))
-                continue # pragma: no cover
+                    out(
+                        '%s%s already exists (same content)' % (pad, dest_full)
+                    )
+                continue  # pragma: no cover
             if interactive:
                 if not query_interactive(
-                    native_(full, fsenc), native_(dest_full, fsenc),
-                    native_(content, fsenc), native_(old_content, fsenc),
-                    simulate=simulate, out_=out_):
+                    native_(full, fsenc),
+                    native_(dest_full, fsenc),
+                    native_(content, fsenc),
+                    native_(old_content, fsenc),
+                    simulate=simulate,
+                    out_=out_,
+                ):
                     continue
             elif not overwrite:
-                continue # pragma: no cover 
+                continue  # pragma: no cover
         if verbosity and use_pkg_resources:
             out('%sCopying %s to %s' % (pad, full, dest_full))
         elif verbosity:
             out(
-                '%sCopying %s to %s' % (pad, os.path.basename(full),
-                                        dest_full))
+                '%sCopying %s to %s' % (pad, os.path.basename(full), dest_full)
+            )
         if not simulate:
             with open(dest_full, 'wb') as f:
                 f.write(content)
 
+
 def should_skip_file(name):
     """
     Checks if a file should be skipped based on its name.
@@ -164,38 +203,60 @@ def should_skip_file(name):
         return 'Skipping version control directory %(filename)s'
     return None
 
+
 # Overridden on user's request:
 all_answer = None
 
-def query_interactive(src_fn, dest_fn, src_content, dest_content,
-                      simulate, out_=sys.stdout):
+
+def query_interactive(
+    src_fn, dest_fn, src_content, dest_content, simulate, out_=sys.stdout
+):
     def out(msg):
         out_.write(msg)
         out_.write('\n')
         out_.flush()
+
     global all_answer
     from difflib import unified_diff, context_diff
-    u_diff = list(unified_diff(
-        dest_content.splitlines(),
-        src_content.splitlines(),
-        dest_fn, src_fn))
-    c_diff = list(context_diff(
-        dest_content.splitlines(),
-        src_content.splitlines(),
-        dest_fn, src_fn))
-    added = len([l for l in u_diff if l.startswith('+') and
-                 not l.startswith('+++')])
-    removed = len([l for l in u_diff if l.startswith('-') and
-                   not l.startswith('---')])
+
+    u_diff = list(
+        unified_diff(
+            dest_content.splitlines(),
+            src_content.splitlines(),
+            dest_fn,
+            src_fn,
+        )
+    )
+    c_diff = list(
+        context_diff(
+            dest_content.splitlines(),
+            src_content.splitlines(),
+            dest_fn,
+            src_fn,
+        )
+    )
+    added = len(
+        [l for l in u_diff if l.startswith('+') and not l.startswith('+++')]
+    )
+    removed = len(
+        [l for l in u_diff if l.startswith('-') and not l.startswith('---')]
+    )
     if added > removed:
         msg = '; %i lines added' % (added - removed)
     elif removed > added:
         msg = '; %i lines removed' % (removed - added)
     else:
         msg = ''
-    out('Replace %i bytes with %i bytes (%i/%i lines changed%s)' % (
-        len(dest_content), len(src_content),
-        removed, len(dest_content.splitlines()), msg))
+    out(
+        'Replace %i bytes with %i bytes (%i/%i lines changed%s)'
+        % (
+            len(dest_content),
+            len(src_content),
+            removed,
+            len(dest_content.splitlines()),
+            msg,
+        )
+    )
     prompt = 'Overwrite %s [y/n/d/B/?] ' % dest_fn
     while 1:
         if all_answer is None:
@@ -204,6 +265,7 @@ def query_interactive(src_fn, dest_fn, src_content, dest_content,
             response = all_answer
         if not response or response[0] == 'b':
             import shutil
+
             new_dest_fn = dest_fn + '.bak'
             n = 0
             while os.path.exists(new_dest_fn):
@@ -230,6 +292,7 @@ def query_interactive(src_fn, dest_fn, src_content, dest_content,
         else:
             out(query_usage)
 
+
 query_usage = """\
 Responses:
   Y(es):    Overwrite the file with the new content.
@@ -240,39 +303,47 @@ Responses:
   Type "all Y/N/B" to use Y/N/B for answer to all future questions
 """
 
+
 def makedirs(dir, verbosity, pad):
     parent = os.path.dirname(os.path.abspath(dir))
     if not os.path.exists(parent):
         makedirs(parent, verbosity, pad)  # pragma: no cover
     os.mkdir(dir)
 
+
 def substitute_filename(fn, vars):
     for var, value in vars.items():
         fn = fn.replace('+%s+' % var, str(value))
     return fn
 
-def substitute_content(content, vars, filename='<string>',
-                       template_renderer=None):
+
+def substitute_content(
+    content, vars, filename='<string>', template_renderer=None
+):
     v = standard_vars.copy()
     v.update(vars)
     return template_renderer(content, v, filename=filename)
 
+
 def html_quote(s):
     if s is None:
         return ''
     return escape(str(s), 1)
 
+
 def url_quote(s):
     if s is None:
         return ''
     return compat_url_quote(str(s))
 
+
 def test(conf, true_cond, false_cond=None):
     if conf:
         return true_cond
     else:
         return false_cond
 
+
 def skip_template(condition=True, *args):
     """
     Raise SkipTemplate, which causes copydir to skip the template
@@ -286,6 +357,7 @@ def skip_template(condition=True, *args):
     if condition:
         raise SkipTemplate(*args)
 
+
 standard_vars = {
     'nothing': None,
     'html_quote': html_quote,
@@ -297,5 +369,4 @@ standard_vars = {
     'bool': bool,
     'SkipTemplate': SkipTemplate,
     'skip_template': skip_template,
-    }
-
+}
diff --git a/src/pyramid/scaffolds/template.py b/src/pyramid/scaffolds/template.py
index e5098e815..60b543842 100644
--- a/src/pyramid/scaffolds/template.py
+++ b/src/pyramid/scaffolds/template.py
@@ -6,19 +6,18 @@ import re
 import sys
 import os
 
-from pyramid.compat import (
-    native_,
-    bytes_,
-    )
+from pyramid.compat import native_, bytes_
 
 from pyramid.scaffolds import copydir
 
 fsenc = sys.getfilesystemencoding()
 
+
 class Template(object):
     """ Inherit from this base class and override methods to use the Pyramid
     scaffolding system."""
-    copydir = copydir # for testing
+
+    copydir = copydir  # for testing
     _template_dir = None
 
     def __init__(self, name):
@@ -36,7 +35,10 @@ class Template(object):
         try:
             return bytes_(
                 substitute_escaped_double_braces(
-                    substitute_double_braces(content, TypeMapper(vars))), fsenc)
+                    substitute_double_braces(content, TypeMapper(vars))
+                ),
+                fsenc,
+            )
         except Exception as e:
             _add_except(e, ' in file %s' % filename)
             raise
@@ -54,7 +56,8 @@ class Template(object):
         construct a path.  If _template_dir is a tuple, it should be a
         2-element tuple: ``(package_name, package_relative_path)``."""
         assert self._template_dir is not None, (
-            "Template %r didn't set _template_dir" % self)
+            "Template %r didn't set _template_dir" % self
+        )
         if isinstance(self._template_dir, tuple):
             return self._template_dir
         else:
@@ -65,13 +68,13 @@ class Template(object):
         self.write_files(command, output_dir, vars)
         self.post(command, output_dir, vars)
 
-    def pre(self, command, output_dir, vars): # pragma: no cover
+    def pre(self, command, output_dir, vars):  # pragma: no cover
         """
         Called before template is applied.
         """
         pass
 
-    def post(self, command, output_dir, vars): # pragma: no cover
+    def post(self, command, output_dir, vars):  # pragma: no cover
         """
         Called after template is applied.
         """
@@ -95,15 +98,15 @@ class Template(object):
             overwrite=command.args.overwrite,
             indent=1,
             template_renderer=self.render_template,
-            )
+        )
 
-    def makedirs(self, dir): # pragma: no cover
+    def makedirs(self, dir):  # pragma: no cover
         return os.makedirs(dir)
 
-    def exists(self, path): # pragma: no cover
+    def exists(self, path):  # pragma: no cover
         return os.path.exists(path)
 
-    def out(self, msg): # pragma: no cover
+    def out(self, msg):  # pragma: no cover
         print(msg)
 
     # hair for exit with usage when paster create is used under 1.3 instead
@@ -113,13 +116,15 @@ class Template(object):
     # required_templates tuple is required to allow it to get as far as
     # calling check_vars.
     required_templates = ()
+
     def check_vars(self, vars, other):
         raise RuntimeError(
             'Under Pyramid 1.3, you should use the "pcreate" command rather '
-            'than "paster create"')
+            'than "paster create"'
+        )
 
-class TypeMapper(dict):
 
+class TypeMapper(dict):
     def __getitem__(self, item):
         options = item.split('|')
         for op in options[:-1]:
@@ -135,6 +140,7 @@ class TypeMapper(dict):
         else:
             return str(value)
 
+
 def eval_with_catch(expr, vars):
     try:
         return eval(expr, vars)
@@ -142,23 +148,32 @@ def eval_with_catch(expr, vars):
         _add_except(e, 'in expression %r' % expr)
         raise
 
+
 double_brace_pattern = re.compile(r'{{(?P<braced>.*?)}}')
 
+
 def substitute_double_braces(content, values):
     def double_bracerepl(match):
         value = match.group('braced').strip()
         return values[value]
+
     return double_brace_pattern.sub(double_bracerepl, content)
 
-escaped_double_brace_pattern = re.compile(r'\\{\\{(?P<escape_braced>[^\\]*?)\\}\\}')
+
+escaped_double_brace_pattern = re.compile(
+    r'\\{\\{(?P<escape_braced>[^\\]*?)\\}\\}'
+)
+
 
 def substitute_escaped_double_braces(content):
     def escaped_double_bracerepl(match):
         value = match.group('escape_braced').strip()
         return "{{%(value)s}}" % locals()
+
     return escaped_double_brace_pattern.sub(escaped_double_bracerepl, content)
 
-def _add_except(exc, info): # pragma: no cover
+
+def _add_except(exc, info):  # pragma: no cover
     if not hasattr(exc, 'args') or exc.args is None:
         return
     args = list(exc.args)
@@ -168,5 +183,3 @@ def _add_except(exc, info): # pragma: no cover
         args = [info]
     exc.args = tuple(args)
     return
-
-
diff --git a/src/pyramid/scaffolds/tests.py b/src/pyramid/scaffolds/tests.py
index 44680a464..cb8842dbe 100644
--- a/src/pyramid/scaffolds/tests.py
+++ b/src/pyramid/scaffolds/tests.py
@@ -15,12 +15,12 @@ class TemplateTest(object):
     def make_venv(self, directory):  # pragma: no cover
         import virtualenv
         from virtualenv import Logger
+
         logger = Logger([(Logger.level_for_integer(2), sys.stdout)])
         virtualenv.logger = logger
-        virtualenv.create_environment(directory,
-                                      site_packages=False,
-                                      clear=False,
-                                      unzip_setuptools=True)
+        virtualenv.create_environment(
+            directory, site_packages=False, clear=False, unzip_setuptools=True
+        )
 
     def install(self, tmpl_name):  # pragma: no cover
         try:
@@ -36,14 +36,18 @@ class TemplateTest(object):
             os.chdir('Dingle')
             subprocess.check_call([pip, 'install', '.[testing]'])
             if tmpl_name == 'alchemy':
-                populate = os.path.join(self.directory, 'bin',
-                                        'initialize_Dingle_db')
+                populate = os.path.join(
+                    self.directory, 'bin', 'initialize_Dingle_db'
+                )
                 subprocess.check_call([populate, 'development.ini'])
-            subprocess.check_call([
-                os.path.join(self.directory, 'bin', 'py.test')])
+            subprocess.check_call(
+                [os.path.join(self.directory, 'bin', 'py.test')]
+            )
             pserve = os.path.join(self.directory, 'bin', 'pserve')
-            for ininame, hastoolbar in (('development.ini', True),
-                                        ('production.ini', False)):
+            for ininame, hastoolbar in (
+                ('development.ini', True),
+                ('production.ini', False),
+            ):
                 proc = subprocess.Popen([pserve, ininame])
                 try:
                     time.sleep(5)
@@ -66,10 +70,10 @@ class TemplateTest(object):
             shutil.rmtree(self.directory)
             os.chdir(self.old_cwd)
 
-if __name__ == '__main__':     # pragma: no cover
+
+if __name__ == '__main__':  # pragma: no cover
     templates = ['starter', 'alchemy', 'zodb']
 
     for name in templates:
         test = TemplateTest()
         test.install(name)
-    
diff --git a/src/pyramid/scripting.py b/src/pyramid/scripting.py
index 087b55ccb..cbf9d5e32 100644
--- a/src/pyramid/scripting.py
+++ b/src/pyramid/scripting.py
@@ -1,16 +1,14 @@
 from pyramid.config import global_registries
 from pyramid.exceptions import ConfigurationError
 
-from pyramid.interfaces import (
-    IRequestFactory,
-    IRootFactory,
-    )
+from pyramid.interfaces import IRequestFactory, IRootFactory
 from pyramid.request import Request
 from pyramid.request import apply_request_extensions
 
 from pyramid.threadlocal import RequestContext
 from pyramid.traversal import DefaultRootFactory
 
+
 def get_root(app, request=None):
     """ Return a tuple composed of ``(root, closer)`` when provided a
     :term:`router` instance as the ``app`` argument.  The ``root``
@@ -29,11 +27,14 @@ def get_root(app, request=None):
     request.registry = registry
     ctx = RequestContext(request)
     ctx.begin()
+
     def closer():
         ctx.end()
+
     root = app.root_factory(request)
     return root, closer
 
+
 def prepare(request=None, registry=None):
     """ This function pushes data onto the Pyramid threadlocal stack
     (request and registry), making those objects 'current'.  It
@@ -80,9 +81,11 @@ def prepare(request=None, registry=None):
     if registry is None:
         registry = getattr(request, 'registry', global_registries.last)
     if registry is None:
-        raise ConfigurationError('No valid Pyramid applications could be '
-                                 'found, make sure one has been created '
-                                 'before trying to activate it.')
+        raise ConfigurationError(
+            'No valid Pyramid applications could be '
+            'found, make sure one has been created '
+            'before trying to activate it.'
+        )
     if request is None:
         request = _make_request('/', registry)
     # NB: even though _make_request might have already set registry on
@@ -92,10 +95,13 @@ def prepare(request=None, registry=None):
     ctx = RequestContext(request)
     ctx.begin()
     apply_request_extensions(request)
+
     def closer():
         ctx.end()
-    root_factory = registry.queryUtility(IRootFactory,
-                                         default=DefaultRootFactory)
+
+    root_factory = registry.queryUtility(
+        IRootFactory, default=DefaultRootFactory
+    )
     root = root_factory(request)
     if getattr(request, 'context', None) is None:
         request.context = root
@@ -107,6 +113,7 @@ def prepare(request=None, registry=None):
         root_factory=root_factory,
     )
 
+
 class AppEnvironment(dict):
     def __enter__(self):
         return self
@@ -114,6 +121,7 @@ class AppEnvironment(dict):
     def __exit__(self, type, value, traceback):
         self['closer']()
 
+
 def _make_request(path, registry=None):
     """ Return a :meth:`pyramid.request.Request` object anchored at a
     given path. The object returned will be generated from the supplied
diff --git a/src/pyramid/scripts/common.py b/src/pyramid/scripts/common.py
index f4b8027db..9181eea8e 100644
--- a/src/pyramid/scripts/common.py
+++ b/src/pyramid/scripts/common.py
@@ -1,5 +1,6 @@
 import plaster
 
+
 def parse_vars(args):
     """
     Given variables like ``['a=b', 'c=d']`` turns it into ``{'a':
@@ -8,13 +9,12 @@ def parse_vars(args):
     result = {}
     for arg in args:
         if '=' not in arg:
-            raise ValueError(
-                'Variable assignment %r invalid (no "=")'
-                % arg)
+            raise ValueError('Variable assignment %r invalid (no "=")' % arg)
         name, value = arg.split('=', 1)
         result[name] = value
     return result
 
+
 def get_config_loader(config_uri):
     """
     Find a ``plaster.ILoader`` object supporting the "wsgi" protocol.
diff --git a/src/pyramid/scripts/pcreate.py b/src/pyramid/scripts/pcreate.py
index a6db520ce..f3dffefef 100644
--- a/src/pyramid/scripts/pcreate.py
+++ b/src/pyramid/scripts/pcreate.py
@@ -33,60 +33,88 @@ https://github.com/Pylons/?q=cookiecutter
 """,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
-    parser.add_argument('-s', '--scaffold',
-                        dest='scaffold_name',
-                        action='append',
-                        help=("Add a scaffold to the create process "
-                              "(multiple -s args accepted)"))
-    parser.add_argument('-t', '--template',
-                        dest='scaffold_name',
-                        action='append',
-                        help=('A backwards compatibility alias for '
-                              '-s/--scaffold.  Add a scaffold to the '
-                              'create process (multiple -t args accepted)'))
-    parser.add_argument('-l', '--list',
-                        dest='list',
-                        action='store_true',
-                        help="List all available scaffold names")
-    parser.add_argument('--list-templates',
-                        dest='list',
-                        action='store_true',
-                        help=("A backwards compatibility alias for -l/--list. "
-                              "List all available scaffold names."))
-    parser.add_argument('--package-name',
-                        dest='package_name',
-                        action='store',
-                        help='Package name to use. The name provided is '
-                             'assumed to be a valid Python package name, and '
-                             'will not be validated. By default the package '
-                             'name is derived from the value of '
-                             'output_directory.')
-    parser.add_argument('--simulate',
-                        dest='simulate',
-                        action='store_true',
-                        help='Simulate but do no work')
-    parser.add_argument('--overwrite',
-                        dest='overwrite',
-                        action='store_true',
-                        help='Always overwrite')
-    parser.add_argument('--interactive',
-                        dest='interactive',
-                        action='store_true',
-                        help='When a file would be overwritten, interrogate '
-                             '(this is the default, but you may specify it to '
-                             'override --overwrite)')
-    parser.add_argument('--ignore-conflicting-name',
-                        dest='force_bad_name',
-                        action='store_true',
-                        default=False,
-                        help='Do create a project even if the chosen name '
-                             'is the name of an already existing / importable '
-                             'package.')
-    parser.add_argument('output_directory',
-                        nargs='?',
-                        default=None,
-                        help='The directory where the project will be '
-                             'created.')
+    parser.add_argument(
+        '-s',
+        '--scaffold',
+        dest='scaffold_name',
+        action='append',
+        help=(
+            "Add a scaffold to the create process "
+            "(multiple -s args accepted)"
+        ),
+    )
+    parser.add_argument(
+        '-t',
+        '--template',
+        dest='scaffold_name',
+        action='append',
+        help=(
+            'A backwards compatibility alias for '
+            '-s/--scaffold.  Add a scaffold to the '
+            'create process (multiple -t args accepted)'
+        ),
+    )
+    parser.add_argument(
+        '-l',
+        '--list',
+        dest='list',
+        action='store_true',
+        help="List all available scaffold names",
+    )
+    parser.add_argument(
+        '--list-templates',
+        dest='list',
+        action='store_true',
+        help=(
+            "A backwards compatibility alias for -l/--list. "
+            "List all available scaffold names."
+        ),
+    )
+    parser.add_argument(
+        '--package-name',
+        dest='package_name',
+        action='store',
+        help='Package name to use. The name provided is '
+        'assumed to be a valid Python package name, and '
+        'will not be validated. By default the package '
+        'name is derived from the value of '
+        'output_directory.',
+    )
+    parser.add_argument(
+        '--simulate',
+        dest='simulate',
+        action='store_true',
+        help='Simulate but do no work',
+    )
+    parser.add_argument(
+        '--overwrite',
+        dest='overwrite',
+        action='store_true',
+        help='Always overwrite',
+    )
+    parser.add_argument(
+        '--interactive',
+        dest='interactive',
+        action='store_true',
+        help='When a file would be overwritten, interrogate '
+        '(this is the default, but you may specify it to '
+        'override --overwrite)',
+    )
+    parser.add_argument(
+        '--ignore-conflicting-name',
+        dest='force_bad_name',
+        action='store_true',
+        default=False,
+        help='Do create a project even if the chosen name '
+        'is the name of an already existing / importable '
+        'package.',
+    )
+    parser.add_argument(
+        'output_directory',
+        nargs='?',
+        default=None,
+        help='The directory where the project will be ' 'created.',
+    )
 
     pyramid_dist = pkg_resources.get_distribution("pyramid")
 
@@ -123,7 +151,8 @@ https://github.com/Pylons/?q=cookiecutter
         project_name = os.path.basename(os.path.split(output_dir)[1])
         if self.args.package_name is None:
             pkg_name = _bad_chars_re.sub(
-                '', project_name.lower().replace('-', '_'))
+                '', project_name.lower().replace('-', '_')
+            )
             safe_name = pkg_resources.safe_name(project_name)
         else:
             pkg_name = self.args.package_name
@@ -170,9 +199,14 @@ https://github.com/Pylons/?q=cookiecutter
             max_name = max([len(t.name) for t in scaffolds])
             self.out('Available scaffolds:')
             for scaffold in scaffolds:
-                self.out('  %s:%s  %s' % (
-                    scaffold.name,
-                    ' ' * (max_name - len(scaffold.name)), scaffold.summary))
+                self.out(
+                    '  %s:%s  %s'
+                    % (
+                        scaffold.name,
+                        ' ' * (max_name - len(scaffold.name)),
+                        scaffold.summary,
+                    )
+                )
         else:
             self.out('No scaffolds available')
         return 0
@@ -186,8 +220,10 @@ https://github.com/Pylons/?q=cookiecutter
                 scaffold = scaffold_class(entry.name)
                 scaffolds.append(scaffold)
             except Exception as e:  # pragma: no cover
-                self.out('Warning: could not load entry point %s (%s: %s)' % (
-                    entry.name, e.__class__.__name__, e))
+                self.out(
+                    'Warning: could not load entry point %s (%s: %s)'
+                    % (entry.name, e.__class__.__name__, e)
+                )
         return scaffolds
 
     def out(self, msg):  # pragma: no cover
@@ -196,8 +232,10 @@ https://github.com/Pylons/?q=cookiecutter
 
     def validate_input(self):
         if not self.args.scaffold_name:
-            self.out('You must provide at least one scaffold name: '
-                     '-s <scaffold name>')
+            self.out(
+                'You must provide at least one scaffold name: '
+                '-s <scaffold name>'
+            )
             self.out('')
             self.show_scaffolds()
             return False
@@ -213,11 +251,14 @@ https://github.com/Pylons/?q=cookiecutter
         pkg_name = self.project_vars['package']
 
         if pkg_name == 'site' and not self.args.force_bad_name:
-            self.out('The package name "site" has a special meaning in '
-                     'Python. Are you sure you want to use it as your '
-                     'project\'s name?')
-            return self.confirm_bad_name('Really use "{0}"?: '.format(
-                pkg_name))
+            self.out(
+                'The package name "site" has a special meaning in '
+                'Python. Are you sure you want to use it as your '
+                'project\'s name?'
+            )
+            return self.confirm_bad_name(
+                'Really use "{0}"?: '.format(pkg_name)
+            )
 
         # check if pkg_name can be imported (i.e. already exists in current
         # $PYTHON_PATH, if so - let the user confirm
@@ -232,8 +273,10 @@ https://github.com/Pylons/?q=cookiecutter
 
         if self.args.force_bad_name:
             return True
-        self.out('A package named "{0}" already exists, are you sure you want '
-                 'to use it as your project\'s name?'.format(pkg_name))
+        self.out(
+            'A package named "{0}" already exists, are you sure you want '
+            'to use it as your project\'s name?'.format(pkg_name)
+        )
         return self.confirm_bad_name('Really use "{0}"?: '.format(pkg_name))
 
     def confirm_bad_name(self, prompt):  # pragma: no cover
@@ -241,11 +284,14 @@ https://github.com/Pylons/?q=cookiecutter
         return answer.strip().lower() == 'y'
 
     def _warn_pcreate_deprecated(self):
-        self.out('''\
+        self.out(
+            '''\
 Note: As of Pyramid 1.8, this command is deprecated. Use a specific
 cookiecutter instead:
 https://github.com/pylons/?query=cookiecutter
-''')
+'''
+        )
+
 
 if __name__ == '__main__':  # pragma: no cover
     sys.exit(main() or 0)
diff --git a/src/pyramid/scripts/pdistreport.py b/src/pyramid/scripts/pdistreport.py
index 1952e5d39..3ace9451e 100644
--- a/src/pyramid/scripts/pdistreport.py
+++ b/src/pyramid/scripts/pdistreport.py
@@ -4,19 +4,27 @@ import pkg_resources
 import argparse
 from operator import itemgetter
 
-def out(*args): # pragma: no cover
+
+def out(*args):  # pragma: no cover
     for arg in args:
         sys.stdout.write(arg)
         sys.stdout.write(' ')
     sys.stdout.write('\n')
 
+
 def get_parser():
     parser = argparse.ArgumentParser(
-        description="Show Python distribution versions and locations in use")
+        description="Show Python distribution versions and locations in use"
+    )
     return parser
 
-def main(argv=sys.argv, pkg_resources=pkg_resources, platform=platform.platform,
-         out=out):
+
+def main(
+    argv=sys.argv,
+    pkg_resources=pkg_resources,
+    platform=platform.platform,
+    out=out,
+):
     # all args except argv are for unit testing purposes only
     parser = get_parser()
     parser.parse_args(argv[1:])
@@ -24,11 +32,13 @@ def main(argv=sys.argv, pkg_resources=pkg_resources, platform=platform.platform,
     for distribution in pkg_resources.working_set:
         name = distribution.project_name
         packages.append(
-            {'version': distribution.version,
-             'lowername': name.lower(),
-             'name': name,
-             'location':distribution.location}
-            )
+            {
+                'version': distribution.version,
+                'lowername': name.lower(),
+                'name': name,
+                'location': distribution.location,
+            }
+        )
     packages = sorted(packages, key=itemgetter('lowername'))
     pyramid_version = pkg_resources.get_distribution('pyramid').version
     plat = platform()
@@ -39,5 +49,6 @@ def main(argv=sys.argv, pkg_resources=pkg_resources, platform=platform.platform,
         out(' ', package['name'], package['version'])
         out('   ', package['location'])
 
-if __name__ == '__main__': # pragma: no cover
+
+if __name__ == '__main__':  # pragma: no cover
     sys.exit(main() or 0)
diff --git a/src/pyramid/scripts/prequest.py b/src/pyramid/scripts/prequest.py
index f0681afd7..e8f5ff8b3 100644
--- a/src/pyramid/scripts/prequest.py
+++ b/src/pyramid/scripts/prequest.py
@@ -8,10 +8,12 @@ from pyramid.request import Request
 from pyramid.scripts.common import get_config_loader
 from pyramid.scripts.common import parse_vars
 
+
 def main(argv=sys.argv, quiet=False):
     command = PRequestCommand(argv, quiet)
     return command.run()
 
+
 class PRequestCommand(object):
     description = """\
     Submit a HTTP request to a web application.
@@ -48,15 +50,16 @@ class PRequestCommand(object):
     parser = argparse.ArgumentParser(
         description=textwrap.dedent(description),
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        )
+    )
     parser.add_argument(
-        '-n', '--app-name',
+        '-n',
+        '--app-name',
         dest='app_name',
         metavar='NAME',
         help=(
             "Load the named application from the config file (default 'main')"
         ),
-        )
+    )
     parser.add_argument(
         '--header',
         dest='headers',
@@ -67,47 +70,55 @@ class PRequestCommand(object):
         ),
     )
     parser.add_argument(
-        '-d', '--display-headers',
+        '-d',
+        '--display-headers',
         dest='display_headers',
         action='store_true',
-        help='Display status and headers before the response body'
-        )
+        help='Display status and headers before the response body',
+    )
     parser.add_argument(
-        '-m', '--method',
+        '-m',
+        '--method',
         dest='method',
-        choices=['GET', 'HEAD', 'POST', 'PUT', 'PATCH','DELETE',
-                 'PROPFIND', 'OPTIONS'],
+        choices=[
+            'GET',
+            'HEAD',
+            'POST',
+            'PUT',
+            'PATCH',
+            'DELETE',
+            'PROPFIND',
+            'OPTIONS',
+        ],
         help='Request method type (GET, POST, PUT, PATCH, DELETE, '
-             'PROPFIND, OPTIONS)',
-        )
+        'PROPFIND, OPTIONS)',
+    )
     parser.add_argument(
-        '-l', '--login',
+        '-l',
+        '--login',
         dest='login',
         help='HTTP basic auth username:password pair',
-        )
+    )
 
     parser.add_argument(
         'config_uri',
         nargs='?',
         default=None,
         help='The URI to the configuration file.',
-        )
+    )
 
     parser.add_argument(
-        'path_info',
-        nargs='?',
-        default=None,
-        help='The path of the request.',
-        )
+        'path_info', nargs='?', default=None, help='The path of the request.'
+    )
 
     parser.add_argument(
         'config_vars',
         nargs='*',
         default=(),
         help="Variables required by the config file. For example, "
-             "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
-             "passed here.",
-        )
+        "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
+        "passed here.",
+    )
 
     _get_config_loader = staticmethod(get_config_loader)
     stdin = sys.stdin
@@ -116,7 +127,7 @@ class PRequestCommand(object):
         self.quiet = quiet
         self.args = self.parser.parse_args(argv[1:])
 
-    def out(self, msg): # pragma: no cover
+    def out(self, msg):  # pragma: no cover
         if not self.quiet:
             print(msg)
 
@@ -153,7 +164,8 @@ class PRequestCommand(object):
                 if ':' not in item:
                     self.out(
                         "Bad --header=%s option, value must be in the form "
-                        "'name:value'" % item)
+                        "'name:value'" % item
+                    )
                     return 2
                 name, value = item.split(':', 1)
                 headers[name] = value.strip()
@@ -162,13 +174,13 @@ class PRequestCommand(object):
 
         environ = {
             'REQUEST_METHOD': request_method,
-            'SCRIPT_NAME': '',           # may be empty if app is at the root
+            'SCRIPT_NAME': '',  # may be empty if app is at the root
             'PATH_INFO': path,
             'SERVER_NAME': 'localhost',  # always mandatory
-            'SERVER_PORT': '80',         # always mandatory
+            'SERVER_PORT': '80',  # always mandatory
             'SERVER_PROTOCOL': 'HTTP/1.0',
             'CONTENT_TYPE': 'text/plain',
-            'REMOTE_ADDR':'127.0.0.1',
+            'REMOTE_ADDR': '127.0.0.1',
             'wsgi.run_once': True,
             'wsgi.multithread': False,
             'wsgi.multiprocess': False,
@@ -178,7 +190,7 @@ class PRequestCommand(object):
             'QUERY_STRING': qs,
             'HTTP_ACCEPT': 'text/plain;q=1.0, */*;q=0.1',
             'paste.command_request': True,
-            }
+        }
 
         if request_method in ('POST', 'PUT', 'PATCH'):
             environ['wsgi.input'] = self.stdin
@@ -203,5 +215,6 @@ class PRequestCommand(object):
             self.out(response.body)
         return 0
 
-if __name__ == '__main__': # pragma: no cover
+
+if __name__ == '__main__':  # pragma: no cover
     sys.exit(main() or 0)
diff --git a/src/pyramid/scripts/proutes.py b/src/pyramid/scripts/proutes.py
index 69d61ae8f..2bce7d1de 100644
--- a/src/pyramid/scripts/proutes.py
+++ b/src/pyramid/scripts/proutes.py
@@ -110,7 +110,7 @@ def _get_view_module(view_callable):
             if original_view.package_name is not None:
                 return '%s:%s' % (
                     original_view.package_name,
-                    original_view.docroot
+                    original_view.docroot,
                 )
             else:
                 return original_view.docroot
@@ -122,10 +122,7 @@ def _get_view_module(view_callable):
         # for them and remove this logic
         view_name = str(view_callable)
 
-    view_module = '%s.%s' % (
-        view_callable.__module__,
-        view_name,
-    )
+    view_module = '%s.%s' % (view_callable.__module__, view_name)
 
     # If pyramid wraps something in wsgiapp or wsgiapp2 decorators
     # that is currently returned as pyramid.router.decorator, lets
@@ -139,24 +136,17 @@ def _get_view_module(view_callable):
 def get_route_data(route, registry):
     pattern = _get_pattern(route)
 
-    request_iface = registry.queryUtility(
-        IRouteRequest,
-        name=route.name
-    )
+    request_iface = registry.queryUtility(IRouteRequest, name=route.name)
 
     route_request_methods = None
     view_request_methods_order = []
     view_request_methods = {}
     view_callable = None
 
-    route_intr = registry.introspector.get(
-        'routes', route.name
-    )
+    route_intr = registry.introspector.get('routes', route.name)
 
     if request_iface is None:
-        return [
-            (route.name, _get_pattern(route), UNKNOWN_KEY, ANY_KEY)
-        ]
+        return [(route.name, _get_pattern(route), UNKNOWN_KEY, ANY_KEY)]
 
     view_callables = _find_views(registry, request_iface, Interface, '')
     if view_callables:
@@ -188,7 +178,7 @@ def get_route_data(route, registry):
                         view_callable = getattr(view['callable'], view['attr'])
                         view_module = '%s.%s' % (
                             _get_view_module(view['callable']),
-                            view['attr']
+                            view['attr'],
                         )
                     else:
                         view_callable = view['callable']
@@ -217,17 +207,11 @@ def get_route_data(route, registry):
 
     for view_module in view_request_methods_order:
         methods = view_request_methods[view_module]
-        request_methods = _get_request_methods(
-            route_request_methods,
-            methods
-        )
+        request_methods = _get_request_methods(route_request_methods, methods)
 
-        final_routes.append((
-            route.name,
-            pattern,
-            view_module,
-            request_methods,
-        ))
+        final_routes.append(
+            (route.name, pattern, view_module, request_methods)
+        )
 
     return final_routes
 
@@ -251,43 +235,49 @@ class PRoutesCommand(object):
     parser = argparse.ArgumentParser(
         description=textwrap.dedent(description),
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        )
-    parser.add_argument('-g', '--glob',
-                        action='store',
-                        dest='glob',
-                        default='',
-                        help='Display routes matching glob pattern')
-
-    parser.add_argument('-f', '--format',
-                        action='store',
-                        dest='format',
-                        default='',
-                        help=('Choose which columns to display, this will '
-                              'override the format key in the [proutes] ini '
-                              'section'))
+    )
+    parser.add_argument(
+        '-g',
+        '--glob',
+        action='store',
+        dest='glob',
+        default='',
+        help='Display routes matching glob pattern',
+    )
+
+    parser.add_argument(
+        '-f',
+        '--format',
+        action='store',
+        dest='format',
+        default='',
+        help=(
+            'Choose which columns to display, this will '
+            'override the format key in the [proutes] ini '
+            'section'
+        ),
+    )
 
     parser.add_argument(
         'config_uri',
         nargs='?',
         default=None,
         help='The URI to the configuration file.',
-        )
+    )
 
     parser.add_argument(
         'config_vars',
         nargs='*',
         default=(),
         help="Variables required by the config file. For example, "
-             "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
-             "passed here.",
-        )
+        "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
+        "passed here.",
+    )
 
     def __init__(self, argv, quiet=False):
         self.args = self.parser.parse_args(argv[1:])
         self.quiet = quiet
-        self.available_formats = [
-            'name', 'pattern', 'view', 'method'
-        ]
+        self.available_formats = ['name', 'pattern', 'view', 'method']
         self.column_format = self.available_formats
 
     def validate_formats(self, formats):
@@ -296,10 +286,7 @@ class PRoutesCommand(object):
             if fmt not in self.available_formats:
                 invalid_formats.append(fmt)
 
-        msg = (
-            'You provided invalid formats %s, '
-            'Available formats are %s'
-        )
+        msg = 'You provided invalid formats %s, ' 'Available formats are %s'
 
         if invalid_formats:
             msg = msg % (invalid_formats, self.available_formats)
@@ -321,6 +308,7 @@ class PRoutesCommand(object):
 
     def _get_mapper(self, registry):
         from pyramid.config import Configurator
+
         config = Configurator(registry=registry)
         return config.get_routes_mapper()
 
@@ -361,25 +349,29 @@ class PRoutesCommand(object):
         if len(routes) == 0:
             return 0
 
-        mapped_routes = [{
-            'name': 'Name',
-            'pattern': 'Pattern',
-            'view': 'View',
-            'method': 'Method'
-        },{
-            'name': '----',
-            'pattern': '-------',
-            'view': '----',
-            'method': '------'
-        }]
+        mapped_routes = [
+            {
+                'name': 'Name',
+                'pattern': 'Pattern',
+                'view': 'View',
+                'method': 'Method',
+            },
+            {
+                'name': '----',
+                'pattern': '-------',
+                'view': '----',
+                'method': '------',
+            },
+        ]
 
         for route in routes:
             route_data = get_route_data(route, registry)
 
             for name, pattern, view, method in route_data:
                 if self.args.glob:
-                    match = (fnmatch.fnmatch(name, self.args.glob) or
-                             fnmatch.fnmatch(pattern, self.args.glob))
+                    match = fnmatch.fnmatch(
+                        name, self.args.glob
+                    ) or fnmatch.fnmatch(pattern, self.args.glob)
                     if not match:
                         continue
 
@@ -395,12 +387,14 @@ class PRoutesCommand(object):
                 if len(method) > max_method:
                     max_method = len(method)
 
-                mapped_routes.append({
-                    'name': name,
-                    'pattern': pattern,
-                    'view': view,
-                    'method': method
-                })
+                mapped_routes.append(
+                    {
+                        'name': name,
+                        'pattern': pattern,
+                        'view': view,
+                        'method': method,
+                    }
+                )
 
         fmt = _get_print_format(
             self.column_format, max_name, max_pattern, max_view, max_method
diff --git a/src/pyramid/scripts/pserve.py b/src/pyramid/scripts/pserve.py
index 8ee6e1467..581479d65 100644
--- a/src/pyramid/scripts/pserve.py
+++ b/src/pyramid/scripts/pserve.py
@@ -46,67 +46,86 @@ class PServeCommand(object):
     parser = argparse.ArgumentParser(
         description=textwrap.dedent(description),
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        )
+    )
     parser.add_argument(
-        '-n', '--app-name',
+        '-n',
+        '--app-name',
         dest='app_name',
         metavar='NAME',
-        help="Load the named application (default main)")
+        help="Load the named application (default main)",
+    )
     parser.add_argument(
-        '-s', '--server',
+        '-s',
+        '--server',
         dest='server',
         metavar='SERVER_TYPE',
-        help="Use the named server.")
+        help="Use the named server.",
+    )
     parser.add_argument(
         '--server-name',
         dest='server_name',
         metavar='SECTION_NAME',
-        help=("Use the named server as defined in the configuration file "
-              "(default: main)"))
+        help=(
+            "Use the named server as defined in the configuration file "
+            "(default: main)"
+        ),
+    )
     parser.add_argument(
         '--reload',
         dest='reload',
         action='store_true',
-        help="Use auto-restart file monitor")
+        help="Use auto-restart file monitor",
+    )
     parser.add_argument(
         '--reload-interval',
         dest='reload_interval',
         default=1,
-        help=("Seconds between checking files (low number can cause "
-              "significant CPU usage)"))
+        help=(
+            "Seconds between checking files (low number can cause "
+            "significant CPU usage)"
+        ),
+    )
     parser.add_argument(
-        '-b', '--browser',
+        '-b',
+        '--browser',
         dest='browser',
         action='store_true',
-        help=("Open a web browser to the server url. The server url is "
-              "determined from the 'open_url' setting in the 'pserve' "
-              "section of the configuration file."))
+        help=(
+            "Open a web browser to the server url. The server url is "
+            "determined from the 'open_url' setting in the 'pserve' "
+            "section of the configuration file."
+        ),
+    )
     parser.add_argument(
-        '-v', '--verbose',
+        '-v',
+        '--verbose',
         default=default_verbosity,
         dest='verbose',
         action='count',
-        help="Set verbose level (default " + str(default_verbosity) + ")")
+        help="Set verbose level (default " + str(default_verbosity) + ")",
+    )
     parser.add_argument(
-        '-q', '--quiet',
+        '-q',
+        '--quiet',
         action='store_const',
         const=0,
         dest='verbose',
-        help="Suppress verbose output")
+        help="Suppress verbose output",
+    )
     parser.add_argument(
         'config_uri',
         nargs='?',
         default=None,
         help='The URI to the configuration file.',
-        )
+    )
     parser.add_argument(
         'config_vars',
         nargs='*',
         default=(),
         help="Variables required by the config file. For example, "
-             "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
-             "passed here.",
-        )
+        "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
+        "passed here.",
+    )
 
     _get_config_loader = staticmethod(get_config_loader)  # for testing
 
@@ -187,18 +206,23 @@ class PServeCommand(object):
 
             if not url:
                 url = self.guess_server_url(
-                    server_loader, server_name, config_vars)
+                    server_loader, server_name, config_vars
+                )
 
             if not url:
-                self.out('WARNING: could not determine the server\'s url to '
-                         'open the browser. To fix this set the "open_url" '
-                         'setting in the [pserve] section of the '
-                         'configuration file.')
+                self.out(
+                    'WARNING: could not determine the server\'s url to '
+                    'open the browser. To fix this set the "open_url" '
+                    'setting in the [pserve] section of the '
+                    'configuration file.'
+                )
 
             else:
+
                 def open_browser():
                     time.sleep(1)
                     webbrowser.open(url)
+
                 t = threading.Thread(target=open_browser)
                 t.setDaemon(True)
                 t.start()
@@ -210,7 +234,7 @@ class PServeCommand(object):
                 'pyramid.scripts.pserve.main',
                 reload_interval=int(self.args.reload_interval),
                 verbose=self.args.verbose,
-                worker_kwargs=self.worker_kwargs
+                worker_kwargs=self.worker_kwargs,
             )
             return 0
 
@@ -250,6 +274,7 @@ class PServeCommand(object):
 # For paste.deploy server instantiation (egg:pyramid#wsgiref)
 def wsgiref_server_runner(wsgi_app, global_conf, **kw):  # pragma: no cover
     from wsgiref.simple_server import make_server
+
     host = kw.get('host', '0.0.0.0')
     port = int(kw.get('port', 8080))
     server = make_server(host, port, wsgi_app)
@@ -259,11 +284,18 @@ def wsgiref_server_runner(wsgi_app, global_conf, **kw):  # pragma: no cover
 
 # For paste.deploy server instantiation (egg:pyramid#cherrypy)
 def cherrypy_server_runner(
-        app, global_conf=None, host='127.0.0.1', port=None,
-        ssl_pem=None, protocol_version=None, numthreads=None,
-        server_name=None, max=None, request_queue_size=None,
-        timeout=None
-        ):  # pragma: no cover
+    app,
+    global_conf=None,
+    host='127.0.0.1',
+    port=None,
+    ssl_pem=None,
+    protocol_version=None,
+    numthreads=None,
+    server_name=None,
+    max=None,
+    request_queue_size=None,
+    timeout=None,
+):  # pragma: no cover
     """
     Entry point for CherryPy's WSGI server
 
@@ -346,8 +378,7 @@ def cherrypy_server_runner(
     except ImportError:
         from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer
 
-    server = WSGIServer(bind_addr, app,
-                        server_name=server_name, **kwargs)
+    server = WSGIServer(bind_addr, app, server_name=server_name, **kwargs)
     if ssl_pem is not None:
         if PY2:
             server.ssl_certificate = server.ssl_private_key = ssl_pem
@@ -368,8 +399,10 @@ def cherrypy_server_runner(
     try:
         protocol = is_ssl and 'https' or 'http'
         if host == '0.0.0.0':
-            print('serving on 0.0.0.0:%s view at %s://127.0.0.1:%s' %
-                  (port, protocol, port))
+            print(
+                'serving on 0.0.0.0:%s view at %s://127.0.0.1:%s'
+                % (port, protocol, port)
+            )
         else:
             print('serving on %s://%s:%s' % (protocol, host, port))
         server.start()
diff --git a/src/pyramid/scripts/pshell.py b/src/pyramid/scripts/pshell.py
index 4898eb39f..e63114d18 100644
--- a/src/pyramid/scripts/pshell.py
+++ b/src/pyramid/scripts/pshell.py
@@ -16,6 +16,7 @@ from pyramid.settings import aslist
 from pyramid.scripts.common import get_config_loader
 from pyramid.scripts.common import parse_vars
 
+
 def main(argv=sys.argv, quiet=False):
     command = PShellCommand(argv, quiet)
     return command.run()
@@ -49,38 +50,52 @@ class PShellCommand(object):
     parser = argparse.ArgumentParser(
         description=textwrap.dedent(description),
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        )
-    parser.add_argument('-p', '--python-shell',
-                        action='store',
-                        dest='python_shell',
-                        default='',
-                        help=('Select the shell to use. A list of possible '
-                              'shells is available using the --list-shells '
-                              'option.'))
-    parser.add_argument('-l', '--list-shells',
-                        dest='list',
-                        action='store_true',
-                        help='List all available shells.')
-    parser.add_argument('--setup',
-                        dest='setup',
-                        help=("A callable that will be passed the environment "
-                              "before it is made available to the shell. This "
-                              "option will override the 'setup' key in the "
-                              "[pshell] ini section."))
-    parser.add_argument('config_uri',
-                        nargs='?',
-                        default=None,
-                        help='The URI to the configuration file.')
+    )
+    parser.add_argument(
+        '-p',
+        '--python-shell',
+        action='store',
+        dest='python_shell',
+        default='',
+        help=(
+            'Select the shell to use. A list of possible '
+            'shells is available using the --list-shells '
+            'option.'
+        ),
+    )
+    parser.add_argument(
+        '-l',
+        '--list-shells',
+        dest='list',
+        action='store_true',
+        help='List all available shells.',
+    )
+    parser.add_argument(
+        '--setup',
+        dest='setup',
+        help=(
+            "A callable that will be passed the environment "
+            "before it is made available to the shell. This "
+            "option will override the 'setup' key in the "
+            "[pshell] ini section."
+        ),
+    )
+    parser.add_argument(
+        'config_uri',
+        nargs='?',
+        default=None,
+        help='The URI to the configuration file.',
+    )
     parser.add_argument(
         'config_vars',
         nargs='*',
         default=(),
         help="Variables required by the config file. For example, "
-             "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
-             "passed here.",
-        )
+        "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
+        "passed here.",
+    )
 
-    default_runner = python_shell_runner # testing
+    default_runner = python_shell_runner  # testing
 
     loaded_objects = {}
     object_help = {}
@@ -107,7 +122,7 @@ class PShellCommand(object):
                 self.loaded_objects[k] = self.resolver.maybe_resolve(v)
                 self.object_help[k] = v
 
-    def out(self, msg): # pragma: no cover
+    def out(self, msg):  # pragma: no cover
         if not self.quiet:
             print(msg)
 
@@ -152,8 +167,9 @@ class PShellCommand(object):
         env_help['root'] = 'Root of the default resource tree.'
         env_help['registry'] = 'Active Pyramid registry.'
         env_help['request'] = 'Active request object.'
-        env_help['root_factory'] = (
-            'Default root factory used to create `root`.')
+        env_help[
+            'root_factory'
+        ] = 'Default root factory used to create `root`.'
 
         # load the pshell section of the ini file
         env.update(self.loaded_objects)
@@ -236,6 +252,7 @@ class PShellCommand(object):
                 # by default prioritize all shells above python
                 preferred_shells = [k for k in shells.keys() if k != 'python']
             max_weight = len(preferred_shells)
+
             def order(x):
                 # invert weight to reverse sort the list
                 # (closer to the front is higher priority)
@@ -243,6 +260,7 @@ class PShellCommand(object):
                     return preferred_shells.index(x[0].lower()) - max_weight
                 except ValueError:
                     return 1
+
             sorted_shells = sorted(shells.items(), key=order)
 
             if len(sorted_shells) > 0:
@@ -266,5 +284,5 @@ class PShellCommand(object):
         return shell
 
 
-if __name__ == '__main__': # pragma: no cover
+if __name__ == '__main__':  # pragma: no cover
     sys.exit(main() or 0)
diff --git a/src/pyramid/scripts/ptweens.py b/src/pyramid/scripts/ptweens.py
index d5cbebe12..e6a5c5ac7 100644
--- a/src/pyramid/scripts/ptweens.py
+++ b/src/pyramid/scripts/ptweens.py
@@ -10,10 +10,12 @@ from pyramid.paster import bootstrap
 from pyramid.paster import setup_logging
 from pyramid.scripts.common import parse_vars
 
+
 def main(argv=sys.argv, quiet=False):
     command = PTweensCommand(argv, quiet)
     return command.run()
 
+
 class PTweensCommand(object):
     description = """\
     Print all implicit and explicit tween objects used by a Pyramid
@@ -31,25 +33,27 @@ class PTweensCommand(object):
     parser = argparse.ArgumentParser(
         description=textwrap.dedent(description),
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        )
+    )
 
-    parser.add_argument('config_uri',
-                        nargs='?',
-                        default=None,
-                        help='The URI to the configuration file.')
+    parser.add_argument(
+        'config_uri',
+        nargs='?',
+        default=None,
+        help='The URI to the configuration file.',
+    )
 
     parser.add_argument(
         'config_vars',
         nargs='*',
         default=(),
         help="Variables required by the config file. For example, "
-             "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
-             "passed here.",
-        )
+        "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
+        "passed here.",
+    )
 
     stdout = sys.stdout
-    bootstrap = staticmethod(bootstrap) # testing
-    setup_logging = staticmethod(setup_logging) # testing
+    bootstrap = staticmethod(bootstrap)  # testing
+    setup_logging = staticmethod(setup_logging)  # testing
 
     def __init__(self, argv, quiet=False):
         self.quiet = quiet
@@ -57,10 +61,11 @@ class PTweensCommand(object):
 
     def _get_tweens(self, registry):
         from pyramid.config import Configurator
+
         config = Configurator(registry=registry)
         return config.registry.queryUtility(ITweens)
 
-    def out(self, msg): # pragma: no cover
+    def out(self, msg):  # pragma: no cover
         if not self.quiet:
             print(msg)
 
@@ -86,8 +91,10 @@ class PTweensCommand(object):
         if tweens is not None:
             explicit = tweens.explicit
             if explicit:
-                self.out('"pyramid.tweens" config value set '
-                         '(explicitly ordered tweens used)')
+                self.out(
+                    '"pyramid.tweens" config value set '
+                    '(explicitly ordered tweens used)'
+                )
                 self.out('')
                 self.out('Explicit Tween Chain (used)')
                 self.out('')
@@ -97,13 +104,16 @@ class PTweensCommand(object):
                 self.out('')
                 self.show_chain(tweens.implicit())
             else:
-                self.out('"pyramid.tweens" config value NOT set '
-                         '(implicitly ordered tweens used)')
+                self.out(
+                    '"pyramid.tweens" config value NOT set '
+                    '(implicitly ordered tweens used)'
+                )
                 self.out('')
                 self.out('Implicit Tween Chain')
                 self.out('')
                 self.show_chain(tweens.implicit())
         return 0
 
-if __name__ == '__main__': # pragma: no cover
+
+if __name__ == '__main__':  # pragma: no cover
     sys.exit(main() or 0)
diff --git a/src/pyramid/scripts/pviews.py b/src/pyramid/scripts/pviews.py
index c0df2f078..891dc4709 100644
--- a/src/pyramid/scripts/pviews.py
+++ b/src/pyramid/scripts/pviews.py
@@ -9,10 +9,12 @@ from pyramid.request import Request
 from pyramid.scripts.common import parse_vars
 from pyramid.view import _find_views
 
+
 def main(argv=sys.argv, quiet=False):
     command = PViewsCommand(argv, quiet)
     return command.run()
 
+
 class PViewsCommand(object):
     description = """\
     Print, for a given URL, the views that might match. Underneath each
@@ -31,38 +33,41 @@ class PViewsCommand(object):
     parser = argparse.ArgumentParser(
         description=textwrap.dedent(description),
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        )
+    )
 
-    parser.add_argument('config_uri',
-                        nargs='?',
-                        default=None,
-                        help='The URI to the configuration file.')
+    parser.add_argument(
+        'config_uri',
+        nargs='?',
+        default=None,
+        help='The URI to the configuration file.',
+    )
 
-    parser.add_argument('url',
-                        nargs='?',
-                        default=None,
-                        help='The path info portion of the URL.')
+    parser.add_argument(
+        'url',
+        nargs='?',
+        default=None,
+        help='The path info portion of the URL.',
+    )
     parser.add_argument(
         'config_vars',
         nargs='*',
         default=(),
         help="Variables required by the config file. For example, "
-             "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
-             "passed here.",
-        )
+        "`http_port=%%(http_port)s` would expect `http_port=8080` to be "
+        "passed here.",
+    )
 
-
-    bootstrap = staticmethod(bootstrap) # testing
-    setup_logging = staticmethod(setup_logging) # testing
+    bootstrap = staticmethod(bootstrap)  # testing
+    setup_logging = staticmethod(setup_logging)  # testing
 
     def __init__(self, argv, quiet=False):
         self.quiet = quiet
         self.args = self.parser.parse_args(argv[1:])
 
-    def out(self, msg): # pragma: no cover
+    def out(self, msg):  # pragma: no cover
         if not self.quiet:
             print(msg)
-    
+
     def _find_multi_routes(self, mapper, request):
         infos = []
         path = request.environ['PATH_INFO']
@@ -70,7 +75,7 @@ class PViewsCommand(object):
         for route in mapper.get_routes():
             match = route.match(path)
             if match is not None:
-                info = {'match':match, 'route':route}
+                info = {'match': match, 'route': route}
                 infos.append(info)
         return infos
 
@@ -99,22 +104,17 @@ class PViewsCommand(object):
 
         @implementer(IMultiView)
         class RoutesMultiView(object):
-
             def __init__(self, infos, context_iface, root_factory, request):
                 self.views = []
                 for info in infos:
                     match, route = info['match'], info['route']
                     if route is not None:
                         request_iface = registry.queryUtility(
-                            IRouteRequest,
-                            name=route.name,
-                            default=IRequest)
+                            IRouteRequest, name=route.name, default=IRequest
+                        )
                         views = _find_views(
-                            request.registry,
-                            request_iface,
-                            context_iface,
-                            ''
-                            )
+                            request.registry, request_iface, context_iface, ''
+                        )
                         if not views:
                             continue
                         view = views[0]
@@ -148,9 +148,8 @@ class PViewsCommand(object):
                     attrs['matched_route'] = route
                     request.environ['bfg.routes.matchdict'] = match
                     request_iface = registry.queryUtility(
-                        IRouteRequest,
-                        name=route.name,
-                        default=IRequest)
+                        IRouteRequest, name=route.name, default=IRequest
+                    )
                     root_factory = route.factory or root_factory
             if len(infos) > 1:
                 routes_multiview = infos
@@ -171,11 +170,8 @@ class PViewsCommand(object):
         context_iface = providedBy(context)
         if routes_multiview is None:
             views = _find_views(
-                request.registry,
-                request_iface,
-                context_iface,
-                view_name,
-                )
+                request.registry, request_iface, context_iface, view_name
+            )
             if views:
                 view = views[0]
             else:
@@ -186,11 +182,8 @@ class PViewsCommand(object):
         # routes are not registered with a view name
         if view is None:
             views = _find_views(
-                request.registry,
-                request_iface,
-                context_iface,
-                '',
-                )
+                request.registry, request_iface, context_iface, ''
+            )
             if views:
                 view = views[0]
             else:
@@ -285,5 +278,6 @@ class PViewsCommand(object):
         env['closer']()
         return 0
 
-if __name__ == '__main__': # pragma: no cover
+
+if __name__ == '__main__':  # pragma: no cover
     sys.exit(main() or 0)
diff --git a/src/pyramid/security.py b/src/pyramid/security.py
index 0bdca090b..9e256f73c 100644
--- a/src/pyramid/security.py
+++ b/src/pyramid/security.py
@@ -7,7 +7,7 @@ from pyramid.interfaces import (
     ISecuredView,
     IView,
     IViewClassifier,
-    )
+)
 
 from pyramid.compat import map_
 from pyramid.threadlocal import get_current_registry
@@ -17,6 +17,7 @@ Authenticated = 'system.Authenticated'
 Allow = 'Allow'
 Deny = 'Deny'
 
+
 class AllPermissionsList(object):
     """ Stand in 'permission list' to represent all permissions """
 
@@ -29,22 +30,26 @@ class AllPermissionsList(object):
     def __eq__(self, other):
         return isinstance(other, self.__class__)
 
+
 ALL_PERMISSIONS = AllPermissionsList()
 DENY_ALL = (Deny, Everyone, ALL_PERMISSIONS)
 
 NO_PERMISSION_REQUIRED = '__no_permission_required__'
 
+
 def _get_registry(request):
     try:
         reg = request.registry
     except AttributeError:
-        reg = get_current_registry() # b/c
+        reg = get_current_registry()  # b/c
     return reg
 
+
 def _get_authentication_policy(request):
     registry = _get_registry(request)
     return registry.queryUtility(IAuthenticationPolicy)
 
+
 def has_permission(permission, context, request):
     """
     A function that calls :meth:`pyramid.request.Request.has_permission`
@@ -56,15 +61,16 @@ def has_permission(permission, context, request):
     .. versionchanged:: 1.5a3
         If context is None, then attempt to use the context attribute of self;
         if not set, then the AttributeError is propagated.
-    """    
+    """
     return request.has_permission(permission, context)
 
+
 deprecated(
     'has_permission',
     'As of Pyramid 1.5 the "pyramid.security.has_permission" API is now '
     'deprecated.  It will be removed in Pyramid 1.8.  Use the '
-    '"has_permission" method of the Pyramid request instead.'
-    )
+    '"has_permission" method of the Pyramid request instead.',
+)
 
 
 def authenticated_userid(request):
@@ -74,15 +80,17 @@ def authenticated_userid(request):
     
     .. deprecated:: 1.5
        Use :attr:`pyramid.request.Request.authenticated_userid` instead.
-    """        
+    """
     return request.authenticated_userid
 
+
 deprecated(
     'authenticated_userid',
     'As of Pyramid 1.5 the "pyramid.security.authenticated_userid" API is now '
     'deprecated.  It will be removed in Pyramid 1.8.  Use the '
-    '"authenticated_userid" attribute of the Pyramid request instead.'
-    )
+    '"authenticated_userid" attribute of the Pyramid request instead.',
+)
+
 
 def unauthenticated_userid(request):
     """ 
@@ -91,15 +99,17 @@ def unauthenticated_userid(request):
     
     .. deprecated:: 1.5
         Use :attr:`pyramid.request.Request.unauthenticated_userid` instead.
-    """        
+    """
     return request.unauthenticated_userid
 
+
 deprecated(
     'unauthenticated_userid',
     'As of Pyramid 1.5 the "pyramid.security.unauthenticated_userid" API is '
     'now deprecated.  It will be removed in Pyramid 1.8.  Use the '
-    '"unauthenticated_userid" attribute of the Pyramid request instead.'
-    )
+    '"unauthenticated_userid" attribute of the Pyramid request instead.',
+)
+
 
 def effective_principals(request):
     """
@@ -108,15 +118,17 @@ def effective_principals(request):
     
     .. deprecated:: 1.5
         Use :attr:`pyramid.request.Request.effective_principals` instead.
-    """            
+    """
     return request.effective_principals
 
+
 deprecated(
     'effective_principals',
     'As of Pyramid 1.5 the "pyramid.security.effective_principals" API is '
     'now deprecated.  It will be removed in Pyramid 1.8.  Use the '
-    '"effective_principals" attribute of the Pyramid request instead.'
-    )
+    '"effective_principals" attribute of the Pyramid request instead.',
+)
+
 
 def remember(request, userid, **kw):
     """
@@ -154,6 +166,7 @@ def remember(request, userid, **kw):
         return []
     return policy.remember(request, userid, **kw)
 
+
 def forget(request):
     """
     Return a sequence of header tuples (e.g. ``[('Set-Cookie',
@@ -172,12 +185,13 @@ def forget(request):
 
     If no :term:`authentication policy` is in use, this function will
     always return an empty sequence.
-    """            
+    """
     policy = _get_authentication_policy(request)
     if policy is None:
         return []
     return policy.forget(request)
 
+
 def principals_allowed_by_permission(context, permission):
     """ Provided a ``context`` (a resource object), and a ``permission``
     (a string or unicode object), if an :term:`authorization policy` is
@@ -201,6 +215,7 @@ def principals_allowed_by_permission(context, permission):
         return [Everyone]
     return policy.principals_allowed_by_permission(context, permission)
 
+
 def view_execution_permitted(context, request, name=''):
     """ If the view specified by ``context`` and ``name`` is protected
     by a :term:`permission`, check the permission associated with the
@@ -222,12 +237,15 @@ def view_execution_permitted(context, request, name=''):
     if view is None:
         view = reg.adapters.lookup(provides, IView, name=name)
         if view is None:
-            raise TypeError('No registered view satisfies the constraints. '
-                            'It would not make sense to claim that this view '
-                            '"is" or "is not" permitted.')
+            raise TypeError(
+                'No registered view satisfies the constraints. '
+                'It would not make sense to claim that this view '
+                '"is" or "is not" permitted.'
+            )
         return Allowed(
-            'Allowed: view name %r in context %r (no permission defined)' %
-            (name, context))
+            'Allowed: view name %r in context %r (no permission defined)'
+            % (name, context)
+        )
     return view.__permitted__(context, request)
 
 
@@ -255,9 +273,12 @@ class PermitsResult(int):
         return self.msg
 
     def __repr__(self):
-        return '<%s instance at %s with msg %r>' % (self.__class__.__name__,
-                                                    id(self),
-                                                    self.msg)
+        return '<%s instance at %s with msg %r>' % (
+            self.__class__.__name__,
+            id(self),
+            self.msg,
+        )
+
 
 class Denied(PermitsResult):
     """
@@ -268,8 +289,10 @@ class Denied(PermitsResult):
     the deny.
 
     """
+
     boolval = 0
 
+
 class Allowed(PermitsResult):
     """
     An instance of ``Allowed`` is returned when a security-related
@@ -279,8 +302,10 @@ class Allowed(PermitsResult):
     the allow.
 
     """
+
     boolval = 1
 
+
 class ACLPermitsResult(PermitsResult):
     def __new__(cls, ace, acl, permission, principals, context):
         """
@@ -294,17 +319,12 @@ class ACLPermitsResult(PermitsResult):
                         searched.
 
         """
-        fmt = ('%s permission %r via ACE %r in ACL %r on context %r for '
-               'principals %r')
+        fmt = (
+            '%s permission %r via ACE %r in ACL %r on context %r for '
+            'principals %r'
+        )
         inst = PermitsResult.__new__(
-            cls,
-            fmt,
-            cls.__name__,
-            permission,
-            ace,
-            acl,
-            context,
-            principals,
+            cls, fmt, cls.__name__, permission, ace, acl, context, principals
         )
         inst.permission = permission
         inst.ace = ace
@@ -313,6 +333,7 @@ class ACLPermitsResult(PermitsResult):
         inst.context = context
         return inst
 
+
 class ACLDenied(ACLPermitsResult, Denied):
     """
     An instance of ``ACLDenied`` is a specialization of
@@ -326,6 +347,7 @@ class ACLDenied(ACLPermitsResult, Denied):
 
     """
 
+
 class ACLAllowed(ACLPermitsResult, Allowed):
     """
     An instance of ``ACLAllowed`` is a specialization of
@@ -339,8 +361,8 @@ class ACLAllowed(ACLPermitsResult, Allowed):
 
     """
 
-class AuthenticationAPIMixin(object):
 
+class AuthenticationAPIMixin(object):
     def _get_authentication_policy(self):
         reg = _get_registry(self)
         return reg.queryUtility(IAuthenticationPolicy)
@@ -389,8 +411,8 @@ class AuthenticationAPIMixin(object):
             return [Everyone]
         return policy.effective_principals(self)
 
-class AuthorizationAPIMixin(object):
 
+class AuthorizationAPIMixin(object):
     def has_permission(self, permission, context=None):
         """ Given a permission and an optional context, returns an instance of
         :data:`pyramid.security.Allowed` if the permission is granted to this
@@ -421,7 +443,9 @@ class AuthorizationAPIMixin(object):
             return Allowed('No authentication policy in use.')
         authz_policy = reg.queryUtility(IAuthorizationPolicy)
         if authz_policy is None:
-            raise ValueError('Authentication policy registered without '
-                             'authorization policy') # should never happen
+            raise ValueError(
+                'Authentication policy registered without '
+                'authorization policy'
+            )  # should never happen
         principals = authn_policy.effective_principals(self)
         return authz_policy.permits(context, principals, permission)
diff --git a/src/pyramid/session.py b/src/pyramid/session.py
index b953fa184..9d4ef6dbb 100644
--- a/src/pyramid/session.py
+++ b/src/pyramid/session.py
@@ -9,22 +9,10 @@ import warnings
 from zope.deprecation import deprecated
 from zope.interface import implementer
 
-from webob.cookies import (
-    JSONSerializer,
-    SignedSerializer,
-)
+from webob.cookies import JSONSerializer, SignedSerializer
 
-from pyramid.compat import (
-    pickle,
-    PY2,
-    text_,
-    bytes_,
-    native_,
-    )
-from pyramid.csrf import (
-    check_csrf_origin,
-    check_csrf_token,
-)
+from pyramid.compat import pickle, PY2, text_, bytes_, native_
+from pyramid.csrf import check_csrf_origin, check_csrf_token
 
 from pyramid.interfaces import ISession
 from pyramid.util import strings_differ
@@ -33,25 +21,31 @@ from pyramid.util import strings_differ
 def manage_accessed(wrapped):
     """ Decorator which causes a cookie to be renewed when an accessor
     method is called."""
+
     def accessed(session, *arg, **kw):
         session.accessed = now = int(time.time())
         if session._reissue_time is not None:
             if now - session.renewed > session._reissue_time:
                 session.changed()
         return wrapped(session, *arg, **kw)
+
     accessed.__doc__ = wrapped.__doc__
     return accessed
 
+
 def manage_changed(wrapped):
     """ Decorator which causes a cookie to be set when a setter method
     is called."""
+
     def changed(session, *arg, **kw):
         session.accessed = int(time.time())
         session.changed()
         return wrapped(session, *arg, **kw)
+
     changed.__doc__ = wrapped.__doc__
     return changed
 
+
 def signed_serialize(data, secret):
     """ Serialize any pickleable structure (``data``) and sign it
     using the ``secret`` (must be a string).  Return the
@@ -82,6 +76,7 @@ def signed_serialize(data, secret):
     sig = hmac.new(secret, pickled, hashlib.sha1).hexdigest()
     return sig + native_(base64.b64encode(pickled))
 
+
 deprecated(
     'signed_serialize',
     'This function will be removed in Pyramid 2.0. It is using pickle-based '
@@ -89,6 +84,7 @@ deprecated(
     'attacks.',
 )
 
+
 def signed_deserialize(serialized, secret, hmac=hmac):
     """ Deserialize the value returned from ``signed_serialize``.  If
     the value cannot be deserialized for any reason, a
@@ -111,8 +107,10 @@ def signed_deserialize(serialized, secret, hmac=hmac):
     """
     # hmac parameterized only for unit tests
     try:
-        input_sig, pickled = (bytes_(serialized[:40]),
-                              base64.b64decode(bytes_(serialized[40:])))
+        input_sig, pickled = (
+            bytes_(serialized[:40]),
+            base64.b64decode(bytes_(serialized[40:])),
+        )
     except (binascii.Error, TypeError) as e:
         # Badly formed data can make base64 die
         raise ValueError('Badly formed base64 data: %s' % e)
@@ -131,6 +129,7 @@ def signed_deserialize(serialized, secret, hmac=hmac):
 
     return pickle.loads(pickled)
 
+
 deprecated(
     'signed_deserialize',
     'This function will be removed in Pyramid 2.0. It is using pickle-based '
@@ -149,6 +148,7 @@ class PickleSerializer(object):
     Defaults to :attr:`pickle.HIGHEST_PROTOCOL`.
 
     """
+
     def __init__(self, protocol=pickle.HIGHEST_PROTOCOL):
         self.protocol = protocol
 
@@ -180,7 +180,7 @@ def BaseCookieSessionFactory(
     timeout=1200,
     reissue_time=0,
     set_on_exception=True,
-    ):
+):
     """
     Configure a :term:`session factory` which will provide cookie-based
     sessions.  The return value of this function is a :term:`session factory`,
@@ -280,7 +280,9 @@ def BaseCookieSessionFactory(
         _cookie_samesite = samesite
         _cookie_on_exception = set_on_exception
         _timeout = timeout if timeout is None else int(timeout)
-        _reissue_time = reissue_time if reissue_time is None else int(reissue_time)
+        _reissue_time = (
+            reissue_time if reissue_time is None else int(reissue_time)
+        )
 
         # dirty flag
         _dirty = False
@@ -330,13 +332,15 @@ def BaseCookieSessionFactory(
         def changed(self):
             if not self._dirty:
                 self._dirty = True
+
                 def set_cookie_callback(request, response):
                     self._set_cookie(response)
-                    self.request = None # explicitly break cycle for gc
+                    self.request = None  # explicitly break cycle for gc
+
                 self.request.add_response_callback(set_cookie_callback)
 
         def invalidate(self):
-            self.clear() # XXX probably needs to unset cookie
+            self.clear()  # XXX probably needs to unset cookie
 
         # non-modifying dictionary methods
         get = manage_accessed(dict.get)
@@ -398,16 +402,18 @@ def BaseCookieSessionFactory(
         def _set_cookie(self, response):
             if not self._cookie_on_exception:
                 exception = getattr(self.request, 'exception', None)
-                if exception is not None: # dont set a cookie during exceptions
+                if (
+                    exception is not None
+                ):  # dont set a cookie during exceptions
                     return False
-            cookieval = native_(serializer.dumps(
-                (self.accessed, self.created, dict(self))
-                ))
+            cookieval = native_(
+                serializer.dumps((self.accessed, self.created, dict(self)))
+            )
             if len(cookieval) > 4064:
                 raise ValueError(
-                    'Cookie value is too long to store (%s bytes)' %
-                    len(cookieval)
-                    )
+                    'Cookie value is too long to store (%s bytes)'
+                    % len(cookieval)
+                )
             response.set_cookie(
                 self._cookie_name,
                 value=cookieval,
@@ -417,7 +423,7 @@ def BaseCookieSessionFactory(
                 secure=self._cookie_secure,
                 httponly=self._cookie_httponly,
                 samesite=self._cookie_samesite,
-                )
+            )
             return True
 
     return CookieSession
@@ -436,7 +442,7 @@ def UnencryptedCookieSessionFactoryConfig(
     cookie_on_exception=True,
     signed_serialize=signed_serialize,
     signed_deserialize=signed_deserialize,
-    ):
+):
     """
     .. deprecated:: 1.5
         Use :func:`pyramid.session.SignedCookieSessionFactory` instead.
@@ -530,18 +536,19 @@ def UnencryptedCookieSessionFactoryConfig(
         httponly=cookie_httponly,
         samesite=cookie_samesite,
         timeout=timeout,
-        reissue_time=0, # to keep session.accessed == session.renewed
+        reissue_time=0,  # to keep session.accessed == session.renewed
         set_on_exception=cookie_on_exception,
     )
 
+
 deprecated(
     'UnencryptedCookieSessionFactoryConfig',
     'The UnencryptedCookieSessionFactoryConfig callable is deprecated as of '
     'Pyramid 1.5.  Use ``pyramid.session.SignedCookieSessionFactory`` instead.'
     ' Caveat: Cookies generated using SignedCookieSessionFactory are not '
     'compatible with cookies generated using UnencryptedCookieSessionFactory, '
-    'so existing user session data will be destroyed if you switch to it.'
-    )
+    'so existing user session data will be destroyed if you switch to it.',
+)
 
 
 def SignedCookieSessionFactory(
@@ -559,7 +566,7 @@ def SignedCookieSessionFactory(
     hashalg='sha512',
     salt='pyramid.session.',
     serializer=None,
-    ):
+):
     """
     .. versionadded:: 1.5
 
@@ -681,11 +688,8 @@ def SignedCookieSessionFactory(
         )
 
     signed_serializer = SignedSerializer(
-        secret,
-        salt,
-        hashalg,
-        serializer=serializer,
-        )
+        secret, salt, hashalg, serializer=serializer
+    )
 
     return BaseCookieSessionFactory(
         signed_serializer,
@@ -701,12 +705,17 @@ def SignedCookieSessionFactory(
         set_on_exception=set_on_exception,
     )
 
+
 check_csrf_origin = check_csrf_origin  # api
-deprecated('check_csrf_origin',
-           'pyramid.session.check_csrf_origin is deprecated as of Pyramid '
-           '1.9. Use pyramid.csrf.check_csrf_origin instead.')
+deprecated(
+    'check_csrf_origin',
+    'pyramid.session.check_csrf_origin is deprecated as of Pyramid '
+    '1.9. Use pyramid.csrf.check_csrf_origin instead.',
+)
 
 check_csrf_token = check_csrf_token  # api
-deprecated('check_csrf_token',
-           'pyramid.session.check_csrf_token is deprecated as of Pyramid '
-           '1.9. Use pyramid.csrf.check_csrf_token instead.')
+deprecated(
+    'check_csrf_token',
+    'pyramid.session.check_csrf_token is deprecated as of Pyramid '
+    '1.9. Use pyramid.csrf.check_csrf_token instead.',
+)
diff --git a/src/pyramid/settings.py b/src/pyramid/settings.py
index 8a498d572..af9433840 100644
--- a/src/pyramid/settings.py
+++ b/src/pyramid/settings.py
@@ -3,6 +3,7 @@ from pyramid.compat import string_types
 truthy = frozenset(('t', 'true', 'y', 'yes', 'on', '1'))
 falsey = frozenset(('f', 'false', 'n', 'no', 'off', '0'))
 
+
 def asbool(s):
     """ Return the boolean value ``True`` if the case-lowered value of string
     input ``s`` is a :term:`truthy string`. If ``s`` is already one of the
@@ -14,11 +15,13 @@ def asbool(s):
     s = str(s).strip()
     return s.lower() in truthy
 
+
 def aslist_cronly(value):
     if isinstance(value, string_types):
         value = filter(None, [x.strip() for x in value.splitlines()])
     return list(value)
 
+
 def aslist(value, flatten=True):
     """ Return a list of strings, separating the input based on newlines
     and, if flatten=True (the default), also split on spaces within
diff --git a/src/pyramid/static.py b/src/pyramid/static.py
index 70fdf877b..58ad97a46 100644
--- a/src/pyramid/static.py
+++ b/src/pyramid/static.py
@@ -2,47 +2,25 @@
 import json
 import os
 
-from os.path import (
-    getmtime,
-    normcase,
-    normpath,
-    join,
-    isdir,
-    exists,
-    )
-
-from pkg_resources import (
-    resource_exists,
-    resource_filename,
-    resource_isdir,
-    )
-
-from pyramid.asset import (
-    abspath_from_asset_spec,
-    resolve_asset_spec,
-)
-
-from pyramid.compat import (
-    lru_cache,
-    text_,
-)
-
-from pyramid.httpexceptions import (
-    HTTPNotFound,
-    HTTPMovedPermanently,
-    )
+from os.path import getmtime, normcase, normpath, join, isdir, exists
+
+from pkg_resources import resource_exists, resource_filename, resource_isdir
+
+from pyramid.asset import abspath_from_asset_spec, resolve_asset_spec
+
+from pyramid.compat import lru_cache, text_
+
+from pyramid.httpexceptions import HTTPNotFound, HTTPMovedPermanently
 
 from pyramid.path import caller_package
 
-from pyramid.response import (
-    _guess_type,
-    FileResponse,
-)
+from pyramid.response import _guess_type, FileResponse
 
 from pyramid.traversal import traversal_path_info
 
 slash = text_('/')
 
+
 class static_view(object):
     """ An instance of this class is a callable which can act as a
     :app:`Pyramid` :term:`view callable`; this view will serve
@@ -88,8 +66,14 @@ class static_view(object):
        to override the assets it contains.
     """
 
-    def __init__(self, root_dir, cache_max_age=3600, package_name=None,
-                 use_subpath=False, index='index.html'):
+    def __init__(
+        self,
+        root_dir,
+        cache_max_age=3600,
+        package_name=None,
+        use_subpath=False,
+        index='index.html',
+    ):
         # package_name is for bw compat; it is preferred to pass in a
         # package-relative path as root_dir
         # (e.g. ``anotherpackage:foo/static``).
@@ -113,20 +97,21 @@ class static_view(object):
         if path is None:
             raise HTTPNotFound('Out of bounds: %s' % request.url)
 
-        if self.package_name: # package resource
+        if self.package_name:  # package resource
             resource_path = '%s/%s' % (self.docroot.rstrip('/'), path)
             if resource_isdir(self.package_name, resource_path):
                 if not request.path_url.endswith('/'):
                     self.add_slash_redirect(request)
                 resource_path = '%s/%s' % (
-                    resource_path.rstrip('/'), self.index
+                    resource_path.rstrip('/'),
+                    self.index,
                 )
 
             if not resource_exists(self.package_name, resource_path):
                 raise HTTPNotFound(request.url)
             filepath = resource_filename(self.package_name, resource_path)
 
-        else: # filesystem file
+        else:  # filesystem file
 
             # os.path.normpath converts / to \ on windows
             filepath = normcase(normpath(join(self.norm_docroot, path)))
@@ -139,8 +124,12 @@ class static_view(object):
 
         content_type, content_encoding = _guess_type(filepath)
         return FileResponse(
-            filepath, request, self.cache_max_age,
-            content_type, content_encoding=None)
+            filepath,
+            request,
+            self.cache_max_age,
+            content_type,
+            content_encoding=None,
+        )
 
     def add_slash_redirect(self, request):
         url = request.path_url + '/'
@@ -149,14 +138,19 @@ class static_view(object):
             url = url + '?' + qs
         raise HTTPMovedPermanently(url)
 
+
 _seps = set(['/', os.sep])
+
+
 def _contains_slash(item):
     for sep in _seps:
         if sep in item:
             return True
 
+
 _has_insecure_pathelement = set(['..', '.', '']).intersection
 
+
 @lru_cache(1000)
 def _secure_path(path_tuple):
     if _has_insecure_pathelement(path_tuple):
@@ -166,9 +160,10 @@ def _secure_path(path_tuple):
         return None
     if any([_contains_slash(item) for item in path_tuple]):
         return None
-    encoded = slash.join(path_tuple) # will be unicode
+    encoded = slash.join(path_tuple)  # will be unicode
     return encoded
 
+
 class QueryStringCacheBuster(object):
     """
     An implementation of :class:`~pyramid.interfaces.ICacheBuster` which adds
@@ -182,6 +177,7 @@ class QueryStringCacheBuster(object):
 
     .. versionadded:: 1.6
     """
+
     def __init__(self, param='x'):
         self.param = param
 
@@ -194,6 +190,7 @@ class QueryStringCacheBuster(object):
             kw['_query'] = tuple(query) + ((self.param, token),)
         return subpath, kw
 
+
 class QueryStringConstantCacheBuster(QueryStringCacheBuster):
     """
     An implementation of :class:`~pyramid.interfaces.ICacheBuster` which adds
@@ -207,6 +204,7 @@ class QueryStringConstantCacheBuster(QueryStringCacheBuster):
 
     .. versionadded:: 1.6
     """
+
     def __init__(self, token, param='x'):
         super(QueryStringConstantCacheBuster, self).__init__(param=param)
         self._token = token
@@ -214,6 +212,7 @@ class QueryStringConstantCacheBuster(QueryStringCacheBuster):
     def tokenize(self, request, subpath, kw):
         return self._token
 
+
 class ManifestCacheBuster(object):
     """
     An implementation of :class:`~pyramid.interfaces.ICacheBuster` which
@@ -255,13 +254,15 @@ class ManifestCacheBuster(object):
 
     .. versionadded:: 1.6
     """
-    exists = staticmethod(exists) # testing
-    getmtime = staticmethod(getmtime) # testing
+
+    exists = staticmethod(exists)  # testing
+    getmtime = staticmethod(getmtime)  # testing
 
     def __init__(self, manifest_spec, reload=False):
         package_name = caller_package().__name__
         self.manifest_path = abspath_from_asset_spec(
-            manifest_spec, package_name)
+            manifest_spec, package_name
+        )
         self.reload = reload
 
         self._mtime = None
diff --git a/src/pyramid/testing.py b/src/pyramid/testing.py
index 4986c0e27..e2549f0b9 100644
--- a/src/pyramid/testing.py
+++ b/src/pyramid/testing.py
@@ -2,22 +2,11 @@ import copy
 import os
 from contextlib import contextmanager
 
-from zope.interface import (
-    implementer,
-    alsoProvides,
-    )
+from zope.interface import implementer, alsoProvides
 
-from pyramid.interfaces import (
-    IRequest,
-    ISession,
-    )
+from pyramid.interfaces import IRequest, ISession
 
-from pyramid.compat import (
-    PY3,
-    PYPY,
-    class_types,
-    text_,
-    )
+from pyramid.compat import PY3, PYPY, class_types, text_
 
 from pyramid.config import Configurator
 from pyramid.decorator import reify
@@ -30,12 +19,9 @@ from pyramid.security import (
     Everyone,
     AuthenticationAPIMixin,
     AuthorizationAPIMixin,
-    )
+)
 
-from pyramid.threadlocal import (
-    get_current_registry,
-    manager,
-    )
+from pyramid.threadlocal import get_current_registry, manager
 
 from pyramid.i18n import LocalizerRequestMixin
 from pyramid.request import CallbackMethodsMixin
@@ -46,17 +32,27 @@ from pyramid.view import ViewMethodsMixin
 
 _marker = object()
 
+
 class DummyRootFactory(object):
     __parent__ = None
     __name__ = None
+
     def __init__(self, request):
         if 'bfg.routes.matchdict' in request:
             self.__dict__.update(request['bfg.routes.matchdict'])
 
+
 class DummySecurityPolicy(object):
     """ A standin for both an IAuthentication and IAuthorization policy """
-    def __init__(self, userid=None, groupids=(), permissive=True,
-                 remember_result=None, forget_result=None):
+
+    def __init__(
+        self,
+        userid=None,
+        groupids=(),
+        permissive=True,
+        remember_result=None,
+        forget_result=None,
+    ):
         self.userid = userid
         self.groupids = groupids
         self.permissive = permissive
@@ -95,6 +91,7 @@ class DummySecurityPolicy(object):
     def principals_allowed_by_permission(self, context, permission):
         return self.effective_principals(None)
 
+
 class DummyTemplateRenderer(object):
     """
     An instance of this class is returned from
@@ -103,6 +100,7 @@ class DummyTemplateRenderer(object):
     assertion which compares data passed to the renderer by the view
     function against expected key/value pairs.
     """
+
     def __init__(self, string_response=''):
         self._received = {}
         self._string_response = string_response
@@ -113,9 +111,11 @@ class DummyTemplateRenderer(object):
     # source code, *everything* is an API!
     def _get_string_response(self):
         return self._string_response
+
     def _set_string_response(self, response):
         self._string_response = response
         self._implementation.response = response
+
     string_response = property(_get_string_response, _set_string_response)
 
     def implementation(self):
@@ -151,19 +151,23 @@ class DummyTemplateRenderer(object):
                 if myval is _marker:
                     raise AssertionError(
                         'A value for key "%s" was not passed to the renderer'
-                        % k)
+                        % k
+                    )
 
             if myval != v:
                 raise AssertionError(
-                    '\nasserted value for %s: %r\nactual value: %r' % (
-                        k, v, myval))
+                    '\nasserted value for %s: %r\nactual value: %r'
+                    % (k, v, myval)
+                )
         return True
 
 
 class DummyResource:
     """ A dummy :app:`Pyramid` :term:`resource` object."""
-    def __init__(self, __name__=None, __parent__=None, __provides__=None,
-                 **kw):
+
+    def __init__(
+        self, __name__=None, __parent__=None, __provides__=None, **kw
+    ):
         """ The resource's ``__name__`` attribute will be set to the
         value of the ``__name__`` argument, and the resource's
         ``__parent__`` attribute will be set to the value of the
@@ -250,12 +254,15 @@ class DummyResource:
             inst.__parent__ = __parent__
         return inst
 
-DummyModel = DummyResource # b/w compat (forever)
+
+DummyModel = DummyResource  # b/w compat (forever)
+
 
 @implementer(ISession)
 class DummySession(dict):
     created = None
     new = True
+
     def changed(self):
         pass
 
@@ -286,6 +293,7 @@ class DummySession(dict):
             token = self.new_csrf_token()
         return token
 
+
 @implementer(IRequest)
 class DummyRequest(
     URLMethodsMixin,
@@ -295,7 +303,7 @@ class DummyRequest(
     AuthenticationAPIMixin,
     AuthorizationAPIMixin,
     ViewMethodsMixin,
-    ):
+):
     """ A DummyRequest object (incompletely) imitates a :term:`request` object.
 
     The ``params``, ``environ``, ``headers``, ``path``, and
@@ -322,6 +330,7 @@ class DummyRequest(
     a Request, use the :class:`pyramid.request.Request` class itself rather
     than this class while writing tests.
     """
+
     method = 'GET'
     application_url = 'http://example.com'
     host = 'example.com:80'
@@ -333,8 +342,16 @@ class DummyRequest(
     _registry = None
     request_iface = IRequest
 
-    def __init__(self, params=None, environ=None, headers=None, path='/',
-                 cookies=None, post=None, **kw):
+    def __init__(
+        self,
+        params=None,
+        environ=None,
+        headers=None,
+        path='/',
+        cookies=None,
+        post=None,
+        **kw
+    ):
         if environ is None:
             environ = {}
         if params is None:
@@ -369,7 +386,7 @@ class DummyRequest(
         self.context = None
         self.root = None
         self.virtual_root = None
-        self.marshalled = params # repoze.monty
+        self.marshalled = params  # repoze.monty
         self.session = DummySession()
         self.__dict__.update(kw)
 
@@ -391,11 +408,18 @@ class DummyRequest(
         f = _get_response_factory(self.registry)
         return f(self)
 
+
 have_zca = True
 
 
-def setUp(registry=None, request=None, hook_zca=True, autocommit=True,
-          settings=None, package=None):
+def setUp(
+    registry=None,
+    request=None,
+    hook_zca=True,
+    autocommit=True,
+    settings=None,
+    package=None,
+):
     """
     Set :app:`Pyramid` registry and request thread locals for the
     duration of a single unit test.
@@ -462,8 +486,9 @@ def setUp(registry=None, request=None, hook_zca=True, autocommit=True,
         registry = Registry('testing')
     if package is None:
         package = caller_package()
-    config = Configurator(registry=registry, autocommit=autocommit,
-                          package=package)
+    config = Configurator(
+        registry=registry, autocommit=autocommit, package=package
+    )
     if settings is None:
         settings = {}
     if getattr(registry, 'settings', None) is None:
@@ -486,12 +511,13 @@ def setUp(registry=None, request=None, hook_zca=True, autocommit=True,
     global have_zca
     try:
         have_zca and hook_zca and config.hook_zca()
-    except ImportError: # pragma: no cover
+    except ImportError:  # pragma: no cover
         # (dont choke on not being able to import z.component)
         have_zca = False
     config.begin(request=request)
     return config
 
+
 def tearDown(unhook_zca=True):
     """Undo the effects of :func:`pyramid.testing.setUp`.  Use this
     function in the ``tearDown`` method of a unit test that uses
@@ -507,8 +533,9 @@ def tearDown(unhook_zca=True):
     if unhook_zca and have_zca:
         try:
             from zope.component import getSiteManager
+
             getSiteManager.reset()
-        except ImportError: # pragma: no cover
+        except ImportError:  # pragma: no cover
             have_zca = False
     info = manager.pop()
     manager.clear()
@@ -524,6 +551,7 @@ def tearDown(unhook_zca=True):
                 # understand, let's not blow up
                 pass
 
+
 def cleanUp(*arg, **kw):
     """ An alias for :func:`pyramid.testing.setUp`. """
     package = kw.get('package', None)
@@ -532,6 +560,7 @@ def cleanUp(*arg, **kw):
         kw['package'] = package
     return setUp(*arg, **kw)
 
+
 class DummyRendererFactory(object):
     """ Registered by
     :meth:`pyramid.config.Configurator.testing_add_renderer` as
@@ -540,9 +569,10 @@ class DummyRendererFactory(object):
     wild believing they can register either.  The ``factory`` argument
     passed to this constructor is usually the *real* template renderer
     factory, found when ``testing_add_renderer`` is called."""
+
     def __init__(self, name, factory):
         self.name = name
-        self.factory = factory # the "real" renderer factory reg'd previously
+        self.factory = factory  # the "real" renderer factory reg'd previously
         self.renderers = {}
 
     def add(self, spec, renderer):
@@ -562,8 +592,9 @@ class DummyRendererFactory(object):
                 if self.factory:
                     renderer = self.factory(info)
                 else:
-                    raise KeyError('No testing renderer registered for %r' %
-                                   spec)
+                    raise KeyError(
+                        'No testing renderer registered for %r' % spec
+                    )
         return renderer
 
 
@@ -571,15 +602,19 @@ class MockTemplate(object):
     def __init__(self, response):
         self._received = {}
         self.response = response
+
     def __getattr__(self, attrname):
         return self
+
     def __getitem__(self, attrname):
         return self
+
     def __call__(self, *arg, **kw):
         self._received.update(kw)
         return self.response
 
-def skip_on(*platforms): # pragma: no  cover
+
+def skip_on(*platforms):  # pragma: no  cover
     skip = False
     for platform in platforms:
         if skip_on.os_name.startswith(platform):
@@ -596,22 +631,26 @@ def skip_on(*platforms): # pragma: no  cover
             else:
                 return func
         else:
+
             def wrapper(*args, **kw):
                 if skip:
                     return
                 return func(*args, **kw)
+
             wrapper.__name__ = func.__name__
             wrapper.__doc__ = func.__doc__
             return wrapper
+
     return decorator
-skip_on.os_name = os.name # for testing
+
+
+skip_on.os_name = os.name  # for testing
+
 
 @contextmanager
-def testConfig(registry=None,
-        request=None,
-        hook_zca=True,
-        autocommit=True,
-        settings=None):
+def testConfig(
+    registry=None, request=None, hook_zca=True, autocommit=True, settings=None
+):
     """Returns a context manager for test set up.
 
     This context manager calls :func:`pyramid.testing.setUp` when
@@ -630,11 +669,13 @@ def testConfig(registry=None,
             req = DummyRequest()
             resp = myview(req)
     """
-    config = setUp(registry=registry,
-            request=request,
-            hook_zca=hook_zca,
-            autocommit=autocommit,
-            settings=settings)
+    config = setUp(
+        registry=registry,
+        request=request,
+        hook_zca=hook_zca,
+        autocommit=autocommit,
+        settings=settings,
+    )
     try:
         yield config
     finally:
diff --git a/src/pyramid/threadlocal.py b/src/pyramid/threadlocal.py
index e8f825715..7eca5b0f0 100644
--- a/src/pyramid/threadlocal.py
+++ b/src/pyramid/threadlocal.py
@@ -2,6 +2,7 @@ import threading
 
 from pyramid.registry import global_registry
 
+
 class ThreadLocalManager(threading.local):
     def __init__(self, default=None):
         # http://code.google.com/p/google-app-engine-django/issues/detail?id=119
@@ -15,7 +16,7 @@ class ThreadLocalManager(threading.local):
     def push(self, info):
         self.stack.append(info)
 
-    set = push # b/c
+    set = push  # b/c
 
     def pop(self):
         if self.stack:
@@ -30,11 +31,14 @@ class ThreadLocalManager(threading.local):
     def clear(self):
         self.stack[:] = []
 
+
 def defaults():
     return {'request': None, 'registry': global_registry}
 
+
 manager = ThreadLocalManager(default=defaults)
 
+
 def get_current_request():
     """
     Return the currently active request or ``None`` if no request
@@ -49,7 +53,10 @@ def get_current_request():
     """
     return manager.get()['request']
 
-def get_current_registry(context=None): # context required by getSiteManager API
+
+def get_current_registry(
+    context=None
+):  # context required by getSiteManager API
     """
     Return the currently active :term:`application registry` or the
     global application registry if no request is currently active.
@@ -63,6 +70,7 @@ def get_current_registry(context=None): # context required by getSiteManager API
     """
     return manager.get()['registry']
 
+
 class RequestContext(object):
     def __init__(self, request):
         self.request = request
diff --git a/src/pyramid/traversal.py b/src/pyramid/traversal.py
index d8f4690fd..322f57ed6 100644
--- a/src/pyramid/traversal.py
+++ b/src/pyramid/traversal.py
@@ -6,7 +6,7 @@ from pyramid.interfaces import (
     IRequestFactory,
     ITraverser,
     VH_ROOT_KEY,
-    )
+)
 
 from pyramid.compat import (
     PY2,
@@ -19,18 +19,19 @@ from pyramid.compat import (
     decode_path_info,
     unquote_bytes_to_wsgi,
     lru_cache,
-    )
+)
 
 from pyramid.encode import url_quote
 from pyramid.exceptions import URLDecodeError
 from pyramid.location import lineage
 from pyramid.threadlocal import get_current_registry
 
-PATH_SEGMENT_SAFE = "~!$&'()*+,;=:@" # from webob
+PATH_SEGMENT_SAFE = "~!$&'()*+,;=:@"  # from webob
 PATH_SAFE = PATH_SEGMENT_SAFE + "/"
 
 empty = text_('')
 
+
 def find_root(resource):
     """ Find the root node in the resource tree to which ``resource``
     belongs. Note that ``resource`` should be :term:`location`-aware.
@@ -43,6 +44,7 @@ def find_root(resource):
             break
     return resource
 
+
 def find_resource(resource, path):
     """ Given a resource object and a string or tuple representing a path
     (such as the return value of :func:`pyramid.traversal.resource_path` or
@@ -101,7 +103,9 @@ def find_resource(resource, path):
         raise KeyError('%r has no subelement %s' % (context, view_name))
     return context
 
-find_model = find_resource # b/w compat (forever)
+
+find_model = find_resource  # b/w compat (forever)
+
 
 def find_interface(resource, class_or_interface):
     """
@@ -121,6 +125,7 @@ def find_interface(resource, class_or_interface):
         if test(location):
             return location
 
+
 def resource_path(resource, *elements):
     """ Return a string object representing the absolute physical path of the
     resource object based on its position in the resource tree, e.g
@@ -166,7 +171,9 @@ def resource_path(resource, *elements):
     # which caches the joined result for us
     return _join_path_tuple(resource_path_tuple(resource, *elements))
 
-model_path = resource_path # b/w compat (forever)
+
+model_path = resource_path  # b/w compat (forever)
+
 
 def traverse(resource, path):
     """Given a resource object as ``resource`` and a string or tuple
@@ -314,7 +321,8 @@ def traverse(resource, path):
 
     request_factory = reg.queryUtility(IRequestFactory)
     if request_factory is None:
-        from pyramid.request import Request # avoid circdep
+        from pyramid.request import Request  # avoid circdep
+
         request_factory = Request
 
     request = request_factory.blank(path)
@@ -325,6 +333,7 @@ def traverse(resource, path):
 
     return traverser(request)
 
+
 def resource_path_tuple(resource, *elements):
     """
     Return a tuple representing the absolute physical path of the
@@ -365,8 +374,10 @@ def resource_path_tuple(resource, *elements):
     """
     return tuple(_resource_path_list(resource, *elements))
 
+
 model_path_tuple = resource_path_tuple  # b/w compat (forever)
 
+
 def _resource_path_list(resource, *elements):
     """ Implementation detail shared by resource_path and resource_path_tuple"""
     path = [loc.__name__ or '' for loc in lineage(resource)]
@@ -374,7 +385,9 @@ def _resource_path_list(resource, *elements):
     path.extend(elements)
     return path
 
-_model_path_list = _resource_path_list # b/w compat, not an API
+
+_model_path_list = _resource_path_list  # b/w compat, not an API
+
 
 def virtual_root(resource, request):
     """
@@ -412,7 +425,7 @@ def virtual_root(resource, request):
 
     vpath, rpath = url_adapter.virtual_path, url_adapter.physical_path
     if rpath != vpath and rpath.endswith(vpath):
-        vroot_path = rpath[:-len(vpath)]
+        vroot_path = rpath[: -len(vpath)]
         return find_resource(resource, vroot_path)
 
     try:
@@ -420,6 +433,7 @@ def virtual_root(resource, request):
     except AttributeError:
         return find_root(resource)
 
+
 def traversal_path(path):
     """ Variant of :func:`pyramid.traversal.traversal_path_info` suitable for
     decoding paths that are URL-encoded.
@@ -435,8 +449,9 @@ def traversal_path(path):
         # must not possess characters outside ascii
         path = path.encode('ascii')
     # we unquote this path exactly like a PEP 3333 server would
-    path = unquote_bytes_to_wsgi(path) # result will be a native string
-    return traversal_path_info(path) # result will be a tuple of unicode
+    path = unquote_bytes_to_wsgi(path)  # result will be a native string
+    return traversal_path_info(path)  # result will be a tuple of unicode
+
 
 @lru_cache(1000)
 def traversal_path_info(path):
@@ -510,10 +525,11 @@ def traversal_path_info(path):
       applications in :app:`Pyramid`.
     """
     try:
-        path = decode_path_info(path) # result will be Unicode
+        path = decode_path_info(path)  # result will be Unicode
     except UnicodeDecodeError as e:
         raise URLDecodeError(e.encoding, e.object, e.start, e.end, e.reason)
-    return split_path_info(path) # result will be tuple of Unicode
+    return split_path_info(path)  # result will be tuple of Unicode
+
 
 @lru_cache(1000)
 def split_path_info(path):
@@ -531,6 +547,7 @@ def split_path_info(path):
             clean.append(segment)
     return tuple(clean)
 
+
 _segment_cache = {}
 
 quote_path_segment_doc = """ \
@@ -574,7 +591,9 @@ if PY2:
         try:
             return _segment_cache[(segment, safe)]
         except KeyError:
-            if segment.__class__ is text_type: #isinstance slighly slower (~15%)
+            if (
+                segment.__class__ is text_type
+            ):  # isinstance slighly slower (~15%)
                 result = url_quote(segment.encode('utf-8'), safe)
             else:
                 result = url_quote(str(segment), safe)
@@ -582,7 +601,10 @@ if PY2:
             # will generate exactly one Python bytecode (STORE_SUBSCR)
             _segment_cache[(segment, safe)] = result
             return result
+
+
 else:
+
     def quote_path_segment(segment, safe=PATH_SEGMENT_SAFE):
         """ %s """ % quote_path_segment_doc
         # The bit of this code that deals with ``_segment_cache`` is an
@@ -601,8 +623,10 @@ else:
             _segment_cache[(segment, safe)] = result
             return result
 
+
 slash = text_('/')
 
+
 @implementer(ITraverser)
 class ResourceTreeTraverser(object):
     """ A resource tree traverser that should be used (for speed) when
@@ -610,7 +634,6 @@ class ResourceTreeTraverser(object):
     ``__parent__`` attribute (ie. every resource in the tree is
     :term:`location` aware) ."""
 
-
     VH_ROOT_KEY = VH_ROOT_KEY
     VIEW_SELECTOR = '@@'
 
@@ -647,14 +670,17 @@ class ResourceTreeTraverser(object):
                 # if environ['PATH_INFO'] is just not there
                 path = slash
             except UnicodeDecodeError as e:
-                raise URLDecodeError(e.encoding, e.object, e.start, e.end,
-                                     e.reason)
+                raise URLDecodeError(
+                    e.encoding, e.object, e.start, e.end, e.reason
+                )
 
         if self.VH_ROOT_KEY in environ:
             # HTTP_X_VHM_ROOT
             vroot_path = decode_path_info(environ[self.VH_ROOT_KEY])
             vroot_tuple = split_path_info(vroot_path)
-            vpath = vroot_path + path # both will (must) be unicode or asciistr
+            vpath = (
+                vroot_path + path
+            )  # both will (must) be unicode or asciistr
             vroot_idx = len(vroot_tuple) - 1
         else:
             vroot_tuple = ()
@@ -664,7 +690,7 @@ class ResourceTreeTraverser(object):
         root = self.root
         ob = vroot = root
 
-        if vpath == slash: # invariant: vpath must not be empty
+        if vpath == slash:  # invariant: vpath must not be empty
             # prevent a call to traversal_path if we know it's going
             # to return the empty tuple
             vpath_tuple = ()
@@ -677,44 +703,60 @@ class ResourceTreeTraverser(object):
             vpath_tuple = split_path_info(vpath)
             for segment in vpath_tuple:
                 if segment[:2] == view_selector:
-                    return {'context': ob,
-                            'view_name': segment[2:],
-                            'subpath': vpath_tuple[i + 1:],
-                            'traversed': vpath_tuple[:vroot_idx + i + 1],
-                            'virtual_root': vroot,
-                            'virtual_root_path': vroot_tuple,
-                            'root': root}
+                    return {
+                        'context': ob,
+                        'view_name': segment[2:],
+                        'subpath': vpath_tuple[i + 1 :],
+                        'traversed': vpath_tuple[: vroot_idx + i + 1],
+                        'virtual_root': vroot,
+                        'virtual_root_path': vroot_tuple,
+                        'root': root,
+                    }
                 try:
                     getitem = ob.__getitem__
                 except AttributeError:
-                    return {'context': ob,
-                            'view_name': segment,
-                            'subpath': vpath_tuple[i + 1:],
-                            'traversed': vpath_tuple[:vroot_idx + i + 1],
-                            'virtual_root': vroot,
-                            'virtual_root_path': vroot_tuple,
-                            'root': root}
+                    return {
+                        'context': ob,
+                        'view_name': segment,
+                        'subpath': vpath_tuple[i + 1 :],
+                        'traversed': vpath_tuple[: vroot_idx + i + 1],
+                        'virtual_root': vroot,
+                        'virtual_root_path': vroot_tuple,
+                        'root': root,
+                    }
 
                 try:
                     next = getitem(segment)
                 except KeyError:
-                    return {'context': ob,
-                            'view_name': segment,
-                            'subpath': vpath_tuple[i + 1:],
-                            'traversed': vpath_tuple[:vroot_idx + i + 1],
-                            'virtual_root': vroot,
-                            'virtual_root_path': vroot_tuple,
-                            'root': root}
+                    return {
+                        'context': ob,
+                        'view_name': segment,
+                        'subpath': vpath_tuple[i + 1 :],
+                        'traversed': vpath_tuple[: vroot_idx + i + 1],
+                        'virtual_root': vroot,
+                        'virtual_root_path': vroot_tuple,
+                        'root': root,
+                    }
                 if i == vroot_idx:
                     vroot = next
                 ob = next
                 i += 1
 
-        return {'context':ob, 'view_name':empty, 'subpath':subpath,
-                'traversed':vpath_tuple, 'virtual_root':vroot,
-                'virtual_root_path':vroot_tuple, 'root':root}
+        return {
+            'context': ob,
+            'view_name': empty,
+            'subpath': subpath,
+            'traversed': vpath_tuple,
+            'virtual_root': vroot,
+            'virtual_root_path': vroot_tuple,
+            'root': root,
+        }
+
+
+ModelGraphTraverser = (
+    ResourceTreeTraverser
+)  # b/w compat, not API, used in wild
 
-ModelGraphTraverser = ResourceTreeTraverser # b/w compat, not API, used in wild
 
 @implementer(IResourceURL)
 class ResourceURL(object):
@@ -742,19 +784,24 @@ class ResourceURL(object):
                 vroot_path_tuple = tuple(vroot_path.split('/'))
                 numels = len(vroot_path_tuple)
                 virtual_path_tuple = ('',) + physical_path_tuple[numels:]
-                virtual_path = physical_path[len(vroot_path):]
+                virtual_path = physical_path[len(vroot_path) :]
 
-        self.virtual_path = virtual_path    # IResourceURL attr
+        self.virtual_path = virtual_path  # IResourceURL attr
         self.physical_path = physical_path  # IResourceURL attr
-        self.virtual_path_tuple = virtual_path_tuple # IResourceURL attr (1.5)
-        self.physical_path_tuple = physical_path_tuple # IResourceURL attr (1.5)
+        self.virtual_path_tuple = virtual_path_tuple  # IResourceURL attr (1.5)
+        self.physical_path_tuple = (
+            physical_path_tuple
+        )  # IResourceURL attr (1.5)
+
 
 @lru_cache(1000)
 def _join_path_tuple(tuple):
     return tuple and '/'.join([quote_path_segment(x) for x in tuple]) or '/'
 
+
 class DefaultRootFactory:
     __parent__ = None
     __name__ = None
+
     def __init__(self, request):
         pass
diff --git a/src/pyramid/tweens.py b/src/pyramid/tweens.py
index 740b6961c..839c53b8f 100644
--- a/src/pyramid/tweens.py
+++ b/src/pyramid/tweens.py
@@ -3,6 +3,7 @@ import sys
 from pyramid.compat import reraise
 from pyramid.httpexceptions import HTTPNotFound
 
+
 def _error_handler(request, exc):
     # NOTE: we do not need to delete exc_info because this function
     # should never be in the call stack of the exception
@@ -17,6 +18,7 @@ def _error_handler(request, exc):
 
     return response
 
+
 def excview_tween_factory(handler, registry):
     """ A :term:`tween` factory which produces a tween that catches an
     exception raised by downstream tweens (or the main Pyramid request
@@ -43,6 +45,7 @@ def excview_tween_factory(handler, registry):
 
     return excview_tween
 
+
 MAIN = 'MAIN'
 INGRESS = 'INGRESS'
 EXCVIEW = 'pyramid.tweens.excview_tween_factory'
diff --git a/src/pyramid/url.py b/src/pyramid/url.py
index 852aa5e55..c6cf3da7f 100644
--- a/src/pyramid/url.py
+++ b/src/pyramid/url.py
@@ -2,21 +2,10 @@
 
 import os
 
-from pyramid.interfaces import (
-    IResourceURL,
-    IRoutesMapper,
-    IStaticURLInfo,
-    )
+from pyramid.interfaces import IResourceURL, IRoutesMapper, IStaticURLInfo
 
-from pyramid.compat import (
-    bytes_,
-    lru_cache,
-    string_types,
-    )
-from pyramid.encode import (
-    url_quote,
-    urlencode,
-)
+from pyramid.compat import bytes_, lru_cache, string_types
+from pyramid.encode import url_quote, urlencode
 from pyramid.path import caller_package
 from pyramid.threadlocal import get_current_registry
 
@@ -25,11 +14,12 @@ from pyramid.traversal import (
     quote_path_segment,
     PATH_SAFE,
     PATH_SEGMENT_SAFE,
-    )
+)
 
-QUERY_SAFE = "/?:@!$&'()*+,;=" # RFC 3986
+QUERY_SAFE = "/?:@!$&'()*+,;="  # RFC 3986
 ANCHOR_SAFE = QUERY_SAFE
 
+
 def parse_url_overrides(request, kw):
     """
     Parse special arguments passed when generating urls.
@@ -48,7 +38,7 @@ def parse_url_overrides(request, kw):
     anchor = kw.pop('_anchor', '')
 
     if app_url is None:
-        if (scheme is not None or host is not None or port is not None):
+        if scheme is not None or host is not None or port is not None:
             app_url = request._partial_application_url(scheme, host, port)
         else:
             app_url = request.application_url
@@ -66,6 +56,7 @@ def parse_url_overrides(request, kw):
 
     return app_url, qs, frag
 
+
 class URLMethodsMixin(object):
     """ Request methods mixin for BaseRequest having to do with URL
     generation """
@@ -115,7 +106,7 @@ class URLMethodsMixin(object):
         if port:
             url += ':%s' % port
 
-        url_encoding = getattr(self, 'url_encoding', 'utf-8') # webob 1.2b3+
+        url_encoding = getattr(self, 'url_encoding', 'utf-8')  # webob 1.2b3+
         bscript_name = bytes_(self.script_name, url_encoding)
         return url + url_quote(bscript_name, PATH_SAFE)
 
@@ -255,7 +246,7 @@ class URLMethodsMixin(object):
         try:
             reg = self.registry
         except AttributeError:
-            reg = get_current_registry() # b/c
+            reg = get_current_registry()  # b/c
         mapper = reg.getUtility(IRoutesMapper)
         route = mapper.get_route(route_name)
 
@@ -267,7 +258,7 @@ class URLMethodsMixin(object):
 
         app_url, qs, anchor = parse_url_overrides(self, kw)
 
-        path = route.generate(kw) # raises KeyError if generate fails
+        path = route.generate(kw)  # raises KeyError if generate fails
 
         if elements:
             suffix = _join_elements(elements)
@@ -522,7 +513,7 @@ class URLMethodsMixin(object):
         try:
             reg = self.registry
         except AttributeError:
-            reg = get_current_registry() # b/c
+            reg = get_current_registry()  # b/c
 
         url_adapter = reg.queryMultiAdapter((resource, self), IResourceURL)
         if url_adapter is None:
@@ -531,9 +522,7 @@ class URLMethodsMixin(object):
         virtual_path = getattr(url_adapter, 'virtual_path', None)
 
         urlkw = {}
-        for name in (
-            'app_url', 'scheme', 'host', 'port', 'query', 'anchor'
-        ):
+        for name in ('app_url', 'scheme', 'host', 'port', 'query', 'anchor'):
             val = kw.get(name, None)
             if val is not None:
                 urlkw['_' + name] = val
@@ -583,7 +572,7 @@ class URLMethodsMixin(object):
 
         return resource_url + suffix + qs + anchor
 
-    model_url = resource_url # b/w compat forever
+    model_url = resource_url  # b/w compat forever
 
     def resource_path(self, resource, *elements, **kw):
         """
@@ -651,7 +640,7 @@ class URLMethodsMixin(object):
         try:
             reg = self.registry
         except AttributeError:
-            reg = get_current_registry() # b/c
+            reg = get_current_registry()  # b/c
 
         info = reg.queryUtility(IStaticURLInfo)
         if info is None:
@@ -803,6 +792,7 @@ def route_url(route_name, request, *elements, **kw):
     """
     return request.route_url(route_name, *elements, **kw)
 
+
 def route_path(route_name, request, *elements, **kw):
     """
     This is a backwards compatibility function.  Its result is the same as
@@ -814,6 +804,7 @@ def route_path(route_name, request, *elements, **kw):
     """
     return request.route_path(route_name, *elements, **kw)
 
+
 def resource_url(resource, request, *elements, **kw):
     """
     This is a backwards compatibility function.  Its result is the same as
@@ -825,7 +816,8 @@ def resource_url(resource, request, *elements, **kw):
     """
     return request.resource_url(resource, *elements, **kw)
 
-model_url = resource_url # b/w compat (forever)
+
+model_url = resource_url  # b/w compat (forever)
 
 
 def static_url(path, request, **kw):
@@ -865,6 +857,7 @@ def static_path(path, request, **kw):
             path = '%s:%s' % (package.__name__, path)
     return request.static_path(path, **kw)
 
+
 def current_route_url(request, *elements, **kw):
     """
     This is a backwards compatibility function.  Its result is the same as
@@ -877,6 +870,7 @@ def current_route_url(request, *elements, **kw):
     """
     return request.current_route_url(*elements, **kw)
 
+
 def current_route_path(request, *elements, **kw):
     """
     This is a backwards compatibility function.  Its result is the same as
@@ -889,6 +883,9 @@ def current_route_path(request, *elements, **kw):
     """
     return request.current_route_path(*elements, **kw)
 
+
 @lru_cache(1000)
 def _join_elements(elements):
-    return '/'.join([quote_path_segment(s, safe=PATH_SEGMENT_SAFE) for s in elements])
+    return '/'.join(
+        [quote_path_segment(s, safe=PATH_SEGMENT_SAFE) for s in elements]
+    )
diff --git a/src/pyramid/urldispatch.py b/src/pyramid/urldispatch.py
index a61071845..de8a69d2a 100644
--- a/src/pyramid/urldispatch.py
+++ b/src/pyramid/urldispatch.py
@@ -1,10 +1,7 @@
 import re
 from zope.interface import implementer
 
-from pyramid.interfaces import (
-    IRoutesMapper,
-    IRoute,
-    )
+from pyramid.interfaces import IRoutesMapper, IRoute
 
 from pyramid.compat import (
     PY2,
@@ -15,30 +12,29 @@ from pyramid.compat import (
     binary_type,
     is_nonstr_iter,
     decode_path_info,
-    )
+)
 
 from pyramid.exceptions import URLDecodeError
 
-from pyramid.traversal import (
-    quote_path_segment,
-    split_path_info,
-    PATH_SAFE,
-    )
+from pyramid.traversal import quote_path_segment, split_path_info, PATH_SAFE
 
 _marker = object()
 
+
 @implementer(IRoute)
 class Route(object):
-    def __init__(self, name, pattern, factory=None, predicates=(),
-                 pregenerator=None):
+    def __init__(
+        self, name, pattern, factory=None, predicates=(), pregenerator=None
+    ):
         self.pattern = pattern
-        self.path = pattern # indefinite b/w compat, not in interface
+        self.path = pattern  # indefinite b/w compat, not in interface
         self.match, self.generate = _compile_route(pattern)
         self.name = name
         self.factory = factory
         self.predicates = predicates
         self.pregenerator = pregenerator
 
+
 @implementer(IRoutesMapper)
 class RoutesMapper(object):
     def __init__(self):
@@ -59,8 +55,15 @@ class RoutesMapper(object):
     def get_route(self, name):
         return self.routes.get(name)
 
-    def connect(self, name, pattern, factory=None, predicates=(),
-                pregenerator=None, static=False):
+    def connect(
+        self,
+        name,
+        pattern,
+        factory=None,
+        predicates=(),
+        pregenerator=None,
+        static=False,
+    ):
         if name in self.routes:
             oldroute = self.routes[name]
             if oldroute in self.routelist:
@@ -86,18 +89,21 @@ class RoutesMapper(object):
         except KeyError:
             path = '/'
         except UnicodeDecodeError as e:
-            raise URLDecodeError(e.encoding, e.object, e.start, e.end, e.reason)
+            raise URLDecodeError(
+                e.encoding, e.object, e.start, e.end, e.reason
+            )
 
         for route in self.routelist:
             match = route.match(path)
             if match is not None:
                 preds = route.predicates
-                info = {'match':match, 'route':route}
+                info = {'match': match, 'route': route}
                 if preds and not all((p(info, request) for p in preds)):
                     continue
                 return info
 
-        return {'route':None, 'match':None}
+        return {'route': None, 'match': None}
+
 
 # stolen from bobo and modified
 old_route_re = re.compile(r'(\:[_a-zA-Z]\w*)')
@@ -109,10 +115,12 @@ star_at_end = re.compile(r'\*(\w*)$')
 # (\{[a-zA-Z][^\}]*\}) but that choked when supplied with e.g. {foo:\d{4}}.
 route_re = re.compile(r'(\{[_a-zA-Z][^{}]*(?:\{[^{}]*\}[^{}]*)*\})')
 
+
 def update_pattern(matchobj):
     name = matchobj.group(0)
     return '{%s}' % name[1:]
 
+
 def _compile_route(route):
     # This function really wants to consume Unicode patterns natively, but if
     # someone passes us a bytestring, we allow it by converting it to Unicode
@@ -126,7 +134,8 @@ def _compile_route(route):
             raise ValueError(
                 'The pattern value passed to add_route must be '
                 'either a Unicode string or a plain string without '
-                'any non-ASCII characters (you provided %r).' % route)
+                'any non-ASCII characters (you provided %r).' % route
+            )
 
     if old_route_re.search(route) and not route_re.search(route):
         route = old_route_re.sub(update_pattern, route)
@@ -145,17 +154,19 @@ def _compile_route(route):
     pat.reverse()
     rpat = []
     gen = []
-    prefix = pat.pop() # invar: always at least one element (route='/'+route)
+    prefix = pat.pop()  # invar: always at least one element (route='/'+route)
 
     # We want to generate URL-encoded URLs, so we url-quote the prefix, being
     # careful not to quote any embedded slashes.  We have to replace '%' with
     # '%%' afterwards, as the strings that go into "gen" are used as string
     # replacement targets.
-    gen.append(quote_path_segment(prefix, safe='/').replace('%', '%%')) # native
-    rpat.append(re.escape(prefix)) # unicode
+    gen.append(
+        quote_path_segment(prefix, safe='/').replace('%', '%%')
+    )  # native
+    rpat.append(re.escape(prefix))  # unicode
 
     while pat:
-        name = pat.pop() # unicode
+        name = pat.pop()  # unicode
         name = name[1:-1]
         if ':' in name:
             # reg may contain colons as well,
@@ -163,12 +174,12 @@ def _compile_route(route):
             name, reg = name.split(':', 1)
         else:
             reg = '[^/]+'
-        gen.append('%%(%s)s' % native_(name)) # native
-        name = '(?P<%s>%s)' % (name, reg) # unicode
+        gen.append('%%(%s)s' % native_(name))  # native
+        name = '(?P<%s>%s)' % (name, reg)  # unicode
         rpat.append(name)
-        s = pat.pop() # unicode
+        s = pat.pop()  # unicode
         if s:
-            rpat.append(re.escape(s)) # unicode
+            rpat.append(re.escape(s))  # unicode
             # We want to generate URL-encoded URLs, so we url-quote this
             # literal in the pattern, being careful not to quote the embedded
             # slashes.  We have to replace '%' with '%%' afterwards, as the
@@ -177,12 +188,13 @@ def _compile_route(route):
             gen.append(quote_path_segment(s, safe='/').replace('%', '%%'))
 
     if remainder:
-        rpat.append('(?P<%s>.*?)' % remainder) # unicode
-        gen.append('%%(%s)s' % native_(remainder)) # native
+        rpat.append('(?P<%s>.*?)' % remainder)  # unicode
+        gen.append('%%(%s)s' % native_(remainder))  # native
 
-    pattern = ''.join(rpat) + '$' # unicode
+    pattern = ''.join(rpat) + '$'  # unicode
 
     match = re.compile(pattern).match
+
     def matcher(path):
         # This function really wants to consume Unicode patterns natively,
         # but if someone passes us a bytestring, we allow it by converting it
@@ -227,9 +239,7 @@ def _compile_route(route):
             if k == remainder:
                 # a stararg argument
                 if is_nonstr_iter(v):
-                    v = '/'.join(
-                        [q(x) for x in v]
-                        ) # native
+                    v = '/'.join([q(x) for x in v])  # native
                 else:
                     if v.__class__ not in string_types:
                         v = str(v)
@@ -243,7 +253,7 @@ def _compile_route(route):
             # at this point, the value will be a native string
             newdict[k] = v
 
-        result = gen % newdict # native string result
+        result = gen % newdict  # native string result
         return result
 
     return matcher, generator
diff --git a/src/pyramid/util.py b/src/pyramid/util.py
index 6655455bf..bebf9e7d3 100644
--- a/src/pyramid/util.py
+++ b/src/pyramid/util.py
@@ -1,5 +1,6 @@
 from contextlib import contextmanager
 import functools
+
 try:
     # py2.7.7+ and py3.3+ have native comparison support
     from hmac import compare_digest
@@ -8,10 +9,7 @@ except ImportError:  # pragma: no cover
 import inspect
 import weakref
 
-from pyramid.exceptions import (
-    ConfigurationError,
-    CyclicDependencyError,
-    )
+from pyramid.exceptions import ConfigurationError, CyclicDependencyError
 
 from pyramid.compat import (
     getargspec,
@@ -22,8 +20,8 @@ from pyramid.compat import (
     bytes_,
     text_,
     PY2,
-    native_
-    )
+    native_,
+)
 
 from pyramid.path import DottedNameResolver as _DottedNameResolver
 
@@ -31,21 +29,26 @@ _marker = object()
 
 
 class DottedNameResolver(_DottedNameResolver):
-    def __init__(self, package=None): # default to package = None for bw compat
+    def __init__(
+        self, package=None
+    ):  # default to package = None for bw compat
         _DottedNameResolver.__init__(self, package)
 
+
 def is_string_or_iterable(v):
     if isinstance(v, string_types):
         return True
     if hasattr(v, '__iter__'):
         return True
 
+
 def as_sorted_tuple(val):
     if not is_nonstr_iter(val):
         val = (val,)
     val = tuple(sorted(val))
     return val
 
+
 class InstancePropertyHelper(object):
     """A helper object for assigning properties and descriptors to instances.
     It is not normally possible to do this because descriptors must be
@@ -56,6 +59,7 @@ class InstancePropertyHelper(object):
     per-property and then invoking :meth:`.apply` on target objects.
 
     """
+
     def __init__(self):
         self.properties = {}
 
@@ -81,7 +85,8 @@ class InstancePropertyHelper(object):
             name = callable.__name__
             fn = callable
         if reify:
-            import pyramid.decorator # avoid circular import
+            import pyramid.decorator  # avoid circular import
+
             fn = pyramid.decorator.reify(fn)
         elif not is_property:
             fn = property(fn)
@@ -141,6 +146,7 @@ class InstancePropertyHelper(object):
         if self.properties:
             self.apply_properties(target, self.properties)
 
+
 class InstancePropertyMixin(object):
     """ Mixin that will allow an instance to add properties at
     run-time as if they had been defined via @property or @reify
@@ -200,7 +206,9 @@ class InstancePropertyMixin(object):
            1
         """
         InstancePropertyHelper.set_property(
-            self, callable, name=name, reify=reify)
+            self, callable, name=name, reify=reify
+        )
+
 
 class WeakOrderedSet(object):
     """ Maintain a set of items.
@@ -268,6 +276,7 @@ class WeakOrderedSet(object):
             oid = self._order[-1]
             return self._items[oid]()
 
+
 def strings_differ(string1, string2, compare_digest=compare_digest):
     """Check whether two strings differ while avoiding timing attacks.
 
@@ -299,6 +308,7 @@ def strings_differ(string1, string2, compare_digest=compare_digest):
             invalid_bits += a != b
     return invalid_bits != 0
 
+
 def object_description(object):
     """ Produce a human-consumable text description of ``object``,
     usually involving a Python dotted name. For example:
@@ -345,11 +355,12 @@ def object_description(object):
         return text_('module %s' % modulename)
     if inspect.ismethod(object):
         oself = getattr(object, '__self__', None)
-        if oself is None: # pragma: no cover
+        if oself is None:  # pragma: no cover
             oself = getattr(object, 'im_self', None)
-        return text_('method %s of class %s.%s' %
-                     (object.__name__, modulename,
-                      oself.__class__.__name__))
+        return text_(
+            'method %s of class %s.%s'
+            % (object.__name__, modulename, oself.__class__.__name__)
+        )
 
     if inspect.isclass(object):
         dottedname = '%s.%s' % (modulename, object.__name__)
@@ -359,12 +370,14 @@ def object_description(object):
         return text_('function %s' % dottedname)
     return text_('object %s' % str(object))
 
+
 def shortrepr(object, closer):
     r = str(object)
     if len(r) > 100:
         r = r[:100] + ' ... %s' % closer
     return r
 
+
 class Sentinel(object):
     def __init__(self, repr):
         self.repr = repr
@@ -372,19 +385,18 @@ class Sentinel(object):
     def __repr__(self):
         return self.repr
 
+
 FIRST = Sentinel('FIRST')
 LAST = Sentinel('LAST')
 
+
 class TopologicalSorter(object):
     """ A utility class which can be used to perform topological sorts against
     tuple-like data."""
+
     def __init__(
-        self,
-        default_before=LAST,
-        default_after=None,
-        first=FIRST,
-        last=LAST,
-        ):
+        self, default_before=LAST, default_after=None, first=FIRST, last=LAST
+    ):
         self.names = []
         self.req_before = set()
         self.req_after = set()
@@ -414,7 +426,7 @@ class TopologicalSorter(object):
             self.req_before.remove(name)
             for u in before:
                 self.order.remove((name, u))
-                
+
     def add(self, name, val, after=None, before=None):
         """ Add a node to the sort input.  The ``name`` should be a string or
         any other hashable object, the ``val`` should be the sortable (doesn't
@@ -454,7 +466,6 @@ class TopologicalSorter(object):
             self.order += [(name, o) for o in before]
             self.req_before.add(name)
 
-
     def sorted(self):
         """ Returns the sort input values in topologically sorted order"""
         order = [(self.first, self.last)]
@@ -469,7 +480,7 @@ class TopologicalSorter(object):
         def add_node(node):
             if node not in graph:
                 roots.append(node)
-                graph[node] = [0] # 0 = number of arcs coming into this node
+                graph[node] = [0]  # 0 = number of arcs coming into this node
 
         def add_arc(fromnode, tonode):
             graph[fromnode].append(tonode)
@@ -482,7 +493,7 @@ class TopologicalSorter(object):
 
         has_before, has_after = set(), set()
         for a, b in order:
-            if a in names and b in names: # deal with missing dependencies
+            if a in names and b in names:  # deal with missing dependencies
                 add_arc(a, b)
                 has_before.add(a)
                 has_after.add(b)
@@ -507,7 +518,7 @@ class TopologicalSorter(object):
             for child in children:
                 arcs = graph[child][0]
                 arcs -= 1
-                graph[child][0] = arcs 
+                graph[child][0] = arcs
                 if arcs == 0:
                     roots.insert(0, child)
             del graph[root]
@@ -542,6 +553,7 @@ def get_callable_name(name):
         )
         raise ConfigurationError(msg % name)
 
+
 @contextmanager
 def hide_attrs(obj, *attrs):
     """
@@ -574,9 +586,11 @@ def is_same_domain(host, pattern):
         return False
 
     pattern = pattern.lower()
-    return (pattern[0] == "." and
-            (host.endswith(pattern) or host == pattern[1:]) or
-            pattern == host)
+    return (
+        pattern[0] == "."
+        and (host.endswith(pattern) or host == pattern[1:])
+        or pattern == host
+    )
 
 
 def make_contextmanager(fn):
@@ -590,6 +604,7 @@ def make_contextmanager(fn):
     @functools.wraps(fn)
     def wrapper(*a, **kw):
         yield fn(*a, **kw)
+
     return wrapper
 
 
diff --git a/src/pyramid/view.py b/src/pyramid/view.py
index 769328344..c45b976bb 100644
--- a/src/pyramid/view.py
+++ b/src/pyramid/view.py
@@ -13,31 +13,26 @@ from pyramid.interfaces import (
     IViewClassifier,
     IRequest,
     IExceptionViewClassifier,
-    )
+)
 
 from pyramid.compat import decode_path_info
 from pyramid.compat import reraise as reraise_
 
-from pyramid.exceptions import (
-    ConfigurationError,
-    PredicateMismatch,
-)
+from pyramid.exceptions import ConfigurationError, PredicateMismatch
 
 from pyramid.httpexceptions import (
     HTTPNotFound,
     HTTPTemporaryRedirect,
     default_exceptionresponse_view,
-    )
+)
 
-from pyramid.threadlocal import (
-    get_current_registry,
-    manager,
-    )
+from pyramid.threadlocal import get_current_registry, manager
 
 from pyramid.util import hide_attrs
 
 _marker = object()
 
+
 def render_view_to_response(context, request, name='', secure=True):
     """ Call the :term:`view callable` configured with a :term:`view
     configuration` that matches the :term:`view name` ``name``
@@ -84,9 +79,9 @@ def render_view_to_response(context, request, name='', secure=True):
         name,
         secure=secure,
         request_iface=request_iface,
-        )
+    )
 
-    return response # NB: might be None
+    return response  # NB: might be None
 
 
 def render_view_to_iterable(context, request, name='', secure=True):
@@ -119,6 +114,7 @@ def render_view_to_iterable(context, request, name='', secure=True):
         return None
     return response.app_iter
 
+
 def render_view(context, request, name='', secure=True):
     """ Call the :term:`view callable` configured with a :term:`view
     configuration` that matches the :term:`view name` ``name``
@@ -146,6 +142,7 @@ def render_view(context, request, name='', secure=True):
         return None
     return b''.join(iterable)
 
+
 class view_config(object):
     """ A function, class or method :term:`decorator` which allows a
     developer to create view registrations nearer to a :term:`view
@@ -213,7 +210,9 @@ class view_config(object):
         because of the limitation of ``venusian.Scanner.scan``.
 
     """
-    venusian = venusian # for testing injection
+
+    venusian = venusian  # for testing injection
+
     def __init__(self, **settings):
         if 'for_' in settings:
             if settings.get('context') is None:
@@ -229,8 +228,9 @@ class view_config(object):
             config = context.config.with_package(info.module)
             config.add_view(view=ob, **settings)
 
-        info = self.venusian.attach(wrapped, callback, category=category,
-                                    depth=depth + 1)
+        info = self.venusian.attach(
+            wrapped, callback, category=category, depth=depth + 1
+        )
 
         if info.scope == 'class':
             # if the decorator was attached to a method in a class, or
@@ -239,10 +239,12 @@ class view_config(object):
             if settings.get('attr') is None:
                 settings['attr'] = wrapped.__name__
 
-        settings['_info'] = info.codeinfo # fbo "action_method"
+        settings['_info'] = info.codeinfo  # fbo "action_method"
         return wrapped
 
-bfg_view = view_config # bw compat (forever)
+
+bfg_view = view_config  # bw compat (forever)
+
 
 class view_defaults(view_config):
     """ A class :term:`decorator` which, when applied to a class, will
@@ -257,6 +259,7 @@ class view_defaults(view_config):
         wrapped.__view_defaults__ = self.__dict__.copy()
         return wrapped
 
+
 class AppendSlashNotFoundViewFactory(object):
     """ There can only be one :term:`Not Found view` in any
     :app:`Pyramid` application.  Even if you use
@@ -292,7 +295,10 @@ class AppendSlashNotFoundViewFactory(object):
     .. deprecated:: 1.3
 
     """
-    def __init__(self, notfound_view=None, redirect_class=HTTPTemporaryRedirect):
+
+    def __init__(
+        self, notfound_view=None, redirect_class=HTTPTemporaryRedirect
+    ):
         if notfound_view is None:
             notfound_view = default_exceptionresponse_view
         self.notfound_view = notfound_view
@@ -309,9 +315,12 @@ class AppendSlashNotFoundViewFactory(object):
                     qs = request.query_string
                     if qs:
                         qs = '?' + qs
-                    return self.redirect_class(location=request.path + '/' + qs)
+                    return self.redirect_class(
+                        location=request.path + '/' + qs
+                    )
         return self.notfound_view(context, request)
 
+
 append_slash_notfound_view = AppendSlashNotFoundViewFactory()
 append_slash_notfound_view.__doc__ = """\
 For behavior like Django's ``APPEND_SLASH=True``, use this view as the
@@ -337,6 +346,7 @@ view as the Not Found view::
 
 """
 
+
 class notfound_view_config(object):
     """
     .. versionadded:: 1.3
@@ -417,8 +427,9 @@ class notfound_view_config(object):
             config = context.config.with_package(info.module)
             config.add_notfound_view(view=ob, **settings)
 
-        info = self.venusian.attach(wrapped, callback, category=category,
-                                    depth=depth + 1)
+        info = self.venusian.attach(
+            wrapped, callback, category=category, depth=depth + 1
+        )
 
         if info.scope == 'class':
             # if the decorator was attached to a method in a class, or
@@ -427,9 +438,10 @@ class notfound_view_config(object):
             if settings.get('attr') is None:
                 settings['attr'] = wrapped.__name__
 
-        settings['_info'] = info.codeinfo # fbo "action_method"
+        settings['_info'] = info.codeinfo  # fbo "action_method"
         return wrapped
 
+
 class forbidden_view_config(object):
     """
     .. versionadded:: 1.3
@@ -479,8 +491,9 @@ class forbidden_view_config(object):
             config = context.config.with_package(info.module)
             config.add_forbidden_view(view=ob, **settings)
 
-        info = self.venusian.attach(wrapped, callback, category=category,
-                                    depth=depth + 1)
+        info = self.venusian.attach(
+            wrapped, callback, category=category, depth=depth + 1
+        )
 
         if info.scope == 'class':
             # if the decorator was attached to a method in a class, or
@@ -489,9 +502,10 @@ class forbidden_view_config(object):
             if settings.get('attr') is None:
                 settings['attr'] = wrapped.__name__
 
-        settings['_info'] = info.codeinfo # fbo "action_method"
+        settings['_info'] = info.codeinfo  # fbo "action_method"
         return wrapped
 
+
 class exception_view_config(object):
     """
     .. versionadded:: 1.8
@@ -526,6 +540,7 @@ class exception_view_config(object):
        Added the ``_depth`` and ``_category`` arguments.
 
     """
+
     venusian = venusian
 
     def __init__(self, *args, **settings):
@@ -545,8 +560,9 @@ class exception_view_config(object):
             config = context.config.with_package(info.module)
             config.add_exception_view(view=ob, **settings)
 
-        info = self.venusian.attach(wrapped, callback, category=category,
-                                    depth=depth + 1)
+        info = self.venusian.attach(
+            wrapped, callback, category=category, depth=depth + 1
+        )
 
         if info.scope == 'class':
             # if the decorator was attached to a method in a class, or
@@ -555,9 +571,10 @@ class exception_view_config(object):
             if settings.get('attr') is None:
                 settings['attr'] = wrapped.__name__
 
-        settings['_info'] = info.codeinfo # fbo "action_method"
+        settings['_info'] = info.codeinfo  # fbo "action_method"
         return wrapped
 
+
 def _find_views(
     registry,
     request_iface,
@@ -565,7 +582,7 @@ def _find_views(
     view_name,
     view_types=None,
     view_classifier=None,
-    ):
+):
     if view_types is None:
         view_types = (IView, ISecuredView, IMultiView)
     if view_classifier is None:
@@ -581,9 +598,7 @@ def _find_views(
             source_ifaces = (view_classifier, req_type, ctx_type)
             for view_type in view_types:
                 view_callable = registered(
-                    source_ifaces,
-                    view_type,
-                    name=view_name,
+                    source_ifaces, view_type, name=view_name
                 )
                 if view_callable is not None:
                     views.append(view_callable)
@@ -599,6 +614,7 @@ def _find_views(
 
     return views
 
+
 def _call_view(
     registry,
     request,
@@ -609,7 +625,7 @@ def _call_view(
     view_classifier=None,
     secure=True,
     request_iface=None,
-    ):
+):
     if request_iface is None:
         request_iface = getattr(request, 'request_iface', IRequest)
     view_callables = _find_views(
@@ -619,7 +635,7 @@ def _call_view(
         view_name,
         view_types=view_types,
         view_classifier=view_classifier,
-        )
+    )
 
     pme = None
     response = None
@@ -631,10 +647,8 @@ def _call_view(
                 # the view will have a __call_permissive__ attribute if it's
                 # secured; otherwise it won't.
                 view_callable = getattr(
-                    view_callable,
-                    '__call_permissive__',
-                    view_callable
-                    )
+                    view_callable, '__call_permissive__', view_callable
+                )
 
             # if this view is secured, it will raise a Forbidden
             # appropriately if the executing user does not have the proper
@@ -649,15 +663,13 @@ def _call_view(
 
     return response
 
+
 class ViewMethodsMixin(object):
     """ Request methods mixin for BaseRequest having to do with executing
     views """
+
     def invoke_exception_view(
-        self,
-        exc_info=None,
-        request=None,
-        secure=True,
-        reraise=False,
+        self, exc_info=None, request=None, secure=True, reraise=False
     ):
         """ Executes an exception view related to the request it's called upon.
         The arguments it takes are these:
@@ -742,7 +754,7 @@ class ViewMethodsMixin(object):
                     view_classifier=IExceptionViewClassifier,
                     secure=secure,
                     request_iface=request_iface.combined,
-                    )
+                )
             except Exception:
                 if reraise:
                     reraise_(*exc_info)
diff --git a/src/pyramid/viewderivers.py b/src/pyramid/viewderivers.py
index d914a4752..0b4758554 100644
--- a/src/pyramid/viewderivers.py
+++ b/src/pyramid/viewderivers.py
@@ -1,15 +1,9 @@
 import inspect
 
-from zope.interface import (
-    implementer,
-    provider,
-    )
+from zope.interface import implementer, provider
 
 from pyramid.security import NO_PERMISSION_REQUIRED
-from pyramid.csrf import (
-    check_csrf_origin,
-    check_csrf_token,
-)
+from pyramid.csrf import check_csrf_origin, check_csrf_token
 from pyramid.response import Response
 
 from pyramid.interfaces import (
@@ -21,21 +15,13 @@ from pyramid.interfaces import (
     IResponse,
     IViewMapper,
     IViewMapperFactory,
-    )
+)
 
-from pyramid.compat import (
-    is_bound_method,
-    is_unbound_method,
-    )
+from pyramid.compat import is_bound_method, is_unbound_method
 
-from pyramid.exceptions import (
-    ConfigurationError,
-    )
+from pyramid.exceptions import ConfigurationError
 from pyramid.httpexceptions import HTTPForbidden
-from pyramid.util import (
-    object_description,
-    takes_one_arg,
-)
+from pyramid.util import object_description, takes_one_arg
 from pyramid.view import render_view_to_response
 from pyramid import renderers
 
@@ -47,9 +33,11 @@ def view_description(view):
         # custom view mappers might not add __text__
         return object_description(view)
 
+
 def requestonly(view, attr=None):
     return takes_one_arg(view, attr=attr, argname='request')
 
+
 @implementer(IViewMapper)
 @provider(IViewMapperFactory)
 class DefaultViewMapper(object):
@@ -58,10 +46,12 @@ class DefaultViewMapper(object):
 
     def __call__(self, view):
         if is_unbound_method(view) and self.attr is None:
-            raise ConfigurationError((
-                'Unbound method calls are not supported, please set the class '
-                'as your `view` and the method as your `attr`'
-            ))
+            raise ConfigurationError(
+                (
+                    'Unbound method calls are not supported, please set the class '
+                    'as your `view` and the method as your `attr`'
+                )
+            )
 
         if inspect.isclass(view):
             view = self.map_class(view)
@@ -76,7 +66,9 @@ class DefaultViewMapper(object):
         else:
             mapped_view = self.map_class_native(view)
         mapped_view.__text__ = 'method %s of %s' % (
-            self.attr or '__call__', object_description(view))
+            self.attr or '__call__',
+            object_description(view),
+        )
         return mapped_view
 
     def map_nonclass(self, view):
@@ -98,11 +90,15 @@ class DefaultViewMapper(object):
             # bound method.
             if is_bound_method(view):
                 _mapped_view = mapped_view
+
                 def mapped_view(context, request):
                     return _mapped_view(context, request)
+
             if self.attr is not None:
                 mapped_view.__text__ = 'attr %s of %s' % (
-                    self.attr, object_description(view))
+                    self.attr,
+                    object_description(view),
+                )
             else:
                 mapped_view.__text__ = object_description(view)
         return mapped_view
@@ -110,6 +106,7 @@ class DefaultViewMapper(object):
     def map_class_requestonly(self, view):
         # its a class that has an __init__ which only accepts request
         attr = self.attr
+
         def _class_requestonly_view(context, request):
             inst = view(request)
             request.__view__ = inst
@@ -118,12 +115,14 @@ class DefaultViewMapper(object):
             else:
                 response = getattr(inst, attr)()
             return response
+
         return _class_requestonly_view
 
     def map_class_native(self, view):
         # its a class that has an __init__ which accepts both context and
         # request
         attr = self.attr
+
         def _class_view(context, request):
             inst = view(context, request)
             request.__view__ = inst
@@ -132,18 +131,21 @@ class DefaultViewMapper(object):
             else:
                 response = getattr(inst, attr)()
             return response
+
         return _class_view
 
     def map_nonclass_requestonly(self, view):
         # its a function that has a __call__ which accepts only a single
         # request argument
         attr = self.attr
+
         def _requestonly_view(context, request):
             if attr is None:
                 response = view(request)
             else:
                 response = getattr(view, attr)(request)
             return response
+
         return _requestonly_view
 
     def map_nonclass_attr(self, view):
@@ -152,6 +154,7 @@ class DefaultViewMapper(object):
         def _attr_view(context, request):
             response = getattr(view, self.attr)(context, request)
             return response
+
         return _attr_view
 
 
@@ -159,8 +162,10 @@ def wraps_view(wrapper):
     def inner(view, info):
         wrapper_view = wrapper(view, info)
         return preserve_view_attrs(view, wrapper_view)
+
     return inner
 
+
 def preserve_view_attrs(view, wrapper):
     if view is None:
         return wrapper
@@ -185,9 +190,16 @@ def preserve_view_attrs(view, wrapper):
 
     # attrs that may not exist on "view", but, if so, must be attached to
     # "wrapped view"
-    for attr in ('__permitted__', '__call_permissive__', '__permission__',
-                 '__predicated__', '__predicates__', '__accept__',
-                 '__order__', '__text__'):
+    for attr in (
+        '__permitted__',
+        '__call_permissive__',
+        '__permission__',
+        '__predicated__',
+        '__predicates__',
+        '__accept__',
+        '__order__',
+        '__text__',
+    ):
         try:
             setattr(wrapper, attr, getattr(view, attr))
         except AttributeError:
@@ -195,6 +207,7 @@ def preserve_view_attrs(view, wrapper):
 
     return wrapper
 
+
 def mapped_view(view, info):
     mapper = info.options.get('mapper')
     if mapper is None:
@@ -207,29 +220,37 @@ def mapped_view(view, info):
     mapped_view = mapper(**info.options)(view)
     return mapped_view
 
+
 mapped_view.options = ('mapper', 'attr')
 
+
 def owrapped_view(view, info):
     wrapper_viewname = info.options.get('wrapper')
     viewname = info.options.get('name')
     if not wrapper_viewname:
         return view
+
     def _owrapped_view(context, request):
         response = view(context, request)
         request.wrapped_response = response
         request.wrapped_body = response.body
         request.wrapped_view = view
-        wrapped_response = render_view_to_response(context, request,
-                                                   wrapper_viewname)
+        wrapped_response = render_view_to_response(
+            context, request, wrapper_viewname
+        )
         if wrapped_response is None:
             raise ValueError(
                 'No wrapper view named %r found when executing view '
-                'named %r' % (wrapper_viewname, viewname))
+                'named %r' % (wrapper_viewname, viewname)
+            )
         return wrapped_response
+
     return _owrapped_view
 
+
 owrapped_view.options = ('name', 'wrapper')
 
+
 def http_cached_view(view, info):
     if info.settings.get('prevent_http_cache', False):
         return view
@@ -247,27 +268,33 @@ def http_cached_view(view, info):
         except ValueError:
             raise ConfigurationError(
                 'If http_cache parameter is a tuple or list, it must be '
-                'in the form (seconds, options); not %s' % (seconds,))
+                'in the form (seconds, options); not %s' % (seconds,)
+            )
 
     def wrapper(context, request):
         response = view(context, request)
-        prevent_caching = getattr(response.cache_control, 'prevent_auto',
-                                  False)
+        prevent_caching = getattr(
+            response.cache_control, 'prevent_auto', False
+        )
         if not prevent_caching:
             response.cache_expires(seconds, **options)
         return response
 
     return wrapper
 
+
 http_cached_view.options = ('http_cache',)
 
+
 def secured_view(view, info):
     for wrapper in (_secured_view, _authdebug_view):
         view = wraps_view(wrapper)(view, info)
     return view
 
+
 secured_view.options = ('permission',)
 
+
 def _secured_view(view, info):
     permission = explicit_val = info.options.get('permission')
     if permission is None:
@@ -287,18 +314,23 @@ def _secured_view(view, info):
         return view
 
     if authn_policy and authz_policy and (permission is not None):
+
         def permitted(context, request):
             principals = authn_policy.effective_principals(request)
             return authz_policy.permits(context, principals, permission)
+
         def secured_view(context, request):
             result = permitted(context, request)
             if result:
                 return view(context, request)
             view_name = getattr(view, '__name__', view)
             msg = getattr(
-                request, 'authdebug_message',
-                'Unauthorized: %s failed permission check' % view_name)
+                request,
+                'authdebug_message',
+                'Unauthorized: %s failed permission check' % view_name,
+            )
             raise HTTPForbidden(msg, result=result)
+
         wrapped_view = secured_view
         wrapped_view.__call_permissive__ = view
         wrapped_view.__permitted__ = permitted
@@ -306,6 +338,7 @@ def _secured_view(view, info):
 
     return wrapped_view
 
+
 def _authdebug_view(view, info):
     wrapped_view = view
     settings = info.settings
@@ -321,6 +354,7 @@ def _authdebug_view(view, info):
         return view
 
     if settings and settings.get('debug_authorization', False):
+
         def authdebug_view(context, request):
             view_name = getattr(request, 'view_name', None)
 
@@ -331,24 +365,29 @@ def _authdebug_view(view, info):
                     msg = 'Allowed (no permission registered)'
                 else:
                     principals = authn_policy.effective_principals(request)
-                    msg = str(authz_policy.permits(
-                        context, principals, permission))
+                    msg = str(
+                        authz_policy.permits(context, principals, permission)
+                    )
             else:
                 msg = 'Allowed (no authorization policy in use)'
 
             view_name = getattr(request, 'view_name', None)
             url = getattr(request, 'url', None)
-            msg = ('debug_authorization of url %s (view name %r against '
-                   'context %r): %s' % (url, view_name, context, msg))
+            msg = (
+                'debug_authorization of url %s (view name %r against '
+                'context %r): %s' % (url, view_name, context, msg)
+            )
             if logger:
                 logger.debug(msg)
             if request is not None:
                 request.authdebug_message = msg
             return view(context, request)
+
         wrapped_view = authdebug_view
 
     return wrapped_view
 
+
 def rendered_view(view, info):
     # one way or another this wrapper must produce a Response (unless
     # the renderer is a NullRendererHelper)
@@ -360,23 +399,29 @@ def rendered_view(view, info):
         # a view registration.
         def viewresult_to_response(context, request):
             result = view(context, request)
-            if result.__class__ is Response: # common case
+            if result.__class__ is Response:  # common case
                 response = result
             else:
                 response = info.registry.queryAdapterOrSelf(result, IResponse)
                 if response is None:
                     if result is None:
-                        append = (' You may have forgotten to return a value '
-                                  'from the view callable.')
+                        append = (
+                            ' You may have forgotten to return a value '
+                            'from the view callable.'
+                        )
                     elif isinstance(result, dict):
-                        append = (' You may have forgotten to define a '
-                                  'renderer in the view configuration.')
+                        append = (
+                            ' You may have forgotten to define a '
+                            'renderer in the view configuration.'
+                        )
                     else:
                         append = ''
 
-                    msg = ('Could not convert return value of the view '
-                           'callable %s into a response object. '
-                           'The value returned was %r.' + append)
+                    msg = (
+                        'Could not convert return value of the view '
+                        'callable %s into a response object. '
+                        'The value returned was %r.' + append
+                    )
 
                     raise ValueError(msg % (view_description(view), result))
 
@@ -389,7 +434,7 @@ def rendered_view(view, info):
 
     def rendered_view(context, request):
         result = view(context, request)
-        if result.__class__ is Response: # potential common case
+        if result.__class__ is Response:  # potential common case
             response = result
         else:
             # this must adapt, it can't do a simple interface check
@@ -403,7 +448,8 @@ def rendered_view(view, info):
                     view_renderer = renderers.RendererHelper(
                         name=renderer_name,
                         package=info.package,
-                        registry=info.registry)
+                        registry=info.registry,
+                    )
                 else:
                     view_renderer = renderer.clone()
                 if '__view__' in attrs:
@@ -411,21 +457,26 @@ def rendered_view(view, info):
                 else:
                     view_inst = getattr(view, '__original_view__', view)
                 response = view_renderer.render_view(
-                    request, result, view_inst, context)
+                    request, result, view_inst, context
+                )
         return response
 
     return rendered_view
 
+
 rendered_view.options = ('renderer',)
 
+
 def decorated_view(view, info):
     decorator = info.options.get('decorator')
     if decorator is None:
         return view
     return decorator(view)
 
+
 decorated_view.options = ('decorator',)
 
+
 def csrf_view(view, info):
     explicit_val = info.options.get('require_csrf')
     defaults = info.registry.queryUtility(IDefaultCSRFOptions)
@@ -443,29 +494,29 @@ def csrf_view(view, info):
         callback = defaults.callback
 
     enabled = (
-        explicit_val is True or
+        explicit_val is True
+        or
         # fallback to the default val if not explicitly enabled
         # but only if the view is not an exception view
-        (
-            explicit_val is not False and default_val and
-            not info.exception_only
-        )
+        (explicit_val is not False and default_val and not info.exception_only)
     )
     # disable if both header and token are disabled
     enabled = enabled and (token or header)
     wrapped_view = view
     if enabled:
+
         def csrf_view(context, request):
-            if (
-                request.method not in safe_methods and
-                (callback is None or callback(request))
+            if request.method not in safe_methods and (
+                callback is None or callback(request)
             ):
                 check_csrf_origin(request, raises=True)
                 check_csrf_token(request, token, header, raises=True)
             return view(context, request)
+
         wrapped_view = csrf_view
     return wrapped_view
 
+
 csrf_view.options = ('require_csrf',)
 
 VIEW = 'VIEW'
diff --git a/src/pyramid/wsgi.py b/src/pyramid/wsgi.py
index 1c1bded32..b3f3803e4 100644
--- a/src/pyramid/wsgi.py
+++ b/src/pyramid/wsgi.py
@@ -1,6 +1,7 @@
 from functools import wraps
 from pyramid.request import call_app_with_subpath_as_path_info
 
+
 def wsgiapp(wrapped):
     """ Decorator to turn a WSGI application into a :app:`Pyramid`
     :term:`view callable`.  This decorator differs from the
@@ -41,6 +42,7 @@ def wsgiapp(wrapped):
         return wraps(wrapped)(decorator)
     return wraps(wrapped, ('__module__', '__doc__'))(decorator)
 
+
 def wsgiapp2(wrapped):
     """ Decorator to turn a WSGI application into a :app:`Pyramid`
     view callable.  This decorator differs from the
diff --git a/tests/__init__.py b/tests/__init__.py
index a62c29f47..944343e82 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -1,3 +1,2 @@
-
 def dummy_extend(*args):
     """used to test Configurator.extend"""
diff --git a/tests/pkgs/ccbugapp/__init__.py b/tests/pkgs/ccbugapp/__init__.py
index afe21d4e0..908a36e3e 100644
--- a/tests/pkgs/ccbugapp/__init__.py
+++ b/tests/pkgs/ccbugapp/__init__.py
@@ -1,16 +1,20 @@
 from webob import Response
 
+
 def rdf_view(request):
     """ """
     return Response('rdf')
 
+
 def juri_view(request):
     """ """
     return Response('juri')
 
+
 def includeme(config):
     config.add_route('rdf', 'licenses/:license_code/:license_version/rdf')
-    config.add_route('juri',
-                     'licenses/:license_code/:license_version/:jurisdiction')
+    config.add_route(
+        'juri', 'licenses/:license_code/:license_version/:jurisdiction'
+    )
     config.add_view(rdf_view, route_name='rdf')
     config.add_view(juri_view, route_name='juri')
diff --git a/tests/pkgs/conflictapp/__init__.py b/tests/pkgs/conflictapp/__init__.py
index d85aa0e1e..840813994 100644
--- a/tests/pkgs/conflictapp/__init__.py
+++ b/tests/pkgs/conflictapp/__init__.py
@@ -2,15 +2,19 @@ from pyramid.response import Response
 from pyramid.authentication import AuthTktAuthenticationPolicy
 from pyramid.authorization import ACLAuthorizationPolicy
 
+
 def aview(request):
     return Response('a view')
 
+
 def routeview(request):
     return Response('route view')
 
+
 def protectedview(request):
     return Response('protected view')
 
+
 def includeme(config):
     # purposely sorta-randomly ordered (route comes after view naming it,
     # authz comes after views)
@@ -18,7 +22,8 @@ def includeme(config):
     config.add_view(protectedview, name='protected', permission='view')
     config.add_view(routeview, route_name='aroute')
     config.add_route('aroute', '/route')
-    config.set_authentication_policy(AuthTktAuthenticationPolicy(
-        'seekri1t', hashalg='sha512'))
+    config.set_authentication_policy(
+        AuthTktAuthenticationPolicy('seekri1t', hashalg='sha512')
+    )
     config.set_authorization_policy(ACLAuthorizationPolicy())
     config.include('tests.pkgs.conflictapp.included')
diff --git a/tests/pkgs/conflictapp/included.py b/tests/pkgs/conflictapp/included.py
index 0b76fb2bc..5f483ff81 100644
--- a/tests/pkgs/conflictapp/included.py
+++ b/tests/pkgs/conflictapp/included.py
@@ -1,6 +1,9 @@
 from webob import Response
 
-def bview(request): return Response('b view')
+
+def bview(request):
+    return Response('b view')
+
 
 def includeme(config):
     config.add_view(bview)
diff --git a/tests/pkgs/defpermbugapp/__init__.py b/tests/pkgs/defpermbugapp/__init__.py
index 3e59aa623..81897e86a 100644
--- a/tests/pkgs/defpermbugapp/__init__.py
+++ b/tests/pkgs/defpermbugapp/__init__.py
@@ -2,25 +2,29 @@ from webob import Response
 from pyramid.security import NO_PERMISSION_REQUIRED
 from pyramid.view import view_config
 
+
 @view_config(name='x')
-def x_view(request): # pragma: no cover
-     return Response('this is private!')
+def x_view(request):  # pragma: no cover
+    return Response('this is private!')
+
 
 @view_config(name='y', permission='private2')
-def y_view(request): # pragma: no cover
-     return Response('this is private too!')
-     
+def y_view(request):  # pragma: no cover
+    return Response('this is private too!')
+
+
 @view_config(name='z', permission=NO_PERMISSION_REQUIRED)
 def z_view(request):
-     return Response('this is public')
+    return Response('this is public')
+
 
 def includeme(config):
-     from pyramid.authorization import ACLAuthorizationPolicy
-     from pyramid.authentication import AuthTktAuthenticationPolicy
-     authn_policy = AuthTktAuthenticationPolicy('seekt1t', hashalg='sha512')
-     authz_policy = ACLAuthorizationPolicy()
-     config.scan('tests.pkgs.defpermbugapp')
-     config._set_authentication_policy(authn_policy)
-     config._set_authorization_policy(authz_policy)
-     config.set_default_permission('private')
-     
+    from pyramid.authorization import ACLAuthorizationPolicy
+    from pyramid.authentication import AuthTktAuthenticationPolicy
+
+    authn_policy = AuthTktAuthenticationPolicy('seekt1t', hashalg='sha512')
+    authz_policy = ACLAuthorizationPolicy()
+    config.scan('tests.pkgs.defpermbugapp')
+    config._set_authentication_policy(authn_policy)
+    config._set_authorization_policy(authz_policy)
+    config.set_default_permission('private')
diff --git a/tests/pkgs/eventonly/__init__.py b/tests/pkgs/eventonly/__init__.py
index 452ae35a7..c48b539a1 100644
--- a/tests/pkgs/eventonly/__init__.py
+++ b/tests/pkgs/eventonly/__init__.py
@@ -1,6 +1,7 @@
 from pyramid.view import view_config
 from pyramid.events import subscriber
 
+
 class Yup(object):
     def __init__(self, val, config):
         self.val = val
@@ -13,37 +14,46 @@ class Yup(object):
     def __call__(self, event):
         return getattr(event.response, 'yup', False)
 
+
 class Foo(object):
     def __init__(self, response):
         self.response = response
 
+
 class Bar(object):
     pass
 
+
 @subscriber(Foo)
 def foo(event):
     event.response.text += 'foo '
 
+
 @subscriber(Foo, yup=True)
 def fooyup(event):
     event.response.text += 'fooyup '
-    
+
+
 @subscriber([Foo, Bar])
 def foobar(event):
     event.response.text += 'foobar '
 
+
 @subscriber([Foo, Bar])
 def foobar2(event, context):
     event.response.text += 'foobar2 '
 
+
 @subscriber([Foo, Bar], yup=True)
 def foobaryup(event):
     event.response.text += 'foobaryup '
 
+
 @subscriber([Foo, Bar], yup=True)
 def foobaryup2(event, context):
     event.response.text += 'foobaryup2 '
 
+
 @view_config(name='sendfoo')
 def sendfoo(request):
     response = request.response
@@ -51,6 +61,7 @@ def sendfoo(request):
     request.registry.notify(Foo(response))
     return response
 
+
 @view_config(name='sendfoobar')
 def sendfoobar(request):
     response = request.response
@@ -58,7 +69,7 @@ def sendfoobar(request):
     request.registry.notify(Foo(response), Bar())
     return response
 
+
 def includeme(config):
     config.add_subscriber_predicate('yup', Yup)
     config.scan('tests.pkgs.eventonly')
-    
diff --git a/tests/pkgs/exceptionviewapp/__init__.py b/tests/pkgs/exceptionviewapp/__init__.py
index ffc1b47c6..19804d242 100644
--- a/tests/pkgs/exceptionviewapp/__init__.py
+++ b/tests/pkgs/exceptionviewapp/__init__.py
@@ -1,31 +1,47 @@
 from pyramid.httpexceptions import HTTPException
 
+
 def includeme(config):
     config.add_route('route_raise_exception', 'route_raise_exception')
     config.add_route('route_raise_httpexception', 'route_raise_httpexception')
-    config.add_route('route_raise_exception2', 'route_raise_exception2',
-                     factory='.models.route_factory')
-    config.add_route('route_raise_exception3', 'route_raise_exception3',
-                    factory='.models.route_factory2')
+    config.add_route(
+        'route_raise_exception2',
+        'route_raise_exception2',
+        factory='.models.route_factory',
+    )
+    config.add_route(
+        'route_raise_exception3',
+        'route_raise_exception3',
+        factory='.models.route_factory2',
+    )
     config.add_route('route_raise_exception4', 'route_raise_exception4')
     config.add_view('.views.maybe')
     config.add_view('.views.no', context='.models.NotAnException')
     config.add_view('.views.yes', context=".models.AnException")
     config.add_view('.views.raise_exception', name='raise_exception')
-    config.add_view('.views.raise_exception',
-                    route_name='route_raise_exception')
-    config.add_view('.views.raise_exception',
-                    route_name='route_raise_exception2')
-    config.add_view('.views.raise_exception',
-                    route_name='route_raise_exception3')
-    config.add_view('.views.whoa', context='.models.AnException',
-                    route_name='route_raise_exception3')
-    config.add_view('.views.raise_exception',
-                    route_name='route_raise_exception4')
-    config.add_view('.views.whoa', context='.models.AnException',
-                    route_name='route_raise_exception4')
-    config.add_view('.views.raise_httpexception',
-                    route_name='route_raise_httpexception')
+    config.add_view(
+        '.views.raise_exception', route_name='route_raise_exception'
+    )
+    config.add_view(
+        '.views.raise_exception', route_name='route_raise_exception2'
+    )
+    config.add_view(
+        '.views.raise_exception', route_name='route_raise_exception3'
+    )
+    config.add_view(
+        '.views.whoa',
+        context='.models.AnException',
+        route_name='route_raise_exception3',
+    )
+    config.add_view(
+        '.views.raise_exception', route_name='route_raise_exception4'
+    )
+    config.add_view(
+        '.views.whoa',
+        context='.models.AnException',
+        route_name='route_raise_exception4',
+    )
+    config.add_view(
+        '.views.raise_httpexception', route_name='route_raise_httpexception'
+    )
     config.add_view('.views.catch_httpexception', context=HTTPException)
-    
-                    
diff --git a/tests/pkgs/exceptionviewapp/models.py b/tests/pkgs/exceptionviewapp/models.py
index fe407badc..25f8e9156 100644
--- a/tests/pkgs/exceptionviewapp/models.py
+++ b/tests/pkgs/exceptionviewapp/models.py
@@ -1,18 +1,22 @@
-
 class NotAnException(object):
     pass
 
+
 class AnException(Exception):
     pass
 
+
 class RouteContext(object):
     pass
 
+
 class RouteContext2(object):
     pass
 
+
 def route_factory(*arg):
     return RouteContext()
 
+
 def route_factory2(*arg):
     return RouteContext2()
diff --git a/tests/pkgs/exceptionviewapp/views.py b/tests/pkgs/exceptionviewapp/views.py
index 4953056bc..ca2c4fffb 100644
--- a/tests/pkgs/exceptionviewapp/views.py
+++ b/tests/pkgs/exceptionviewapp/views.py
@@ -2,23 +2,30 @@ from webob import Response
 from .models import AnException
 from pyramid.httpexceptions import HTTPBadRequest
 
+
 def no(request):
     return Response('no')
 
+
 def yes(request):
     return Response('yes')
-    
+
+
 def maybe(request):
     return Response('maybe')
 
+
 def whoa(request):
     return Response('whoa')
 
+
 def raise_exception(request):
     raise AnException()
 
+
 def raise_httpexception(request):
     raise HTTPBadRequest
 
+
 def catch_httpexception(request):
     return Response('caught')
diff --git a/tests/pkgs/fixtureapp/__init__.py b/tests/pkgs/fixtureapp/__init__.py
index 27063aae2..ffc8adb4a 100644
--- a/tests/pkgs/fixtureapp/__init__.py
+++ b/tests/pkgs/fixtureapp/__init__.py
@@ -3,10 +3,12 @@ def includeme(config):
     config.add_view('.views.exception_view', context=RuntimeError)
     config.add_view('.views.protected_view', name='protected.html')
     config.add_view('.views.erroneous_view', name='error.html')
-    config.add_view('.views.fixture_view', name='dummyskin.html',
-                    request_type='.views.IDummy')
+    config.add_view(
+        '.views.fixture_view',
+        name='dummyskin.html',
+        request_type='.views.IDummy',
+    )
     from .models import fixture, IFixture
+
     config.registry.registerUtility(fixture, IFixture)
     config.add_view('.views.fixture_view', name='another.html')
-
-    
diff --git a/tests/pkgs/fixtureapp/models.py b/tests/pkgs/fixtureapp/models.py
index d80d14bb3..5ad640df9 100644
--- a/tests/pkgs/fixtureapp/models.py
+++ b/tests/pkgs/fixtureapp/models.py
@@ -1,8 +1,9 @@
 from zope.interface import Interface
 
+
 class IFixture(Interface):
     pass
 
+
 def fixture():
     """ """
-
diff --git a/tests/pkgs/fixtureapp/subpackage/__init__.py b/tests/pkgs/fixtureapp/subpackage/__init__.py
index d3173e636..5bb534f79 100644
--- a/tests/pkgs/fixtureapp/subpackage/__init__.py
+++ b/tests/pkgs/fixtureapp/subpackage/__init__.py
@@ -1 +1 @@
-#package
+# package
diff --git a/tests/pkgs/fixtureapp/views.py b/tests/pkgs/fixtureapp/views.py
index cbfc5a574..78df81c6f 100644
--- a/tests/pkgs/fixtureapp/views.py
+++ b/tests/pkgs/fixtureapp/views.py
@@ -2,21 +2,26 @@ from zope.interface import Interface
 from webob import Response
 from pyramid.httpexceptions import HTTPForbidden
 
+
 def fixture_view(context, request):
     """ """
     return Response('fixture')
 
+
 def erroneous_view(context, request):
     """ """
     raise RuntimeError()
 
+
 def exception_view(context, request):
     """ """
     return Response('supressed')
 
+
 def protected_view(context, request):
     """ """
     raise HTTPForbidden()
 
+
 class IDummy(Interface):
     pass
diff --git a/tests/pkgs/forbiddenapp/__init__.py b/tests/pkgs/forbiddenapp/__init__.py
index c378126fc..9ebf62a9d 100644
--- a/tests/pkgs/forbiddenapp/__init__.py
+++ b/tests/pkgs/forbiddenapp/__init__.py
@@ -2,23 +2,27 @@ from webob import Response
 from pyramid.httpexceptions import HTTPForbidden
 from pyramid.compat import bytes_
 
-def x_view(request): # pragma: no cover
-     return Response('this is private!')
+
+def x_view(request):  # pragma: no cover
+    return Response('this is private!')
+
 
 def forbidden_view(context, request):
-     msg = context.message
-     result = context.result
-     message = msg + '\n' + str(result)
-     resp = HTTPForbidden()
-     resp.body = bytes_(message)
-     return resp
+    msg = context.message
+    result = context.result
+    message = msg + '\n' + str(result)
+    resp = HTTPForbidden()
+    resp.body = bytes_(message)
+    return resp
+
 
 def includeme(config):
-     from pyramid.authentication import AuthTktAuthenticationPolicy
-     from pyramid.authorization import ACLAuthorizationPolicy
-     authn_policy = AuthTktAuthenticationPolicy('seekr1t', hashalg='sha512')
-     authz_policy = ACLAuthorizationPolicy()
-     config._set_authentication_policy(authn_policy)
-     config._set_authorization_policy(authz_policy)
-     config.add_view(x_view, name='x', permission='private')
-     config.add_view(forbidden_view, context=HTTPForbidden)
+    from pyramid.authentication import AuthTktAuthenticationPolicy
+    from pyramid.authorization import ACLAuthorizationPolicy
+
+    authn_policy = AuthTktAuthenticationPolicy('seekr1t', hashalg='sha512')
+    authz_policy = ACLAuthorizationPolicy()
+    config._set_authentication_policy(authn_policy)
+    config._set_authorization_policy(authz_policy)
+    config.add_view(x_view, name='x', permission='private')
+    config.add_view(forbidden_view, context=HTTPForbidden)
diff --git a/tests/pkgs/forbiddenview/__init__.py b/tests/pkgs/forbiddenview/__init__.py
index 6b4c3c116..4c78d961c 100644
--- a/tests/pkgs/forbiddenview/__init__.py
+++ b/tests/pkgs/forbiddenview/__init__.py
@@ -3,22 +3,27 @@ from pyramid.response import Response
 from pyramid.authentication import AuthTktAuthenticationPolicy
 from pyramid.authorization import ACLAuthorizationPolicy
 
+
 @forbidden_view_config(route_name='foo')
-def foo_forbidden(request): # pragma: no cover
+def foo_forbidden(request):  # pragma: no cover
     return Response('foo_forbidden')
 
+
 @forbidden_view_config()
 def forbidden(request):
     return Response('generic_forbidden')
 
+
 @view_config(route_name='foo')
-def foo(request): # pragma: no cover
+def foo(request):  # pragma: no cover
     return Response('OK foo')
 
+
 @view_config(route_name='bar')
-def bar(request): # pragma: no cover
+def bar(request):  # pragma: no cover
     return Response('OK bar')
 
+
 def includeme(config):
     authn_policy = AuthTktAuthenticationPolicy('seekri1', hashalg='sha512')
     authz_policy = ACLAuthorizationPolicy()
@@ -28,4 +33,3 @@ def includeme(config):
     config.add_route('foo', '/foo')
     config.add_route('bar', '/bar')
     config.scan('tests.pkgs.forbiddenview')
-    
diff --git a/tests/pkgs/hybridapp/__init__.py b/tests/pkgs/hybridapp/__init__.py
index 1cc2dde83..001e1b882 100644
--- a/tests/pkgs/hybridapp/__init__.py
+++ b/tests/pkgs/hybridapp/__init__.py
@@ -1,39 +1,46 @@
 def includeme(config):
-  # <!-- we want this view to "win" -->
-  config.add_route('route', 'abc')
-  config.add_view('.views.route_view', route_name='route')
-  # <!-- .. even though this one has a more specific context -->
-  config.add_view('.views.global_view',
-                  context='pyramid.traversal.DefaultRootFactory')
-  config.add_view('.views.global2_view',
-                  context='pyramid.traversal.DefaultRootFactory',
-                  name='global2')
-  config.add_route('route2', 'def')
-  # <!-- we want this view to win for route2 even though global view with 
-  #     context is more specific -->
-  config.add_view('.views.route2_view', route_name='route2')
+    # <!-- we want this view to "win" -->
+    config.add_route('route', 'abc')
+    config.add_view('.views.route_view', route_name='route')
+    # <!-- .. even though this one has a more specific context -->
+    config.add_view(
+        '.views.global_view', context='pyramid.traversal.DefaultRootFactory'
+    )
+    config.add_view(
+        '.views.global2_view',
+        context='pyramid.traversal.DefaultRootFactory',
+        name='global2',
+    )
+    config.add_route('route2', 'def')
+    # <!-- we want this view to win for route2 even though global view with
+    #     context is more specific -->
+    config.add_view('.views.route2_view', route_name='route2')
 
-  # <!-- the global view should be found for this route -->
-  config.add_route('route3', 'ghi', use_global_views=True)
-  # <!-- the global view should not be found for this route -->
-  config.add_route('route4', 'jkl')
-  # <!-- the global view should not be found for this route (/global2) -->
-  config.add_route('route5', 'mno/*traverse')
-  # <!-- the global view should be found for this route (/global2) -->
-  config.add_route('route6', 'pqr/*traverse', use_global_views=True)
-  config.add_route('route7', 'error')
-  config.add_view('.views.erroneous_view', route_name='route7')
-  config.add_route('route8', 'error2')
-  config.add_view('.views.erroneous_view', route_name='route8')
-  # <!-- we want this view to "win" for route7 as exception view -->
-  config.add_view('.views.exception_view', context=RuntimeError)
-  # <!-- we want this view to "win" for route8 as exception view-->
-  config.add_view('.views.exception2_view', context=RuntimeError,
-                  route_name='route8')
-  config.add_route('route9', 'error_sub')
-  config.add_view('.views.erroneous_sub_view', route_name='route9')
-  # <!-- we want this view to "win" for route9 as exception view... -->
-  config.add_view('.views.exception2_view', context='.views.SuperException',
-                  route_name='route9')
-  # <!-- ...even if we have more context-specialized view for exception -->
-  config.add_view('.views.exception_view', context='.views.SubException')
+    # <!-- the global view should be found for this route -->
+    config.add_route('route3', 'ghi', use_global_views=True)
+    # <!-- the global view should not be found for this route -->
+    config.add_route('route4', 'jkl')
+    # <!-- the global view should not be found for this route (/global2) -->
+    config.add_route('route5', 'mno/*traverse')
+    # <!-- the global view should be found for this route (/global2) -->
+    config.add_route('route6', 'pqr/*traverse', use_global_views=True)
+    config.add_route('route7', 'error')
+    config.add_view('.views.erroneous_view', route_name='route7')
+    config.add_route('route8', 'error2')
+    config.add_view('.views.erroneous_view', route_name='route8')
+    # <!-- we want this view to "win" for route7 as exception view -->
+    config.add_view('.views.exception_view', context=RuntimeError)
+    # <!-- we want this view to "win" for route8 as exception view-->
+    config.add_view(
+        '.views.exception2_view', context=RuntimeError, route_name='route8'
+    )
+    config.add_route('route9', 'error_sub')
+    config.add_view('.views.erroneous_sub_view', route_name='route9')
+    # <!-- we want this view to "win" for route9 as exception view... -->
+    config.add_view(
+        '.views.exception2_view',
+        context='.views.SuperException',
+        route_name='route9',
+    )
+    # <!-- ...even if we have more context-specialized view for exception -->
+    config.add_view('.views.exception_view', context='.views.SubException')
diff --git a/tests/pkgs/hybridapp/views.py b/tests/pkgs/hybridapp/views.py
index 135ef8290..695a79531 100644
--- a/tests/pkgs/hybridapp/views.py
+++ b/tests/pkgs/hybridapp/views.py
@@ -1,39 +1,49 @@
 from webob import Response
 
+
 def route_view(request):
     """ """
     return Response('route')
 
+
 def global_view(request):
     """ """
     return Response('global')
 
+
 def global2_view(request):
     """ """
     return Response('global2')
 
+
 def route2_view(request):
     """ """
     return Response('route2')
 
+
 def exception_view(request):
     """ """
     return Response('supressed')
 
+
 def exception2_view(request):
     """ """
     return Response('supressed2')
 
+
 def erroneous_view(request):
     """ """
     raise RuntimeError()
 
+
 def erroneous_sub_view(request):
     """ """
     raise SubException()
 
+
 class SuperException(Exception):
     """ """
 
+
 class SubException(SuperException):
     """ """
diff --git a/tests/pkgs/includeapp1/root.py b/tests/pkgs/includeapp1/root.py
index 986356d81..369ab9f38 100644
--- a/tests/pkgs/includeapp1/root.py
+++ b/tests/pkgs/includeapp1/root.py
@@ -1,10 +1,11 @@
 from pyramid.response import Response
 
+
 def aview(request):
     return Response('root')
 
+
 def configure(config):
     config.add_view(aview)
     config.include('tests.pkgs.includeapp1.two.configure')
     config.commit()
-    
diff --git a/tests/pkgs/includeapp1/three.py b/tests/pkgs/includeapp1/three.py
index 973f91d99..b8d881244 100644
--- a/tests/pkgs/includeapp1/three.py
+++ b/tests/pkgs/includeapp1/three.py
@@ -1,10 +1,11 @@
 from pyramid.response import Response
 
+
 def aview(request):
     return Response('three')
 
+
 def configure(config):
     config.add_view(aview, name='three')
-    config.include('tests.pkgs.includeapp1.two.configure') # should not cycle
-    config.add_view(aview) # will be overridden by root when resolved
-    
+    config.include('tests.pkgs.includeapp1.two.configure')  # should not cycle
+    config.add_view(aview)  # will be overridden by root when resolved
diff --git a/tests/pkgs/includeapp1/two.py b/tests/pkgs/includeapp1/two.py
index 6b8bb5539..727161c8e 100644
--- a/tests/pkgs/includeapp1/two.py
+++ b/tests/pkgs/includeapp1/two.py
@@ -1,9 +1,11 @@
 from pyramid.response import Response
 
+
 def aview(request):
     return Response('two')
 
+
 def configure(config):
     config.add_view(aview, name='two')
     config.include('tests.pkgs.includeapp1.three.configure')
-    config.add_view(aview) # will be overridden by root when resolved
+    config.add_view(aview)  # will be overridden by root when resolved
diff --git a/tests/pkgs/notfoundview/__init__.py b/tests/pkgs/notfoundview/__init__.py
index 8ba3ff9ed..f606ec671 100644
--- a/tests/pkgs/notfoundview/__init__.py
+++ b/tests/pkgs/notfoundview/__init__.py
@@ -1,30 +1,35 @@
 from pyramid.view import notfound_view_config, view_config
 from pyramid.response import Response
 
+
 @notfound_view_config(route_name='foo', append_slash=True)
-def foo_notfound(request): # pragma: no cover
+def foo_notfound(request):  # pragma: no cover
     return Response('foo_notfound')
 
+
 @notfound_view_config(route_name='baz')
 def baz_notfound(request):
     return Response('baz_notfound')
 
+
 @notfound_view_config(append_slash=True)
 def notfound(request):
     return Response('generic_notfound')
 
+
 @view_config(route_name='bar')
 def bar(request):
     return Response('OK bar')
 
+
 @view_config(route_name='foo2')
 def foo2(request):
     return Response('OK foo2')
 
+
 def includeme(config):
     config.add_route('foo', '/foo')
     config.add_route('foo2', '/foo/')
     config.add_route('bar', '/bar/')
     config.add_route('baz', '/baz')
     config.scan('tests.pkgs.notfoundview')
-    
diff --git a/tests/pkgs/permbugapp/__init__.py b/tests/pkgs/permbugapp/__init__.py
index 4868427a5..aedd405f8 100644
--- a/tests/pkgs/permbugapp/__init__.py
+++ b/tests/pkgs/permbugapp/__init__.py
@@ -2,21 +2,26 @@ from pyramid.compat import escape
 from pyramid.security import view_execution_permitted
 from pyramid.response import Response
 
-def x_view(request): # pragma: no cover
-     return Response('this is private!')
+
+def x_view(request):  # pragma: no cover
+    return Response('this is private!')
+
 
 def test(context, request):
     # should return false
-     msg = 'Allow ./x? %s' % repr(view_execution_permitted(
-         context, request, 'x'))
-     return Response(escape(msg))
+    msg = 'Allow ./x? %s' % repr(
+        view_execution_permitted(context, request, 'x')
+    )
+    return Response(escape(msg))
+
 
 def includeme(config):
-     from pyramid.authentication import AuthTktAuthenticationPolicy
-     from pyramid.authorization import ACLAuthorizationPolicy
-     authn_policy = AuthTktAuthenticationPolicy('seekt1t', hashalg='sha512')
-     authz_policy = ACLAuthorizationPolicy()
-     config.set_authentication_policy(authn_policy)
-     config.set_authorization_policy(authz_policy)
-     config.add_view(test, name='test')
-     config.add_view(x_view, name='x', permission='private')
+    from pyramid.authentication import AuthTktAuthenticationPolicy
+    from pyramid.authorization import ACLAuthorizationPolicy
+
+    authn_policy = AuthTktAuthenticationPolicy('seekt1t', hashalg='sha512')
+    authz_policy = ACLAuthorizationPolicy()
+    config.set_authentication_policy(authn_policy)
+    config.set_authorization_policy(authz_policy)
+    config.add_view(test, name='test')
+    config.add_view(x_view, name='x', permission='private')
diff --git a/tests/pkgs/rendererscanapp/__init__.py b/tests/pkgs/rendererscanapp/__init__.py
index f3276a063..1fc831e66 100644
--- a/tests/pkgs/rendererscanapp/__init__.py
+++ b/tests/pkgs/rendererscanapp/__init__.py
@@ -1,9 +1,10 @@
 from pyramid.view import view_config
 
+
 @view_config(name='one', renderer='json')
 def one(request):
-    return {'name':'One!'}
+    return {'name': 'One!'}
+
 
 def includeme(config):
     config.scan()
-    
diff --git a/tests/pkgs/rendererscanapp/two/__init__.py b/tests/pkgs/rendererscanapp/two/__init__.py
index 6f575dd83..7d3990317 100644
--- a/tests/pkgs/rendererscanapp/two/__init__.py
+++ b/tests/pkgs/rendererscanapp/two/__init__.py
@@ -1,6 +1,6 @@
 from pyramid.view import view_config
 
+
 @view_config(name='two', renderer='json')
 def two(request):
-    return {'nameagain':'Two!'}
-
+    return {'nameagain': 'Two!'}
diff --git a/tests/pkgs/restbugapp/__init__.py b/tests/pkgs/restbugapp/__init__.py
index 9ad79e32e..ae0a80f01 100644
--- a/tests/pkgs/restbugapp/__init__.py
+++ b/tests/pkgs/restbugapp/__init__.py
@@ -1,15 +1,19 @@
 def includeme(config):
-    config.add_route('gameactions_pet_get_pets', '/pet',
-                     request_method='GET')
-    config.add_route('gameactions_pet_care_for_pet', '/pet',
-                     request_method='POST')
-    config.add_view('.views.PetRESTView',
-                    route_name='gameactions_pet_get_pets',
-                    attr='GET',
-                    permission='view',
-                    renderer='json')
-    config.add_view('.views.PetRESTView',
-                    route_name='gameactions_pet_care_for_pet',
-                    attr='POST',
-                    permission='view',
-                    renderer='json')
+    config.add_route('gameactions_pet_get_pets', '/pet', request_method='GET')
+    config.add_route(
+        'gameactions_pet_care_for_pet', '/pet', request_method='POST'
+    )
+    config.add_view(
+        '.views.PetRESTView',
+        route_name='gameactions_pet_get_pets',
+        attr='GET',
+        permission='view',
+        renderer='json',
+    )
+    config.add_view(
+        '.views.PetRESTView',
+        route_name='gameactions_pet_care_for_pet',
+        attr='POST',
+        permission='view',
+        renderer='json',
+    )
diff --git a/tests/pkgs/restbugapp/views.py b/tests/pkgs/restbugapp/views.py
index 2ace59fa9..161321aed 100644
--- a/tests/pkgs/restbugapp/views.py
+++ b/tests/pkgs/restbugapp/views.py
@@ -1,15 +1,17 @@
 from pyramid.response import Response
 
+
 class BaseRESTView(object):
     def __init__(self, context, request):
         self.context = context
         self.request = request
-        
+
+
 class PetRESTView(BaseRESTView):
     """ REST Controller to control action of an avatar """
+
     def __init__(self, context, request):
         super(PetRESTView, self).__init__(context, request)
 
     def GET(self):
         return Response('gotten')
-    
diff --git a/tests/pkgs/static_abspath/__init__.py b/tests/pkgs/static_abspath/__init__.py
index 812cca467..0c875b96f 100644
--- a/tests/pkgs/static_abspath/__init__.py
+++ b/tests/pkgs/static_abspath/__init__.py
@@ -1,7 +1,7 @@
 import os
 
+
 def includeme(config):
-    here =  here = os.path.dirname(__file__)
+    here = here = os.path.dirname(__file__)
     fixtures = os.path.normpath(os.path.join(here, '..', '..', 'fixtures'))
     config.add_static_view('/', fixtures)
-
diff --git a/tests/pkgs/static_assetspec/__init__.py b/tests/pkgs/static_assetspec/__init__.py
index dcb438aff..e7d3e9373 100644
--- a/tests/pkgs/static_assetspec/__init__.py
+++ b/tests/pkgs/static_assetspec/__init__.py
@@ -1,3 +1,2 @@
 def includeme(config):
     config.add_static_view('/', 'tests:fixtures')
-
diff --git a/tests/pkgs/static_routeprefix/__init__.py b/tests/pkgs/static_routeprefix/__init__.py
index 6a3a80712..f64f31292 100644
--- a/tests/pkgs/static_routeprefix/__init__.py
+++ b/tests/pkgs/static_routeprefix/__init__.py
@@ -2,6 +2,6 @@ def includeme(config):
     config.add_static_view('/static', 'tests:fixtures')
     config.include(includeme2, route_prefix='/prefix')
 
+
 def includeme2(config):
     config.add_static_view('/static', 'tests:fixtures/static')
-
diff --git a/tests/pkgs/staticpermapp/__init__.py b/tests/pkgs/staticpermapp/__init__.py
index b5038260f..ffc87d39a 100644
--- a/tests/pkgs/staticpermapp/__init__.py
+++ b/tests/pkgs/staticpermapp/__init__.py
@@ -1,25 +1,32 @@
 class RootFactory(object):
     __acl__ = [('Allow', 'fred', 'view')]
+
     def __init__(self, request):
         pass
 
+
 class LocalRootFactory(object):
     __acl__ = [('Allow', 'bob', 'view')]
+
     def __init__(self, request):
         pass
-    
+
 
 def includeme(config):
-     from pyramid.authentication import RemoteUserAuthenticationPolicy
-     from pyramid.authorization import ACLAuthorizationPolicy
-     authn_policy = RemoteUserAuthenticationPolicy()
-     authz_policy = ACLAuthorizationPolicy()
-     config._set_authentication_policy(authn_policy)
-     config._set_authorization_policy(authz_policy)
-     config.add_static_view('allowed', 'tests:fixtures/static/')
-     config.add_static_view('protected', 'tests:fixtures/static/',
-                            permission='view')
-     config.add_static_view('factory_protected',
-                            'tests:fixtures/static/',
-                            permission='view',
-                            factory=LocalRootFactory)
+    from pyramid.authentication import RemoteUserAuthenticationPolicy
+    from pyramid.authorization import ACLAuthorizationPolicy
+
+    authn_policy = RemoteUserAuthenticationPolicy()
+    authz_policy = ACLAuthorizationPolicy()
+    config._set_authentication_policy(authn_policy)
+    config._set_authorization_policy(authz_policy)
+    config.add_static_view('allowed', 'tests:fixtures/static/')
+    config.add_static_view(
+        'protected', 'tests:fixtures/static/', permission='view'
+    )
+    config.add_static_view(
+        'factory_protected',
+        'tests:fixtures/static/',
+        permission='view',
+        factory=LocalRootFactory,
+    )
diff --git a/tests/pkgs/subrequestapp/__init__.py b/tests/pkgs/subrequestapp/__init__.py
index e4b1d386a..261af6434 100644
--- a/tests/pkgs/subrequestapp/__init__.py
+++ b/tests/pkgs/subrequestapp/__init__.py
@@ -1,26 +1,31 @@
 from pyramid.config import Configurator
 from pyramid.request import Request
 
+
 def view_one(request):
     subreq = Request.blank('/view_two')
     response = request.invoke_subrequest(subreq, use_tweens=False)
     return response
 
+
 def view_two(request):
     # check that request.foo is valid for a subrequest
     return 'This came from view_two, foo=%s' % (request.foo,)
 
+
 def view_three(request):
     subreq = Request.blank('/view_four')
     try:
         return request.invoke_subrequest(subreq, use_tweens=True)
-    except: # pragma: no cover
+    except:  # pragma: no cover
         request.response.body = b'Value error raised'
         return request.response
 
+
 def view_four(request):
     raise ValueError('foo')
 
+
 def view_five(request):
     subreq = Request.blank('/view_four')
     try:
@@ -29,11 +34,13 @@ def view_five(request):
         request.response.body = b'Value error raised'
         return request.response
 
+
 def excview(request):
     request.response.status_int = 500
     request.response.body = b'Bad stuff happened'
     return request.response
 
+
 def main():
     config = Configurator()
     config.add_route('one', '/view_one')
@@ -49,4 +56,3 @@ def main():
     config.add_view(view_five, route_name='five')
     config.add_request_method(lambda r: 'bar', 'foo', property=True)
     return config
-
diff --git a/tests/pkgs/viewdecoratorapp/__init__.py b/tests/pkgs/viewdecoratorapp/__init__.py
index 099bd29d5..99b7ea9c7 100644
--- a/tests/pkgs/viewdecoratorapp/__init__.py
+++ b/tests/pkgs/viewdecoratorapp/__init__.py
@@ -1,3 +1,2 @@
 def includeme(config):
     config.scan('tests.pkgs.viewdecoratorapp')
-    
diff --git a/tests/pkgs/viewdecoratorapp/views/views.py b/tests/pkgs/viewdecoratorapp/views/views.py
index 18ec78847..6879acd2b 100644
--- a/tests/pkgs/viewdecoratorapp/views/views.py
+++ b/tests/pkgs/viewdecoratorapp/views/views.py
@@ -1,12 +1,11 @@
 from pyramid.view import view_config
 
+
 @view_config(renderer='json', name='first')
 def first(request):
-    return {'result':'OK1'}
+    return {'result': 'OK1'}
 
-@view_config(
-    renderer='json',
-             name='second')
-def second(request):
-    return {'result':'OK2'}
 
+@view_config(renderer='json', name='second')
+def second(request):
+    return {'result': 'OK2'}
diff --git a/tests/pkgs/wsgiapp2app/__init__.py b/tests/pkgs/wsgiapp2app/__init__.py
index e2024198e..f7452f52c 100644
--- a/tests/pkgs/wsgiapp2app/__init__.py
+++ b/tests/pkgs/wsgiapp2app/__init__.py
@@ -1,6 +1,7 @@
 from pyramid.view import view_config
 from pyramid.wsgi import wsgiapp2
 
+
 @view_config(name='hello', renderer='string')
 @wsgiapp2
 def hello(environ, start_response):
@@ -10,8 +11,10 @@ def hello(environ, start_response):
     start_response('200 OK', response_headers)
     return [b'Hello!']
 
+
 def main():
     from pyramid.config import Configurator
+
     c = Configurator()
     c.scan()
     return c
diff --git a/tests/test_asset.py b/tests/test_asset.py
index cddeb48df..55a3c0336 100644
--- a/tests/test_asset.py
+++ b/tests/test_asset.py
@@ -3,9 +3,11 @@ import os
 
 here = os.path.abspath(os.path.dirname(__file__))
 
+
 class Test_resolve_asset_spec(unittest.TestCase):
     def _callFUT(self, spec, package_name='__main__'):
         from pyramid.resource import resolve_asset_spec
+
         return resolve_asset_spec(spec, package_name)
 
     def test_abspath(self):
@@ -19,7 +21,7 @@ class Test_resolve_asset_spec(unittest.TestCase):
         package_name, filename = self._callFUT(path, pkg)
         self.assertEqual(package_name, 'tests')
         self.assertEqual(filename, 'test_asset.py')
-        
+
     def test_abs_spec(self):
         pkg = 'tests'
         path = 'pyramid.nottests:test_asset.py'
@@ -36,6 +38,7 @@ class Test_resolve_asset_spec(unittest.TestCase):
 
     def test_package_name_is_package_object(self):
         import tests
+
         pkg = tests
         path = 'test_asset.py'
         package_name, filename = self._callFUT(path, pkg)
@@ -46,6 +49,7 @@ class Test_resolve_asset_spec(unittest.TestCase):
 class Test_abspath_from_asset_spec(unittest.TestCase):
     def _callFUT(self, spec, pname='__main__'):
         from pyramid.resource import abspath_from_asset_spec
+
         return abspath_from_asset_spec(spec, pname)
 
     def test_pname_is_None_before_resolve_asset_spec(self):
@@ -60,9 +64,11 @@ class Test_abspath_from_asset_spec(unittest.TestCase):
         result = self._callFUT('abc', 'tests')
         self.assertEqual(result, os.path.join(here, 'abc'))
 
+
 class Test_asset_spec_from_abspath(unittest.TestCase):
     def _callFUT(self, abspath, package):
         from pyramid.asset import asset_spec_from_abspath
+
         return asset_spec_from_abspath(abspath, package)
 
     def test_package_name_is_main(self):
@@ -82,7 +88,7 @@ class Test_asset_spec_from_abspath(unittest.TestCase):
         result = self._callFUT(here, pkg)
         self.assertEqual(result, here)
 
+
 class DummyPackage:
     def __init__(self, name):
         self.__name__ = name
-    
diff --git a/tests/test_authentication.py b/tests/test_authentication.py
index 4fbc3fe2e..fc3e60587 100644
--- a/tests/test_authentication.py
+++ b/tests/test_authentication.py
@@ -1,14 +1,13 @@
 import unittest
 import warnings
 from pyramid import testing
-from pyramid.compat import (
-    text_,
-    bytes_,
-    )
+from pyramid.compat import text_, bytes_
+
 
 class TestCallbackAuthenticationPolicyDebugging(unittest.TestCase):
     def setUp(self):
         from pyramid.interfaces import IDebugLogger
+
         self.config = testing.setUp()
         self.config.registry.registerUtility(self, IDebugLogger)
         self.messages = []
@@ -21,9 +20,11 @@ class TestCallbackAuthenticationPolicyDebugging(unittest.TestCase):
 
     def _makeOne(self, userid=None, callback=None):
         from pyramid.authentication import CallbackAuthenticationPolicy
+
         class MyAuthenticationPolicy(CallbackAuthenticationPolicy):
             def unauthenticated_userid(self, request):
                 return userid
+
         policy = MyAuthenticationPolicy()
         policy.debug = True
         policy.callback = callback
@@ -38,7 +39,8 @@ class TestCallbackAuthenticationPolicyDebugging(unittest.TestCase):
             self.messages[0],
             'tests.test_authentication.MyAuthenticationPolicy.'
             'authenticated_userid: call to unauthenticated_userid returned '
-            'None; returning None')
+            'None; returning None',
+        )
 
     def test_authenticated_userid_no_callback(self):
         request = DummyRequest(registry=self.config.registry)
@@ -47,14 +49,17 @@ class TestCallbackAuthenticationPolicyDebugging(unittest.TestCase):
         self.assertEqual(len(self.messages), 1)
         self.assertEqual(
             self.messages[0],
-             "tests.test_authentication.MyAuthenticationPolicy."
+            "tests.test_authentication.MyAuthenticationPolicy."
             "authenticated_userid: there was no groupfinder callback; "
-            "returning 'fred'")
+            "returning 'fred'",
+        )
 
     def test_authenticated_userid_with_callback_fail(self):
         request = DummyRequest(registry=self.config.registry)
+
         def callback(userid, request):
             return None
+
         policy = self._makeOne(userid='fred', callback=callback)
         self.assertEqual(policy.authenticated_userid(request), None)
         self.assertEqual(len(self.messages), 1)
@@ -62,12 +67,15 @@ class TestCallbackAuthenticationPolicyDebugging(unittest.TestCase):
             self.messages[0],
             'tests.test_authentication.MyAuthenticationPolicy.'
             'authenticated_userid: groupfinder callback returned None; '
-            'returning None')
+            'returning None',
+        )
 
     def test_authenticated_userid_with_callback_success(self):
         request = DummyRequest(registry=self.config.registry)
+
         def callback(userid, request):
             return []
+
         policy = self._makeOne(userid='fred', callback=callback)
         self.assertEqual(policy.authenticated_userid(request), 'fred')
         self.assertEqual(len(self.messages), 1)
@@ -75,7 +83,8 @@ class TestCallbackAuthenticationPolicyDebugging(unittest.TestCase):
             self.messages[0],
             "tests.test_authentication.MyAuthenticationPolicy."
             "authenticated_userid: groupfinder callback returned []; "
-            "returning 'fred'")
+            "returning 'fred'",
+        )
 
     def test_authenticated_userid_fails_cleaning_as_Authenticated(self):
         request = DummyRequest(registry=self.config.registry)
@@ -87,7 +96,8 @@ class TestCallbackAuthenticationPolicyDebugging(unittest.TestCase):
             "tests.test_authentication.MyAuthenticationPolicy."
             "authenticated_userid: use of userid 'system.Authenticated' is "
             "disallowed by any built-in Pyramid security policy, returning "
-            "None")
+            "None",
+        )
 
     def test_authenticated_userid_fails_cleaning_as_Everyone(self):
         request = DummyRequest(registry=self.config.registry)
@@ -99,107 +109,127 @@ class TestCallbackAuthenticationPolicyDebugging(unittest.TestCase):
             "tests.test_authentication.MyAuthenticationPolicy."
             "authenticated_userid: use of userid 'system.Everyone' is "
             "disallowed by any built-in Pyramid security policy, returning "
-            "None")
+            "None",
+        )
 
     def test_effective_principals_no_unauthenticated_userid(self):
         request = DummyRequest(registry=self.config.registry)
         policy = self._makeOne()
-        self.assertEqual(policy.effective_principals(request),
-                         ['system.Everyone'])
+        self.assertEqual(
+            policy.effective_principals(request), ['system.Everyone']
+        )
         self.assertEqual(len(self.messages), 1)
         self.assertEqual(
             self.messages[0],
             "tests.test_authentication.MyAuthenticationPolicy."
             "effective_principals: unauthenticated_userid returned None; "
-            "returning ['system.Everyone']")
+            "returning ['system.Everyone']",
+        )
 
     def test_effective_principals_no_callback(self):
         request = DummyRequest(registry=self.config.registry)
         policy = self._makeOne(userid='fred')
         self.assertEqual(
             policy.effective_principals(request),
-            ['system.Everyone', 'system.Authenticated', 'fred'])
+            ['system.Everyone', 'system.Authenticated', 'fred'],
+        )
         self.assertEqual(len(self.messages), 2)
         self.assertEqual(
             self.messages[0],
             'tests.test_authentication.MyAuthenticationPolicy.'
             'effective_principals: groupfinder callback is None, so groups '
-            'is []')
+            'is []',
+        )
         self.assertEqual(
             self.messages[1],
             "tests.test_authentication.MyAuthenticationPolicy."
             "effective_principals: returning effective principals: "
-            "['system.Everyone', 'system.Authenticated', 'fred']")
+            "['system.Everyone', 'system.Authenticated', 'fred']",
+        )
 
     def test_effective_principals_with_callback_fail(self):
         request = DummyRequest(registry=self.config.registry)
+
         def callback(userid, request):
             return None
+
         policy = self._makeOne(userid='fred', callback=callback)
         self.assertEqual(
-            policy.effective_principals(request), ['system.Everyone'])
+            policy.effective_principals(request), ['system.Everyone']
+        )
         self.assertEqual(len(self.messages), 2)
         self.assertEqual(
             self.messages[0],
             'tests.test_authentication.MyAuthenticationPolicy.'
             'effective_principals: groupfinder callback returned None as '
-            'groups')
+            'groups',
+        )
         self.assertEqual(
             self.messages[1],
             "tests.test_authentication.MyAuthenticationPolicy."
             "effective_principals: returning effective principals: "
-            "['system.Everyone']")
+            "['system.Everyone']",
+        )
 
     def test_effective_principals_with_callback_success(self):
         request = DummyRequest(registry=self.config.registry)
+
         def callback(userid, request):
             return []
+
         policy = self._makeOne(userid='fred', callback=callback)
         self.assertEqual(
             policy.effective_principals(request),
-            ['system.Everyone', 'system.Authenticated', 'fred'])
+            ['system.Everyone', 'system.Authenticated', 'fred'],
+        )
         self.assertEqual(len(self.messages), 2)
         self.assertEqual(
             self.messages[0],
             'tests.test_authentication.MyAuthenticationPolicy.'
-            'effective_principals: groupfinder callback returned [] as groups')
+            'effective_principals: groupfinder callback returned [] as groups',
+        )
         self.assertEqual(
             self.messages[1],
             "tests.test_authentication.MyAuthenticationPolicy."
             "effective_principals: returning effective principals: "
-            "['system.Everyone', 'system.Authenticated', 'fred']")
+            "['system.Everyone', 'system.Authenticated', 'fred']",
+        )
 
     def test_effective_principals_with_unclean_principal_Authenticated(self):
         request = DummyRequest(registry=self.config.registry)
         policy = self._makeOne(userid='system.Authenticated')
         self.assertEqual(
-            policy.effective_principals(request),
-            ['system.Everyone'])
+            policy.effective_principals(request), ['system.Everyone']
+        )
         self.assertEqual(len(self.messages), 1)
         self.assertEqual(
             self.messages[0],
             "tests.test_authentication.MyAuthenticationPolicy."
             "effective_principals: unauthenticated_userid returned disallowed "
             "'system.Authenticated'; returning ['system.Everyone'] as if it "
-            "was None")
+            "was None",
+        )
 
     def test_effective_principals_with_unclean_principal_Everyone(self):
         request = DummyRequest(registry=self.config.registry)
         policy = self._makeOne(userid='system.Everyone')
         self.assertEqual(
-            policy.effective_principals(request),
-            ['system.Everyone'])
+            policy.effective_principals(request), ['system.Everyone']
+        )
         self.assertEqual(len(self.messages), 1)
         self.assertEqual(
             self.messages[0],
             "tests.test_authentication.MyAuthenticationPolicy."
             "effective_principals: unauthenticated_userid returned disallowed "
             "'system.Everyone'; returning ['system.Everyone'] as if it "
-            "was None")
+            "was None",
+        )
+
 
 class TestRepozeWho1AuthenticationPolicy(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.authentication import RepozeWho1AuthenticationPolicy
+
         return RepozeWho1AuthenticationPolicy
 
     def _makeOne(self, identifier_name='auth_tkt', callback=None):
@@ -208,11 +238,13 @@ class TestRepozeWho1AuthenticationPolicy(unittest.TestCase):
     def test_class_implements_IAuthenticationPolicy(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IAuthenticationPolicy
+
         verifyClass(IAuthenticationPolicy, self._getTargetClass())
 
     def test_instance_implements_IAuthenticationPolicy(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IAuthenticationPolicy
+
         verifyObject(IAuthenticationPolicy, self._makeOne())
 
     def test_unauthenticated_userid_returns_None(self):
@@ -222,7 +254,8 @@ class TestRepozeWho1AuthenticationPolicy(unittest.TestCase):
 
     def test_unauthenticated_userid(self):
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'fred'}})
+            {'repoze.who.identity': {'repoze.who.userid': 'fred'}}
+        )
         policy = self._makeOne()
         self.assertEqual(policy.unauthenticated_userid(request), 'fred')
 
@@ -233,48 +266,61 @@ class TestRepozeWho1AuthenticationPolicy(unittest.TestCase):
 
     def test_authenticated_userid(self):
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'fred'}})
+            {'repoze.who.identity': {'repoze.who.userid': 'fred'}}
+        )
         policy = self._makeOne()
         self.assertEqual(policy.authenticated_userid(request), 'fred')
 
     def test_authenticated_userid_repoze_who_userid_is_None(self):
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':None}})
+            {'repoze.who.identity': {'repoze.who.userid': None}}
+        )
         policy = self._makeOne()
         self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_authenticated_userid_with_callback_returns_None(self):
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'fred'}})
+            {'repoze.who.identity': {'repoze.who.userid': 'fred'}}
+        )
+
         def callback(identity, request):
             return None
+
         policy = self._makeOne(callback=callback)
         self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_authenticated_userid_with_callback_returns_something(self):
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'fred'}})
+            {'repoze.who.identity': {'repoze.who.userid': 'fred'}}
+        )
+
         def callback(identity, request):
             return ['agroup']
+
         policy = self._makeOne(callback=callback)
         self.assertEqual(policy.authenticated_userid(request), 'fred')
 
     def test_authenticated_userid_unclean_principal_Authenticated(self):
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'system.Authenticated'}}
-            )
+            {
+                'repoze.who.identity': {
+                    'repoze.who.userid': 'system.Authenticated'
+                }
+            }
+        )
         policy = self._makeOne()
         self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_authenticated_userid_unclean_principal_Everyone(self):
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'system.Everyone'}}
-            )
+            {'repoze.who.identity': {'repoze.who.userid': 'system.Everyone'}}
+        )
         policy = self._makeOne()
         self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_effective_principals_None(self):
         from pyramid.security import Everyone
+
         request = DummyRequest({})
         policy = self._makeOne()
         self.assertEqual(policy.effective_principals(request), [Everyone])
@@ -282,56 +328,86 @@ class TestRepozeWho1AuthenticationPolicy(unittest.TestCase):
     def test_effective_principals_userid_only(self):
         from pyramid.security import Everyone
         from pyramid.security import Authenticated
+
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'fred'}})
+            {'repoze.who.identity': {'repoze.who.userid': 'fred'}}
+        )
         policy = self._makeOne()
-        self.assertEqual(policy.effective_principals(request),
-                         [Everyone, Authenticated, 'fred'])
+        self.assertEqual(
+            policy.effective_principals(request),
+            [Everyone, Authenticated, 'fred'],
+        )
 
     def test_effective_principals_userid_and_groups(self):
         from pyramid.security import Everyone
         from pyramid.security import Authenticated
+
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'fred',
-                                    'groups':['quux', 'biz']}})
+            {
+                'repoze.who.identity': {
+                    'repoze.who.userid': 'fred',
+                    'groups': ['quux', 'biz'],
+                }
+            }
+        )
+
         def callback(identity, request):
             return identity['groups']
+
         policy = self._makeOne(callback=callback)
-        self.assertEqual(policy.effective_principals(request),
-                         [Everyone, Authenticated, 'fred', 'quux', 'biz'])
+        self.assertEqual(
+            policy.effective_principals(request),
+            [Everyone, Authenticated, 'fred', 'quux', 'biz'],
+        )
 
     def test_effective_principals_userid_callback_returns_None(self):
         from pyramid.security import Everyone
+
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'fred',
-                                    'groups':['quux', 'biz']}})
+            {
+                'repoze.who.identity': {
+                    'repoze.who.userid': 'fred',
+                    'groups': ['quux', 'biz'],
+                }
+            }
+        )
+
         def callback(identity, request):
             return None
+
         policy = self._makeOne(callback=callback)
         self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals_repoze_who_userid_is_None(self):
         from pyramid.security import Everyone
+
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':None}}
-            )
+            {'repoze.who.identity': {'repoze.who.userid': None}}
+        )
         policy = self._makeOne()
         self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals_repoze_who_userid_is_unclean_Everyone(self):
         from pyramid.security import Everyone
+
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'system.Everyone'}}
-            )
+            {'repoze.who.identity': {'repoze.who.userid': 'system.Everyone'}}
+        )
         policy = self._makeOne()
         self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals_repoze_who_userid_is_unclean_Authenticated(
-        self):
+        self
+    ):
         from pyramid.security import Everyone
+
         request = DummyRequest(
-            {'repoze.who.identity':{'repoze.who.userid':'system.Authenticated'}}
-            )
+            {
+                'repoze.who.identity': {
+                    'repoze.who.userid': 'system.Authenticated'
+                }
+            }
+        )
         policy = self._makeOne()
         self.assertEqual(policy.effective_principals(request), [Everyone])
 
@@ -343,20 +419,20 @@ class TestRepozeWho1AuthenticationPolicy(unittest.TestCase):
 
     def test_remember(self):
         authtkt = DummyWhoPlugin()
-        request = DummyRequest(
-            {'repoze.who.plugins':{'auth_tkt':authtkt}})
+        request = DummyRequest({'repoze.who.plugins': {'auth_tkt': authtkt}})
         policy = self._makeOne()
         result = policy.remember(request, 'fred')
         self.assertEqual(result[0], request.environ)
-        self.assertEqual(result[1], {'repoze.who.userid':'fred'})
+        self.assertEqual(result[1], {'repoze.who.userid': 'fred'})
 
     def test_remember_kwargs(self):
         authtkt = DummyWhoPlugin()
-        request = DummyRequest(
-            {'repoze.who.plugins':{'auth_tkt':authtkt}})
+        request = DummyRequest({'repoze.who.plugins': {'auth_tkt': authtkt}})
         policy = self._makeOne()
         result = policy.remember(request, 'fred', max_age=23)
-        self.assertEqual(result[1], {'repoze.who.userid':'fred', 'max_age': 23})
+        self.assertEqual(
+            result[1], {'repoze.who.userid': 'fred', 'max_age': 23}
+        )
 
     def test_forget_no_plugins(self):
         request = DummyRequest({})
@@ -367,17 +443,21 @@ class TestRepozeWho1AuthenticationPolicy(unittest.TestCase):
     def test_forget(self):
         authtkt = DummyWhoPlugin()
         request = DummyRequest(
-            {'repoze.who.plugins':{'auth_tkt':authtkt},
-             'repoze.who.identity':{'repoze.who.userid':'fred'},
-             })
+            {
+                'repoze.who.plugins': {'auth_tkt': authtkt},
+                'repoze.who.identity': {'repoze.who.userid': 'fred'},
+            }
+        )
         policy = self._makeOne()
         result = policy.forget(request)
         self.assertEqual(result[0], request.environ)
         self.assertEqual(result[1], request.environ['repoze.who.identity'])
 
+
 class TestRemoteUserAuthenticationPolicy(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.authentication import RemoteUserAuthenticationPolicy
+
         return RemoteUserAuthenticationPolicy
 
     def _makeOne(self, environ_key='REMOTE_USER', callback=None):
@@ -386,11 +466,13 @@ class TestRemoteUserAuthenticationPolicy(unittest.TestCase):
     def test_class_implements_IAuthenticationPolicy(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IAuthenticationPolicy
+
         verifyClass(IAuthenticationPolicy, self._getTargetClass())
 
     def test_instance_implements_IAuthenticationPolicy(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IAuthenticationPolicy
+
         verifyObject(IAuthenticationPolicy, self._makeOne())
 
     def test_unauthenticated_userid_returns_None(self):
@@ -399,7 +481,7 @@ class TestRemoteUserAuthenticationPolicy(unittest.TestCase):
         self.assertEqual(policy.unauthenticated_userid(request), None)
 
     def test_unauthenticated_userid(self):
-        request = DummyRequest({'REMOTE_USER':'fred'})
+        request = DummyRequest({'REMOTE_USER': 'fred'})
         policy = self._makeOne()
         self.assertEqual(policy.unauthenticated_userid(request), 'fred')
 
@@ -409,12 +491,13 @@ class TestRemoteUserAuthenticationPolicy(unittest.TestCase):
         self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_authenticated_userid(self):
-        request = DummyRequest({'REMOTE_USER':'fred'})
+        request = DummyRequest({'REMOTE_USER': 'fred'})
         policy = self._makeOne()
         self.assertEqual(policy.authenticated_userid(request), 'fred')
 
     def test_effective_principals_None(self):
         from pyramid.security import Everyone
+
         request = DummyRequest({})
         policy = self._makeOne()
         self.assertEqual(policy.effective_principals(request), [Everyone])
@@ -422,26 +505,31 @@ class TestRemoteUserAuthenticationPolicy(unittest.TestCase):
     def test_effective_principals(self):
         from pyramid.security import Everyone
         from pyramid.security import Authenticated
-        request = DummyRequest({'REMOTE_USER':'fred'})
+
+        request = DummyRequest({'REMOTE_USER': 'fred'})
         policy = self._makeOne()
-        self.assertEqual(policy.effective_principals(request),
-                         [Everyone, Authenticated, 'fred'])
+        self.assertEqual(
+            policy.effective_principals(request),
+            [Everyone, Authenticated, 'fred'],
+        )
 
     def test_remember(self):
-        request = DummyRequest({'REMOTE_USER':'fred'})
+        request = DummyRequest({'REMOTE_USER': 'fred'})
         policy = self._makeOne()
         result = policy.remember(request, 'fred')
         self.assertEqual(result, [])
 
     def test_forget(self):
-        request = DummyRequest({'REMOTE_USER':'fred'})
+        request = DummyRequest({'REMOTE_USER': 'fred'})
         policy = self._makeOne()
         result = policy.forget(request)
         self.assertEqual(result, [])
 
+
 class TestAuthTktAuthenticationPolicy(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.authentication import AuthTktAuthenticationPolicy
+
         return AuthTktAuthenticationPolicy
 
     def _makeOne(self, callback, cookieidentity, **kw):
@@ -460,10 +548,16 @@ class TestAuthTktAuthenticationPolicy(unittest.TestCase):
     def test_allargs(self):
         # pass all known args
         inst = self._getTargetClass()(
-            'secret', callback=None, cookie_name=None, secure=False,
-            include_ip=False, timeout=None, reissue_time=None,
-            hashalg='sha512', samesite=None,
-            )
+            'secret',
+            callback=None,
+            cookie_name=None,
+            secure=False,
+            include_ip=False,
+            timeout=None,
+            reissue_time=None,
+            hashalg='sha512',
+            samesite=None,
+        )
         self.assertEqual(inst.callback, None)
 
     def test_hashalg_override(self):
@@ -477,8 +571,8 @@ class TestAuthTktAuthenticationPolicy(unittest.TestCase):
         self.assertEqual(policy.unauthenticated_userid(request), None)
 
     def test_unauthenticated_userid(self):
-        request = DummyRequest({'REMOTE_USER':'fred'})
-        policy = self._makeOne(None, {'userid':'fred'})
+        request = DummyRequest({'REMOTE_USER': 'fred'})
+        policy = self._makeOne(None, {'userid': 'fred'})
         self.assertEqual(policy.unauthenticated_userid(request), 'fred')
 
     def test_authenticated_userid_no_cookie_identity(self):
@@ -488,41 +582,54 @@ class TestAuthTktAuthenticationPolicy(unittest.TestCase):
 
     def test_authenticated_userid_callback_returns_None(self):
         request = DummyRequest({})
+
         def callback(userid, request):
             return None
-        policy = self._makeOne(callback, {'userid':'fred'})
+
+        policy = self._makeOne(callback, {'userid': 'fred'})
         self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_authenticated_userid(self):
         request = DummyRequest({})
+
         def callback(userid, request):
             return True
-        policy = self._makeOne(callback, {'userid':'fred'})
+
+        policy = self._makeOne(callback, {'userid': 'fred'})
         self.assertEqual(policy.authenticated_userid(request), 'fred')
 
     def test_effective_principals_no_cookie_identity(self):
         from pyramid.security import Everyone
+
         request = DummyRequest({})
         policy = self._makeOne(None, None)
         self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals_callback_returns_None(self):
         from pyramid.security import Everyone
+
         request = DummyRequest({})
+
         def callback(userid, request):
             return None
-        policy = self._makeOne(callback, {'userid':'fred'})
+
+        policy = self._makeOne(callback, {'userid': 'fred'})
         self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals(self):
         from pyramid.security import Everyone
         from pyramid.security import Authenticated
+
         request = DummyRequest({})
+
         def callback(userid, request):
             return ['group.foo']
-        policy = self._makeOne(callback, {'userid':'fred'})
-        self.assertEqual(policy.effective_principals(request),
-                             [Everyone, Authenticated, 'fred', 'group.foo'])
+
+        policy = self._makeOne(callback, {'userid': 'fred'})
+        self.assertEqual(
+            policy.effective_principals(request),
+            [Everyone, Authenticated, 'fred', 'group.foo'],
+        )
 
     def test_remember(self):
         request = DummyRequest({})
@@ -534,7 +641,7 @@ class TestAuthTktAuthenticationPolicy(unittest.TestCase):
         request = DummyRequest({})
         policy = self._makeOne(None, None)
         result = policy.remember(request, 'fred', a=1, b=2)
-        self.assertEqual(policy.cookie.kw, {'a':1, 'b':2})
+        self.assertEqual(policy.cookie.kw, {'a': 1, 'b': 2})
         self.assertEqual(result, [])
 
     def test_forget(self):
@@ -546,16 +653,20 @@ class TestAuthTktAuthenticationPolicy(unittest.TestCase):
     def test_class_implements_IAuthenticationPolicy(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IAuthenticationPolicy
+
         verifyClass(IAuthenticationPolicy, self._getTargetClass())
 
     def test_instance_implements_IAuthenticationPolicy(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IAuthenticationPolicy
+
         verifyObject(IAuthenticationPolicy, self._makeOne(None, None))
 
+
 class TestAuthTktCookieHelper(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.authentication import AuthTktCookieHelper
+
         return AuthTktCookieHelper
 
     def _makeOne(self, *arg, **kw):
@@ -570,7 +681,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         return helper
 
     def _makeRequest(self, cookie=None, ipv6=False):
-        environ = {'wsgi.version': (1,0)}
+        environ = {'wsgi.version': (1, 0)}
 
         if ipv6 is False:
             environ['REMOTE_ADDR'] = '1.1.1.1'
@@ -588,7 +699,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         return D
 
     def _parseHeaders(self, headers):
-        return [ self._parseHeader(header) for header in headers ]
+        return [self._parseHeader(header) for header in headers]
 
     def _parseHeader(self, header):
         cookie = self._parseCookie(header[1])
@@ -596,18 +707,25 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
     def _parseCookie(self, cookie):
         from pyramid.compat import SimpleCookie
+
         cookies = SimpleCookie()
         cookies.load(cookie)
         return cookies.get('auth_tkt')
 
     def test_init_cookie_str_reissue_invalid(self):
-        self.assertRaises(ValueError, self._makeOne, 'secret', reissue_time='invalid value')
+        self.assertRaises(
+            ValueError, self._makeOne, 'secret', reissue_time='invalid value'
+        )
 
     def test_init_cookie_str_timeout_invalid(self):
-        self.assertRaises(ValueError, self._makeOne, 'secret', timeout='invalid value')
+        self.assertRaises(
+            ValueError, self._makeOne, 'secret', timeout='invalid value'
+        )
 
     def test_init_cookie_str_max_age_invalid(self):
-        self.assertRaises(ValueError, self._makeOne, 'secret', max_age='invalid value')
+        self.assertRaises(
+            ValueError, self._makeOne, 'secret', max_age='invalid value'
+        )
 
     def test_identify_nocookie(self):
         helper = self._makeOne('secret')
@@ -635,8 +753,8 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(helper.auth_tkt.secret, 'secret')
         environ = request.environ
         self.assertEqual(environ['REMOTE_USER_TOKENS'], ())
-        self.assertEqual(environ['REMOTE_USER_DATA'],'')
-        self.assertEqual(environ['AUTH_TYPE'],'cookie')
+        self.assertEqual(environ['REMOTE_USER_DATA'], '')
+        self.assertEqual(environ['AUTH_TYPE'], 'cookie')
 
     def test_identify_good_cookie_include_ipv6(self):
         helper = self._makeOne('secret', include_ip=True)
@@ -652,8 +770,8 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(helper.auth_tkt.secret, 'secret')
         environ = request.environ
         self.assertEqual(environ['REMOTE_USER_TOKENS'], ())
-        self.assertEqual(environ['REMOTE_USER_DATA'],'')
-        self.assertEqual(environ['AUTH_TYPE'],'cookie')
+        self.assertEqual(environ['REMOTE_USER_DATA'], '')
+        self.assertEqual(environ['AUTH_TYPE'], 'cookie')
 
     def test_identify_good_cookie_dont_include_ip(self):
         helper = self._makeOne('secret', include_ip=False)
@@ -669,8 +787,8 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(helper.auth_tkt.secret, 'secret')
         environ = request.environ
         self.assertEqual(environ['REMOTE_USER_TOKENS'], ())
-        self.assertEqual(environ['REMOTE_USER_DATA'],'')
-        self.assertEqual(environ['AUTH_TYPE'],'cookie')
+        self.assertEqual(environ['REMOTE_USER_DATA'], '')
+        self.assertEqual(environ['AUTH_TYPE'], 'cookie')
 
     def test_identify_good_cookie_int_useridtype(self):
         helper = self._makeOne('secret', include_ip=False)
@@ -685,8 +803,8 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(result['timestamp'], 0)
         environ = request.environ
         self.assertEqual(environ['REMOTE_USER_TOKENS'], ())
-        self.assertEqual(environ['REMOTE_USER_DATA'],'userid_type:int')
-        self.assertEqual(environ['AUTH_TYPE'],'cookie')
+        self.assertEqual(environ['REMOTE_USER_DATA'], 'userid_type:int')
+        self.assertEqual(environ['AUTH_TYPE'], 'cookie')
 
     def test_identify_nonuseridtype_user_data(self):
         helper = self._makeOne('secret', include_ip=False)
@@ -701,8 +819,8 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(result['timestamp'], 0)
         environ = request.environ
         self.assertEqual(environ['REMOTE_USER_TOKENS'], ())
-        self.assertEqual(environ['REMOTE_USER_DATA'],'bogus:int')
-        self.assertEqual(environ['AUTH_TYPE'],'cookie')
+        self.assertEqual(environ['REMOTE_USER_DATA'], 'bogus:int')
+        self.assertEqual(environ['AUTH_TYPE'], 'cookie')
 
     def test_identify_good_cookie_unknown_useridtype(self):
         helper = self._makeOne('secret', include_ip=False)
@@ -717,11 +835,12 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(result['timestamp'], 0)
         environ = request.environ
         self.assertEqual(environ['REMOTE_USER_TOKENS'], ())
-        self.assertEqual(environ['REMOTE_USER_DATA'],'userid_type:unknown')
-        self.assertEqual(environ['AUTH_TYPE'],'cookie')
+        self.assertEqual(environ['REMOTE_USER_DATA'], 'userid_type:unknown')
+        self.assertEqual(environ['AUTH_TYPE'], 'cookie')
 
     def test_identify_good_cookie_b64str_useridtype(self):
         from base64 import b64encode
+
         helper = self._makeOne('secret', include_ip=False)
         helper.auth_tkt.userid = b64encode(b'encoded').strip()
         helper.auth_tkt.user_data = 'userid_type:b64str'
@@ -734,11 +853,12 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(result['timestamp'], 0)
         environ = request.environ
         self.assertEqual(environ['REMOTE_USER_TOKENS'], ())
-        self.assertEqual(environ['REMOTE_USER_DATA'],'userid_type:b64str')
-        self.assertEqual(environ['AUTH_TYPE'],'cookie')
+        self.assertEqual(environ['REMOTE_USER_DATA'], 'userid_type:b64str')
+        self.assertEqual(environ['AUTH_TYPE'], 'cookie')
 
     def test_identify_good_cookie_b64unicode_useridtype(self):
         from base64 import b64encode
+
         helper = self._makeOne('secret', include_ip=False)
         helper.auth_tkt.userid = b64encode(b'\xc3\xa9ncoded').strip()
         helper.auth_tkt.user_data = 'userid_type:b64unicode'
@@ -751,8 +871,8 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(result['timestamp'], 0)
         environ = request.environ
         self.assertEqual(environ['REMOTE_USER_TOKENS'], ())
-        self.assertEqual(environ['REMOTE_USER_DATA'],'userid_type:b64unicode')
-        self.assertEqual(environ['AUTH_TYPE'],'cookie')
+        self.assertEqual(environ['REMOTE_USER_DATA'], 'userid_type:b64unicode')
+        self.assertEqual(environ['AUTH_TYPE'], 'cookie')
 
     def test_identify_bad_cookie(self):
         helper = self._makeOne('secret', include_ip=True)
@@ -771,22 +891,24 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
     def test_identify_cookie_timeout_aged(self):
         import time
+
         helper = self._makeOne('secret', timeout=10)
         now = time.time()
         helper.auth_tkt.timestamp = now - 1
         helper.now = now + 10
-        helper.auth_tkt.tokens = (text_('a'), )
+        helper.auth_tkt.tokens = (text_('a'),)
         request = self._makeRequest('bogus')
         result = helper.identify(request)
         self.assertFalse(result)
 
     def test_identify_cookie_reissue(self):
         import time
+
         helper = self._makeOne('secret', timeout=10, reissue_time=0)
         now = time.time()
         helper.auth_tkt.timestamp = now
         helper.now = now + 1
-        helper.auth_tkt.tokens = (text_('a'), )
+        helper.auth_tkt.tokens = (text_('a'),)
         request = self._makeRequest('bogus')
         result = helper.identify(request)
         self.assertTrue(result)
@@ -798,11 +920,12 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
     def test_identify_cookie_str_reissue(self):
         import time
+
         helper = self._makeOne('secret', timeout=10, reissue_time='0')
         now = time.time()
         helper.auth_tkt.timestamp = now
         helper.now = now + 1
-        helper.auth_tkt.tokens = (text_('a'), )
+        helper.auth_tkt.tokens = (text_('a'),)
         request = self._makeRequest('bogus')
         result = helper.identify(request)
         self.assertTrue(result)
@@ -814,6 +937,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
     def test_identify_cookie_reissue_already_reissued_this_request(self):
         import time
+
         helper = self._makeOne('secret', timeout=10, reissue_time=0)
         now = time.time()
         helper.auth_tkt.timestamp = now
@@ -826,6 +950,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
     def test_identify_cookie_reissue_notyet(self):
         import time
+
         helper = self._makeOne('secret', timeout=10, reissue_time=10)
         now = time.time()
         helper.auth_tkt.timestamp = now
@@ -837,6 +962,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
     def test_identify_cookie_reissue_revoked_by_forget(self):
         import time
+
         helper = self._makeOne('secret', timeout=10, reissue_time=0)
         now = time.time()
         helper.auth_tkt.timestamp = now
@@ -854,6 +980,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
     def test_identify_cookie_reissue_revoked_by_remember(self):
         import time
+
         helper = self._makeOne('secret', timeout=10, reissue_time=0)
         now = time.time()
         helper.auth_tkt.timestamp = now
@@ -872,6 +999,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
     def test_identify_cookie_reissue_with_tokens_default(self):
         # see https://github.com/Pylons/pyramid/issues#issue/108
         import time
+
         helper = self._makeOne('secret', timeout=10, reissue_time=0)
         auth_tkt = DummyAuthTktModule(tokens=[''])
         helper.auth_tkt = auth_tkt
@@ -902,13 +1030,15 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertTrue(result[0][1].startswith('auth_tkt='))
 
         self.assertEqual(result[1][0], 'Set-Cookie')
-        self.assertTrue(result[1][1].endswith(
-            '; Domain=localhost; Path=/; SameSite=Lax'))
+        self.assertTrue(
+            result[1][1].endswith('; Domain=localhost; Path=/; SameSite=Lax')
+        )
         self.assertTrue(result[1][1].startswith('auth_tkt='))
 
         self.assertEqual(result[2][0], 'Set-Cookie')
-        self.assertTrue(result[2][1].endswith(
-            '; Domain=.localhost; Path=/; SameSite=Lax'))
+        self.assertTrue(
+            result[2][1].endswith('; Domain=.localhost; Path=/; SameSite=Lax')
+        )
         self.assertTrue(result[2][1].startswith('auth_tkt='))
 
     def test_remember_nondefault_samesite(self):
@@ -922,13 +1052,19 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertTrue(result[0][1].startswith('auth_tkt='))
 
         self.assertEqual(result[1][0], 'Set-Cookie')
-        self.assertTrue(result[1][1].endswith(
-            '; Domain=localhost; Path=/; SameSite=Strict'))
+        self.assertTrue(
+            result[1][1].endswith(
+                '; Domain=localhost; Path=/; SameSite=Strict'
+            )
+        )
         self.assertTrue(result[1][1].startswith('auth_tkt='))
 
         self.assertEqual(result[2][0], 'Set-Cookie')
-        self.assertTrue(result[2][1].endswith(
-            '; Domain=.localhost; Path=/; SameSite=Strict'))
+        self.assertTrue(
+            result[2][1].endswith(
+                '; Domain=.localhost; Path=/; SameSite=Strict'
+            )
+        )
         self.assertTrue(result[2][1].startswith('auth_tkt='))
 
     def test_remember_None_samesite(self):
@@ -938,17 +1074,15 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(len(result), 3)
 
         self.assertEqual(result[0][0], 'Set-Cookie')
-        self.assertTrue(result[0][1].endswith('; Path=/')) # no samesite
+        self.assertTrue(result[0][1].endswith('; Path=/'))  # no samesite
         self.assertTrue(result[0][1].startswith('auth_tkt='))
 
         self.assertEqual(result[1][0], 'Set-Cookie')
-        self.assertTrue(result[1][1].endswith(
-            '; Domain=localhost; Path=/'))
+        self.assertTrue(result[1][1].endswith('; Domain=localhost; Path=/'))
         self.assertTrue(result[1][1].startswith('auth_tkt='))
 
         self.assertEqual(result[2][0], 'Set-Cookie')
-        self.assertTrue(result[2][1].endswith(
-            '; Domain=.localhost; Path=/'))
+        self.assertTrue(result[2][1].endswith('; Domain=.localhost; Path=/'))
         self.assertTrue(result[2][1].startswith('auth_tkt='))
 
     def test_remember_include_ip(self):
@@ -962,35 +1096,45 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertTrue(result[0][1].startswith('auth_tkt='))
 
         self.assertEqual(result[1][0], 'Set-Cookie')
-        self.assertTrue(result[1][1].endswith(
-            '; Domain=localhost; Path=/; SameSite=Lax'))
+        self.assertTrue(
+            result[1][1].endswith('; Domain=localhost; Path=/; SameSite=Lax')
+        )
         self.assertTrue(result[1][1].startswith('auth_tkt='))
 
         self.assertEqual(result[2][0], 'Set-Cookie')
-        self.assertTrue(result[2][1].endswith(
-            '; Domain=.localhost; Path=/; SameSite=Lax'))
+        self.assertTrue(
+            result[2][1].endswith('; Domain=.localhost; Path=/; SameSite=Lax')
+        )
         self.assertTrue(result[2][1].startswith('auth_tkt='))
 
     def test_remember_path(self):
-        helper = self._makeOne('secret', include_ip=True,
-                               path="/cgi-bin/app.cgi/")
+        helper = self._makeOne(
+            'secret', include_ip=True, path="/cgi-bin/app.cgi/"
+        )
         request = self._makeRequest()
         result = helper.remember(request, 'other')
         self.assertEqual(len(result), 3)
 
         self.assertEqual(result[0][0], 'Set-Cookie')
-        self.assertTrue(result[0][1].endswith(
-            '; Path=/cgi-bin/app.cgi/; SameSite=Lax'))
+        self.assertTrue(
+            result[0][1].endswith('; Path=/cgi-bin/app.cgi/; SameSite=Lax')
+        )
         self.assertTrue(result[0][1].startswith('auth_tkt='))
 
         self.assertEqual(result[1][0], 'Set-Cookie')
-        self.assertTrue(result[1][1].endswith(
-            '; Domain=localhost; Path=/cgi-bin/app.cgi/; SameSite=Lax'))
+        self.assertTrue(
+            result[1][1].endswith(
+                '; Domain=localhost; Path=/cgi-bin/app.cgi/; SameSite=Lax'
+            )
+        )
         self.assertTrue(result[1][1].startswith('auth_tkt='))
 
         self.assertEqual(result[2][0], 'Set-Cookie')
-        self.assertTrue(result[2][1].endswith(
-            '; Domain=.localhost; Path=/cgi-bin/app.cgi/; SameSite=Lax'))
+        self.assertTrue(
+            result[2][1].endswith(
+                '; Domain=.localhost; Path=/cgi-bin/app.cgi/; SameSite=Lax'
+            )
+        )
         self.assertTrue(result[2][1].startswith('auth_tkt='))
 
     def test_remember_http_only(self):
@@ -1040,8 +1184,9 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertTrue(result[0][1].startswith('auth_tkt='))
 
         self.assertEqual(result[1][0], 'Set-Cookie')
-        self.assertTrue(result[1][1].endswith(
-            '; Domain=localhost; Path=/; SameSite=Lax'))
+        self.assertTrue(
+            result[1][1].endswith('; Domain=localhost; Path=/; SameSite=Lax')
+        )
         self.assertTrue(result[1][1].startswith('auth_tkt='))
 
     def test_remember_parent_domain(self):
@@ -1052,8 +1197,11 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(len(result), 1)
 
         self.assertEqual(result[0][0], 'Set-Cookie')
-        self.assertTrue(result[0][1].endswith(
-            '; Domain=.example.com; Path=/; SameSite=Lax'))
+        self.assertTrue(
+            result[0][1].endswith(
+                '; Domain=.example.com; Path=/; SameSite=Lax'
+            )
+        )
         self.assertTrue(result[0][1].startswith('auth_tkt='))
 
     def test_remember_parent_domain_supercedes_wild_domain(self):
@@ -1062,8 +1210,11 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         request.domain = 'www.example.com'
         result = helper.remember(request, 'other')
         self.assertEqual(len(result), 1)
-        self.assertTrue(result[0][1].endswith(
-            '; Domain=.example.com; Path=/; SameSite=Lax'))
+        self.assertTrue(
+            result[0][1].endswith(
+                '; Domain=.example.com; Path=/; SameSite=Lax'
+            )
+        )
 
     def test_remember_explicit_domain(self):
         helper = self._makeOne('secret', domain='pyramid.bazinga')
@@ -1073,30 +1224,42 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(len(result), 1)
 
         self.assertEqual(result[0][0], 'Set-Cookie')
-        self.assertTrue(result[0][1].endswith(
-                '; Domain=pyramid.bazinga; Path=/; SameSite=Lax'))
+        self.assertTrue(
+            result[0][1].endswith(
+                '; Domain=pyramid.bazinga; Path=/; SameSite=Lax'
+            )
+        )
         self.assertTrue(result[0][1].startswith('auth_tkt='))
 
     def test_remember_domain_supercedes_parent_and_wild_domain(self):
-        helper = self._makeOne('secret', domain='pyramid.bazinga',
-                parent_domain=True, wild_domain=True)
+        helper = self._makeOne(
+            'secret',
+            domain='pyramid.bazinga',
+            parent_domain=True,
+            wild_domain=True,
+        )
         request = self._makeRequest()
         request.domain = 'www.example.com'
         result = helper.remember(request, 'other')
         self.assertEqual(len(result), 1)
-        self.assertTrue(result[0][1].endswith(
-                '; Domain=pyramid.bazinga; Path=/; SameSite=Lax'))
+        self.assertTrue(
+            result[0][1].endswith(
+                '; Domain=pyramid.bazinga; Path=/; SameSite=Lax'
+            )
+        )
 
     def test_remember_binary_userid(self):
         import base64
+
         helper = self._makeOne('secret')
         request = self._makeRequest()
         result = helper.remember(request, b'userid')
         values = self._parseHeaders(result)
         self.assertEqual(len(result), 3)
         val = self._cookieValue(values[0])
-        self.assertEqual(val['userid'],
-                         text_(base64.b64encode(b'userid').strip()))
+        self.assertEqual(
+            val['userid'], text_(base64.b64encode(b'userid').strip())
+        )
         self.assertEqual(val['user_data'], 'userid_type:b64str')
 
     def test_remember_int_userid(self):
@@ -1111,6 +1274,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
     def test_remember_long_userid(self):
         from pyramid.compat import long
+
         helper = self._makeOne('secret')
         request = self._makeRequest()
         result = helper.remember(request, long(1))
@@ -1122,6 +1286,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
     def test_remember_unicode_userid(self):
         import base64
+
         helper = self._makeOne('secret')
         request = self._makeRequest()
         userid = text_(b'\xc2\xa9', 'utf-8')
@@ -1129,8 +1294,9 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         values = self._parseHeaders(result)
         self.assertEqual(len(result), 3)
         val = self._cookieValue(values[0])
-        self.assertEqual(val['userid'],
-                         text_(base64.b64encode(userid.encode('utf-8'))))
+        self.assertEqual(
+            val['userid'], text_(base64.b64encode(userid.encode('utf-8')))
+        )
         self.assertEqual(val['user_data'], 'userid_type:b64unicode')
 
     def test_remember_insane_userid(self):
@@ -1169,7 +1335,13 @@ class TestAuthTktCookieHelper(unittest.TestCase):
     def test_remember_str_max_age_invalid(self):
         helper = self._makeOne('secret')
         request = self._makeRequest()
-        self.assertRaises(ValueError, helper.remember, request, 'userid', max_age='invalid value')
+        self.assertRaises(
+            ValueError,
+            helper.remember,
+            request,
+            'userid',
+            max_age='invalid value',
+        )
 
     def test_remember_tokens(self):
         helper = self._makeOne('secret')
@@ -1194,18 +1366,24 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
         self.assertEqual(result[0][0], 'Set-Cookie')
         cookieval = result[0][1]
-        self.assertTrue('SameSite=Strict' in
-                        [x.strip() for x in cookieval.split(';')], cookieval)
+        self.assertTrue(
+            'SameSite=Strict' in [x.strip() for x in cookieval.split(';')],
+            cookieval,
+        )
 
         self.assertEqual(result[1][0], 'Set-Cookie')
         cookieval = result[1][1]
-        self.assertTrue('SameSite=Strict' in
-                        [x.strip() for x in cookieval.split(';')], cookieval)
+        self.assertTrue(
+            'SameSite=Strict' in [x.strip() for x in cookieval.split(';')],
+            cookieval,
+        )
 
         self.assertEqual(result[2][0], 'Set-Cookie')
         cookieval = result[2][1]
-        self.assertTrue('SameSite=Strict' in
-                        [x.strip() for x in cookieval.split(';')], cookieval)
+        self.assertTrue(
+            'SameSite=Strict' in [x.strip() for x in cookieval.split(';')],
+            cookieval,
+        )
 
     def test_remember_samesite_default(self):
         helper = self._makeOne('secret')
@@ -1215,18 +1393,24 @@ class TestAuthTktCookieHelper(unittest.TestCase):
 
         self.assertEqual(result[0][0], 'Set-Cookie')
         cookieval = result[0][1]
-        self.assertTrue('SameSite=Lax' in
-                        [x.strip() for x in cookieval.split(';')], cookieval)
+        self.assertTrue(
+            'SameSite=Lax' in [x.strip() for x in cookieval.split(';')],
+            cookieval,
+        )
 
         self.assertEqual(result[1][0], 'Set-Cookie')
         cookieval = result[1][1]
-        self.assertTrue('SameSite=Lax' in
-                        [x.strip() for x in cookieval.split(';')], cookieval)
+        self.assertTrue(
+            'SameSite=Lax' in [x.strip() for x in cookieval.split(';')],
+            cookieval,
+        )
 
         self.assertEqual(result[2][0], 'Set-Cookie')
         cookieval = result[2][1]
-        self.assertTrue('SameSite=Lax' in
-                        [x.strip() for x in cookieval.split(';')], cookieval)
+        self.assertTrue(
+            'SameSite=Lax' in [x.strip() for x in cookieval.split(';')],
+            cookieval,
+        )
 
     def test_remember_unicode_but_ascii_token(self):
         helper = self._makeOne('secret')
@@ -1240,16 +1424,19 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         helper = self._makeOne('secret')
         request = self._makeRequest()
         la = text_(b'La Pe\xc3\xb1a', 'utf-8')
-        self.assertRaises(ValueError, helper.remember, request, 'other',
-                          tokens=(la,))
+        self.assertRaises(
+            ValueError, helper.remember, request, 'other', tokens=(la,)
+        )
 
     def test_remember_invalid_token_format(self):
         helper = self._makeOne('secret')
         request = self._makeRequest()
-        self.assertRaises(ValueError, helper.remember, request, 'other',
-                          tokens=('foo bar',))
-        self.assertRaises(ValueError, helper.remember, request, 'other',
-                          tokens=('1bar',))
+        self.assertRaises(
+            ValueError, helper.remember, request, 'other', tokens=('foo bar',)
+        )
+        self.assertRaises(
+            ValueError, helper.remember, request, 'other', tokens=('1bar',)
+        )
 
     def test_forget(self):
         helper = self._makeOne('secret')
@@ -1261,26 +1448,28 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(
             value,
             'auth_tkt=; Max-Age=0; Path=/; '
-            'expires=Wed, 31-Dec-97 23:59:59 GMT; SameSite=Lax'
-            )
+            'expires=Wed, 31-Dec-97 23:59:59 GMT; SameSite=Lax',
+        )
         name, value = headers[1]
         self.assertEqual(name, 'Set-Cookie')
         self.assertEqual(
             value,
             'auth_tkt=; Domain=localhost; Max-Age=0; Path=/; '
-            'expires=Wed, 31-Dec-97 23:59:59 GMT; SameSite=Lax'
-            )
+            'expires=Wed, 31-Dec-97 23:59:59 GMT; SameSite=Lax',
+        )
         name, value = headers[2]
         self.assertEqual(name, 'Set-Cookie')
         self.assertEqual(
             value,
             'auth_tkt=; Domain=.localhost; Max-Age=0; Path=/; '
-            'expires=Wed, 31-Dec-97 23:59:59 GMT; SameSite=Lax'
-            )
+            'expires=Wed, 31-Dec-97 23:59:59 GMT; SameSite=Lax',
+        )
+
 
 class TestAuthTicket(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.authentication import AuthTicket
+
         return AuthTicket(*arg, **kw)
 
     def test_ctor_with_tokens(self):
@@ -1297,37 +1486,53 @@ class TestAuthTicket(unittest.TestCase):
         self.assertEqual(result, '126fd6224912187ee9ffa80e0b81420c')
 
     def test_digest_sha512(self):
-        ticket = self._makeOne('secret', 'userid', '0.0.0.0',
-                               time=10, hashalg='sha512')
+        ticket = self._makeOne(
+            'secret', 'userid', '0.0.0.0', time=10, hashalg='sha512'
+        )
         result = ticket.digest()
-        self.assertEqual(result, '74770b2e0d5b1a54c2a466ec567a40f7d7823576aa49'\
-                                 '3c65fc3445e9b44097f4a80410319ef8cb256a2e60b9'\
-                                 'c2002e48a9e33a3e8ee4379352c04ef96d2cb278')
+        self.assertEqual(
+            result,
+            '74770b2e0d5b1a54c2a466ec567a40f7d7823576aa49'
+            '3c65fc3445e9b44097f4a80410319ef8cb256a2e60b9'
+            'c2002e48a9e33a3e8ee4379352c04ef96d2cb278',
+        )
 
     def test_cookie_value(self):
-        ticket = self._makeOne('secret', 'userid', '0.0.0.0', time=10,
-                               tokens=('a', 'b'))
+        ticket = self._makeOne(
+            'secret', 'userid', '0.0.0.0', time=10, tokens=('a', 'b')
+        )
         result = ticket.cookie_value()
-        self.assertEqual(result,
-                         '66f9cc3e423dc57c91df696cf3d1f0d80000000auserid!a,b!')
+        self.assertEqual(
+            result, '66f9cc3e423dc57c91df696cf3d1f0d80000000auserid!a,b!'
+        )
 
     def test_ipv4(self):
-        ticket = self._makeOne('secret', 'userid', '198.51.100.1',
-                               time=10, hashalg='sha256')
+        ticket = self._makeOne(
+            'secret', 'userid', '198.51.100.1', time=10, hashalg='sha256'
+        )
         result = ticket.cookie_value()
-        self.assertEqual(result, 'b3e7156db4f8abde4439c4a6499a0668f9e7ffd7fa27b'\
-                                 '798400ecdade8d76c530000000auserid!')
+        self.assertEqual(
+            result,
+            'b3e7156db4f8abde4439c4a6499a0668f9e7ffd7fa27b'
+            '798400ecdade8d76c530000000auserid!',
+        )
 
     def test_ipv6(self):
-        ticket = self._makeOne('secret', 'userid', '2001:db8::1',
-                               time=10, hashalg='sha256')
+        ticket = self._makeOne(
+            'secret', 'userid', '2001:db8::1', time=10, hashalg='sha256'
+        )
         result = ticket.cookie_value()
-        self.assertEqual(result, 'd025b601a0f12ca6d008aa35ff3a22b7d8f3d1c1456c8'\
-                                 '5becf8760cd7a2fa4910000000auserid!')
+        self.assertEqual(
+            result,
+            'd025b601a0f12ca6d008aa35ff3a22b7d8f3d1c1456c8'
+            '5becf8760cd7a2fa4910000000auserid!',
+        )
+
 
 class TestBadTicket(unittest.TestCase):
     def _makeOne(self, msg, expected=None):
         from pyramid.authentication import BadTicket
+
         return BadTicket(msg, expected)
 
     def test_it(self):
@@ -1335,14 +1540,19 @@ class TestBadTicket(unittest.TestCase):
         self.assertEqual(exc.expected, True)
         self.assertTrue(isinstance(exc, Exception))
 
+
 class Test_parse_ticket(unittest.TestCase):
     def _callFUT(self, secret, ticket, ip, hashalg='md5'):
         from pyramid.authentication import parse_ticket
+
         return parse_ticket(secret, ticket, ip, hashalg)
 
     def _assertRaisesBadTicket(self, secret, ticket, ip, hashalg='md5'):
         from pyramid.authentication import BadTicket
-        self.assertRaises(BadTicket,self._callFUT, secret, ticket, ip, hashalg)
+
+        self.assertRaises(
+            BadTicket, self._callFUT, secret, ticket, ip, hashalg
+        )
 
     def test_bad_timestamp(self):
         ticket = 'x' * 64
@@ -1362,27 +1572,35 @@ class Test_parse_ticket(unittest.TestCase):
         self.assertEqual(result, (10, 'userid', ['a', 'b'], ''))
 
     def test_correct_with_user_data_sha512(self):
-        ticket = text_('7d947cdef99bad55f8e3382a8bd089bb9dd0547f7925b7d189adc1'
-                       '160cab0ec0e6888faa41eba641a18522b26f19109f3ffafb769767'
-                       'ba8a26d02aaeae56599a0000000auserid!a,b!')
+        ticket = text_(
+            '7d947cdef99bad55f8e3382a8bd089bb9dd0547f7925b7d189adc1'
+            '160cab0ec0e6888faa41eba641a18522b26f19109f3ffafb769767'
+            'ba8a26d02aaeae56599a0000000auserid!a,b!'
+        )
         result = self._callFUT('secret', ticket, '0.0.0.0', 'sha512')
         self.assertEqual(result, (10, 'userid', ['a', 'b'], ''))
 
     def test_ipv4(self):
-        ticket = text_('b3e7156db4f8abde4439c4a6499a0668f9e7ffd7fa27b798400ecd'
-                       'ade8d76c530000000auserid!')
+        ticket = text_(
+            'b3e7156db4f8abde4439c4a6499a0668f9e7ffd7fa27b798400ecd'
+            'ade8d76c530000000auserid!'
+        )
         result = self._callFUT('secret', ticket, '198.51.100.1', 'sha256')
         self.assertEqual(result, (10, 'userid', [''], ''))
 
     def test_ipv6(self):
-        ticket = text_('d025b601a0f12ca6d008aa35ff3a22b7d8f3d1c1456c85becf8760'
-                       'cd7a2fa4910000000auserid!')
+        ticket = text_(
+            'd025b601a0f12ca6d008aa35ff3a22b7d8f3d1c1456c85becf8760'
+            'cd7a2fa4910000000auserid!'
+        )
         result = self._callFUT('secret', ticket, '2001:db8::1', 'sha256')
         self.assertEqual(result, (10, 'userid', [''], ''))
 
+
 class TestSessionAuthenticationPolicy(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.authentication import SessionAuthenticationPolicy
+
         return SessionAuthenticationPolicy
 
     def _makeOne(self, callback=None, prefix=''):
@@ -1391,11 +1609,13 @@ class TestSessionAuthenticationPolicy(unittest.TestCase):
     def test_class_implements_IAuthenticationPolicy(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IAuthenticationPolicy
+
         verifyClass(IAuthenticationPolicy, self._getTargetClass())
 
     def test_instance_implements_IAuthenticationPolicy(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IAuthenticationPolicy
+
         verifyObject(IAuthenticationPolicy, self._makeOne())
 
     def test_unauthenticated_userid_returns_None(self):
@@ -1404,7 +1624,7 @@ class TestSessionAuthenticationPolicy(unittest.TestCase):
         self.assertEqual(policy.unauthenticated_userid(request), None)
 
     def test_unauthenticated_userid(self):
-        request = DummyRequest(session={'userid':'fred'})
+        request = DummyRequest(session={'userid': 'fred'})
         policy = self._makeOne()
         self.assertEqual(policy.unauthenticated_userid(request), 'fred')
 
@@ -1414,42 +1634,55 @@ class TestSessionAuthenticationPolicy(unittest.TestCase):
         self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_authenticated_userid_callback_returns_None(self):
-        request = DummyRequest(session={'userid':'fred'})
+        request = DummyRequest(session={'userid': 'fred'})
+
         def callback(userid, request):
             return None
+
         policy = self._makeOne(callback)
         self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_authenticated_userid(self):
-        request = DummyRequest(session={'userid':'fred'})
+        request = DummyRequest(session={'userid': 'fred'})
+
         def callback(userid, request):
             return True
+
         policy = self._makeOne(callback)
         self.assertEqual(policy.authenticated_userid(request), 'fred')
 
     def test_effective_principals_no_identity(self):
         from pyramid.security import Everyone
+
         request = DummyRequest()
         policy = self._makeOne()
         self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals_callback_returns_None(self):
         from pyramid.security import Everyone
-        request = DummyRequest(session={'userid':'fred'})
+
+        request = DummyRequest(session={'userid': 'fred'})
+
         def callback(userid, request):
             return None
+
         policy = self._makeOne(callback)
         self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals(self):
         from pyramid.security import Everyone
         from pyramid.security import Authenticated
-        request = DummyRequest(session={'userid':'fred'})
+
+        request = DummyRequest(session={'userid': 'fred'})
+
         def callback(userid, request):
             return ['group.foo']
+
         policy = self._makeOne(callback)
-        self.assertEqual(policy.effective_principals(request),
-                         [Everyone, Authenticated, 'fred', 'group.foo'])
+        self.assertEqual(
+            policy.effective_principals(request),
+            [Everyone, Authenticated, 'fred', 'group.foo'],
+        )
 
     def test_remember(self):
         request = DummyRequest()
@@ -1459,7 +1692,7 @@ class TestSessionAuthenticationPolicy(unittest.TestCase):
         self.assertEqual(result, [])
 
     def test_forget(self):
-        request = DummyRequest(session={'userid':'fred'})
+        request = DummyRequest(session={'userid': 'fred'})
         policy = self._makeOne()
         result = policy.forget(request)
         self.assertEqual(request.session.get('userid'), None)
@@ -1472,9 +1705,11 @@ class TestSessionAuthenticationPolicy(unittest.TestCase):
         self.assertEqual(request.session.get('userid'), None)
         self.assertEqual(result, [])
 
+
 class TestBasicAuthAuthenticationPolicy(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.authentication import BasicAuthAuthenticationPolicy as cls
+
         return cls
 
     def _makeOne(self, check):
@@ -1483,13 +1718,16 @@ class TestBasicAuthAuthenticationPolicy(unittest.TestCase):
     def test_class_implements_IAuthenticationPolicy(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IAuthenticationPolicy
+
         verifyClass(IAuthenticationPolicy, self._getTargetClass())
 
     def test_unauthenticated_userid(self):
         import base64
+
         request = testing.DummyRequest()
         request.headers['Authorization'] = 'Basic %s' % base64.b64encode(
-            bytes_('chrisr:password')).decode('ascii')
+            bytes_('chrisr:password')
+        ).decode('ascii')
         policy = self._makeOne(None)
         self.assertEqual(policy.unauthenticated_userid(request), 'chrisr')
 
@@ -1518,45 +1756,65 @@ class TestBasicAuthAuthenticationPolicy(unittest.TestCase):
 
     def test_authenticated_userid(self):
         import base64
+
         request = testing.DummyRequest()
         request.headers['Authorization'] = 'Basic %s' % base64.b64encode(
-            bytes_('chrisr:password')).decode('ascii')
+            bytes_('chrisr:password')
+        ).decode('ascii')
+
         def check(username, password, request):
             return []
+
         policy = self._makeOne(check)
         self.assertEqual(policy.authenticated_userid(request), 'chrisr')
 
     def test_authenticated_userid_utf8(self):
         import base64
+
         request = testing.DummyRequest()
-        inputs = (b'm\xc3\xb6rk\xc3\xb6:'
-                  b'm\xc3\xb6rk\xc3\xb6password').decode('utf-8')
+        inputs = (
+            b'm\xc3\xb6rk\xc3\xb6:' b'm\xc3\xb6rk\xc3\xb6password'
+        ).decode('utf-8')
         request.headers['Authorization'] = 'Basic %s' % (
-            base64.b64encode(inputs.encode('utf-8')).decode('latin-1'))
+            base64.b64encode(inputs.encode('utf-8')).decode('latin-1')
+        )
+
         def check(username, password, request):
             return []
+
         policy = self._makeOne(check)
-        self.assertEqual(policy.authenticated_userid(request),
-                         b'm\xc3\xb6rk\xc3\xb6'.decode('utf-8'))
+        self.assertEqual(
+            policy.authenticated_userid(request),
+            b'm\xc3\xb6rk\xc3\xb6'.decode('utf-8'),
+        )
 
     def test_authenticated_userid_latin1(self):
         import base64
+
         request = testing.DummyRequest()
-        inputs = (b'm\xc3\xb6rk\xc3\xb6:'
-                  b'm\xc3\xb6rk\xc3\xb6password').decode('utf-8')
+        inputs = (
+            b'm\xc3\xb6rk\xc3\xb6:' b'm\xc3\xb6rk\xc3\xb6password'
+        ).decode('utf-8')
         request.headers['Authorization'] = 'Basic %s' % (
-            base64.b64encode(inputs.encode('latin-1')).decode('latin-1'))
+            base64.b64encode(inputs.encode('latin-1')).decode('latin-1')
+        )
+
         def check(username, password, request):
             return []
+
         policy = self._makeOne(check)
-        self.assertEqual(policy.authenticated_userid(request),
-                         b'm\xc3\xb6rk\xc3\xb6'.decode('utf-8'))
+        self.assertEqual(
+            policy.authenticated_userid(request),
+            b'm\xc3\xb6rk\xc3\xb6'.decode('utf-8'),
+        )
 
     def test_unauthenticated_userid_invalid_payload(self):
         import base64
+
         request = testing.DummyRequest()
         request.headers['Authorization'] = 'Basic %s' % base64.b64encode(
-            bytes_('chrisrpassword')).decode('ascii')
+            bytes_('chrisrpassword')
+        ).decode('ascii')
         policy = self._makeOne(None)
         self.assertEqual(policy.unauthenticated_userid(request), None)
 
@@ -1566,13 +1824,16 @@ class TestBasicAuthAuthenticationPolicy(unittest.TestCase):
 
     def test_forget(self):
         policy = self._makeOne(None)
-        self.assertEqual(policy.forget(None), [
-            ('WWW-Authenticate', 'Basic realm="SomeRealm"')])
+        self.assertEqual(
+            policy.forget(None),
+            [('WWW-Authenticate', 'Basic realm="SomeRealm"')],
+        )
 
 
 class TestExtractHTTPBasicCredentials(unittest.TestCase):
     def _get_func(self):
         from pyramid.authentication import extract_http_basic_credentials
+
         return extract_http_basic_credentials
 
     def test_no_auth_header(self):
@@ -1583,17 +1844,21 @@ class TestExtractHTTPBasicCredentials(unittest.TestCase):
 
     def test_invalid_payload(self):
         import base64
+
         request = testing.DummyRequest()
         request.headers['Authorization'] = 'Basic %s' % base64.b64encode(
-            bytes_('chrisrpassword')).decode('ascii')
+            bytes_('chrisrpassword')
+        ).decode('ascii')
         fn = self._get_func()
         self.assertIsNone(fn(request))
 
     def test_not_a_basic_auth_scheme(self):
         import base64
+
         request = testing.DummyRequest()
         request.headers['Authorization'] = 'OtherScheme %s' % base64.b64encode(
-            bytes_('chrisr:password')).decode('ascii')
+            bytes_('chrisr:password')
+        ).decode('ascii')
         fn = self._get_func()
         self.assertIsNone(fn(request))
 
@@ -1605,44 +1870,60 @@ class TestExtractHTTPBasicCredentials(unittest.TestCase):
 
     def test_latin1_payload(self):
         import base64
+
         request = testing.DummyRequest()
-        inputs = (b'm\xc3\xb6rk\xc3\xb6:'
-                  b'm\xc3\xb6rk\xc3\xb6password').decode('utf-8')
+        inputs = (
+            b'm\xc3\xb6rk\xc3\xb6:' b'm\xc3\xb6rk\xc3\xb6password'
+        ).decode('utf-8')
         request.headers['Authorization'] = 'Basic %s' % (
-            base64.b64encode(inputs.encode('latin-1')).decode('latin-1'))
+            base64.b64encode(inputs.encode('latin-1')).decode('latin-1')
+        )
         fn = self._get_func()
-        self.assertEqual(fn(request), (
-            b'm\xc3\xb6rk\xc3\xb6'.decode('utf-8'),
-            b'm\xc3\xb6rk\xc3\xb6password'.decode('utf-8')
-        ))
+        self.assertEqual(
+            fn(request),
+            (
+                b'm\xc3\xb6rk\xc3\xb6'.decode('utf-8'),
+                b'm\xc3\xb6rk\xc3\xb6password'.decode('utf-8'),
+            ),
+        )
 
     def test_utf8_payload(self):
         import base64
+
         request = testing.DummyRequest()
-        inputs = (b'm\xc3\xb6rk\xc3\xb6:'
-                  b'm\xc3\xb6rk\xc3\xb6password').decode('utf-8')
+        inputs = (
+            b'm\xc3\xb6rk\xc3\xb6:' b'm\xc3\xb6rk\xc3\xb6password'
+        ).decode('utf-8')
         request.headers['Authorization'] = 'Basic %s' % (
-            base64.b64encode(inputs.encode('utf-8')).decode('latin-1'))
+            base64.b64encode(inputs.encode('utf-8')).decode('latin-1')
+        )
         fn = self._get_func()
-        self.assertEqual(fn(request), (
-            b'm\xc3\xb6rk\xc3\xb6'.decode('utf-8'),
-            b'm\xc3\xb6rk\xc3\xb6password'.decode('utf-8')
-        ))
+        self.assertEqual(
+            fn(request),
+            (
+                b'm\xc3\xb6rk\xc3\xb6'.decode('utf-8'),
+                b'm\xc3\xb6rk\xc3\xb6password'.decode('utf-8'),
+            ),
+        )
 
     def test_namedtuple_return(self):
         import base64
+
         request = testing.DummyRequest()
         request.headers['Authorization'] = 'Basic %s' % base64.b64encode(
-            bytes_('chrisr:pass')).decode('ascii')
+            bytes_('chrisr:pass')
+        ).decode('ascii')
         fn = self._get_func()
         result = fn(request)
 
         self.assertEqual(result.username, 'chrisr')
         self.assertEqual(result.password, 'pass')
-        
+
+
 class DummyContext:
     pass
 
+
 class DummyCookies(object):
     def __init__(self, cookie):
         self.cookie = cookie
@@ -1650,8 +1931,10 @@ class DummyCookies(object):
     def get(self, name):
         return self.cookie
 
+
 class DummyRequest:
     domain = 'localhost'
+
     def __init__(self, environ=None, session=None, registry=None, cookie=None):
         self.environ = environ or {}
         self.session = session or {}
@@ -1662,6 +1945,7 @@ class DummyRequest:
     def add_response_callback(self, callback):
         self.callbacks.append(callback)
 
+
 class DummyWhoPlugin:
     def remember(self, environ, identity):
         return environ, identity
@@ -1669,6 +1953,7 @@ class DummyWhoPlugin:
     def forget(self, environ, identity):
         return environ, identity
 
+
 class DummyCookieHelper:
     def __init__(self, result):
         self.result = result
@@ -1683,15 +1968,24 @@ class DummyCookieHelper:
     def forget(self, *arg):
         return []
 
+
 class DummyAuthTktModule(object):
-    def __init__(self, timestamp=0, userid='userid', tokens=(), user_data='',
-                 parse_raise=False, hashalg="md5"):
+    def __init__(
+        self,
+        timestamp=0,
+        userid='userid',
+        tokens=(),
+        user_data='',
+        parse_raise=False,
+        hashalg="md5",
+    ):
         self.timestamp = timestamp
         self.userid = userid
         self.tokens = tokens
         self.user_data = user_data
         self.parse_raise = parse_raise
         self.hashalg = hashalg
+
         def parse_ticket(secret, value, remote_addr, hashalg):
             self.secret = secret
             self.value = value
@@ -1699,6 +1993,7 @@ class DummyAuthTktModule(object):
             if self.parse_raise:
                 raise self.BadTicket()
             return self.timestamp, self.userid, self.tokens, self.user_data
+
         self.parse_ticket = parse_ticket
 
         class AuthTicket(object):
@@ -1710,10 +2005,10 @@ class DummyAuthTktModule(object):
 
             def cookie_value(self):
                 result = {
-                    'secret':self.secret,
-                    'userid':self.userid,
-                    'remote_addr':self.remote_addr
-                    }
+                    'secret': self.secret,
+                    'userid': self.userid,
+                    'remote_addr': self.remote_addr,
+                }
                 result.update(self.kw)
                 tokens = result.pop('tokens', None)
                 if tokens is not None:
@@ -1724,15 +2019,16 @@ class DummyAuthTktModule(object):
                 for k, v in items:
                     if isinstance(v, bytes):
                         v = text_(v)
-                    new_items.append((k,v))
-                result = '/'.join(['%s=%s' % (k, v) for k,v in new_items ])
+                    new_items.append((k, v))
+                result = '/'.join(['%s=%s' % (k, v) for k, v in new_items])
                 return result
+
         self.AuthTicket = AuthTicket
 
     class BadTicket(Exception):
         pass
 
+
 class DummyResponse:
     def __init__(self):
         self.headerlist = []
-
diff --git a/tests/test_authorization.py b/tests/test_authorization.py
index 05cd3b4f8..efb84b203 100644
--- a/tests/test_authorization.py
+++ b/tests/test_authorization.py
@@ -2,6 +2,7 @@ import unittest
 
 from pyramid.testing import cleanUp
 
+
 class TestACLAuthorizationPolicy(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -11,6 +12,7 @@ class TestACLAuthorizationPolicy(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.authorization import ACLAuthorizationPolicy
+
         return ACLAuthorizationPolicy
 
     def _makeOne(self):
@@ -19,18 +21,20 @@ class TestACLAuthorizationPolicy(unittest.TestCase):
     def test_class_implements_IAuthorizationPolicy(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IAuthorizationPolicy
+
         verifyClass(IAuthorizationPolicy, self._getTargetClass())
 
     def test_instance_implements_IAuthorizationPolicy(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IAuthorizationPolicy
+
         verifyObject(IAuthorizationPolicy, self._makeOne())
 
     def test_permits_no_acl(self):
         context = DummyContext()
         policy = self._makeOne()
         self.assertEqual(policy.permits(context, [], 'view'), False)
-        
+
     def test_permits(self):
         from pyramid.security import Deny
         from pyramid.security import Allow
@@ -38,68 +42,76 @@ class TestACLAuthorizationPolicy(unittest.TestCase):
         from pyramid.security import Authenticated
         from pyramid.security import ALL_PERMISSIONS
         from pyramid.security import DENY_ALL
+
         root = DummyContext()
         community = DummyContext(__name__='community', __parent__=root)
         blog = DummyContext(__name__='blog', __parent__=community)
-        root.__acl__ = [
-            (Allow, Authenticated, VIEW),
-            ]
+        root.__acl__ = [(Allow, Authenticated, VIEW)]
         community.__acl__ = [
             (Allow, 'fred', ALL_PERMISSIONS),
             (Allow, 'wilma', VIEW),
             DENY_ALL,
-            ]
+        ]
         blog.__acl__ = [
             (Allow, 'barney', MEMBER_PERMS),
             (Allow, 'wilma', VIEW),
-            ]
+        ]
 
         policy = self._makeOne()
 
-        result = policy.permits(blog, [Everyone, Authenticated, 'wilma'],
-                                'view')
+        result = policy.permits(
+            blog, [Everyone, Authenticated, 'wilma'], 'view'
+        )
         self.assertEqual(result, True)
         self.assertEqual(result.context, blog)
         self.assertEqual(result.ace, (Allow, 'wilma', VIEW))
         self.assertEqual(result.acl, blog.__acl__)
 
-        result = policy.permits(blog, [Everyone, Authenticated, 'wilma'],
-                                'delete')
+        result = policy.permits(
+            blog, [Everyone, Authenticated, 'wilma'], 'delete'
+        )
         self.assertEqual(result, False)
         self.assertEqual(result.context, community)
         self.assertEqual(result.ace, (Deny, Everyone, ALL_PERMISSIONS))
         self.assertEqual(result.acl, community.__acl__)
 
-        result = policy.permits(blog, [Everyone, Authenticated, 'fred'], 'view')
+        result = policy.permits(
+            blog, [Everyone, Authenticated, 'fred'], 'view'
+        )
         self.assertEqual(result, True)
         self.assertEqual(result.context, community)
         self.assertEqual(result.ace, (Allow, 'fred', ALL_PERMISSIONS))
-        result = policy.permits(blog, [Everyone, Authenticated, 'fred'],
-                                'doesntevenexistyet')
+        result = policy.permits(
+            blog, [Everyone, Authenticated, 'fred'], 'doesntevenexistyet'
+        )
         self.assertEqual(result, True)
         self.assertEqual(result.context, community)
         self.assertEqual(result.ace, (Allow, 'fred', ALL_PERMISSIONS))
         self.assertEqual(result.acl, community.__acl__)
 
-        result = policy.permits(blog, [Everyone, Authenticated, 'barney'],
-                                'view')
+        result = policy.permits(
+            blog, [Everyone, Authenticated, 'barney'], 'view'
+        )
         self.assertEqual(result, True)
         self.assertEqual(result.context, blog)
         self.assertEqual(result.ace, (Allow, 'barney', MEMBER_PERMS))
-        result = policy.permits(blog, [Everyone, Authenticated, 'barney'],
-                                'administer')
+        result = policy.permits(
+            blog, [Everyone, Authenticated, 'barney'], 'administer'
+        )
         self.assertEqual(result, False)
         self.assertEqual(result.context, community)
         self.assertEqual(result.ace, (Deny, Everyone, ALL_PERMISSIONS))
         self.assertEqual(result.acl, community.__acl__)
-        
-        result = policy.permits(root, [Everyone, Authenticated, 'someguy'],
-                                'view')
+
+        result = policy.permits(
+            root, [Everyone, Authenticated, 'someguy'], 'view'
+        )
         self.assertEqual(result, True)
         self.assertEqual(result.context, root)
         self.assertEqual(result.ace, (Allow, Authenticated, VIEW))
-        result = policy.permits(blog,
-                                [Everyone, Authenticated, 'someguy'], 'view')
+        result = policy.permits(
+            blog, [Everyone, Authenticated, 'someguy'], 'view'
+        )
         self.assertEqual(result, False)
         self.assertEqual(result.context, community)
         self.assertEqual(result.ace, (Deny, Everyone, ALL_PERMISSIONS))
@@ -116,128 +128,149 @@ class TestACLAuthorizationPolicy(unittest.TestCase):
         self.assertEqual(result, False)
         self.assertEqual(result.ace, '<default deny>')
         self.assertEqual(
-            result.acl,
-            '<No ACL found on any object in resource lineage>')
+            result.acl, '<No ACL found on any object in resource lineage>'
+        )
 
     def test_permits_string_permissions_in_acl(self):
         from pyramid.security import Allow
+
         root = DummyContext()
-        root.__acl__ = [
-            (Allow, 'wilma', 'view_stuff'),
-            ]
+        root.__acl__ = [(Allow, 'wilma', 'view_stuff')]
 
         policy = self._makeOne()
 
         result = policy.permits(root, ['wilma'], 'view')
         # would be True if matching against 'view_stuff' instead of against
         # ['view_stuff']
-        self.assertEqual(result, False) 
+        self.assertEqual(result, False)
 
     def test_principals_allowed_by_permission_direct(self):
         from pyramid.security import Allow
         from pyramid.security import DENY_ALL
+
         context = DummyContext()
-        acl = [ (Allow, 'chrism', ('read', 'write')),
-                DENY_ALL,
-                (Allow, 'other', 'read') ]
+        acl = [
+            (Allow, 'chrism', ('read', 'write')),
+            DENY_ALL,
+            (Allow, 'other', 'read'),
+        ]
         context.__acl__ = acl
         policy = self._makeOne()
         result = sorted(
-            policy.principals_allowed_by_permission(context, 'read'))
+            policy.principals_allowed_by_permission(context, 'read')
+        )
         self.assertEqual(result, ['chrism'])
 
     def test_principals_allowed_by_permission_callable_acl(self):
         from pyramid.security import Allow
         from pyramid.security import DENY_ALL
+
         context = DummyContext()
-        acl = lambda: [ (Allow, 'chrism', ('read', 'write')),
-                        DENY_ALL,
-                        (Allow, 'other', 'read') ]
+        acl = lambda: [
+            (Allow, 'chrism', ('read', 'write')),
+            DENY_ALL,
+            (Allow, 'other', 'read'),
+        ]
         context.__acl__ = acl
         policy = self._makeOne()
         result = sorted(
-            policy.principals_allowed_by_permission(context, 'read'))
+            policy.principals_allowed_by_permission(context, 'read')
+        )
         self.assertEqual(result, ['chrism'])
-        
+
     def test_principals_allowed_by_permission_string_permission(self):
         from pyramid.security import Allow
+
         context = DummyContext()
-        acl = [ (Allow, 'chrism', 'read_it')]
+        acl = [(Allow, 'chrism', 'read_it')]
         context.__acl__ = acl
         policy = self._makeOne()
         result = policy.principals_allowed_by_permission(context, 'read')
         # would be ['chrism'] if 'read' were compared against 'read_it' instead
         # of against ['read_it']
         self.assertEqual(list(result), [])
-        
+
     def test_principals_allowed_by_permission(self):
         from pyramid.security import Allow
         from pyramid.security import Deny
         from pyramid.security import DENY_ALL
         from pyramid.security import ALL_PERMISSIONS
+
         root = DummyContext(__name__='', __parent__=None)
         community = DummyContext(__name__='community', __parent__=root)
         blog = DummyContext(__name__='blog', __parent__=community)
-        root.__acl__ = [ (Allow, 'chrism', ('read', 'write')),
-                         (Allow, 'other', ('read',)),
-                         (Allow, 'jim', ALL_PERMISSIONS)]
-        community.__acl__ = [  (Deny, 'flooz', 'read'),
-                               (Allow, 'flooz', 'read'),
-                               (Allow, 'mork', 'read'),
-                               (Deny, 'jim', 'read'),
-                               (Allow, 'someguy', 'manage')]
-        blog.__acl__ = [ (Allow, 'fred', 'read'),
-                         DENY_ALL]
+        root.__acl__ = [
+            (Allow, 'chrism', ('read', 'write')),
+            (Allow, 'other', ('read',)),
+            (Allow, 'jim', ALL_PERMISSIONS),
+        ]
+        community.__acl__ = [
+            (Deny, 'flooz', 'read'),
+            (Allow, 'flooz', 'read'),
+            (Allow, 'mork', 'read'),
+            (Deny, 'jim', 'read'),
+            (Allow, 'someguy', 'manage'),
+        ]
+        blog.__acl__ = [(Allow, 'fred', 'read'), DENY_ALL]
 
         policy = self._makeOne()
-        
+
         result = sorted(policy.principals_allowed_by_permission(blog, 'read'))
         self.assertEqual(result, ['fred'])
-        result = sorted(policy.principals_allowed_by_permission(community,
-            'read'))
+        result = sorted(
+            policy.principals_allowed_by_permission(community, 'read')
+        )
         self.assertEqual(result, ['chrism', 'mork', 'other'])
-        result = sorted(policy.principals_allowed_by_permission(community,
-            'read'))
+        result = sorted(
+            policy.principals_allowed_by_permission(community, 'read')
+        )
         result = sorted(policy.principals_allowed_by_permission(root, 'read'))
         self.assertEqual(result, ['chrism', 'jim', 'other'])
 
     def test_principals_allowed_by_permission_no_acls(self):
         context = DummyContext()
         policy = self._makeOne()
-        result = sorted(policy.principals_allowed_by_permission(context,'read'))
+        result = sorted(
+            policy.principals_allowed_by_permission(context, 'read')
+        )
         self.assertEqual(result, [])
 
     def test_principals_allowed_by_permission_deny_not_permission_in_acl(self):
         from pyramid.security import Deny
         from pyramid.security import Everyone
+
         context = DummyContext()
-        acl = [ (Deny, Everyone, 'write') ]
+        acl = [(Deny, Everyone, 'write')]
         context.__acl__ = acl
         policy = self._makeOne()
         result = sorted(
-            policy.principals_allowed_by_permission(context, 'read'))
+            policy.principals_allowed_by_permission(context, 'read')
+        )
         self.assertEqual(result, [])
 
     def test_principals_allowed_by_permission_deny_permission_in_acl(self):
         from pyramid.security import Deny
         from pyramid.security import Everyone
+
         context = DummyContext()
-        acl = [ (Deny, Everyone, 'read') ]
+        acl = [(Deny, Everyone, 'read')]
         context.__acl__ = acl
         policy = self._makeOne()
         result = sorted(
-            policy.principals_allowed_by_permission(context, 'read'))
+            policy.principals_allowed_by_permission(context, 'read')
+        )
         self.assertEqual(result, [])
 
     def test_callable_acl(self):
         from pyramid.security import Allow
+
         context = DummyContext()
         fn = lambda self: [(Allow, 'bob', 'read')]
         context.__acl__ = fn.__get__(context, context.__class__)
         policy = self._makeOne()
         result = policy.permits(context, ['bob'], 'read')
         self.assertTrue(result)
-        
+
 
 class DummyContext:
     def __init__(self, *arg, **kw):
@@ -256,4 +289,3 @@ GUEST_PERMS = (VIEW, COMMENT)
 MEMBER_PERMS = GUEST_PERMS + (EDIT, CREATE, DELETE)
 MODERATOR_PERMS = MEMBER_PERMS + (MODERATE,)
 ADMINISTRATOR_PERMS = MODERATOR_PERMS + (ADMINISTER,)
-
diff --git a/tests/test_compat.py b/tests/test_compat.py
index 23ccce82e..46fc7d944 100644
--- a/tests/test_compat.py
+++ b/tests/test_compat.py
@@ -1,6 +1,7 @@
 import unittest
 from pyramid.compat import is_unbound_method
 
+
 class TestUnboundMethods(unittest.TestCase):
     def test_old_style_bound(self):
         self.assertFalse(is_unbound_method(OldStyle().run))
@@ -15,12 +16,17 @@ class TestUnboundMethods(unittest.TestCase):
         self.assertTrue(is_unbound_method(NewStyle.run))
 
     def test_normal_func_unbound(self):
-        def func(): return 'OK'
+        def func():
+            return 'OK'
 
         self.assertFalse(is_unbound_method(func))
 
+
 class OldStyle:
-    def run(self): return 'OK'
+    def run(self):
+        return 'OK'
+
 
 class NewStyle(object):
-    def run(self): return 'OK'
+    def run(self):
+        return 'OK'
diff --git a/tests/test_config/__init__.py b/tests/test_config/__init__.py
index 81d9f4965..315e8c939 100644
--- a/tests/test_config/__init__.py
+++ b/tests/test_config/__init__.py
@@ -3,51 +3,70 @@
 from zope.interface import implementer
 from zope.interface import Interface
 
+
 class IFactory(Interface):
     pass
 
-def dummy_tween_factory(handler, registry): pass
 
-def dummy_tween_factory2(handler, registry): pass
+def dummy_tween_factory(handler, registry):
+    pass
+
+
+def dummy_tween_factory2(handler, registry):
+    pass
+
 
 def dummy_include(config):
     config.registry.included = True
     config.action('discrim', None, config.package)
 
+
 def dummy_include2(config):
     config.registry.also_included = True
     config.action('discrim', None, config.package)
 
+
 includeme = dummy_include
 
+
 class DummyContext:
     pass
 
+
 @implementer(IFactory)
 class DummyFactory(object):
     def __call__(self):
         """ """
 
+
 def dummyfactory(request):
     """ """
 
+
 class IDummy(Interface):
     pass
 
+
 def dummy_view(request):
     return 'OK'
 
+
 def dummy_extend(config, discrim):
     config.action(discrim, None, config.package)
 
+
 def dummy_extend2(config, discrim):
     config.action(discrim, None, config.registry)
 
+
 from functools import partial
+
 dummy_partial = partial(dummy_extend, discrim='partial')
 
+
 class DummyCallable(object):
     def __call__(self, config, discrim):
         config.action(discrim, None, config.package)
-dummy_callable = DummyCallable()
 
+
+dummy_callable = DummyCallable()
diff --git a/tests/test_config/path/scanerror/__init__.py b/tests/test_config/path/scanerror/__init__.py
index 86770ad89..934d6d3ad 100644
--- a/tests/test_config/path/scanerror/__init__.py
+++ b/tests/test_config/path/scanerror/__init__.py
@@ -1,3 +1 @@
 # scan error package
-
-
diff --git a/tests/test_config/pkgs/__init__.py b/tests/test_config/pkgs/__init__.py
index ed88d78b4..5bb534f79 100644
--- a/tests/test_config/pkgs/__init__.py
+++ b/tests/test_config/pkgs/__init__.py
@@ -1,2 +1 @@
 # package
-
diff --git a/tests/test_config/pkgs/asset/__init__.py b/tests/test_config/pkgs/asset/__init__.py
index db5619fbc..5bb534f79 100644
--- a/tests/test_config/pkgs/asset/__init__.py
+++ b/tests/test_config/pkgs/asset/__init__.py
@@ -1,3 +1 @@
 # package
-
-    
diff --git a/tests/test_config/pkgs/asset/subpackage/__init__.py b/tests/test_config/pkgs/asset/subpackage/__init__.py
index d3173e636..5bb534f79 100644
--- a/tests/test_config/pkgs/asset/subpackage/__init__.py
+++ b/tests/test_config/pkgs/asset/subpackage/__init__.py
@@ -1 +1 @@
-#package
+# package
diff --git a/tests/test_config/pkgs/scanextrakw/__init__.py b/tests/test_config/pkgs/scanextrakw/__init__.py
index ce5e07238..ddda504e1 100644
--- a/tests/test_config/pkgs/scanextrakw/__init__.py
+++ b/tests/test_config/pkgs/scanextrakw/__init__.py
@@ -1,14 +1,17 @@
 import venusian
 
+
 def foo(wrapped):
     def bar(scanner, name, wrapped):
         scanner.config.a = scanner.a
+
     venusian.attach(wrapped, bar)
     return wrapped
 
+
 @foo
 def hello():
     pass
 
-hello() # appease coverage
 
+hello()  # appease coverage
diff --git a/tests/test_config/pkgs/scannable/__init__.py b/tests/test_config/pkgs/scannable/__init__.py
index 562413a41..585f4357b 100644
--- a/tests/test_config/pkgs/scannable/__init__.py
+++ b/tests/test_config/pkgs/scannable/__init__.py
@@ -1,19 +1,23 @@
 from pyramid.view import view_config
 from pyramid.renderers import null_renderer
 
+
 @view_config(renderer=null_renderer)
 def grokked(context, request):
     return 'grokked'
 
+
 @view_config(request_method='POST', renderer=null_renderer)
 def grokked_post(context, request):
     return 'grokked_post'
 
+
 @view_config(name='stacked2', renderer=null_renderer)
 @view_config(name='stacked1', renderer=null_renderer)
 def stacked(context, request):
     return 'stacked'
 
+
 class stacked_class(object):
     def __init__(self, context, request):
         self.context = context
@@ -22,11 +26,15 @@ class stacked_class(object):
     def __call__(self):
         return 'stacked_class'
 
-stacked_class = view_config(name='stacked_class1',
-                            renderer=null_renderer)(stacked_class)
-stacked_class = view_config(name='stacked_class2',
-                            renderer=null_renderer)(stacked_class)
-    
+
+stacked_class = view_config(name='stacked_class1', renderer=null_renderer)(
+    stacked_class
+)
+stacked_class = view_config(name='stacked_class2', renderer=null_renderer)(
+    stacked_class
+)
+
+
 class oldstyle_grokked_class:
     def __init__(self, context, request):
         self.context = context
@@ -34,10 +42,12 @@ class oldstyle_grokked_class:
 
     def __call__(self):
         return 'oldstyle_grokked_class'
-    
-oldstyle_grokked_class = view_config(name='oldstyle_grokked_class',
-                                     renderer=null_renderer)(
-    oldstyle_grokked_class)
+
+
+oldstyle_grokked_class = view_config(
+    name='oldstyle_grokked_class', renderer=null_renderer
+)(oldstyle_grokked_class)
+
 
 class grokked_class(object):
     def __init__(self, context, request):
@@ -46,23 +56,30 @@ class grokked_class(object):
 
     def __call__(self):
         return 'grokked_class'
-        
-grokked_class = view_config(name='grokked_class',
-                            renderer=null_renderer)(grokked_class)
+
+
+grokked_class = view_config(name='grokked_class', renderer=null_renderer)(
+    grokked_class
+)
+
 
 class Foo(object):
     def __call__(self, context, request):
         return 'grokked_instance'
 
+
 grokked_instance = Foo()
-grokked_instance = view_config(name='grokked_instance',
-                               renderer=null_renderer)(grokked_instance)
+grokked_instance = view_config(
+    name='grokked_instance', renderer=null_renderer
+)(grokked_instance)
+
 
 class Base(object):
     @view_config(name='basemethod', renderer=null_renderer)
     def basemethod(self):
         """ """
-    
+
+
 class MethodViews(Base):
     def __init__(self, context, request):
         self.context = context
@@ -81,16 +98,20 @@ class MethodViews(Base):
     def stacked(self):
         return 'stacked_method'
 
+
 # ungrokkable
 
 A = 1
 B = {}
 
+
 def stuff():
     """ """
 
+
 class Whatever(object):
     pass
 
+
 class Whatever2:
     pass
diff --git a/tests/test_config/pkgs/scannable/another.py b/tests/test_config/pkgs/scannable/another.py
index 529821b5c..e8b71e5e3 100644
--- a/tests/test_config/pkgs/scannable/another.py
+++ b/tests/test_config/pkgs/scannable/another.py
@@ -1,19 +1,23 @@
 from pyramid.view import view_config
 from pyramid.renderers import null_renderer
 
+
 @view_config(name='another', renderer=null_renderer)
 def grokked(context, request):
     return 'another_grokked'
 
+
 @view_config(request_method='POST', name='another', renderer=null_renderer)
 def grokked_post(context, request):
     return 'another_grokked_post'
 
+
 @view_config(name='another_stacked2', renderer=null_renderer)
 @view_config(name='another_stacked1', renderer=null_renderer)
 def stacked(context, request):
     return 'another_stacked'
 
+
 class stacked_class(object):
     def __init__(self, context, request):
         self.context = context
@@ -22,10 +26,14 @@ class stacked_class(object):
     def __call__(self):
         return 'another_stacked_class'
 
-stacked_class = view_config(name='another_stacked_class1',
-                            renderer=null_renderer)(stacked_class)
-stacked_class = view_config(name='another_stacked_class2',
-                            renderer=null_renderer)(stacked_class)
+
+stacked_class = view_config(
+    name='another_stacked_class1', renderer=null_renderer
+)(stacked_class)
+stacked_class = view_config(
+    name='another_stacked_class2', renderer=null_renderer
+)(stacked_class)
+
 
 class oldstyle_grokked_class:
     def __init__(self, context, request):
@@ -34,10 +42,12 @@ class oldstyle_grokked_class:
 
     def __call__(self):
         return 'another_oldstyle_grokked_class'
-    
-oldstyle_grokked_class = view_config(name='another_oldstyle_grokked_class',
-                                     renderer=null_renderer)(
-    oldstyle_grokked_class)
+
+
+oldstyle_grokked_class = view_config(
+    name='another_oldstyle_grokked_class', renderer=null_renderer
+)(oldstyle_grokked_class)
+
 
 class grokked_class(object):
     def __init__(self, context, request):
@@ -46,24 +56,28 @@ class grokked_class(object):
 
     def __call__(self):
         return 'another_grokked_class'
-        
-grokked_class = view_config(name='another_grokked_class',
-                            renderer=null_renderer)(grokked_class)
+
+
+grokked_class = view_config(
+    name='another_grokked_class', renderer=null_renderer
+)(grokked_class)
+
 
 class Foo(object):
     def __call__(self, context, request):
         return 'another_grokked_instance'
 
+
 grokked_instance = Foo()
-grokked_instance = view_config(name='another_grokked_instance',
-                               renderer=null_renderer)(
-    grokked_instance)
+grokked_instance = view_config(
+    name='another_grokked_instance', renderer=null_renderer
+)(grokked_instance)
 
 # ungrokkable
 
 A = 1
 B = {}
 
+
 def stuff():
     """ """
-    
diff --git a/tests/test_config/pkgs/scannable/pod/notinit.py b/tests/test_config/pkgs/scannable/pod/notinit.py
index 91dcd161b..03c93857f 100644
--- a/tests/test_config/pkgs/scannable/pod/notinit.py
+++ b/tests/test_config/pkgs/scannable/pod/notinit.py
@@ -1,6 +1,7 @@
 from pyramid.view import view_config
 from pyramid.renderers import null_renderer
 
+
 @view_config(name='pod_notinit', renderer=null_renderer)
 def subpackage_notinit(context, request):
     return 'pod_notinit'
diff --git a/tests/test_config/pkgs/scannable/subpackage/__init__.py b/tests/test_config/pkgs/scannable/subpackage/__init__.py
index 9e0ddacbd..f89ca33f7 100644
--- a/tests/test_config/pkgs/scannable/subpackage/__init__.py
+++ b/tests/test_config/pkgs/scannable/subpackage/__init__.py
@@ -1,6 +1,7 @@
 from pyramid.view import view_config
 from pyramid.renderers import null_renderer
 
+
 @view_config(name='subpackage_init', renderer=null_renderer)
 def subpackage_init(context, request):
     return 'subpackage_init'
diff --git a/tests/test_config/pkgs/scannable/subpackage/notinit.py b/tests/test_config/pkgs/scannable/subpackage/notinit.py
index f7edd0c68..65c2a4929 100644
--- a/tests/test_config/pkgs/scannable/subpackage/notinit.py
+++ b/tests/test_config/pkgs/scannable/subpackage/notinit.py
@@ -1,6 +1,7 @@
 from pyramid.view import view_config
 from pyramid.renderers import null_renderer
 
+
 @view_config(name='subpackage_notinit', renderer=null_renderer)
 def subpackage_notinit(context, request):
     return 'subpackage_notinit'
diff --git a/tests/test_config/pkgs/scannable/subpackage/subsubpackage/__init__.py b/tests/test_config/pkgs/scannable/subpackage/subsubpackage/__init__.py
index fdda0dffe..ec4bab818 100644
--- a/tests/test_config/pkgs/scannable/subpackage/subsubpackage/__init__.py
+++ b/tests/test_config/pkgs/scannable/subpackage/subsubpackage/__init__.py
@@ -1,6 +1,7 @@
 from pyramid.view import view_config
 from pyramid.renderers import null_renderer
 
+
 @view_config(name='subsubpackage_init', renderer=null_renderer)
 def subpackage_init(context, request):
     return 'subsubpackage_init'
diff --git a/tests/test_config/pkgs/selfscan/__init__.py b/tests/test_config/pkgs/selfscan/__init__.py
index 779ea3eed..8bc8761ca 100644
--- a/tests/test_config/pkgs/selfscan/__init__.py
+++ b/tests/test_config/pkgs/selfscan/__init__.py
@@ -1,11 +1,14 @@
 from pyramid.view import view_config
 
+
 @view_config(renderer='string')
 def abc(request):
     return 'root'
 
+
 def main():
     from pyramid.config import Configurator
+
     c = Configurator()
     c.scan()
     return c
diff --git a/tests/test_config/pkgs/selfscan/another.py b/tests/test_config/pkgs/selfscan/another.py
index a30ad3297..79e0b08de 100644
--- a/tests/test_config/pkgs/selfscan/another.py
+++ b/tests/test_config/pkgs/selfscan/another.py
@@ -1,6 +1,6 @@
 from pyramid.view import view_config
 
+
 @view_config(name='two', renderer='string')
 def two(request):
     return 'two'
-
diff --git a/tests/test_config/test_adapters.py b/tests/test_config/test_adapters.py
index e554520e7..6237995d0 100644
--- a/tests/test_config/test_adapters.py
+++ b/tests/test_config/test_adapters.py
@@ -3,23 +3,30 @@ import unittest
 from pyramid.compat import PY2
 from . import IDummy
 
+
 class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def test_add_subscriber_defaults(self):
         from zope.interface import implementer
         from zope.interface import Interface
+
         class IEvent(Interface):
             pass
+
         @implementer(IEvent)
         class Event:
             pass
+
         L = []
+
         def subscriber(event):
             L.append(event)
+
         config = self._makeOne(autocommit=True)
         config.add_subscriber(subscriber)
         event = Event()
@@ -32,14 +39,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def test_add_subscriber_iface_specified(self):
         from zope.interface import implementer
         from zope.interface import Interface
+
         class IEvent(Interface):
             pass
+
         @implementer(IEvent)
         class Event:
             pass
+
         L = []
+
         def subscriber(event):
             L.append(event)
+
         config = self._makeOne(autocommit=True)
         config.add_subscriber(subscriber, IEvent)
         event = Event()
@@ -52,9 +64,11 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def test_add_subscriber_dottednames(self):
         import tests.test_config
         from pyramid.interfaces import INewRequest
+
         config = self._makeOne(autocommit=True)
-        config.add_subscriber('tests.test_config',
-                              'pyramid.interfaces.INewRequest')
+        config.add_subscriber(
+            'tests.test_config', 'pyramid.interfaces.INewRequest'
+        )
         handlers = list(config.registry.registeredHandlers())
         self.assertEqual(len(handlers), 1)
         handler = handlers[0]
@@ -64,15 +78,20 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def test_add_object_event_subscriber(self):
         from zope.interface import implementer
         from zope.interface import Interface
+
         class IEvent(Interface):
             pass
+
         @implementer(IEvent)
         class Event:
             object = 'foo'
+
         event = Event()
         L = []
+
         def subscriber(object, event):
             L.append(event)
+
         config = self._makeOne(autocommit=True)
         config.add_subscriber(subscriber, (Interface, IEvent))
         config.registry.subscribers((event.object, event), None)
@@ -84,14 +103,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def test_add_subscriber_with_specific_type_and_predicates_True(self):
         from zope.interface import implementer
         from zope.interface import Interface
+
         class IEvent(Interface):
             pass
+
         @implementer(IEvent)
         class Event:
             pass
+
         L = []
+
         def subscriber(event):
             L.append(event)
+
         config = self._makeOne(autocommit=True)
         predlist = config.get_predlist('subscriber')
         jam_predicate = predicate_maker('jam')
@@ -111,14 +135,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def test_add_subscriber_with_default_type_predicates_True(self):
         from zope.interface import implementer
         from zope.interface import Interface
+
         class IEvent(Interface):
             pass
+
         @implementer(IEvent)
         class Event:
             pass
+
         L = []
+
         def subscriber(event):
             L.append(event)
+
         config = self._makeOne(autocommit=True)
         predlist = config.get_predlist('subscriber')
         jam_predicate = predicate_maker('jam')
@@ -138,13 +167,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def test_add_subscriber_with_specific_type_and_predicates_False(self):
         from zope.interface import implementer
         from zope.interface import Interface
+
         class IEvent(Interface):
             pass
+
         @implementer(IEvent)
         class Event:
             pass
+
         L = []
-        def subscriber(event): L.append(event)
+
+        def subscriber(event):
+            L.append(event)
+
         config = self._makeOne(autocommit=True)
         predlist = config.get_predlist('subscriber')
         jam_predicate = predicate_maker('jam')
@@ -161,13 +196,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def test_add_subscriber_with_default_type_predicates_False(self):
         from zope.interface import implementer
         from zope.interface import Interface
+
         class IEvent(Interface):
             pass
+
         @implementer(IEvent)
         class Event:
             pass
+
         L = []
-        def subscriber(event): L.append(event)
+
+        def subscriber(event):
+            L.append(event)
+
         config = self._makeOne(autocommit=True)
         predlist = config.get_predlist('subscriber')
         jam_predicate = predicate_maker('jam')
@@ -184,33 +225,42 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def test_add_subscriber_predicate(self):
         config = self._makeOne()
         L = []
-        def add_predicate(type, name, factory, weighs_less_than=None,
-                          weighs_more_than=None):
+
+        def add_predicate(
+            type, name, factory, weighs_less_than=None, weighs_more_than=None
+        ):
             self.assertEqual(type, 'subscriber')
             self.assertEqual(name, 'name')
             self.assertEqual(factory, 'factory')
             self.assertEqual(weighs_more_than, 1)
             self.assertEqual(weighs_less_than, 2)
             L.append(1)
+
         config._add_predicate = add_predicate
         config.add_subscriber_predicate('name', 'factory', 1, 2)
         self.assertTrue(L)
-        
+
     def test_add_response_adapter(self):
         from pyramid.interfaces import IResponse
+
         config = self._makeOne(autocommit=True)
+
         class Adapter(object):
             def __init__(self, other):
                 self.other = other
+
         config.add_response_adapter(Adapter, str)
         result = config.registry.queryAdapter('foo', IResponse)
         self.assertTrue(result.other, 'foo')
 
     def test_add_response_adapter_self(self):
         from pyramid.interfaces import IResponse
+
         config = self._makeOne(autocommit=True)
+
         class Adapter(object):
             pass
+
         config.add_response_adapter(None, Adapter)
         adapter = Adapter()
         result = config.registry.queryAdapter(adapter, IResponse)
@@ -218,6 +268,7 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
 
     def test_add_response_adapter_dottednames(self):
         from pyramid.interfaces import IResponse
+
         config = self._makeOne(autocommit=True)
         if PY2:
             str_name = '__builtin__.str'
@@ -229,10 +280,12 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
 
     def test_add_traverser_dotted_names(self):
         from pyramid.interfaces import ITraverser
+
         config = self._makeOne(autocommit=True)
         config.add_traverser(
             'tests.test_config.test_adapters.DummyTraverser',
-            'tests.test_config.test_adapters.DummyIface')
+            'tests.test_config.test_adapters.DummyIface',
+        )
         iface = DummyIface()
         traverser = config.registry.getAdapter(iface, ITraverser)
         self.assertEqual(traverser.__class__, DummyTraverser)
@@ -240,6 +293,7 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
 
     def test_add_traverser_default_iface_means_Interface(self):
         from pyramid.interfaces import ITraverser
+
         config = self._makeOne(autocommit=True)
         config.add_traverser(DummyTraverser)
         traverser = config.registry.getAdapter(None, ITraverser)
@@ -247,19 +301,20 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
 
     def test_add_traverser_nondefault_iface(self):
         from pyramid.interfaces import ITraverser
+
         config = self._makeOne(autocommit=True)
         config.add_traverser(DummyTraverser, DummyIface)
         iface = DummyIface()
         traverser = config.registry.getAdapter(iface, ITraverser)
         self.assertEqual(traverser.__class__, DummyTraverser)
         self.assertEqual(traverser.root, iface)
-        
+
     def test_add_traverser_introspectables(self):
         config = self._makeOne()
         config.add_traverser(DummyTraverser, DummyIface)
         actions = config.action_state.actions
         self.assertEqual(len(actions), 1)
-        intrs  = actions[0]['introspectables']
+        intrs = actions[0]['introspectables']
         self.assertEqual(len(intrs), 1)
         intr = intrs[0]
         self.assertEqual(intr.type_name, 'traverser')
@@ -271,25 +326,25 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
 
     def test_add_resource_url_adapter_dotted_names(self):
         from pyramid.interfaces import IResourceURL
+
         config = self._makeOne(autocommit=True)
         config.add_resource_url_adapter(
             'tests.test_config.test_adapters.DummyResourceURL',
             'tests.test_config.test_adapters.DummyIface',
-            )
+        )
         iface = DummyIface()
-        adapter = config.registry.getMultiAdapter((iface, iface), 
-                                                    IResourceURL)
+        adapter = config.registry.getMultiAdapter((iface, iface), IResourceURL)
         self.assertEqual(adapter.__class__, DummyResourceURL)
         self.assertEqual(adapter.resource, iface)
         self.assertEqual(adapter.request, iface)
 
     def test_add_resource_url_default_resource_iface_means_Interface(self):
         from pyramid.interfaces import IResourceURL
+
         config = self._makeOne(autocommit=True)
         config.add_resource_url_adapter(DummyResourceURL)
         iface = DummyIface()
-        adapter = config.registry.getMultiAdapter((iface, iface), 
-                                                    IResourceURL)
+        adapter = config.registry.getMultiAdapter((iface, iface), IResourceURL)
         self.assertEqual(adapter.__class__, DummyResourceURL)
         self.assertEqual(adapter.resource, iface)
         self.assertEqual(adapter.request, iface)
@@ -297,18 +352,17 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
     def test_add_resource_url_nodefault_resource_iface(self):
         from zope.interface import Interface
         from pyramid.interfaces import IResourceURL
+
         config = self._makeOne(autocommit=True)
         config.add_resource_url_adapter(DummyResourceURL, DummyIface)
         iface = DummyIface()
-        adapter = config.registry.getMultiAdapter((iface, iface), 
-                                                    IResourceURL)
+        adapter = config.registry.getMultiAdapter((iface, iface), IResourceURL)
         self.assertEqual(adapter.__class__, DummyResourceURL)
         self.assertEqual(adapter.resource, iface)
         self.assertEqual(adapter.request, iface)
         bad_result = config.registry.queryMultiAdapter(
-            (Interface, Interface),
-            IResourceURL,
-            )
+            (Interface, Interface), IResourceURL
+        )
         self.assertEqual(bad_result, None)
 
     def test_add_resource_url_adapter_introspectables(self):
@@ -316,50 +370,62 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase):
         config.add_resource_url_adapter(DummyResourceURL, DummyIface)
         actions = config.action_state.actions
         self.assertEqual(len(actions), 1)
-        intrs  = actions[0]['introspectables']
+        intrs = actions[0]['introspectables']
         self.assertEqual(len(intrs), 1)
         intr = intrs[0]
         self.assertEqual(intr.type_name, 'resource url adapter')
-        self.assertEqual(intr.discriminator, 
-                         ('resource url adapter', DummyIface))
+        self.assertEqual(
+            intr.discriminator, ('resource url adapter', DummyIface)
+        )
         self.assertEqual(intr.category_name, 'resource url adapters')
         self.assertEqual(
             intr.title,
             "resource url adapter for resource iface "
-            "<class 'tests.test_config.test_adapters.DummyIface'>"
-            )
+            "<class 'tests.test_config.test_adapters.DummyIface'>",
+        )
         self.assertEqual(intr['adapter'], DummyResourceURL)
         self.assertEqual(intr['resource_iface'], DummyIface)
 
+
 class Test_eventonly(unittest.TestCase):
     def _callFUT(self, callee):
         from pyramid.config.adapters import eventonly
+
         return eventonly(callee)
 
     def test_defaults(self):
-        def acallable(event, a=1, b=2): pass
+        def acallable(event, a=1, b=2):
+            pass
+
         self.assertTrue(self._callFUT(acallable))
 
+
 class DummyTraverser(object):
     def __init__(self, root):
         self.root = root
 
+
 class DummyIface(object):
     pass
 
+
 class DummyResourceURL(object):
     def __init__(self, resource, request):
         self.resource = resource
         self.request = request
-        
+
+
 def predicate_maker(name):
     class Predicate(object):
         def __init__(self, val, config):
             self.val = val
+
         def phash(self):
             return 'phash'
+
         text = phash
+
         def __call__(self, event):
             return getattr(event, name, None) == self.val
-    return Predicate
 
+    return Predicate
diff --git a/tests/test_config/test_assets.py b/tests/test_config/test_assets.py
index b16977b99..875846dbd 100644
--- a/tests/test_config/test_assets.py
+++ b/tests/test_config/test_assets.py
@@ -5,48 +5,66 @@ from pyramid.testing import cleanUp
 # we use this folder
 here = os.path.dirname(os.path.abspath(__file__))
 
+
 class TestAssetsConfiguratorMixin(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def test_override_asset_samename(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
         self.assertRaises(ConfigurationError, config.override_asset, 'a', 'a')
 
     def test_override_asset_directory_with_file(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
-        self.assertRaises(ConfigurationError, config.override_asset,
-                          'a:foo/',
-                          'tests.test_config.pkgs.asset:foo.pt')
+        self.assertRaises(
+            ConfigurationError,
+            config.override_asset,
+            'a:foo/',
+            'tests.test_config.pkgs.asset:foo.pt',
+        )
 
     def test_override_asset_file_with_directory(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
-        self.assertRaises(ConfigurationError, config.override_asset,
-                          'a:foo.pt',
-                          'tests.test_config.pkgs.asset:templates/')
+        self.assertRaises(
+            ConfigurationError,
+            config.override_asset,
+            'a:foo.pt',
+            'tests.test_config.pkgs.asset:templates/',
+        )
 
     def test_override_asset_file_with_package(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
-        self.assertRaises(ConfigurationError, config.override_asset,
-                          'a:foo.pt',
-                          'tests.test_config.pkgs.asset')
+        self.assertRaises(
+            ConfigurationError,
+            config.override_asset,
+            'a:foo.pt',
+            'tests.test_config.pkgs.asset',
+        )
 
     def test_override_asset_file_with_file(self):
         from pyramid.config.assets import PackageAssetSource
+
         config = self._makeOne(autocommit=True)
         override = DummyUnderOverride()
         config.override_asset(
             'tests.test_config.pkgs.asset:templates/foo.pt',
             'tests.test_config.pkgs.asset.subpackage:templates/bar.pt',
-            _override=override)
+            _override=override,
+        )
         from tests.test_config.pkgs import asset
         from tests.test_config.pkgs.asset import subpackage
+
         self.assertEqual(override.package, asset)
         self.assertEqual(override.path, 'templates/foo.pt')
         source = override.source
@@ -55,21 +73,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase):
         self.assertEqual(source.prefix, 'templates/bar.pt')
 
         resource_name = ''
-        expected = os.path.join(here, 'pkgs', 'asset',
-                                'subpackage', 'templates', 'bar.pt')
-        self.assertEqual(override.source.get_filename(resource_name),
-                         expected)
+        expected = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
+        )
+        self.assertEqual(override.source.get_filename(resource_name), expected)
 
     def test_override_asset_package_with_package(self):
         from pyramid.config.assets import PackageAssetSource
+
         config = self._makeOne(autocommit=True)
         override = DummyUnderOverride()
         config.override_asset(
             'tests.test_config.pkgs.asset',
             'tests.test_config.pkgs.asset.subpackage',
-            _override=override)
+            _override=override,
+        )
         from tests.test_config.pkgs import asset
         from tests.test_config.pkgs.asset import subpackage
+
         self.assertEqual(override.package, asset)
         self.assertEqual(override.path, '')
         source = override.source
@@ -78,21 +99,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase):
         self.assertEqual(source.prefix, '')
 
         resource_name = 'templates/bar.pt'
-        expected = os.path.join(here, 'pkgs', 'asset',
-                                'subpackage', 'templates', 'bar.pt')
-        self.assertEqual(override.source.get_filename(resource_name),
-                         expected)
+        expected = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
+        )
+        self.assertEqual(override.source.get_filename(resource_name), expected)
 
     def test_override_asset_directory_with_directory(self):
         from pyramid.config.assets import PackageAssetSource
+
         config = self._makeOne(autocommit=True)
         override = DummyUnderOverride()
         config.override_asset(
             'tests.test_config.pkgs.asset:templates/',
             'tests.test_config.pkgs.asset.subpackage:templates/',
-            _override=override)
+            _override=override,
+        )
         from tests.test_config.pkgs import asset
         from tests.test_config.pkgs.asset import subpackage
+
         self.assertEqual(override.package, asset)
         self.assertEqual(override.path, 'templates/')
         source = override.source
@@ -101,21 +125,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase):
         self.assertEqual(source.prefix, 'templates/')
 
         resource_name = 'bar.pt'
-        expected = os.path.join(here, 'pkgs', 'asset',
-                                'subpackage', 'templates', 'bar.pt')
-        self.assertEqual(override.source.get_filename(resource_name),
-                         expected)
+        expected = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
+        )
+        self.assertEqual(override.source.get_filename(resource_name), expected)
 
     def test_override_asset_directory_with_package(self):
         from pyramid.config.assets import PackageAssetSource
+
         config = self._makeOne(autocommit=True)
         override = DummyUnderOverride()
         config.override_asset(
             'tests.test_config.pkgs.asset:templates/',
             'tests.test_config.pkgs.asset.subpackage',
-            _override=override)
+            _override=override,
+        )
         from tests.test_config.pkgs import asset
         from tests.test_config.pkgs.asset import subpackage
+
         self.assertEqual(override.package, asset)
         self.assertEqual(override.path, 'templates/')
         source = override.source
@@ -124,21 +151,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase):
         self.assertEqual(source.prefix, '')
 
         resource_name = 'templates/bar.pt'
-        expected = os.path.join(here, 'pkgs', 'asset',
-                                'subpackage', 'templates', 'bar.pt')
-        self.assertEqual(override.source.get_filename(resource_name),
-                         expected)
+        expected = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
+        )
+        self.assertEqual(override.source.get_filename(resource_name), expected)
 
     def test_override_asset_package_with_directory(self):
         from pyramid.config.assets import PackageAssetSource
+
         config = self._makeOne(autocommit=True)
         override = DummyUnderOverride()
         config.override_asset(
             'tests.test_config.pkgs.asset',
             'tests.test_config.pkgs.asset.subpackage:templates/',
-            _override=override)
+            _override=override,
+        )
         from tests.test_config.pkgs import asset
         from tests.test_config.pkgs.asset import subpackage
+
         self.assertEqual(override.package, asset)
         self.assertEqual(override.path, '')
         source = override.source
@@ -147,44 +177,59 @@ class TestAssetsConfiguratorMixin(unittest.TestCase):
         self.assertEqual(source.prefix, 'templates/')
 
         resource_name = 'bar.pt'
-        expected = os.path.join(here, 'pkgs', 'asset',
-                                'subpackage', 'templates', 'bar.pt')
-        self.assertEqual(override.source.get_filename(resource_name),
-                         expected)
+        expected = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
+        )
+        self.assertEqual(override.source.get_filename(resource_name), expected)
 
     def test_override_asset_directory_with_absfile(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
-        self.assertRaises(ConfigurationError, config.override_asset,
-                          'a:foo/',
-                          os.path.join(here, 'pkgs', 'asset', 'foo.pt'))
+        self.assertRaises(
+            ConfigurationError,
+            config.override_asset,
+            'a:foo/',
+            os.path.join(here, 'pkgs', 'asset', 'foo.pt'),
+        )
 
     def test_override_asset_file_with_absdirectory(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
-        abspath = os.path.join(here, 'pkgs', 'asset', 'subpackage', 'templates')
-        self.assertRaises(ConfigurationError, config.override_asset,
-                          'a:foo.pt',
-                          abspath)
+        abspath = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates'
+        )
+        self.assertRaises(
+            ConfigurationError, config.override_asset, 'a:foo.pt', abspath
+        )
 
     def test_override_asset_file_with_missing_abspath(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
-        self.assertRaises(ConfigurationError, config.override_asset,
-                          'a:foo.pt',
-                          os.path.join(here, 'wont_exist'))
+        self.assertRaises(
+            ConfigurationError,
+            config.override_asset,
+            'a:foo.pt',
+            os.path.join(here, 'wont_exist'),
+        )
 
     def test_override_asset_file_with_absfile(self):
         from pyramid.config.assets import FSAssetSource
+
         config = self._makeOne(autocommit=True)
         override = DummyUnderOverride()
-        abspath = os.path.join(here, 'pkgs', 'asset', 'subpackage',
-                               'templates', 'bar.pt')
+        abspath = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
+        )
         config.override_asset(
             'tests.test_config.pkgs.asset:templates/foo.pt',
             abspath,
-            _override=override)
+            _override=override,
+        )
         from tests.test_config.pkgs import asset
+
         self.assertEqual(override.package, asset)
         self.assertEqual(override.path, 'templates/foo.pt')
         source = override.source
@@ -192,21 +237,26 @@ class TestAssetsConfiguratorMixin(unittest.TestCase):
         self.assertEqual(source.prefix, abspath)
 
         resource_name = ''
-        expected = os.path.join(here, 'pkgs', 'asset',
-                                'subpackage', 'templates', 'bar.pt')
-        self.assertEqual(override.source.get_filename(resource_name),
-                         expected)
+        expected = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
+        )
+        self.assertEqual(override.source.get_filename(resource_name), expected)
 
     def test_override_asset_directory_with_absdirectory(self):
         from pyramid.config.assets import FSAssetSource
+
         config = self._makeOne(autocommit=True)
         override = DummyUnderOverride()
-        abspath = os.path.join(here, 'pkgs', 'asset', 'subpackage', 'templates')
+        abspath = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates'
+        )
         config.override_asset(
             'tests.test_config.pkgs.asset:templates/',
             abspath,
-            _override=override)
+            _override=override,
+        )
         from tests.test_config.pkgs import asset
+
         self.assertEqual(override.package, asset)
         self.assertEqual(override.path, 'templates/')
         source = override.source
@@ -214,21 +264,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase):
         self.assertEqual(source.prefix, abspath)
 
         resource_name = 'bar.pt'
-        expected = os.path.join(here, 'pkgs', 'asset',
-                                'subpackage', 'templates', 'bar.pt')
-        self.assertEqual(override.source.get_filename(resource_name),
-                         expected)
+        expected = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
+        )
+        self.assertEqual(override.source.get_filename(resource_name), expected)
 
     def test_override_asset_package_with_absdirectory(self):
         from pyramid.config.assets import FSAssetSource
+
         config = self._makeOne(autocommit=True)
         override = DummyUnderOverride()
-        abspath = os.path.join(here, 'pkgs', 'asset', 'subpackage', 'templates')
+        abspath = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates'
+        )
         config.override_asset(
-            'tests.test_config.pkgs.asset',
-            abspath,
-            _override=override)
+            'tests.test_config.pkgs.asset', abspath, _override=override
+        )
         from tests.test_config.pkgs import asset
+
         self.assertEqual(override.package, asset)
         self.assertEqual(override.path, '')
         source = override.source
@@ -236,33 +289,39 @@ class TestAssetsConfiguratorMixin(unittest.TestCase):
         self.assertEqual(source.prefix, abspath)
 
         resource_name = 'bar.pt'
-        expected = os.path.join(here, 'pkgs', 'asset',
-                                'subpackage', 'templates', 'bar.pt')
-        self.assertEqual(override.source.get_filename(resource_name),
-                         expected)
+        expected = os.path.join(
+            here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
+        )
+        self.assertEqual(override.source.get_filename(resource_name), expected)
 
     def test__override_not_yet_registered(self):
         from pyramid.interfaces import IPackageOverrides
+
         package = DummyPackage('package')
         source = DummyAssetSource()
         config = self._makeOne()
-        config._override(package, 'path', source,
-                         PackageOverrides=DummyPackageOverrides)
-        overrides = config.registry.queryUtility(IPackageOverrides,
-                                                 name='package')
+        config._override(
+            package, 'path', source, PackageOverrides=DummyPackageOverrides
+        )
+        overrides = config.registry.queryUtility(
+            IPackageOverrides, name='package'
+        )
         self.assertEqual(overrides.inserted, [('path', source)])
         self.assertEqual(overrides.package, package)
 
     def test__override_already_registered(self):
         from pyramid.interfaces import IPackageOverrides
+
         package = DummyPackage('package')
         source = DummyAssetSource()
         overrides = DummyPackageOverrides(package)
         config = self._makeOne()
-        config.registry.registerUtility(overrides, IPackageOverrides,
-                                        name='package')
-        config._override(package, 'path', source,
-                         PackageOverrides=DummyPackageOverrides)
+        config.registry.registerUtility(
+            overrides, IPackageOverrides, name='package'
+        )
+        config._override(
+            package, 'path', source, PackageOverrides=DummyPackageOverrides
+        )
         self.assertEqual(overrides.inserted, [('path', source)])
         self.assertEqual(overrides.package, package)
 
@@ -276,6 +335,7 @@ class TestOverrideProvider(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.config.assets import OverrideProvider
+
         return OverrideProvider
 
     def _makeOne(self, module):
@@ -285,12 +345,14 @@ class TestOverrideProvider(unittest.TestCase):
     def _registerOverrides(self, overrides, name='tests.test_config'):
         from pyramid.interfaces import IPackageOverrides
         from pyramid.threadlocal import get_current_registry
+
         reg = get_current_registry()
         reg.registerUtility(overrides, IPackageOverrides, name=name)
 
     def test_get_resource_filename_no_overrides(self):
         resource_name = 'test_assets.py'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         expected = os.path.join(here, resource_name)
         result = provider.get_resource_filename(None, resource_name)
@@ -299,6 +361,7 @@ class TestOverrideProvider(unittest.TestCase):
     def test_get_resource_stream_no_overrides(self):
         resource_name = 'test_assets.py'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         with provider.get_resource_stream(None, resource_name) as result:
             _assertBody(result.read(), os.path.join(here, resource_name))
@@ -306,6 +369,7 @@ class TestOverrideProvider(unittest.TestCase):
     def test_get_resource_string_no_overrides(self):
         resource_name = 'test_assets.py'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         result = provider.get_resource_string(None, resource_name)
         _assertBody(result, os.path.join(here, resource_name))
@@ -313,6 +377,7 @@ class TestOverrideProvider(unittest.TestCase):
     def test_has_resource_no_overrides(self):
         resource_name = 'test_assets.py'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         result = provider.has_resource(resource_name)
         self.assertEqual(result, True)
@@ -321,6 +386,7 @@ class TestOverrideProvider(unittest.TestCase):
         file_resource_name = 'test_assets.py'
         directory_resource_name = 'files'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         result = provider.resource_isdir(file_resource_name)
         self.assertEqual(result, False)
@@ -330,6 +396,7 @@ class TestOverrideProvider(unittest.TestCase):
     def test_resource_listdir_no_overrides(self):
         resource_name = 'files'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         result = provider.resource_listdir(resource_name)
         self.assertTrue(result)
@@ -339,16 +406,18 @@ class TestOverrideProvider(unittest.TestCase):
         self._registerOverrides(overrides)
         resource_name = 'test_assets.py'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         expected = os.path.join(here, resource_name)
         result = provider.get_resource_filename(None, resource_name)
         self.assertEqual(result, expected)
-        
+
     def test_get_resource_stream_override_returns_None(self):
         overrides = DummyOverrides(None)
         self._registerOverrides(overrides)
         resource_name = 'test_assets.py'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         with provider.get_resource_stream(None, resource_name) as result:
             _assertBody(result.read(), os.path.join(here, resource_name))
@@ -358,6 +427,7 @@ class TestOverrideProvider(unittest.TestCase):
         self._registerOverrides(overrides)
         resource_name = 'test_assets.py'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         result = provider.get_resource_string(None, resource_name)
         _assertBody(result, os.path.join(here, resource_name))
@@ -367,6 +437,7 @@ class TestOverrideProvider(unittest.TestCase):
         self._registerOverrides(overrides)
         resource_name = 'test_assets.py'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         result = provider.has_resource(resource_name)
         self.assertEqual(result, True)
@@ -376,6 +447,7 @@ class TestOverrideProvider(unittest.TestCase):
         self._registerOverrides(overrides)
         resource_name = 'files'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         result = provider.resource_isdir(resource_name)
         self.assertEqual(result, True)
@@ -385,6 +457,7 @@ class TestOverrideProvider(unittest.TestCase):
         self._registerOverrides(overrides)
         resource_name = 'files'
         import tests.test_config
+
         provider = self._makeOne(tests.test_config)
         result = provider.resource_listdir(resource_name)
         self.assertTrue(result)
@@ -392,6 +465,7 @@ class TestOverrideProvider(unittest.TestCase):
     def test_get_resource_filename_override_returns_value(self):
         overrides = DummyOverrides('value')
         import tests.test_config
+
         self._registerOverrides(overrides)
         provider = self._makeOne(tests.test_config)
         result = provider.get_resource_filename(None, 'test_assets.py')
@@ -399,8 +473,10 @@ class TestOverrideProvider(unittest.TestCase):
 
     def test_get_resource_stream_override_returns_value(self):
         from io import BytesIO
+
         overrides = DummyOverrides(BytesIO(b'value'))
         import tests.test_config
+
         self._registerOverrides(overrides)
         provider = self._makeOne(tests.test_config)
         with provider.get_resource_stream(None, 'test_assets.py') as stream:
@@ -409,6 +485,7 @@ class TestOverrideProvider(unittest.TestCase):
     def test_get_resource_string_override_returns_value(self):
         overrides = DummyOverrides('value')
         import tests.test_config
+
         self._registerOverrides(overrides)
         provider = self._makeOne(tests.test_config)
         result = provider.get_resource_string(None, 'test_assets.py')
@@ -417,6 +494,7 @@ class TestOverrideProvider(unittest.TestCase):
     def test_has_resource_override_returns_True(self):
         overrides = DummyOverrides(True)
         import tests.test_config
+
         self._registerOverrides(overrides)
         provider = self._makeOne(tests.test_config)
         result = provider.has_resource('test_assets.py')
@@ -425,6 +503,7 @@ class TestOverrideProvider(unittest.TestCase):
     def test_resource_isdir_override_returns_False(self):
         overrides = DummyOverrides(False)
         import tests.test_config
+
         self._registerOverrides(overrides)
         provider = self._makeOne(tests.test_config)
         result = provider.resource_isdir('files')
@@ -433,14 +512,17 @@ class TestOverrideProvider(unittest.TestCase):
     def test_resource_listdir_override_returns_values(self):
         overrides = DummyOverrides(['a'])
         import tests.test_config
+
         self._registerOverrides(overrides)
         provider = self._makeOne(tests.test_config)
         result = provider.resource_listdir('files')
         self.assertEqual(result, ['a'])
 
+
 class TestPackageOverrides(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.config.assets import PackageOverrides
+
         return PackageOverrides
 
     def _makeOne(self, package=None, pkg_resources=None):
@@ -454,21 +536,25 @@ class TestPackageOverrides(unittest.TestCase):
     def test_class_conforms_to_IPackageOverrides(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IPackageOverrides
+
         verifyClass(IPackageOverrides, self._getTargetClass())
 
     def test_instance_conforms_to_IPackageOverrides(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IPackageOverrides
+
         verifyObject(IPackageOverrides, self._makeOne())
 
     def test_class_conforms_to_IPEP302Loader(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IPEP302Loader
+
         verifyClass(IPEP302Loader, self._getTargetClass())
 
     def test_instance_conforms_to_IPEP302Loader(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IPEP302Loader
+
         verifyObject(IPEP302Loader, self._makeOne())
 
     def test_ctor_package_already_has_loader_of_different_type(self):
@@ -491,11 +577,13 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_ctor_registers_loader_type(self):
         from pyramid.config.assets import OverrideProvider
+
         dummy_pkg_resources = DummyPkgResources()
         package = DummyPackage('package')
         po = self._makeOne(package, dummy_pkg_resources)
-        self.assertEqual(dummy_pkg_resources.registered, [(po.__class__,
-                         OverrideProvider)])
+        self.assertEqual(
+            dummy_pkg_resources.registered, [(po.__class__, OverrideProvider)]
+        )
 
     def test_ctor_sets_local_state(self):
         package = DummyPackage('package')
@@ -505,6 +593,7 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_insert_directory(self):
         from pyramid.config.assets import DirectoryOverride
+
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = [None]
@@ -515,6 +604,7 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_insert_file(self):
         from pyramid.config.assets import FileOverride
+
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = [None]
@@ -526,6 +616,7 @@ class TestPackageOverrides(unittest.TestCase):
     def test_insert_emptystring(self):
         # XXX is this a valid case for a directory?
         from pyramid.config.assets import DirectoryOverride
+
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = [None]
@@ -536,7 +627,7 @@ class TestPackageOverrides(unittest.TestCase):
         self.assertEqual(override.__class__, DirectoryOverride)
 
     def test_filtered_sources(self):
-        overrides = [ DummyOverride(None), DummyOverride('foo')]
+        overrides = [DummyOverride(None), DummyOverride('foo')]
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = overrides
@@ -544,7 +635,7 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_get_filename(self):
         source = DummyAssetSource(filename='foo.pt')
-        overrides = [ DummyOverride(None), DummyOverride((source, ''))]
+        overrides = [DummyOverride(None), DummyOverride((source, ''))]
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = overrides
@@ -554,7 +645,10 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_get_filename_file_doesnt_exist(self):
         source = DummyAssetSource(filename=None)
-        overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))]
+        overrides = [
+            DummyOverride(None),
+            DummyOverride((source, 'wont_exist')),
+        ]
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = overrides
@@ -569,10 +663,13 @@ class TestPackageOverrides(unittest.TestCase):
         po.overrides = overrides
         self.assertEqual(po.get_stream('whatever'), 'a stream?')
         self.assertEqual(source.resource_name, 'foo.pt')
-        
+
     def test_get_stream_file_doesnt_exist(self):
         source = DummyAssetSource(stream=None)
-        overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))]
+        overrides = [
+            DummyOverride(None),
+            DummyOverride((source, 'wont_exist')),
+        ]
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = overrides
@@ -587,10 +684,13 @@ class TestPackageOverrides(unittest.TestCase):
         po.overrides = overrides
         self.assertEqual(po.get_string('whatever'), 'a string')
         self.assertEqual(source.resource_name, 'foo.pt')
-        
+
     def test_get_string_file_doesnt_exist(self):
         source = DummyAssetSource(string=None)
-        overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))]
+        overrides = [
+            DummyOverride(None),
+            DummyOverride((source, 'wont_exist')),
+        ]
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = overrides
@@ -608,7 +708,10 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_has_resource_file_doesnt_exist(self):
         source = DummyAssetSource(exists=None)
-        overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))]
+        overrides = [
+            DummyOverride(None),
+            DummyOverride((source, 'wont_exist')),
+        ]
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = overrides
@@ -635,7 +738,10 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_isdir_doesnt_exist(self):
         source = DummyAssetSource(isdir=None)
-        overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))]
+        overrides = [
+            DummyOverride(None),
+            DummyOverride((source, 'wont_exist')),
+        ]
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = overrides
@@ -653,7 +759,10 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_listdir_doesnt_exist(self):
         source = DummyAssetSource(listdir=None)
-        overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))]
+        overrides = [
+            DummyOverride(None),
+            DummyOverride((source, 'wont_exist')),
+        ]
         package = DummyPackage('package')
         po = self._makeOne(package)
         po.overrides = overrides
@@ -668,7 +777,7 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_get_data_pkg_has___loader__(self):
         package = DummyPackage('package')
-        loader = package.__loader__  = DummyLoader()
+        loader = package.__loader__ = DummyLoader()
         po = self._makeOne(package)
         self.assertEqual(po.get_data('whatever'), b'DEADBEEF')
         self.assertEqual(loader._got_data, 'whatever')
@@ -680,7 +789,7 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_is_package_pkg_has___loader__(self):
         package = DummyPackage('package')
-        loader = package.__loader__  = DummyLoader()
+        loader = package.__loader__ = DummyLoader()
         po = self._makeOne(package)
         self.assertTrue(po.is_package('whatever'))
         self.assertEqual(loader._is_package, 'whatever')
@@ -692,7 +801,7 @@ class TestPackageOverrides(unittest.TestCase):
 
     def test_get_code_pkg_has___loader__(self):
         package = DummyPackage('package')
-        loader = package.__loader__  = DummyLoader()
+        loader = package.__loader__ = DummyLoader()
         po = self._makeOne(package)
         self.assertEqual(po.get_code('whatever'), b'DEADBEEF')
         self.assertEqual(loader._got_code, 'whatever')
@@ -709,17 +818,20 @@ class TestPackageOverrides(unittest.TestCase):
         self.assertEqual(po.get_source('whatever'), 'def foo():\n    pass')
         self.assertEqual(loader._got_source, 'whatever')
 
-class AssetSourceIntegrationTests(object):
 
+class AssetSourceIntegrationTests(object):
     def test_get_filename(self):
         source = self._makeOne('')
-        self.assertEqual(source.get_filename('test_assets.py'),
-                         os.path.join(here, 'test_assets.py'))
+        self.assertEqual(
+            source.get_filename('test_assets.py'),
+            os.path.join(here, 'test_assets.py'),
+        )
 
     def test_get_filename_with_prefix(self):
         source = self._makeOne('test_assets.py')
-        self.assertEqual(source.get_filename(''),
-                         os.path.join(here, 'test_assets.py'))
+        self.assertEqual(
+            source.get_filename(''), os.path.join(here, 'test_assets.py')
+        )
 
     def test_get_filename_file_doesnt_exist(self):
         source = self._makeOne('')
@@ -741,13 +853,16 @@ class AssetSourceIntegrationTests(object):
 
     def test_get_string(self):
         source = self._makeOne('')
-        _assertBody(source.get_string('test_assets.py'),
-                    os.path.join(here, 'test_assets.py'))
+        _assertBody(
+            source.get_string('test_assets.py'),
+            os.path.join(here, 'test_assets.py'),
+        )
 
     def test_get_string_with_prefix(self):
         source = self._makeOne('test_assets.py')
-        _assertBody(source.get_string(''),
-                    os.path.join(here, 'test_assets.py'))
+        _assertBody(
+            source.get_string(''), os.path.join(here, 'test_assets.py')
+        )
 
     def test_get_string_file_doesnt_exist(self):
         source = self._makeOne('')
@@ -785,28 +900,33 @@ class AssetSourceIntegrationTests(object):
         source = self._makeOne('')
         self.assertEqual(source.listdir('wont_exist'), None)
 
-class TestPackageAssetSource(AssetSourceIntegrationTests, unittest.TestCase):
 
+class TestPackageAssetSource(AssetSourceIntegrationTests, unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.config.assets import PackageAssetSource
+
         return PackageAssetSource
 
     def _makeOne(self, prefix, package='tests.test_config'):
         klass = self._getTargetClass()
         return klass(package, prefix)
 
+
 class TestFSAssetSource(AssetSourceIntegrationTests, unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.config.assets import FSAssetSource
+
         return FSAssetSource
 
     def _makeOne(self, prefix, base_prefix=here):
         klass = self._getTargetClass()
         return klass(os.path.join(base_prefix, prefix))
 
+
 class TestDirectoryOverride(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.config.assets import DirectoryOverride
+
         return DirectoryOverride
 
     def _makeOne(self, path, source):
@@ -818,16 +938,18 @@ class TestDirectoryOverride(unittest.TestCase):
         o = self._makeOne('foo/', source)
         result = o('foo/something.pt')
         self.assertEqual(result, (source, 'something.pt'))
-        
+
     def test_it_no_match(self):
         source = DummyAssetSource()
         o = self._makeOne('foo/', source)
         result = o('baz/notfound.pt')
         self.assertEqual(result, None)
 
+
 class TestFileOverride(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.config.assets import FileOverride
+
         return FileOverride
 
     def _makeOne(self, path, source):
@@ -839,13 +961,14 @@ class TestFileOverride(unittest.TestCase):
         o = self._makeOne('foo.pt', source)
         result = o('foo.pt')
         self.assertEqual(result, (source, ''))
-        
+
     def test_it_no_match(self):
         source = DummyAssetSource()
         o = self._makeOne('foo.pt', source)
         result = o('notfound.pt')
         self.assertEqual(result, None)
 
+
 class DummyOverride:
     def __init__(self, result):
         self.result = result
@@ -853,6 +976,7 @@ class DummyOverride:
     def __call__(self, resource_name):
         return self.result
 
+
 class DummyOverrides:
     def __init__(self, result):
         self.result = result
@@ -862,6 +986,7 @@ class DummyOverrides:
 
     listdir = isdir = has_resource = get_stream = get_string = get_filename
 
+
 class DummyPackageOverrides:
     def __init__(self, package):
         self.package = package
@@ -869,7 +994,8 @@ class DummyPackageOverrides:
 
     def insert(self, path, source):
         self.inserted.append((path, source))
-    
+
+
 class DummyPkgResources:
     def __init__(self):
         self.registered = []
@@ -877,10 +1003,12 @@ class DummyPkgResources:
     def register_loader_type(self, typ, inst):
         self.registered.append((typ, inst))
 
+
 class DummyPackage:
     def __init__(self, name):
         self.__name__ = name
 
+
 class DummyAssetSource:
     def __init__(self, **kw):
         self.kw = kw
@@ -908,33 +1036,41 @@ class DummyAssetSource:
     def listdir(self, resource_name):
         self.resource_name = resource_name
         return self.kw['listdir']
- 
+
+
 class DummyLoader:
     _got_data = _is_package = None
+
     def get_data(self, path):
         self._got_data = path
         return b'DEADBEEF'
+
     def is_package(self, fullname):
         self._is_package = fullname
         return True
+
     def get_code(self, fullname):
         self._got_code = fullname
         return b'DEADBEEF'
+
     def get_source(self, fullname):
         self._got_source = fullname
         return 'def foo():\n    pass'
 
+
 class DummyUnderOverride:
     def __call__(self, package, path, source, _info=''):
         self.package = package
         self.path = path
         self.source = source
 
+
 def read_(src):
     with open(src, 'rb') as f:
         contents = f.read()
     return contents
 
+
 def _assertBody(body, filename):
     # strip both \n and \r for windows
     body = body.replace(b'\r', b'')
@@ -942,4 +1078,4 @@ def _assertBody(body, filename):
     data = read_(filename)
     data = data.replace(b'\r', b'')
     data = data.replace(b'\n', b'')
-    assert(body == data)
+    assert body == data
diff --git a/tests/test_config/test_factories.py b/tests/test_config/test_factories.py
index ea8dec720..325ba52f3 100644
--- a/tests/test_config/test_factories.py
+++ b/tests/test_config/test_factories.py
@@ -2,14 +2,17 @@ import unittest
 
 from . import dummyfactory
 
+
 class TestFactoriesMixin(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def test_set_request_factory(self):
         from pyramid.interfaces import IRequestFactory
+
         config = self._makeOne(autocommit=True)
         factory = object()
         config.set_request_factory(factory)
@@ -17,14 +20,16 @@ class TestFactoriesMixin(unittest.TestCase):
 
     def test_set_request_factory_dottedname(self):
         from pyramid.interfaces import IRequestFactory
+
         config = self._makeOne(autocommit=True)
-        config.set_request_factory(
-            'tests.test_config.dummyfactory')
-        self.assertEqual(config.registry.getUtility(IRequestFactory),
-                         dummyfactory)
+        config.set_request_factory('tests.test_config.dummyfactory')
+        self.assertEqual(
+            config.registry.getUtility(IRequestFactory), dummyfactory
+        )
 
     def test_set_response_factory(self):
         from pyramid.interfaces import IResponseFactory
+
         config = self._makeOne(autocommit=True)
         factory = lambda r: object()
         config.set_response_factory(factory)
@@ -32,58 +37,72 @@ class TestFactoriesMixin(unittest.TestCase):
 
     def test_set_response_factory_dottedname(self):
         from pyramid.interfaces import IResponseFactory
+
         config = self._makeOne(autocommit=True)
-        config.set_response_factory(
-            'tests.test_config.dummyfactory')
-        self.assertEqual(config.registry.getUtility(IResponseFactory),
-                         dummyfactory)
+        config.set_response_factory('tests.test_config.dummyfactory')
+        self.assertEqual(
+            config.registry.getUtility(IResponseFactory), dummyfactory
+        )
 
     def test_set_root_factory(self):
         from pyramid.interfaces import IRootFactory
+
         config = self._makeOne()
         config.set_root_factory(dummyfactory)
         self.assertEqual(config.registry.queryUtility(IRootFactory), None)
         config.commit()
-        self.assertEqual(config.registry.getUtility(IRootFactory), dummyfactory)
+        self.assertEqual(
+            config.registry.getUtility(IRootFactory), dummyfactory
+        )
 
     def test_set_root_factory_as_None(self):
         from pyramid.interfaces import IRootFactory
         from pyramid.traversal import DefaultRootFactory
+
         config = self._makeOne()
         config.set_root_factory(None)
         self.assertEqual(config.registry.queryUtility(IRootFactory), None)
         config.commit()
-        self.assertEqual(config.registry.getUtility(IRootFactory),
-                         DefaultRootFactory)
+        self.assertEqual(
+            config.registry.getUtility(IRootFactory), DefaultRootFactory
+        )
 
     def test_set_root_factory_dottedname(self):
         from pyramid.interfaces import IRootFactory
+
         config = self._makeOne()
         config.set_root_factory('tests.test_config.dummyfactory')
         self.assertEqual(config.registry.queryUtility(IRootFactory), None)
         config.commit()
-        self.assertEqual(config.registry.getUtility(IRootFactory), dummyfactory)
+        self.assertEqual(
+            config.registry.getUtility(IRootFactory), dummyfactory
+        )
 
     def test_set_session_factory(self):
         from pyramid.interfaces import ISessionFactory
+
         config = self._makeOne()
         config.set_session_factory(dummyfactory)
         self.assertEqual(config.registry.queryUtility(ISessionFactory), None)
         config.commit()
-        self.assertEqual(config.registry.getUtility(ISessionFactory),
-                         dummyfactory)
+        self.assertEqual(
+            config.registry.getUtility(ISessionFactory), dummyfactory
+        )
 
     def test_set_session_factory_dottedname(self):
         from pyramid.interfaces import ISessionFactory
+
         config = self._makeOne()
         config.set_session_factory('tests.test_config.dummyfactory')
         self.assertEqual(config.registry.queryUtility(ISessionFactory), None)
         config.commit()
-        self.assertEqual(config.registry.getUtility(ISessionFactory),
-                         dummyfactory)
+        self.assertEqual(
+            config.registry.getUtility(ISessionFactory), dummyfactory
+        )
 
     def test_add_request_method_with_callable(self):
         from pyramid.interfaces import IRequestExtensions
+
         config = self._makeOne(autocommit=True)
         callable = lambda x: None
         config.add_request_method(callable, name='foo')
@@ -92,23 +111,34 @@ class TestFactoriesMixin(unittest.TestCase):
 
     def test_add_request_method_with_unnamed_callable(self):
         from pyramid.interfaces import IRequestExtensions
+
         config = self._makeOne(autocommit=True)
-        def foo(self): pass
+
+        def foo(self):
+            pass
+
         config.add_request_method(foo)
         exts = config.registry.getUtility(IRequestExtensions)
         self.assertTrue('foo' in exts.methods)
 
     def test_set_multiple_request_methods_conflict(self):
         from pyramid.exceptions import ConfigurationConflictError
+
         config = self._makeOne()
-        def foo(self): pass
-        def bar(self): pass
+
+        def foo(self):
+            pass
+
+        def bar(self):
+            pass
+
         config.add_request_method(foo, name='bar')
         config.add_request_method(bar, name='bar')
         self.assertRaises(ConfigurationConflictError, config.commit)
 
     def test_add_request_method_with_None_callable(self):
         from pyramid.interfaces import IRequestExtensions
+
         config = self._makeOne(autocommit=True)
         config.add_request_method(name='foo')
         exts = config.registry.queryUtility(IRequestExtensions)
@@ -116,8 +146,12 @@ class TestFactoriesMixin(unittest.TestCase):
 
     def test_add_request_method_with_None_callable_conflict(self):
         from pyramid.exceptions import ConfigurationConflictError
+
         config = self._makeOne()
-        def bar(self): pass
+
+        def bar(self):
+            pass
+
         config.add_request_method(name='foo')
         config.add_request_method(bar, name='foo')
         self.assertRaises(ConfigurationConflictError, config.commit)
@@ -132,7 +166,9 @@ class TestFactoriesMixin(unittest.TestCase):
         from pyramid.exceptions import ConfigurationError
 
         config = self._makeOne(autocommit=True)
-        def boomshaka(r): pass
+
+        def boomshaka(r):
+            pass
 
         def get_bad_name():
             if PY2:
@@ -146,8 +182,12 @@ class TestFactoriesMixin(unittest.TestCase):
 
     def test_set_execution_policy(self):
         from pyramid.interfaces import IExecutionPolicy
+
         config = self._makeOne(autocommit=True)
-        def dummy_policy(environ, router): pass
+
+        def dummy_policy(environ, router):
+            pass
+
         config.set_execution_policy(dummy_policy)
         registry = config.registry
         result = registry.queryUtility(IExecutionPolicy)
@@ -156,6 +196,7 @@ class TestFactoriesMixin(unittest.TestCase):
     def test_set_execution_policy_to_None(self):
         from pyramid.interfaces import IExecutionPolicy
         from pyramid.router import default_execution_policy
+
         config = self._makeOne(autocommit=True)
         config.set_execution_policy(None)
         registry = config.registry
diff --git a/tests/test_config/test_i18n.py b/tests/test_config/test_i18n.py
index 87805f671..5961e9ff2 100644
--- a/tests/test_config/test_i18n.py
+++ b/tests/test_config/test_i18n.py
@@ -5,56 +5,73 @@ from . import dummyfactory
 
 here = os.path.dirname(__file__)
 locale = os.path.abspath(
-    os.path.join(here, '..', 'pkgs', 'localeapp', 'locale'))
+    os.path.join(here, '..', 'pkgs', 'localeapp', 'locale')
+)
 locale2 = os.path.abspath(
-    os.path.join(here, '..', 'pkgs', 'localeapp', 'locale2'))
+    os.path.join(here, '..', 'pkgs', 'localeapp', 'locale2')
+)
 locale3 = os.path.abspath(
-    os.path.join(here, '..', 'pkgs', 'localeapp', 'locale3'))
+    os.path.join(here, '..', 'pkgs', 'localeapp', 'locale3')
+)
+
 
 class TestI18NConfiguratorMixin(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def test_set_locale_negotiator(self):
         from pyramid.interfaces import ILocaleNegotiator
+
         config = self._makeOne(autocommit=True)
-        def negotiator(request): pass
+
+        def negotiator(request):
+            pass
+
         config.set_locale_negotiator(negotiator)
-        self.assertEqual(config.registry.getUtility(ILocaleNegotiator),
-                         negotiator)
+        self.assertEqual(
+            config.registry.getUtility(ILocaleNegotiator), negotiator
+        )
 
     def test_set_locale_negotiator_dottedname(self):
         from pyramid.interfaces import ILocaleNegotiator
+
         config = self._makeOne(autocommit=True)
-        config.set_locale_negotiator(
-            'tests.test_config.dummyfactory')
-        self.assertEqual(config.registry.getUtility(ILocaleNegotiator),
-                         dummyfactory)
+        config.set_locale_negotiator('tests.test_config.dummyfactory')
+        self.assertEqual(
+            config.registry.getUtility(ILocaleNegotiator), dummyfactory
+        )
 
     def test_add_translation_dirs_missing_dir(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
         config.add_translation_dirs('/wont/exist/on/my/system')
         self.assertRaises(ConfigurationError, config.commit)
 
     def test_add_translation_dirs_no_specs(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne()
         config.add_translation_dirs()
-        self.assertEqual(config.registry.queryUtility(ITranslationDirectories),
-                         None)
+        self.assertEqual(
+            config.registry.queryUtility(ITranslationDirectories), None
+        )
 
     def test_add_translation_dirs_asset_spec(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne(autocommit=True)
         config.add_translation_dirs('tests.pkgs.localeapp:locale')
-        self.assertEqual(config.registry.getUtility(ITranslationDirectories),
-                         [locale])
+        self.assertEqual(
+            config.registry.getUtility(ITranslationDirectories), [locale]
+        )
 
     def test_add_translation_dirs_asset_spec_existing_translation_dirs(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne(autocommit=True)
         directories = ['abc']
         config.registry.registerUtility(directories, ITranslationDirectories)
@@ -64,69 +81,93 @@ class TestI18NConfiguratorMixin(unittest.TestCase):
 
     def test_add_translation_dirs_multiple_specs(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne(autocommit=True)
-        config.add_translation_dirs('tests.pkgs.localeapp:locale',
-                                    'tests.pkgs.localeapp:locale2')
-        self.assertEqual(config.registry.getUtility(ITranslationDirectories),
-                         [locale, locale2])
+        config.add_translation_dirs(
+            'tests.pkgs.localeapp:locale', 'tests.pkgs.localeapp:locale2'
+        )
+        self.assertEqual(
+            config.registry.getUtility(ITranslationDirectories),
+            [locale, locale2],
+        )
 
     def test_add_translation_dirs_multiple_specs_multiple_calls(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne(autocommit=True)
-        config.add_translation_dirs('tests.pkgs.localeapp:locale',
-                                    'tests.pkgs.localeapp:locale2')
+        config.add_translation_dirs(
+            'tests.pkgs.localeapp:locale', 'tests.pkgs.localeapp:locale2'
+        )
         config.add_translation_dirs('tests.pkgs.localeapp:locale3')
-        self.assertEqual(config.registry.getUtility(ITranslationDirectories),
-                         [locale3, locale, locale2])
+        self.assertEqual(
+            config.registry.getUtility(ITranslationDirectories),
+            [locale3, locale, locale2],
+        )
 
     def test_add_translation_dirs_override_multiple_specs_multiple_calls(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne(autocommit=True)
-        config.add_translation_dirs('tests.pkgs.localeapp:locale',
-                                    'tests.pkgs.localeapp:locale2')
-        config.add_translation_dirs('tests.pkgs.localeapp:locale3',
-                                    override=True)
-        self.assertEqual(config.registry.getUtility(ITranslationDirectories),
-                         [locale, locale2, locale3])
+        config.add_translation_dirs(
+            'tests.pkgs.localeapp:locale', 'tests.pkgs.localeapp:locale2'
+        )
+        config.add_translation_dirs(
+            'tests.pkgs.localeapp:locale3', override=True
+        )
+        self.assertEqual(
+            config.registry.getUtility(ITranslationDirectories),
+            [locale, locale2, locale3],
+        )
 
     def test_add_translation_dirs_invalid_kwargs(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne(autocommit=True)
         with self.assertRaises(TypeError):
-            config.add_translation_dirs('tests.pkgs.localeapp:locale',
-                                        foo=1)
+            config.add_translation_dirs('tests.pkgs.localeapp:locale', foo=1)
 
     def test_add_translation_dirs_abspath(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne(autocommit=True)
         config.add_translation_dirs(locale)
-        self.assertEqual(config.registry.getUtility(ITranslationDirectories),
-                         [locale])
+        self.assertEqual(
+            config.registry.getUtility(ITranslationDirectories), [locale]
+        )
 
     def test_add_translation_dirs_uses_override_out_of_order(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne()
         config.add_translation_dirs('tests.pkgs.localeapp:locale')
-        config.override_asset('tests.pkgs.localeapp:locale/',
-                              'tests.pkgs.localeapp:locale2/')
+        config.override_asset(
+            'tests.pkgs.localeapp:locale/', 'tests.pkgs.localeapp:locale2/'
+        )
         config.commit()
-        self.assertEqual(config.registry.getUtility(ITranslationDirectories),
-                         [locale2])
+        self.assertEqual(
+            config.registry.getUtility(ITranslationDirectories), [locale2]
+        )
 
     def test_add_translation_dirs_doesnt_use_override_w_autocommit(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne(autocommit=True)
         config.add_translation_dirs('tests.pkgs.localeapp:locale')
-        config.override_asset('tests.pkgs.localeapp:locale/',
-                              'tests.pkgs.localeapp:locale2/')
-        self.assertEqual(config.registry.getUtility(ITranslationDirectories),
-                         [locale])
+        config.override_asset(
+            'tests.pkgs.localeapp:locale/', 'tests.pkgs.localeapp:locale2/'
+        )
+        self.assertEqual(
+            config.registry.getUtility(ITranslationDirectories), [locale]
+        )
 
     def test_add_translation_dirs_uses_override_w_autocommit(self):
         from pyramid.interfaces import ITranslationDirectories
+
         config = self._makeOne(autocommit=True)
-        config.override_asset('tests.pkgs.localeapp:locale/',
-                              'tests.pkgs.localeapp:locale2/')
+        config.override_asset(
+            'tests.pkgs.localeapp:locale/', 'tests.pkgs.localeapp:locale2/'
+        )
         config.add_translation_dirs('tests.pkgs.localeapp:locale')
-        self.assertEqual(config.registry.getUtility(ITranslationDirectories),
-                         [locale2])
+        self.assertEqual(
+            config.registry.getUtility(ITranslationDirectories), [locale2]
+        )
diff --git a/tests/test_config/test_init.py b/tests/test_config/test_init.py
index a3c83357e..a7b19a1ac 100644
--- a/tests/test_config/test_init.py
+++ b/tests/test_config/test_init.py
@@ -17,20 +17,29 @@ from pyramid.exceptions import ConfigurationConflictError
 
 from pyramid.interfaces import IRequest
 
+
 class ConfiguratorTests(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
-    def _getViewCallable(self, config, ctx_iface=None, request_iface=None,
-                         name='', exception_view=False):
+    def _getViewCallable(
+        self,
+        config,
+        ctx_iface=None,
+        request_iface=None,
+        name='',
+        exception_view=False,
+    ):
         from zope.interface import Interface
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
-        if exception_view: # pragma: no cover
+
+        if exception_view:  # pragma: no cover
             classifier = IExceptionViewClassifier
         else:
             classifier = IViewClassifier
@@ -39,16 +48,22 @@ class ConfiguratorTests(unittest.TestCase):
         if request_iface is None:
             request_iface = IRequest
         return config.registry.adapters.lookup(
-            (classifier, request_iface, ctx_iface), IView, name=name,
-            default=None)
+            (classifier, request_iface, ctx_iface),
+            IView,
+            name=name,
+            default=None,
+        )
 
     def _registerEventListener(self, config, event_iface=None):
-        if event_iface is None: # pragma: no cover
+        if event_iface is None:  # pragma: no cover
             from zope.interface import Interface
+
             event_iface = Interface
         L = []
+
         def subscriber(*event):
             L.extend(event)
+
         config.registry.registerHandler(subscriber, (event_iface,))
         return L
 
@@ -62,6 +77,7 @@ class ConfiguratorTests(unittest.TestCase):
         from pyramid.interfaces import ISettings
         from pyramid.config import Configurator
         from pyramid.interfaces import IRendererFactory
+
         config = Configurator()
         this_pkg = sys.modules['tests.test_config']
         self.assertTrue(config.registry.getUtility(ISettings))
@@ -72,27 +88,32 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_begin(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         manager = DummyThreadLocalManager()
         config.manager = manager
         config.begin()
-        self.assertEqual(manager.pushed,
-                         {'registry':config.registry, 'request':None})
+        self.assertEqual(
+            manager.pushed, {'registry': config.registry, 'request': None}
+        )
         self.assertEqual(manager.popped, False)
 
     def test_begin_with_request(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         request = object()
         manager = DummyThreadLocalManager()
         config.manager = manager
         config.begin(request=request)
-        self.assertEqual(manager.pushed,
-                         {'registry':config.registry, 'request':request})
+        self.assertEqual(
+            manager.pushed, {'registry': config.registry, 'request': request}
+        )
         self.assertEqual(manager.popped, False)
 
     def test_begin_overrides_request(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         manager = DummyThreadLocalManager()
         req = object()
@@ -107,6 +128,7 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_begin_propagates_request_for_same_registry(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         manager = DummyThreadLocalManager()
         req = object()
@@ -120,6 +142,7 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_begin_does_not_propagate_request_for_diff_registry(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         manager = DummyThreadLocalManager()
         req = object()
@@ -133,6 +156,7 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_end(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         manager = DummyThreadLocalManager()
         pushed = manager.pushed
@@ -143,14 +167,16 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_context_manager(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         manager = DummyThreadLocalManager()
         config.manager = manager
         view = lambda r: None
         with config as ctx:
             self.assertTrue(config is ctx)
-            self.assertEqual(manager.pushed,
-                             {'registry': config.registry, 'request': None})
+            self.assertEqual(
+                manager.pushed, {'registry': config.registry, 'request': None}
+            )
             self.assertFalse(manager.popped)
             config.add_view(view)
         self.assertTrue(manager.popped)
@@ -160,14 +186,15 @@ class ConfiguratorTests(unittest.TestCase):
     def test_ctor_with_package_registry(self):
         import sys
         from pyramid.config import Configurator
+
         pkg = sys.modules['pyramid']
         config = Configurator(package=pkg)
         self.assertEqual(config.package, pkg)
 
     def test_ctor_noreg_custom_settings(self):
         from pyramid.interfaces import ISettings
-        settings = {'reload_templates':True,
-                    'mysetting':True}
+
+        settings = {'reload_templates': True, 'mysetting': True}
         config = self._makeOne(settings=settings)
         settings = config.registry.getUtility(ISettings)
         self.assertEqual(settings['reload_templates'], True)
@@ -176,12 +203,14 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_ctor_noreg_debug_logger_None_default(self):
         from pyramid.interfaces import IDebugLogger
+
         config = self._makeOne()
         logger = config.registry.getUtility(IDebugLogger)
         self.assertEqual(logger.name, 'tests.test_config')
 
     def test_ctor_noreg_debug_logger_non_None(self):
         from pyramid.interfaces import IDebugLogger
+
         logger = object()
         config = self._makeOne(debug_logger=logger)
         result = config.registry.getUtility(IDebugLogger)
@@ -189,6 +218,7 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_ctor_authentication_policy(self):
         from pyramid.interfaces import IAuthenticationPolicy
+
         policy = object()
         config = self._makeOne(authentication_policy=policy)
         config.commit()
@@ -202,6 +232,7 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_ctor_no_root_factory(self):
         from pyramid.interfaces import IRootFactory
+
         config = self._makeOne()
         self.assertEqual(config.registry.queryUtility(IRootFactory), None)
         config.commit()
@@ -209,6 +240,7 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_ctor_with_root_factory(self):
         from pyramid.interfaces import IRootFactory
+
         factory = object()
         config = self._makeOne(root_factory=factory)
         self.assertEqual(config.registry.queryUtility(IRootFactory), None)
@@ -217,27 +249,36 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_ctor_alternate_renderers(self):
         from pyramid.interfaces import IRendererFactory
+
         renderer = object()
         config = self._makeOne(renderers=[('yeah', renderer)])
         config.commit()
-        self.assertEqual(config.registry.getUtility(IRendererFactory, 'yeah'),
-                         renderer)
+        self.assertEqual(
+            config.registry.getUtility(IRendererFactory, 'yeah'), renderer
+        )
 
     def test_ctor_default_renderers(self):
         from pyramid.interfaces import IRendererFactory
         from pyramid.renderers import json_renderer_factory
+
         config = self._makeOne()
-        self.assertEqual(config.registry.getUtility(IRendererFactory, 'json'),
-                         json_renderer_factory)
+        self.assertEqual(
+            config.registry.getUtility(IRendererFactory, 'json'),
+            json_renderer_factory,
+        )
 
     def test_ctor_default_permission(self):
         from pyramid.interfaces import IDefaultPermission
+
         config = self._makeOne(default_permission='view')
         config.commit()
-        self.assertEqual(config.registry.getUtility(IDefaultPermission), 'view')
+        self.assertEqual(
+            config.registry.getUtility(IDefaultPermission), 'view'
+        )
 
     def test_ctor_session_factory(self):
         from pyramid.interfaces import ISessionFactory
+
         factory = object()
         config = self._makeOne(session_factory=factory)
         self.assertEqual(config.registry.queryUtility(ISessionFactory), None)
@@ -246,39 +287,46 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_ctor_default_view_mapper(self):
         from pyramid.interfaces import IViewMapperFactory
+
         mapper = object()
         config = self._makeOne(default_view_mapper=mapper)
         config.commit()
-        self.assertEqual(config.registry.getUtility(IViewMapperFactory),
-                         mapper)
+        self.assertEqual(
+            config.registry.getUtility(IViewMapperFactory), mapper
+        )
 
     def test_ctor_httpexception_view_default(self):
         from pyramid.interfaces import IExceptionResponse
         from pyramid.httpexceptions import default_exceptionresponse_view
         from pyramid.interfaces import IRequest
+
         config = self._makeOne()
-        view = self._getViewCallable(config,
-                                     ctx_iface=IExceptionResponse,
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config, ctx_iface=IExceptionResponse, request_iface=IRequest
+        )
         self.assertTrue(view.__wraps__ is default_exceptionresponse_view)
 
     def test_ctor_exceptionresponse_view_None(self):
         from pyramid.interfaces import IExceptionResponse
         from pyramid.interfaces import IRequest
+
         config = self._makeOne(exceptionresponse_view=None)
-        view = self._getViewCallable(config,
-                                     ctx_iface=IExceptionResponse,
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config, ctx_iface=IExceptionResponse, request_iface=IRequest
+        )
         self.assertTrue(view is None)
 
     def test_ctor_exceptionresponse_view_custom(self):
         from pyramid.interfaces import IExceptionResponse
         from pyramid.interfaces import IRequest
-        def exceptionresponse_view(context, request): pass
+
+        def exceptionresponse_view(context, request):
+            pass
+
         config = self._makeOne(exceptionresponse_view=exceptionresponse_view)
-        view = self._getViewCallable(config,
-                                     ctx_iface=IExceptionResponse,
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config, ctx_iface=IExceptionResponse, request_iface=IRequest
+        )
         self.assertTrue(view.__wraps__ is exceptionresponse_view)
 
     def test_ctor_with_introspection(self):
@@ -287,27 +335,33 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_ctor_default_webob_response_adapter_registered(self):
         from webob import Response as WebobResponse
+
         response = WebobResponse()
         from pyramid.interfaces import IResponse
+
         config = self._makeOne(autocommit=True)
         result = config.registry.queryAdapter(response, IResponse)
         self.assertEqual(result, response)
-        
+
     def test_with_package_module(self):
         from . import test_init
+
         config = self._makeOne()
         newconfig = config.with_package(test_init)
         import tests.test_config
+
         self.assertEqual(newconfig.package, tests.test_config)
 
     def test_with_package_package(self):
         from tests import test_config
+
         config = self._makeOne()
         newconfig = config.with_package(test_config)
         self.assertEqual(newconfig.package, test_config)
 
     def test_with_package(self):
         import tests
+
         config = self._makeOne()
         config.basepath = 'basepath'
         config.info = 'info'
@@ -325,6 +379,7 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_maybe_dotted_string_success(self):
         import tests.test_config
+
         config = self._makeOne()
         result = config.maybe_dotted('tests.test_config')
         self.assertEqual(result, tests.test_config)
@@ -335,24 +390,28 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_maybe_dotted_notstring_success(self):
         import tests.test_config
+
         config = self._makeOne()
         result = config.maybe_dotted(tests.test_config)
         self.assertEqual(result, tests.test_config)
 
     def test_absolute_asset_spec_already_absolute(self):
         import tests.test_config
+
         config = self._makeOne(package=tests.test_config)
         result = config.absolute_asset_spec('already:absolute')
         self.assertEqual(result, 'already:absolute')
 
     def test_absolute_asset_spec_notastring(self):
         import tests.test_config
+
         config = self._makeOne(package=tests.test_config)
         result = config.absolute_asset_spec(None)
         self.assertEqual(result, None)
 
     def test_absolute_asset_spec_relative(self):
         import tests.test_config
+
         config = self._makeOne(package=tests.test_config)
         result = config.absolute_asset_spec('files')
         self.assertEqual(result, 'tests.test_config:files')
@@ -373,13 +432,17 @@ class ConfiguratorTests(unittest.TestCase):
     def test__fix_registry_queryAdapterOrSelf(self):
         from zope.interface import Interface
         from zope.interface import implementer
+
         class IFoo(Interface):
             pass
+
         @implementer(IFoo)
         class Foo(object):
             pass
+
         class Bar(object):
             pass
+
         adaptation = ()
         foo = Foo()
         bar = Bar()
@@ -397,9 +460,16 @@ class ConfiguratorTests(unittest.TestCase):
         self.assertEqual(len(reg.adapters), 1)
         args, kw = reg.adapters[0]
         self.assertEqual(args[0]('abc'), 'abc')
-        self.assertEqual(kw,
-                         {'info': '', 'provided': 'provided',
-                          'required': 'required', 'name': 'abc', 'event': True})
+        self.assertEqual(
+            kw,
+            {
+                'info': '',
+                'provided': 'provided',
+                'required': 'required',
+                'name': 'abc',
+                'event': True,
+            },
+        )
 
     def test__fix_registry_adds__lock(self):
         reg = DummyRegistry()
@@ -428,6 +498,7 @@ class ConfiguratorTests(unittest.TestCase):
         from webob.exc import WSGIHTTPException
         from pyramid.interfaces import IExceptionResponse
         from pyramid.view import default_exceptionresponse_view
+
         reg = DummyRegistry()
         config = self._makeOne(reg)
         views = []
@@ -435,17 +506,29 @@ class ConfiguratorTests(unittest.TestCase):
         config.add_default_view_predicates = lambda *arg: None
         config._add_tween = lambda *arg, **kw: False
         config.setup_registry()
-        self.assertEqual(views[0], ((default_exceptionresponse_view,),
-                                    {'context':IExceptionResponse}))
-        self.assertEqual(views[1], ((default_exceptionresponse_view,),
-                                    {'context':WSGIHTTPException}))
+        self.assertEqual(
+            views[0],
+            (
+                (default_exceptionresponse_view,),
+                {'context': IExceptionResponse},
+            ),
+        )
+        self.assertEqual(
+            views[1],
+            (
+                (default_exceptionresponse_view,),
+                {'context': WSGIHTTPException},
+            ),
+        )
 
     def test_setup_registry_registers_default_view_predicates(self):
         reg = DummyRegistry()
         config = self._makeOne(reg)
         vp_called = []
         config.add_view = lambda *arg, **kw: None
-        config.add_default_view_predicates = lambda *arg: vp_called.append(True)
+        config.add_default_view_predicates = lambda *arg: vp_called.append(
+            True
+        )
         config._add_tween = lambda *arg, **kw: False
         config.setup_registry()
         self.assertTrue(vp_called)
@@ -453,11 +536,13 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_registers_default_webob_iresponse_adapter(self):
         from webob import Response
         from pyramid.interfaces import IResponse
+
         config = self._makeOne()
         config.setup_registry()
         response = Response()
         self.assertTrue(
-            config.registry.queryAdapter(response, IResponse) is response)
+            config.registry.queryAdapter(response, IResponse) is response
+        )
 
     def test_setup_registry_explicit_notfound_trumps_iexceptionresponse(self):
         from pyramid.renderers import null_renderer
@@ -465,24 +550,29 @@ class ConfiguratorTests(unittest.TestCase):
         from pyramid.interfaces import IRequest
         from pyramid.httpexceptions import HTTPNotFound
         from pyramid.registry import Registry
+
         reg = Registry()
         config = self._makeOne(reg, autocommit=True)
-        config.setup_registry() # registers IExceptionResponse default view
+        config.setup_registry()  # registers IExceptionResponse default view
+
         def myview(context, request):
             return 'OK'
+
         config.add_view(myview, context=HTTPNotFound, renderer=null_renderer)
         request = self._makeRequest(config)
-        view = self._getViewCallable(config,
-                                     ctx_iface=implementedBy(HTTPNotFound),
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config,
+            ctx_iface=implementedBy(HTTPNotFound),
+            request_iface=IRequest,
+        )
         result = view(None, request)
         self.assertEqual(result, 'OK')
 
     def test_setup_registry_custom_settings(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import ISettings
-        settings = {'reload_templates':True,
-                    'mysetting':True}
+
+        settings = {'reload_templates': True, 'mysetting': True}
         reg = Registry()
         config = self._makeOne(reg)
         config.setup_registry(settings=settings)
@@ -494,6 +584,7 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_debug_logger_None_default(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IDebugLogger
+
         reg = Registry()
         config = self._makeOne(reg)
         config.setup_registry()
@@ -503,6 +594,7 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_debug_logger_non_None(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IDebugLogger
+
         logger = object()
         reg = Registry()
         config = self._makeOne(reg)
@@ -513,6 +605,7 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_debug_logger_name(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IDebugLogger
+
         reg = Registry()
         config = self._makeOne(reg)
         config.setup_registry(debug_logger='foo')
@@ -522,6 +615,7 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_authentication_policy(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IAuthenticationPolicy
+
         policy = object()
         reg = Registry()
         config = self._makeOne(reg)
@@ -533,29 +627,36 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_authentication_policy_dottedname(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IAuthenticationPolicy
+
         reg = Registry()
         config = self._makeOne(reg)
         config.setup_registry(authentication_policy='tests.test_config')
         config.commit()
         result = reg.getUtility(IAuthenticationPolicy)
         import tests.test_config
+
         self.assertEqual(result, tests.test_config)
 
     def test_setup_registry_authorization_policy_dottedname(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IAuthorizationPolicy
+
         reg = Registry()
         config = self._makeOne(reg)
         dummy = object()
-        config.setup_registry(authentication_policy=dummy,
-                              authorization_policy='tests.test_config')
+        config.setup_registry(
+            authentication_policy=dummy,
+            authorization_policy='tests.test_config',
+        )
         config.commit()
         result = reg.getUtility(IAuthorizationPolicy)
         import tests.test_config
+
         self.assertEqual(result, tests.test_config)
 
     def test_setup_registry_authorization_policy_only(self):
         from pyramid.registry import Registry
+
         policy = object()
         reg = Registry()
         config = self._makeOne(reg)
@@ -565,6 +666,7 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_no_default_root_factory(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IRootFactory
+
         reg = Registry()
         config = self._makeOne(reg)
         config.setup_registry()
@@ -574,9 +676,11 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_dottedname_root_factory(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IRootFactory
+
         reg = Registry()
         config = self._makeOne(reg)
         import tests.test_config
+
         config.setup_registry(root_factory='tests.test_config')
         self.assertEqual(reg.queryUtility(IRootFactory), None)
         config.commit()
@@ -585,9 +689,11 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_locale_negotiator_dottedname(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import ILocaleNegotiator
+
         reg = Registry()
         config = self._makeOne(reg)
         import tests.test_config
+
         config.setup_registry(locale_negotiator='tests.test_config')
         self.assertEqual(reg.queryUtility(ILocaleNegotiator), None)
         config.commit()
@@ -597,6 +703,7 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_locale_negotiator(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import ILocaleNegotiator
+
         reg = Registry()
         config = self._makeOne(reg)
         negotiator = object()
@@ -609,6 +716,7 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_request_factory(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IRequestFactory
+
         reg = Registry()
         config = self._makeOne(reg)
         factory = object()
@@ -621,6 +729,7 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_response_factory(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IResponseFactory
+
         reg = Registry()
         config = self._makeOne(reg)
         factory = lambda r: object()
@@ -633,9 +742,11 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_request_factory_dottedname(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IRequestFactory
+
         reg = Registry()
         config = self._makeOne(reg)
         import tests.test_config
+
         config.setup_registry(request_factory='tests.test_config')
         self.assertEqual(reg.queryUtility(IRequestFactory), None)
         config.commit()
@@ -645,17 +756,18 @@ class ConfiguratorTests(unittest.TestCase):
     def test_setup_registry_alternate_renderers(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IRendererFactory
+
         renderer = object()
         reg = Registry()
         config = self._makeOne(reg)
         config.setup_registry(renderers=[('yeah', renderer)])
         config.commit()
-        self.assertEqual(reg.getUtility(IRendererFactory, 'yeah'),
-                         renderer)
+        self.assertEqual(reg.getUtility(IRendererFactory, 'yeah'), renderer)
 
     def test_setup_registry_default_permission(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IDefaultPermission
+
         reg = Registry()
         config = self._makeOne(reg)
         config.setup_registry(default_permission='view')
@@ -664,12 +776,12 @@ class ConfiguratorTests(unittest.TestCase):
 
     def test_setup_registry_includes(self):
         from pyramid.registry import Registry
+
         reg = Registry()
         config = self._makeOne(reg)
         settings = {
-            'pyramid.includes':
-"""tests.test_config.dummy_include
-tests.test_config.dummy_include2""",
+            'pyramid.includes': """tests.test_config.dummy_include
+tests.test_config.dummy_include2"""
         }
         config.setup_registry(settings=settings)
         self.assertTrue(reg.included)
@@ -677,11 +789,11 @@ tests.test_config.dummy_include2""",
 
     def test_setup_registry_includes_spaces(self):
         from pyramid.registry import Registry
+
         reg = Registry()
         config = self._makeOne(reg)
         settings = {
-            'pyramid.includes':
-"""tests.test_config.dummy_include tests.test_config.dummy_include2""",
+            'pyramid.includes': """tests.test_config.dummy_include tests.test_config.dummy_include2"""
         }
         config.setup_registry(settings=settings)
         self.assertTrue(reg.included)
@@ -690,19 +802,17 @@ tests.test_config.dummy_include2""",
     def test_setup_registry_tweens(self):
         from pyramid.interfaces import ITweens
         from pyramid.registry import Registry
+
         reg = Registry()
         config = self._makeOne(reg)
-        settings = {
-            'pyramid.tweens':
-                    'tests.test_config.dummy_tween_factory'
-        }
+        settings = {'pyramid.tweens': 'tests.test_config.dummy_tween_factory'}
         config.setup_registry(settings=settings)
         config.commit()
         tweens = config.registry.getUtility(ITweens)
         self.assertEqual(
             tweens.explicit,
-            [('tests.test_config.dummy_tween_factory',
-              dummy_tween_factory)])
+            [('tests.test_config.dummy_tween_factory', dummy_tween_factory)],
+        )
 
     def test_introspector_decorator(self):
         inst = self._makeOne()
@@ -723,6 +833,7 @@ tests.test_config.dummy_include2""",
         import pyramid.config
         from pyramid.router import Router
         from pyramid.interfaces import IApplicationCreated
+
         manager = DummyThreadLocalManager()
         config = self._makeOne()
         subscriber = self._registerEventListener(config, IApplicationCreated)
@@ -739,6 +850,7 @@ tests.test_config.dummy_include2""",
 
     def test_include_with_dotted_name(self):
         from tests import test_config
+
         config = self._makeOne()
         config.include('tests.test_config.dummy_include')
         after = config.action_state
@@ -751,6 +863,7 @@ tests.test_config.dummy_include2""",
 
     def test_include_with_python_callable(self):
         from tests import test_config
+
         config = self._makeOne()
         config.include(dummy_include)
         after = config.action_state
@@ -763,6 +876,7 @@ tests.test_config.dummy_include2""",
 
     def test_include_with_module_defaults_to_includeme(self):
         from tests import test_config
+
         config = self._makeOne()
         config.include('tests.test_config')
         after = config.action_state
@@ -775,24 +889,31 @@ tests.test_config.dummy_include2""",
 
     def test_include_with_module_defaults_to_includeme_missing(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
         self.assertRaises(ConfigurationError, config.include, 'tests')
 
     def test_include_with_route_prefix(self):
         root_config = self._makeOne(autocommit=True)
+
         def dummy_subapp(config):
             self.assertEqual(config.route_prefix, 'root')
+
         root_config.include(dummy_subapp, route_prefix='root')
 
     def test_include_with_nested_route_prefix(self):
         root_config = self._makeOne(autocommit=True, route_prefix='root')
+
         def dummy_subapp2(config):
             self.assertEqual(config.route_prefix, 'root/nested')
+
         def dummy_subapp3(config):
             self.assertEqual(config.route_prefix, 'root/nested/nested2')
             config.include(dummy_subapp4)
+
         def dummy_subapp4(config):
             self.assertEqual(config.route_prefix, 'root/nested/nested2')
+
         def dummy_subapp(config):
             self.assertEqual(config.route_prefix, 'root/nested')
             config.include(dummy_subapp2)
@@ -803,31 +924,39 @@ tests.test_config.dummy_include2""",
     def test_include_with_missing_source_file(self):
         from pyramid.exceptions import ConfigurationError
         import inspect
+
         config = self._makeOne()
+
         class DummyInspect(object):
             def getmodule(self, c):
                 return inspect.getmodule(c)
+
             def getsourcefile(self, c):
                 return None
+
         config.inspect = DummyInspect()
         try:
             config.include('tests.test_config.dummy_include')
         except ConfigurationError as e:
             self.assertEqual(
-                e.args[0], 
+                e.args[0],
                 "No source file for module 'tests.test_config' (.py "
-                "file must exist, refusing to use orphan .pyc or .pyo file).")
-        else: # pragma: no cover
+                "file must exist, refusing to use orphan .pyc or .pyo file).",
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_include_constant_root_package(self):
         import tests
         from tests import test_config
+
         config = self._makeOne(root_package=tests)
         results = {}
+
         def include(config):
             results['package'] = config.package
             results['root_package'] = config.root_package
+
         config.include(include)
         self.assertEqual(results['root_package'], tests)
         self.assertEqual(results['package'], test_config)
@@ -835,9 +964,12 @@ tests.test_config.dummy_include2""",
     def test_include_threadlocals_active(self):
         from pyramid.threadlocal import get_current_registry
         from tests import test_config
+
         stack = []
+
         def include(config):
             stack.append(get_current_registry())
+
         config = self._makeOne()
         config.include(include)
         self.assertTrue(stack[0] is config.registry)
@@ -848,10 +980,11 @@ tests.test_config.dummy_include2""",
 
     def test_action_branching_kw_is_not_None(self):
         config = self._makeOne(autocommit=True)
-        self.assertEqual(config.action('discrim', kw={'a':1}), None)
+        self.assertEqual(config.action('discrim', kw={'a': 1}), None)
 
     def test_action_autocommit_with_introspectables(self):
         from pyramid.config.util import ActionInfo
+
         config = self._makeOne(autocommit=True)
         intr = DummyIntrospectable()
         config.action('discrim', introspectables=(intr,))
@@ -865,25 +998,32 @@ tests.test_config.dummy_include2""",
         intr = DummyIntrospectable()
         config.action('discrim', introspectables=(intr,))
         self.assertEqual(len(intr.registered), 0)
-        
+
     def test_action_branching_nonautocommit_with_config_info(self):
         config = self._makeOne(autocommit=False)
         config.info = 'abc'
         state = DummyActionState()
         state.autocommit = False
         config.action_state = state
-        config.action('discrim', kw={'a':1})
+        config.action('discrim', kw={'a': 1})
         self.assertEqual(
             state.actions,
-            [((),
-             {'args': (),
-             'callable': None,
-             'discriminator': 'discrim',
-             'includepath': (),
-             'info': 'abc',
-             'introspectables': (),
-             'kw': {'a': 1},
-             'order': 0})])
+            [
+                (
+                    (),
+                    {
+                        'args': (),
+                        'callable': None,
+                        'discriminator': 'discrim',
+                        'includepath': (),
+                        'info': 'abc',
+                        'introspectables': (),
+                        'kw': {'a': 1},
+                        'order': 0,
+                    },
+                )
+            ],
+        )
 
     def test_action_branching_nonautocommit_without_config_info(self):
         config = self._makeOne(autocommit=False)
@@ -892,18 +1032,25 @@ tests.test_config.dummy_include2""",
         state = DummyActionState()
         config.action_state = state
         state.autocommit = False
-        config.action('discrim', kw={'a':1})
+        config.action('discrim', kw={'a': 1})
         self.assertEqual(
             state.actions,
-            [((),
-             {'args': (),
-             'callable': None,
-             'discriminator': 'discrim',
-             'includepath': (),
-             'info': 'z',
-             'introspectables': (),
-             'kw': {'a': 1},
-             'order': 0})])
+            [
+                (
+                    (),
+                    {
+                        'args': (),
+                        'callable': None,
+                        'discriminator': 'discrim',
+                        'includepath': (),
+                        'info': 'z',
+                        'introspectables': (),
+                        'kw': {'a': 1},
+                        'order': 0,
+                    },
+                )
+            ],
+        )
 
     def test_action_branching_nonautocommit_with_introspectables(self):
         config = self._makeOne(autocommit=False)
@@ -914,8 +1061,7 @@ tests.test_config.dummy_include2""",
         state.autocommit = False
         intr = DummyIntrospectable()
         config.action('discrim', introspectables=(intr,))
-        self.assertEqual(
-            state.actions[0][1]['introspectables'], (intr,))
+        self.assertEqual(state.actions[0][1]['introspectables'], (intr,))
 
     def test_action_nonautocommit_with_introspectables_introspection_off(self):
         config = self._makeOne(autocommit=False)
@@ -927,14 +1073,14 @@ tests.test_config.dummy_include2""",
         state.autocommit = False
         intr = DummyIntrospectable()
         config.action('discrim', introspectables=(intr,))
-        self.assertEqual(
-            state.actions[0][1]['introspectables'], ())
-        
+        self.assertEqual(state.actions[0][1]['introspectables'], ())
+
     def test_scan_integration(self):
         from zope.interface import alsoProvides
         from pyramid.interfaces import IRequest
         from pyramid.view import render_view_to_response
         import tests.test_config.pkgs.scannable as package
+
         config = self._makeOne(autocommit=True)
         config.scan(package)
 
@@ -951,13 +1097,13 @@ tests.test_config.dummy_include2""",
         result = render_view_to_response(ctx, req, '')
         self.assertEqual(result, 'grokked_post')
 
-        result= render_view_to_response(ctx, req, 'grokked_class')
+        result = render_view_to_response(ctx, req, 'grokked_class')
         self.assertEqual(result, 'grokked_class')
 
-        result= render_view_to_response(ctx, req, 'grokked_instance')
+        result = render_view_to_response(ctx, req, 'grokked_instance')
         self.assertEqual(result, 'grokked_instance')
 
-        result= render_view_to_response(ctx, req, 'oldstyle_grokked_class')
+        result = render_view_to_response(ctx, req, 'oldstyle_grokked_class')
         self.assertEqual(result, 'oldstyle_grokked_class')
 
         req.method = 'GET'
@@ -968,14 +1114,15 @@ tests.test_config.dummy_include2""",
         result = render_view_to_response(ctx, req, 'another')
         self.assertEqual(result, 'another_grokked_post')
 
-        result= render_view_to_response(ctx, req, 'another_grokked_class')
+        result = render_view_to_response(ctx, req, 'another_grokked_class')
         self.assertEqual(result, 'another_grokked_class')
 
-        result= render_view_to_response(ctx, req, 'another_grokked_instance')
+        result = render_view_to_response(ctx, req, 'another_grokked_instance')
         self.assertEqual(result, 'another_grokked_instance')
 
-        result= render_view_to_response(ctx, req,
-                                        'another_oldstyle_grokked_class')
+        result = render_view_to_response(
+            ctx, req, 'another_oldstyle_grokked_class'
+        )
         self.assertEqual(result, 'another_oldstyle_grokked_class')
 
         result = render_view_to_response(ctx, req, 'stacked1')
@@ -1007,8 +1154,9 @@ tests.test_config.dummy_include2""",
         # assertion may fail there.  We don't support Jython at the moment,
         # this is just a note to a future self.
 
-        self.assertRaises(TypeError,
-                          render_view_to_response, ctx, req, 'basemethod')
+        self.assertRaises(
+            TypeError, render_view_to_response, ctx, req, 'basemethod'
+        )
 
         result = render_view_to_response(ctx, req, 'method1')
         self.assertEqual(result, 'method1')
@@ -1039,9 +1187,9 @@ tests.test_config.dummy_include2""",
         from pyramid.interfaces import IRequest
         from pyramid.view import render_view_to_response
         import tests.test_config.pkgs.scannable as package
+
         config = self._makeOne(autocommit=True)
-        config.scan(package, 
-                    ignore='tests.test_config.pkgs.scannable.another')
+        config.scan(package, ignore='tests.test_config.pkgs.scannable.another')
 
         ctx = DummyContext()
         req = DummyRequest()
@@ -1055,11 +1203,12 @@ tests.test_config.dummy_include2""",
         # ignored
         v = render_view_to_response(ctx, req, 'another_stacked_class2')
         self.assertEqual(v, None)
-        
+
     def test_scan_integration_dottedname_package(self):
         from zope.interface import alsoProvides
         from pyramid.interfaces import IRequest
         from pyramid.view import render_view_to_response
+
         config = self._makeOne(autocommit=True)
         config.scan('tests.test_config.pkgs.scannable')
 
@@ -1081,45 +1230,56 @@ tests.test_config.dummy_include2""",
         # fancy sys.path manipulation here to appease "setup.py test" which
         # fails miserably when it can't import something in the package
         import sys
+
         try:
             here = os.path.dirname(__file__)
             path = os.path.join(here, 'path')
             sys.path.append(path)
             config = self._makeOne(autocommit=True)
+
             class FooException(Exception):
                 pass
+
             def onerror(name):
                 raise FooException
-            self.assertRaises(FooException, config.scan, 'scanerror',
-                              onerror=onerror)
+
+            self.assertRaises(
+                FooException, config.scan, 'scanerror', onerror=onerror
+            )
         finally:
             sys.path.remove(path)
 
     def test_scan_integration_conflict(self):
         from tests.test_config.pkgs import selfscan
         from pyramid.config import Configurator
+
         c = Configurator()
         c.scan(selfscan)
         c.scan(selfscan)
         try:
             c.commit()
         except ConfigurationConflictError as why:
+
             def scanconflicts(e):
                 conflicts = e._conflicts.values()
                 for conflict in conflicts:
                     for confinst in conflict:
                         yield confinst.src
+
             which = list(scanconflicts(why))
             self.assertEqual(len(which), 4)
             self.assertTrue("@view_config(renderer='string')" in which)
-            self.assertTrue("@view_config(name='two', renderer='string')" in
-                            which)
+            self.assertTrue(
+                "@view_config(name='two', renderer='string')" in which
+            )
 
     @skip_on('py3')
     def test_hook_zca(self):
         from zope.component import getSiteManager
+
         def foo():
             '123'
+
         try:
             config = self._makeOne()
             config.hook_zca()
@@ -1132,8 +1292,10 @@ tests.test_config.dummy_include2""",
     @skip_on('py3')
     def test_unhook_zca(self):
         from zope.component import getSiteManager
+
         def foo():
             '123'
+
         try:
             getSiteManager.sethook(foo)
             config = self._makeOne()
@@ -1145,18 +1307,29 @@ tests.test_config.dummy_include2""",
 
     def test_commit_conflict_simple(self):
         config = self._makeOne()
-        def view1(request): pass
-        def view2(request): pass
+
+        def view1(request):
+            pass
+
+        def view2(request):
+            pass
+
         config.add_view(view1)
         config.add_view(view2)
         self.assertRaises(ConfigurationConflictError, config.commit)
 
     def test_commit_conflict_resolved_with_include(self):
         config = self._makeOne()
-        def view1(request): pass
-        def view2(request): pass
+
+        def view1(request):
+            pass
+
+        def view2(request):
+            pass
+
         def includeme(config):
             config.add_view(view2)
+
         config.add_view(view1)
         config.include(includeme)
         config.commit()
@@ -1165,12 +1338,19 @@ tests.test_config.dummy_include2""",
 
     def test_commit_conflict_with_two_includes(self):
         config = self._makeOne()
-        def view1(request): pass
-        def view2(request): pass
+
+        def view1(request):
+            pass
+
+        def view2(request):
+            pass
+
         def includeme1(config):
             config.add_view(view1)
+
         def includeme2(config):
             config.add_view(view2)
+
         config.include(includeme1)
         config.include(includeme2)
         try:
@@ -1179,18 +1359,27 @@ tests.test_config.dummy_include2""",
             c1, c2 = _conflictFunctions(why)
             self.assertEqual(c1, 'includeme1')
             self.assertEqual(c2, 'includeme2')
-        else: #pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_commit_conflict_resolved_with_two_includes_and_local(self):
         config = self._makeOne()
-        def view1(request): pass
-        def view2(request): pass
-        def view3(request): pass
+
+        def view1(request):
+            pass
+
+        def view2(request):
+            pass
+
+        def view3(request):
+            pass
+
         def includeme1(config):
             config.add_view(view1)
+
         def includeme2(config):
             config.add_view(view2)
+
         config.include(includeme1)
         config.include(includeme2)
         config.add_view(view3)
@@ -1200,10 +1389,18 @@ tests.test_config.dummy_include2""",
 
     def test_autocommit_no_conflicts(self):
         from pyramid.renderers import null_renderer
+
         config = self._makeOne(autocommit=True)
-        def view1(request): pass
-        def view2(request): pass
-        def view3(request): pass
+
+        def view1(request):
+            pass
+
+        def view2(request):
+            pass
+
+        def view3(request):
+            pass
+
         config.add_view(view1, renderer=null_renderer)
         config.add_view(view2, renderer=null_renderer)
         config.add_view(view3, renderer=null_renderer)
@@ -1213,8 +1410,13 @@ tests.test_config.dummy_include2""",
 
     def test_conflict_set_notfound_view(self):
         config = self._makeOne()
-        def view1(request): pass
-        def view2(request): pass
+
+        def view1(request):
+            pass
+
+        def view2(request):
+            pass
+
         config.set_notfound_view(view1)
         config.set_notfound_view(view2)
         try:
@@ -1223,13 +1425,18 @@ tests.test_config.dummy_include2""",
             c1, c2 = _conflictFunctions(why)
             self.assertEqual(c1, 'test_conflict_set_notfound_view')
             self.assertEqual(c2, 'test_conflict_set_notfound_view')
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_conflict_set_forbidden_view(self):
         config = self._makeOne()
-        def view1(request): pass
-        def view2(request): pass
+
+        def view1(request):
+            pass
+
+        def view2(request):
+            pass
+
         config.set_forbidden_view(view1)
         config.set_forbidden_view(view2)
         try:
@@ -1238,7 +1445,7 @@ tests.test_config.dummy_include2""",
             c1, c2 = _conflictFunctions(why)
             self.assertEqual(c1, 'test_conflict_set_forbidden_view')
             self.assertEqual(c2, 'test_conflict_set_forbidden_view')
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test___getattr__missing_when_directives_exist(self):
@@ -1253,31 +1460,38 @@ tests.test_config.dummy_include2""",
 
     def test___getattr__matches(self):
         config = self._makeOne()
-        def foo(config): pass
-        directives = {'foo':(foo, True)}
+
+        def foo(config):
+            pass
+
+        directives = {'foo': (foo, True)}
         config.registry._directives = directives
         foo_meth = config.foo
         self.assertTrue(getattr(foo_meth, im_func).__docobj__ is foo)
 
     def test___getattr__matches_no_action_wrap(self):
         config = self._makeOne()
-        def foo(config): pass
-        directives = {'foo':(foo, False)}
+
+        def foo(config):
+            pass
+
+        directives = {'foo': (foo, False)}
         config.registry._directives = directives
         foo_meth = config.foo
         self.assertTrue(getattr(foo_meth, im_func) is foo)
 
-class TestConfigurator_add_directive(unittest.TestCase):
 
+class TestConfigurator_add_directive(unittest.TestCase):
     def setUp(self):
         from pyramid.config import Configurator
+
         self.config = Configurator()
 
     def test_extend_with_dotted_name(self):
         from tests import test_config
+
         config = self.config
-        config.add_directive(
-            'dummy_extend', 'tests.test_config.dummy_extend')
+        config.add_directive('dummy_extend', 'tests.test_config.dummy_extend')
         self.assertTrue(hasattr(config, 'dummy_extend'))
         config.dummy_extend('discrim')
         after = config.action_state
@@ -1288,9 +1502,11 @@ class TestConfigurator_add_directive(unittest.TestCase):
 
     def test_add_directive_with_partial(self):
         from tests import test_config
+
         config = self.config
         config.add_directive(
-                'dummy_partial', 'tests.test_config.dummy_partial')
+            'dummy_partial', 'tests.test_config.dummy_partial'
+        )
         self.assertTrue(hasattr(config, 'dummy_partial'))
         config.dummy_partial()
         after = config.action_state
@@ -1301,9 +1517,11 @@ class TestConfigurator_add_directive(unittest.TestCase):
 
     def test_add_directive_with_custom_callable(self):
         from tests import test_config
+
         config = self.config
         config.add_directive(
-                'dummy_callable', 'tests.test_config.dummy_callable')
+            'dummy_callable', 'tests.test_config.dummy_callable'
+        )
         self.assertTrue(hasattr(config, 'dummy_callable'))
         config.dummy_callable('discrim')
         after = config.action_state
@@ -1314,9 +1532,9 @@ class TestConfigurator_add_directive(unittest.TestCase):
 
     def test_extend_with_python_callable(self):
         from tests import test_config
+
         config = self.config
-        config.add_directive(
-            'dummy_extend', dummy_extend)
+        config.add_directive('dummy_extend', dummy_extend)
         self.assertTrue(hasattr(config, 'dummy_extend'))
         config.dummy_extend('discrim')
         after = config.action_state
@@ -1327,10 +1545,8 @@ class TestConfigurator_add_directive(unittest.TestCase):
 
     def test_extend_same_name_doesnt_conflict(self):
         config = self.config
-        config.add_directive(
-            'dummy_extend', dummy_extend)
-        config.add_directive(
-            'dummy_extend', dummy_extend2)
+        config.add_directive('dummy_extend', dummy_extend)
+        config.add_directive('dummy_extend', dummy_extend2)
         self.assertTrue(hasattr(config, 'dummy_extend'))
         config.dummy_extend('discrim')
         after = config.action_state
@@ -1341,8 +1557,7 @@ class TestConfigurator_add_directive(unittest.TestCase):
 
     def test_extend_action_method_successful(self):
         config = self.config
-        config.add_directive(
-            'dummy_extend', dummy_extend)
+        config.add_directive('dummy_extend', dummy_extend)
         config.dummy_extend('discrim')
         config.dummy_extend('discrim')
         self.assertRaises(ConfigurationConflictError, config.commit)
@@ -1360,16 +1575,25 @@ class TestConfigurator_add_directive(unittest.TestCase):
         self.assertEqual(action['callable'], None)
         self.assertEqual(action['args'], config2.package)
 
+
 class TestConfigurator__add_predicate(unittest.TestCase):
     def _makeOne(self):
         from pyramid.config import Configurator
+
         return Configurator()
 
     def test_factory_as_object(self):
         config = self._makeOne()
 
-        def _fakeAction(discriminator, callable=None, args=(), kw=None,
-                        order=0, introspectables=(), **extra):
+        def _fakeAction(
+            discriminator,
+            callable=None,
+            args=(),
+            kw=None,
+            order=0,
+            introspectables=(),
+            **extra
+        ):
             self.assertEqual(len(introspectables), 1)
             self.assertEqual(introspectables[0]['name'], 'testing')
             self.assertEqual(introspectables[0]['factory'], DummyPredicate)
@@ -1380,63 +1604,82 @@ class TestConfigurator__add_predicate(unittest.TestCase):
     def test_factory_as_dotted_name(self):
         config = self._makeOne()
 
-        def _fakeAction(discriminator, callable=None, args=(),
-                        kw=None, order=0, introspectables=(), **extra):
+        def _fakeAction(
+            discriminator,
+            callable=None,
+            args=(),
+            kw=None,
+            order=0,
+            introspectables=(),
+            **extra
+        ):
             self.assertEqual(len(introspectables), 1)
             self.assertEqual(introspectables[0]['name'], 'testing')
             self.assertEqual(introspectables[0]['factory'], DummyPredicate)
 
         config.action = _fakeAction
         config._add_predicate(
-            'route',
-            'testing',
-            'tests.test_config.test_init.DummyPredicate'
-            )
-        
+            'route', 'testing', 'tests.test_config.test_init.DummyPredicate'
+        )
+
+
 class TestActionState(unittest.TestCase):
     def _makeOne(self):
         from pyramid.config import ActionState
+
         return ActionState()
-    
+
     def test_it(self):
         c = self._makeOne()
         self.assertEqual(c.actions, [])
 
     def test_action_simple(self):
         from . import dummyfactory as f
+
         c = self._makeOne()
         c.actions = []
-        c.action(1, f, (1,), {'x':1})
+        c.action(1, f, (1,), {'x': 1})
         self.assertEqual(
             c.actions,
-            [{'args': (1,),
-             'callable': f,
-             'discriminator': 1,
-             'includepath': (),
-             'info': None,
-             'introspectables': (),
-             'kw': {'x': 1},
-             'order': 0}])
+            [
+                {
+                    'args': (1,),
+                    'callable': f,
+                    'discriminator': 1,
+                    'includepath': (),
+                    'info': None,
+                    'introspectables': (),
+                    'kw': {'x': 1},
+                    'order': 0,
+                }
+            ],
+        )
         c.action(None)
         self.assertEqual(
             c.actions,
-            [{'args': (1,),
-             'callable': f,
-             'discriminator': 1,
-             'includepath': (),
-             'info': None,
-             'introspectables': (),
-             'kw': {'x': 1},
-             'order': 0},
-
-             {'args': (),
-             'callable': None,
-             'discriminator': None,
-             'includepath': (),
-             'info': None,
-             'introspectables': (),
-             'kw': {},
-             'order': 0},])
+            [
+                {
+                    'args': (1,),
+                    'callable': f,
+                    'discriminator': 1,
+                    'includepath': (),
+                    'info': None,
+                    'introspectables': (),
+                    'kw': {'x': 1},
+                    'order': 0,
+                },
+                {
+                    'args': (),
+                    'callable': None,
+                    'discriminator': None,
+                    'includepath': (),
+                    'info': None,
+                    'introspectables': (),
+                    'kw': {},
+                    'order': 0,
+                },
+            ],
+        )
 
     def test_action_with_includepath(self):
         c = self._makeOne()
@@ -1444,42 +1687,57 @@ class TestActionState(unittest.TestCase):
         c.action(None, includepath=('abc',))
         self.assertEqual(
             c.actions,
-            [{'args': (),
-             'callable': None,
-             'discriminator': None,
-             'includepath': ('abc',),
-             'info': None,
-             'introspectables': (),
-             'kw': {},
-             'order': 0}])
+            [
+                {
+                    'args': (),
+                    'callable': None,
+                    'discriminator': None,
+                    'includepath': ('abc',),
+                    'info': None,
+                    'introspectables': (),
+                    'kw': {},
+                    'order': 0,
+                }
+            ],
+        )
 
     def test_action_with_info(self):
         c = self._makeOne()
         c.action(None, info='abc')
         self.assertEqual(
             c.actions,
-            [{'args': (),
-             'callable': None,
-             'discriminator': None,
-             'includepath': (),
-             'info': 'abc',
-             'introspectables': (),
-             'kw': {},
-             'order': 0}])
+            [
+                {
+                    'args': (),
+                    'callable': None,
+                    'discriminator': None,
+                    'includepath': (),
+                    'info': 'abc',
+                    'introspectables': (),
+                    'kw': {},
+                    'order': 0,
+                }
+            ],
+        )
 
     def test_action_with_includepath_and_info(self):
         c = self._makeOne()
         c.action(None, includepath=('spec',), info='bleh')
         self.assertEqual(
             c.actions,
-            [{'args': (),
-             'callable': None,
-             'discriminator': None,
-             'includepath': ('spec',),
-             'info': 'bleh',
-             'introspectables': (),
-             'kw': {},
-             'order': 0}])
+            [
+                {
+                    'args': (),
+                    'callable': None,
+                    'discriminator': None,
+                    'includepath': ('spec',),
+                    'info': 'bleh',
+                    'introspectables': (),
+                    'kw': {},
+                    'order': 0,
+                }
+            ],
+        )
 
     def test_action_with_order(self):
         c = self._makeOne()
@@ -1487,14 +1745,19 @@ class TestActionState(unittest.TestCase):
         c.action(None, order=99999)
         self.assertEqual(
             c.actions,
-            [{'args': (),
-             'callable': None,
-             'discriminator': None,
-             'includepath': (),
-             'info': None,
-             'introspectables': (),
-             'kw': {},
-             'order': 99999}])
+            [
+                {
+                    'args': (),
+                    'callable': None,
+                    'discriminator': None,
+                    'includepath': (),
+                    'info': None,
+                    'introspectables': (),
+                    'kw': {},
+                    'order': 99999,
+                }
+            ],
+        )
 
     def test_action_with_introspectables(self):
         c = self._makeOne()
@@ -1503,14 +1766,19 @@ class TestActionState(unittest.TestCase):
         c.action(None, introspectables=(intr,))
         self.assertEqual(
             c.actions,
-            [{'args': (),
-             'callable': None,
-             'discriminator': None,
-             'includepath': (),
-             'info': None,
-             'introspectables': (intr,),
-             'kw': {},
-             'order': 0}])
+            [
+                {
+                    'args': (),
+                    'callable': None,
+                    'discriminator': None,
+                    'includepath': (),
+                    'info': None,
+                    'introspectables': (intr,),
+                    'kw': {},
+                    'order': 0,
+                }
+            ],
+        )
 
     def test_processSpec(self):
         c = self._makeOne()
@@ -1519,190 +1787,269 @@ class TestActionState(unittest.TestCase):
 
     def test_execute_actions_tuples(self):
         output = []
+
         def f(*a, **k):
             output.append((a, k))
+
         c = self._makeOne()
         c.actions = [
             (1, f, (1,)),
-            (1, f, (11,), {}, ('x', )),
+            (1, f, (11,), {}, ('x',)),
             (2, f, (2,)),
             (None, None),
-            ]
+        ]
         c.execute_actions()
-        self.assertEqual(output,  [((1,), {}), ((2,), {})])
+        self.assertEqual(output, [((1,), {}), ((2,), {})])
 
     def test_execute_actions_dicts(self):
         output = []
+
         def f(*a, **k):
             output.append((a, k))
+
         c = self._makeOne()
         c.actions = [
-            {'discriminator':1, 'callable':f, 'args':(1,), 'kw':{},
-             'order':0, 'includepath':(), 'info':None,
-             'introspectables':()},
-            {'discriminator':1, 'callable':f, 'args':(11,), 'kw':{},
-             'includepath':('x',), 'order': 0, 'info':None,
-             'introspectables':()},
-            {'discriminator':2, 'callable':f, 'args':(2,), 'kw':{},
-             'order':0, 'includepath':(), 'info':None,
-             'introspectables':()},
-            {'discriminator':None, 'callable':None, 'args':(), 'kw':{},
-             'order':0, 'includepath':(), 'info':None,
-             'introspectables':()},
-            ]
+            {
+                'discriminator': 1,
+                'callable': f,
+                'args': (1,),
+                'kw': {},
+                'order': 0,
+                'includepath': (),
+                'info': None,
+                'introspectables': (),
+            },
+            {
+                'discriminator': 1,
+                'callable': f,
+                'args': (11,),
+                'kw': {},
+                'includepath': ('x',),
+                'order': 0,
+                'info': None,
+                'introspectables': (),
+            },
+            {
+                'discriminator': 2,
+                'callable': f,
+                'args': (2,),
+                'kw': {},
+                'order': 0,
+                'includepath': (),
+                'info': None,
+                'introspectables': (),
+            },
+            {
+                'discriminator': None,
+                'callable': None,
+                'args': (),
+                'kw': {},
+                'order': 0,
+                'includepath': (),
+                'info': None,
+                'introspectables': (),
+            },
+        ]
         c.execute_actions()
-        self.assertEqual(output,  [((1,), {}), ((2,), {})])
+        self.assertEqual(output, [((1,), {}), ((2,), {})])
 
     def test_execute_actions_with_introspectables(self):
         output = []
+
         def f(*a, **k):
             output.append((a, k))
+
         c = self._makeOne()
         intr = DummyIntrospectable()
         c.actions = [
-            {'discriminator':1, 'callable':f, 'args':(1,), 'kw':{},
-             'order':0, 'includepath':(), 'info':None,
-             'introspectables':(intr,)},
-            ]
+            {
+                'discriminator': 1,
+                'callable': f,
+                'args': (1,),
+                'kw': {},
+                'order': 0,
+                'includepath': (),
+                'info': None,
+                'introspectables': (intr,),
+            }
+        ]
         introspector = object()
         c.execute_actions(introspector=introspector)
-        self.assertEqual(output,  [((1,), {})])
+        self.assertEqual(output, [((1,), {})])
         self.assertEqual(intr.registered, [(introspector, None)])
 
     def test_execute_actions_with_introspectable_no_callable(self):
         c = self._makeOne()
         intr = DummyIntrospectable()
         c.actions = [
-            {'discriminator':1, 'callable':None, 'args':(1,), 'kw':{},
-             'order':0, 'includepath':(), 'info':None,
-             'introspectables':(intr,)},
-            ]
+            {
+                'discriminator': 1,
+                'callable': None,
+                'args': (1,),
+                'kw': {},
+                'order': 0,
+                'includepath': (),
+                'info': None,
+                'introspectables': (intr,),
+            }
+        ]
         introspector = object()
         c.execute_actions(introspector=introspector)
         self.assertEqual(intr.registered, [(introspector, None)])
 
     def test_execute_actions_error(self):
         output = []
+
         def f(*a, **k):
             output.append(('f', a, k))
+
         def bad():
             raise NotImplementedError
+
         c = self._makeOne()
         c.actions = [
             (1, f, (1,)),
-            (1, f, (11,), {}, ('x', )),
+            (1, f, (11,), {}, ('x',)),
             (2, f, (2,)),
-            (3, bad, (), {}, (), 'oops')
-            ]
+            (3, bad, (), {}, (), 'oops'),
+        ]
         self.assertRaises(ConfigurationExecutionError, c.execute_actions)
         self.assertEqual(output, [('f', (1,), {}), ('f', (2,), {})])
 
     def test_reentrant_action(self):
         output = []
         c = self._makeOne()
+
         def f(*a, **k):
             output.append(('f', a, k))
             c.actions.append((3, g, (8,), {}))
+
         def g(*a, **k):
             output.append(('g', a, k))
-        c.actions = [
-            (1, f, (1,)),
-        ]
+
+        c.actions = [(1, f, (1,))]
         c.execute_actions()
         self.assertEqual(output, [('f', (1,), {}), ('g', (8,), {})])
 
     def test_reentrant_action_with_deferred_discriminator(self):
         # see https://github.com/Pylons/pyramid/issues/2697
         from pyramid.registry import Deferred
+
         output = []
         c = self._makeOne()
+
         def f(*a, **k):
             output.append(('f', a, k))
             c.actions.append((4, g, (4,), {}, (), None, 2))
+
         def g(*a, **k):
             output.append(('g', a, k))
+
         def h(*a, **k):
             output.append(('h', a, k))
+
         def discrim():
             self.assertEqual(output, [('f', (1,), {}), ('g', (2,), {})])
             return 3
+
         d = Deferred(discrim)
         c.actions = [
-            (d, h, (3,), {}, (), None, 1), # order 1
-            (1, f, (1,)), # order 0
-            (2, g, (2,)), # order 0
+            (d, h, (3,), {}, (), None, 1),  # order 1
+            (1, f, (1,)),  # order 0
+            (2, g, (2,)),  # order 0
         ]
         c.execute_actions()
-        self.assertEqual(output, [
-            ('f', (1,), {}), ('g', (2,), {}), ('h', (3,), {}), ('g', (4,), {})])
+        self.assertEqual(
+            output,
+            [
+                ('f', (1,), {}),
+                ('g', (2,), {}),
+                ('h', (3,), {}),
+                ('g', (4,), {}),
+            ],
+        )
 
     def test_reentrant_action_error(self):
         from pyramid.exceptions import ConfigurationError
+
         c = self._makeOne()
+
         def f(*a, **k):
             c.actions.append((3, g, (8,), {}, (), None, -1))
-        def g(*a, **k): pass
-        c.actions = [
-            (1, f, (1,)),
-        ]
+
+        def g(*a, **k):
+            pass
+
+        c.actions = [(1, f, (1,))]
         self.assertRaises(ConfigurationError, c.execute_actions)
 
     def test_reentrant_action_without_clear(self):
         c = self._makeOne()
+
         def f(*a, **k):
             c.actions.append((3, g, (8,)))
-        def g(*a, **k): pass
-        c.actions = [
-            (1, f, (1,)),
-        ]
+
+        def g(*a, **k):
+            pass
+
+        c.actions = [(1, f, (1,))]
         c.execute_actions(clear=False)
-        self.assertEqual(c.actions, [
-            (1, f, (1,)),
-            (3, g, (8,)),
-        ])
+        self.assertEqual(c.actions, [(1, f, (1,)), (3, g, (8,))])
 
     def test_executing_conflicting_action_across_orders(self):
         from pyramid.exceptions import ConfigurationConflictError
+
         c = self._makeOne()
-        def f(*a, **k): pass
-        def g(*a, **k): pass
-        c.actions = [
-            (1, f, (1,), {}, (), None, -1),
-            (1, g, (2,)),
-        ]
+
+        def f(*a, **k):
+            pass
+
+        def g(*a, **k):
+            pass
+
+        c.actions = [(1, f, (1,), {}, (), None, -1), (1, g, (2,))]
         self.assertRaises(ConfigurationConflictError, c.execute_actions)
 
     def test_executing_conflicting_action_across_reentrant_orders(self):
         from pyramid.exceptions import ConfigurationConflictError
+
         c = self._makeOne()
+
         def f(*a, **k):
             c.actions.append((1, g, (8,)))
-        def g(*a, **k): pass
-        c.actions = [
-            (1, f, (1,), {}, (), None, -1),
-        ]
+
+        def g(*a, **k):
+            pass
+
+        c.actions = [(1, f, (1,), {}, (), None, -1)]
         self.assertRaises(ConfigurationConflictError, c.execute_actions)
 
+
 class Test_reentrant_action_functional(unittest.TestCase):
     def _makeConfigurator(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def test_functional(self):
         def add_auto_route(config, name, view):
-               def register():
-                   config.add_view(route_name=name, view=view)
-                   config.add_route(name, '/' + name)
-               config.action(
-                   ('auto route', name), register, order=-30
-                   )
+            def register():
+                config.add_view(route_name=name, view=view)
+                config.add_route(name, '/' + name)
+
+            config.action(('auto route', name), register, order=-30)
+
         config = self._makeConfigurator()
         config.add_directive('add_auto_route', add_auto_route)
-        def my_view(request): return request.response
+
+        def my_view(request):
+            return request.response
+
         config.add_auto_route('foo', my_view)
         config.commit()
         from pyramid.interfaces import IRoutesMapper
+
         mapper = config.registry.getUtility(IRoutesMapper)
         routes = mapper.get_routes()
         route = routes[0]
@@ -1713,291 +2060,352 @@ class Test_reentrant_action_functional(unittest.TestCase):
     def test_deferred_discriminator(self):
         # see https://github.com/Pylons/pyramid/issues/2697
         from pyramid.config import PHASE0_CONFIG
+
         config = self._makeConfigurator()
-        def deriver(view, info): return view
+
+        def deriver(view, info):
+            return view
+
         deriver.options = ('foo',)
         config.add_view_deriver(deriver, 'foo_view')
         # add_view uses a deferred discriminator and will fail if executed
         # prior to add_view_deriver executing its action
         config.add_view(lambda r: r.response, name='', foo=1)
+
         def dummy_action():
             # trigger a re-entrant action
             config.action(None, lambda: None)
+
         config.action(None, dummy_action, order=PHASE0_CONFIG)
         config.commit()
 
+
 class Test_resolveConflicts(unittest.TestCase):
     def _callFUT(self, actions):
         from pyramid.config import resolveConflicts
+
         return resolveConflicts(actions)
 
     def test_it_success_tuples(self):
         from . import dummyfactory as f
-        result = self._callFUT([
-            (None, f),
-            (1, f, (1,), {}, (), 'first'),
-            (1, f, (2,), {}, ('x',), 'second'),
-            (1, f, (3,), {}, ('y',), 'third'),
-            (4, f, (4,), {}, ('y',), 'should be last', 99999),
-            (3, f, (3,), {}, ('y',)),
-            (None, f, (5,), {}, ('y',)),
-            ])
+
+        result = self._callFUT(
+            [
+                (None, f),
+                (1, f, (1,), {}, (), 'first'),
+                (1, f, (2,), {}, ('x',), 'second'),
+                (1, f, (3,), {}, ('y',), 'third'),
+                (4, f, (4,), {}, ('y',), 'should be last', 99999),
+                (3, f, (3,), {}, ('y',)),
+                (None, f, (5,), {}, ('y',)),
+            ]
+        )
         result = list(result)
         self.assertEqual(
             result,
-            [{'info': None,
-              'args': (),
-              'callable': f,
-              'introspectables': (),
-              'kw': {},
-              'discriminator': None,
-              'includepath': (),
-              'order': 0},
-
-              {'info': 'first',
-               'args': (1,),
-               'callable': f,
-               'introspectables': (),
-               'kw': {},
-               'discriminator': 1,
-               'includepath': (),
-               'order': 0},
-
-               {'info': None,
-                'args': (3,),
-                'callable': f,
-                'introspectables': (),
-                'kw': {},
-                'discriminator': 3,
-                'includepath': ('y',),
-                'order': 0},
-
-                {'info': None,
-                 'args': (5,),
-                 'callable': f,
-                 'introspectables': (),
-                 'kw': {},
-                 'discriminator': None,
-                 'includepath': ('y',),
-                 'order': 0},
-
-                 {'info': 'should be last',
-                  'args': (4,),
-                  'callable': f,
-                  'introspectables': (),
-                  'kw': {},
-                  'discriminator': 4,
-                  'includepath': ('y',),
-                  'order': 99999}
-                  ]
-                  )
+            [
+                {
+                    'info': None,
+                    'args': (),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': None,
+                    'includepath': (),
+                    'order': 0,
+                },
+                {
+                    'info': 'first',
+                    'args': (1,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 1,
+                    'includepath': (),
+                    'order': 0,
+                },
+                {
+                    'info': None,
+                    'args': (3,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 3,
+                    'includepath': ('y',),
+                    'order': 0,
+                },
+                {
+                    'info': None,
+                    'args': (5,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': None,
+                    'includepath': ('y',),
+                    'order': 0,
+                },
+                {
+                    'info': 'should be last',
+                    'args': (4,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 4,
+                    'includepath': ('y',),
+                    'order': 99999,
+                },
+            ],
+        )
 
     def test_it_success_dicts(self):
         from . import dummyfactory as f
-        result = self._callFUT([
-            (None, f),
-            (1, f, (1,), {}, (), 'first'),
-            (1, f, (2,), {}, ('x',), 'second'),
-            (1, f, (3,), {}, ('y',), 'third'),
-            (4, f, (4,), {}, ('y',), 'should be last', 99999),
-            (3, f, (3,), {}, ('y',)),
-            (None, f, (5,), {}, ('y',)),
-            ])
+
+        result = self._callFUT(
+            [
+                (None, f),
+                (1, f, (1,), {}, (), 'first'),
+                (1, f, (2,), {}, ('x',), 'second'),
+                (1, f, (3,), {}, ('y',), 'third'),
+                (4, f, (4,), {}, ('y',), 'should be last', 99999),
+                (3, f, (3,), {}, ('y',)),
+                (None, f, (5,), {}, ('y',)),
+            ]
+        )
         result = list(result)
         self.assertEqual(
             result,
-            [{'info': None,
-              'args': (),
-              'callable': f,
-              'introspectables': (),
-              'kw': {},
-              'discriminator': None,
-              'includepath': (),
-              'order': 0},
-
-              {'info': 'first',
-               'args': (1,),
-               'callable': f,
-               'introspectables': (),
-               'kw': {},
-               'discriminator': 1,
-               'includepath': (),
-               'order': 0},
-
-               {'info': None,
-                'args': (3,),
-                'callable': f,
-                'introspectables': (),
-                'kw': {},
-                'discriminator': 3,
-                'includepath': ('y',),
-                'order': 0},
-
-                {'info': None,
-                 'args': (5,),
-                 'callable': f,
-                 'introspectables': (),
-                 'kw': {},
-                 'discriminator': None,
-                 'includepath': ('y',),
-                 'order': 0},
-
-                 {'info': 'should be last',
-                  'args': (4,),
-                  'callable': f,
-                  'introspectables': (),
-                  'kw': {},
-                  'discriminator': 4,
-                  'includepath': ('y',),
-                  'order': 99999}
-                  ]
-                  )
+            [
+                {
+                    'info': None,
+                    'args': (),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': None,
+                    'includepath': (),
+                    'order': 0,
+                },
+                {
+                    'info': 'first',
+                    'args': (1,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 1,
+                    'includepath': (),
+                    'order': 0,
+                },
+                {
+                    'info': None,
+                    'args': (3,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 3,
+                    'includepath': ('y',),
+                    'order': 0,
+                },
+                {
+                    'info': None,
+                    'args': (5,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': None,
+                    'includepath': ('y',),
+                    'order': 0,
+                },
+                {
+                    'info': 'should be last',
+                    'args': (4,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 4,
+                    'includepath': ('y',),
+                    'order': 99999,
+                },
+            ],
+        )
 
     def test_it_conflict(self):
         from . import dummyfactory as f
-        result = self._callFUT([
-            (None, f),
-            (1, f, (2,), {}, ('x',), 'eek'),     # will conflict
-            (1, f, (3,), {}, ('y',), 'ack'),     # will conflict
-            (4, f, (4,), {}, ('y',)),
-            (3, f, (3,), {}, ('y',)),
-            (None, f, (5,), {}, ('y',)),
-            ])
+
+        result = self._callFUT(
+            [
+                (None, f),
+                (1, f, (2,), {}, ('x',), 'eek'),  # will conflict
+                (1, f, (3,), {}, ('y',), 'ack'),  # will conflict
+                (4, f, (4,), {}, ('y',)),
+                (3, f, (3,), {}, ('y',)),
+                (None, f, (5,), {}, ('y',)),
+            ]
+        )
         self.assertRaises(ConfigurationConflictError, list, result)
 
     def test_it_with_actions_grouped_by_order(self):
         from . import dummyfactory as f
-        result = self._callFUT([
-            (None, f),                                 # X
-            (1, f, (1,), {}, (), 'third', 10),         # X
-            (1, f, (2,), {}, ('x',), 'fourth', 10),
-            (1, f, (3,), {}, ('y',), 'fifth', 10),
-            (2, f, (1,), {}, (), 'sixth', 10),         # X
-            (3, f, (1,), {}, (), 'seventh', 10),       # X
-            (5, f, (4,), {}, ('y',), 'eighth', 99999), # X
-            (4, f, (3,), {}, (), 'first', 5),          # X
-            (4, f, (5,), {}, ('y',), 'second', 5),
-            ])
+
+        result = self._callFUT(
+            [
+                (None, f),  # X
+                (1, f, (1,), {}, (), 'third', 10),  # X
+                (1, f, (2,), {}, ('x',), 'fourth', 10),
+                (1, f, (3,), {}, ('y',), 'fifth', 10),
+                (2, f, (1,), {}, (), 'sixth', 10),  # X
+                (3, f, (1,), {}, (), 'seventh', 10),  # X
+                (5, f, (4,), {}, ('y',), 'eighth', 99999),  # X
+                (4, f, (3,), {}, (), 'first', 5),  # X
+                (4, f, (5,), {}, ('y',), 'second', 5),
+            ]
+        )
         result = list(result)
         self.assertEqual(len(result), 6)
         # resolved actions should be grouped by (order, i)
         self.assertEqual(
             result,
-            [{'info': None,
-              'args': (),
-              'callable': f,
-              'introspectables': (),
-              'kw': {},
-              'discriminator': None,
-              'includepath': (),
-              'order': 0},
-
-              {'info': 'first',
-               'args': (3,),
-               'callable': f,
-               'introspectables': (),
-               'kw': {},
-               'discriminator': 4,
-               'includepath': (),
-               'order': 5},
-
-               {'info': 'third',
-                'args': (1,),
-                'callable': f,
-                'introspectables': (),
-                'kw': {},
-                'discriminator': 1,
-                'includepath': (),
-                'order': 10},
-
-               {'info': 'sixth',
-                'args': (1,),
-                'callable': f,
-                'introspectables': (),
-                'kw': {},
-                'discriminator': 2,
-                'includepath': (),
-                'order': 10},
-
-               {'info': 'seventh',
-                'args': (1,),
-                'callable': f,
-                'introspectables': (),
-                'kw': {},
-                'discriminator': 3,
-                'includepath': (),
-                'order': 10},
-
-                 {'info': 'eighth',
-                  'args': (4,),
-                  'callable': f,
-                  'introspectables': (),
-                  'kw': {},
-                  'discriminator': 5,
-                  'includepath': ('y',),
-                  'order': 99999}
-                  ]
-                  )
+            [
+                {
+                    'info': None,
+                    'args': (),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': None,
+                    'includepath': (),
+                    'order': 0,
+                },
+                {
+                    'info': 'first',
+                    'args': (3,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 4,
+                    'includepath': (),
+                    'order': 5,
+                },
+                {
+                    'info': 'third',
+                    'args': (1,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 1,
+                    'includepath': (),
+                    'order': 10,
+                },
+                {
+                    'info': 'sixth',
+                    'args': (1,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 2,
+                    'includepath': (),
+                    'order': 10,
+                },
+                {
+                    'info': 'seventh',
+                    'args': (1,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 3,
+                    'includepath': (),
+                    'order': 10,
+                },
+                {
+                    'info': 'eighth',
+                    'args': (4,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 5,
+                    'includepath': ('y',),
+                    'order': 99999,
+                },
+            ],
+        )
 
     def test_override_success_across_orders(self):
         from . import dummyfactory as f
-        result = self._callFUT([
-            (1, f, (2,), {}, ('x',), 'eek', 0),
-            (1, f, (3,), {}, ('x', 'y'), 'ack', 10),
-            ])
+
+        result = self._callFUT(
+            [
+                (1, f, (2,), {}, ('x',), 'eek', 0),
+                (1, f, (3,), {}, ('x', 'y'), 'ack', 10),
+            ]
+        )
         result = list(result)
-        self.assertEqual(result, [
-            {'info': 'eek',
-            'args': (2,),
-            'callable': f,
-            'introspectables': (),
-            'kw': {},
-            'discriminator': 1,
-            'includepath': ('x',),
-            'order': 0},
-        ])
+        self.assertEqual(
+            result,
+            [
+                {
+                    'info': 'eek',
+                    'args': (2,),
+                    'callable': f,
+                    'introspectables': (),
+                    'kw': {},
+                    'discriminator': 1,
+                    'includepath': ('x',),
+                    'order': 0,
+                }
+            ],
+        )
 
     def test_conflicts_across_orders(self):
         from . import dummyfactory as f
-        result = self._callFUT([
-            (1, f, (2,), {}, ('x', 'y'), 'eek', 0),
-            (1, f, (3,), {}, ('x'), 'ack', 10),
-            ])
+
+        result = self._callFUT(
+            [
+                (1, f, (2,), {}, ('x', 'y'), 'eek', 0),
+                (1, f, (3,), {}, ('x'), 'ack', 10),
+            ]
+        )
         self.assertRaises(ConfigurationConflictError, list, result)
 
+
 class TestGlobalRegistriesIntegration(unittest.TestCase):
     def setUp(self):
         from pyramid.config import global_registries
+
         global_registries.empty()
 
     tearDown = setUp
 
     def _makeConfigurator(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def test_global_registries_empty(self):
         from pyramid.config import global_registries
+
         self.assertEqual(global_registries.last, None)
 
     def test_global_registries(self):
         from pyramid.config import global_registries
+
         config1 = self._makeConfigurator()
         config1.make_wsgi_app()
         self.assertEqual(global_registries.last, config1.registry)
         config2 = self._makeConfigurator()
         config2.make_wsgi_app()
         self.assertEqual(global_registries.last, config2.registry)
-        self.assertEqual(list(global_registries),
-                         [config1.registry, config2.registry])
+        self.assertEqual(
+            list(global_registries), [config1.registry, config2.registry]
+        )
         global_registries.remove(config2.registry)
         self.assertEqual(global_registries.last, config1.registry)
 
+
 class DummyRequest:
     subpath = ()
     matchdict = None
     request_iface = IRequest
+
     def __init__(self, environ=None):
         if environ is None:
             environ = {}
@@ -2005,63 +2413,86 @@ class DummyRequest:
         self.params = {}
         self.cookies = {}
 
+
 class DummyThreadLocalManager(object):
     def __init__(self):
         self.pushed = {'registry': None, 'request': None}
         self.popped = False
+
     def push(self, d):
         self.pushed = d
+
     def get(self):
         return self.pushed
+
     def pop(self):
         self.popped = True
 
+
 from zope.interface import implementer
+
+
 @implementer(IDummy)
 class DummyEvent:
     pass
 
+
 class DummyRegistry(object):
     def __init__(self, adaptation=None, util=None):
         self.utilities = []
         self.adapters = []
         self.adaptation = adaptation
         self.util = util
+
     def subscribers(self, events, name):
         self.events = events
         return events
+
     def registerUtility(self, *arg, **kw):
         self.utilities.append((arg, kw))
+
     def registerAdapter(self, *arg, **kw):
         self.adapters.append((arg, kw))
+
     def queryAdapter(self, *arg, **kw):
         return self.adaptation
+
     def queryUtility(self, *arg, **kw):
         return self.util
 
+
 from zope.interface import Interface
+
+
 class IOther(Interface):
     pass
 
+
 def _conflictFunctions(e):
     conflicts = e._conflicts.values()
     for conflict in conflicts:
         for confinst in conflict:
             yield confinst.function
 
+
 class DummyActionState(object):
     autocommit = False
     info = ''
+
     def __init__(self):
         self.actions = []
+
     def action(self, *arg, **kw):
         self.actions.append((arg, kw))
 
+
 class DummyIntrospectable(object):
     def __init__(self):
         self.registered = []
+
     def register(self, introspector, action_info):
         self.registered.append((introspector, action_info))
-        
+
+
 class DummyPredicate(object):
     pass
diff --git a/tests/test_config/test_rendering.py b/tests/test_config/test_rendering.py
index 8794fa9df..a33977c28 100644
--- a/tests/test_config/test_rendering.py
+++ b/tests/test_config/test_rendering.py
@@ -1,34 +1,43 @@
 import unittest
 
+
 class TestRenderingConfiguratorMixin(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def test_add_default_renderers(self):
         from pyramid.config.rendering import DEFAULT_RENDERERS
         from pyramid.interfaces import IRendererFactory
+
         config = self._makeOne(autocommit=True)
         config.add_default_renderers()
         for name, impl in DEFAULT_RENDERERS:
             self.assertTrue(
-                config.registry.queryUtility(IRendererFactory, name) is not None
-                )
+                config.registry.queryUtility(IRendererFactory, name)
+                is not None
+            )
 
     def test_add_renderer(self):
         from pyramid.interfaces import IRendererFactory
+
         config = self._makeOne(autocommit=True)
         renderer = object()
         config.add_renderer('name', renderer)
-        self.assertEqual(config.registry.getUtility(IRendererFactory, 'name'),
-                         renderer)
+        self.assertEqual(
+            config.registry.getUtility(IRendererFactory, 'name'), renderer
+        )
 
     def test_add_renderer_dottedname_factory(self):
         from pyramid.interfaces import IRendererFactory
+
         config = self._makeOne(autocommit=True)
         import tests.test_config
-        config.add_renderer('name', 'tests.test_config')
-        self.assertEqual(config.registry.getUtility(IRendererFactory, 'name'),
-                         tests.test_config)
 
+        config.add_renderer('name', 'tests.test_config')
+        self.assertEqual(
+            config.registry.getUtility(IRendererFactory, 'name'),
+            tests.test_config,
+        )
diff --git a/tests/test_config/test_routes.py b/tests/test_config/test_routes.py
index 870abe0ee..0999f8072 100644
--- a/tests/test_config/test_routes.py
+++ b/tests/test_config/test_routes.py
@@ -4,14 +4,17 @@ from . import dummyfactory
 from . import DummyContext
 from pyramid.compat import text_
 
+
 class RoutesConfiguratorMixinTests(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def _assertRoute(self, config, name, path, num_predicates=0):
         from pyramid.interfaces import IRoutesMapper
+
         mapper = config.registry.getUtility(IRoutesMapper)
         routes = mapper.get_routes()
         route = routes[0]
@@ -33,6 +36,7 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
 
     def test_get_routes_mapper_already_registered(self):
         from pyramid.interfaces import IRoutesMapper
+
         config = self._makeOne()
         mapper = object()
         config.registry.registerUtility(mapper, IRoutesMapper)
@@ -53,8 +57,9 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
     def test_add_route_discriminator(self):
         config = self._makeOne()
         config.add_route('name', 'path')
-        self.assertEqual(config.action_state.actions[-1]['discriminator'],
-                         ('route', 'name'))
+        self.assertEqual(
+            config.action_state.actions[-1]['discriminator'], ('route', 'name')
+        )
 
     def test_add_route_with_factory(self):
         config = self._makeOne(autocommit=True)
@@ -68,13 +73,13 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
         config.add_route('name', 'path/{foo}', static=True)
         mapper = config.get_routes_mapper()
         self.assertEqual(len(mapper.get_routes()), 0)
-        self.assertEqual(mapper.generate('name', {"foo":"a"}), '/path/a')
+        self.assertEqual(mapper.generate('name', {"foo": "a"}), '/path/a')
 
     def test_add_route_with_factory_dottedname(self):
         config = self._makeOne(autocommit=True)
         config.add_route(
-            'name', 'path',
-            factory='tests.test_config.dummyfactory')
+            'name', 'path', factory='tests.test_config.dummyfactory'
+        )
         route = self._assertRoute(config, 'name', 'path')
         self.assertEqual(route.factory, dummyfactory)
 
@@ -116,8 +121,9 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
 
     def test_add_route_with_path_info_highorder(self):
         config = self._makeOne(autocommit=True)
-        config.add_route('name', 'path',
-                         path_info=text_(b'/La Pe\xc3\xb1a', 'utf-8'))
+        config.add_route(
+            'name', 'path', path_info=text_(b'/La Pe\xc3\xb1a', 'utf-8')
+        )
         route = self._assertRoute(config, 'name', 'path', 1)
         predicate = route.predicates[0]
         request = self._makeRequest(config)
@@ -129,8 +135,9 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
 
     def test_add_route_with_path_info_regex(self):
         config = self._makeOne(autocommit=True)
-        config.add_route('name', 'path',
-                         path_info=text_(br'/La Pe\w*', 'utf-8'))
+        config.add_route(
+            'name', 'path', path_info=text_(br'/La Pe\w*', 'utf-8')
+        )
         route = self._assertRoute(config, 'name', 'path', 1)
         predicate = route.predicates[0]
         request = self._makeRequest(config)
@@ -146,7 +153,7 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
         route = self._assertRoute(config, 'name', 'path', 1)
         predicate = route.predicates[0]
         request = self._makeRequest(config)
-        request.params = {'abc':'123'}
+        request.params = {'abc': '123'}
         self.assertEqual(predicate(None, request), True)
         request = self._makeRequest(config)
         request.params = {}
@@ -154,9 +161,15 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
 
     def test_add_route_with_custom_predicates(self):
         import warnings
+
         config = self._makeOne(autocommit=True)
-        def pred1(context, request): pass
-        def pred2(context, request): pass
+
+        def pred1(context, request):
+            pass
+
+        def pred2(context, request):
+            pass
+
         with warnings.catch_warnings(record=True) as w:
             warnings.filterwarnings('always')
             config.add_route('name', 'path', custom_predicates=(pred1, pred2))
@@ -170,7 +183,7 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
         route = self._assertRoute(config, 'name', 'path', 1)
         predicate = route.predicates[0]
         request = self._makeRequest(config)
-        request.headers = {'Host':'example.com'}
+        request.headers = {'Host': 'example.com'}
         self.assertEqual(predicate(None, request), True)
         request = self._makeRequest(config)
         request.headers = {}
@@ -222,6 +235,7 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
 
     def test_add_route_no_path_no_pattern(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
         self.assertRaises(ConfigurationError, config.add_route, 'name')
 
@@ -234,46 +248,52 @@ class RoutesConfiguratorMixinTests(unittest.TestCase):
     def test_add_route_no_view_with_view_attr(self):
         config = self._makeOne(autocommit=True)
         from pyramid.exceptions import ConfigurationError
+
         try:
             config.add_route('name', '/pattern', view_attr='abc')
         except ConfigurationError:
             pass
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_add_route_no_view_with_view_context(self):
         config = self._makeOne(autocommit=True)
         from pyramid.exceptions import ConfigurationError
+
         try:
             config.add_route('name', '/pattern', view_context=DummyContext)
         except ConfigurationError:
             pass
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_add_route_no_view_with_view_permission(self):
         config = self._makeOne(autocommit=True)
         from pyramid.exceptions import ConfigurationError
+
         try:
             config.add_route('name', '/pattern', view_permission='edit')
         except ConfigurationError:
             pass
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_add_route_no_view_with_view_renderer(self):
         config = self._makeOne(autocommit=True)
         from pyramid.exceptions import ConfigurationError
+
         try:
             config.add_route('name', '/pattern', view_renderer='json')
         except ConfigurationError:
             pass
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
+
 class DummyRequest:
     subpath = ()
     matchdict = None
+
     def __init__(self, environ=None):
         if environ is None:
             environ = {}
@@ -281,6 +301,7 @@ class DummyRequest:
         self.params = {}
         self.cookies = {}
 
+
 class DummyAccept(object):
     def __init__(self, *matches, **kw):
         self.matches = list(matches)
diff --git a/tests/test_config/test_security.py b/tests/test_config/test_security.py
index 5db8e21fc..77f7f0440 100644
--- a/tests/test_config/test_security.py
+++ b/tests/test_config/test_security.py
@@ -3,9 +3,11 @@ import unittest
 from pyramid.exceptions import ConfigurationExecutionError
 from pyramid.exceptions import ConfigurationError
 
+
 class ConfiguratorSecurityMethodsTests(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
@@ -18,12 +20,14 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase):
     def test_set_authentication_policy_no_authz_policy_autocommit(self):
         config = self._makeOne(autocommit=True)
         policy = object()
-        self.assertRaises(ConfigurationError,
-                          config.set_authentication_policy, policy)
+        self.assertRaises(
+            ConfigurationError, config.set_authentication_policy, policy
+        )
 
     def test_set_authentication_policy_with_authz_policy(self):
         from pyramid.interfaces import IAuthenticationPolicy
         from pyramid.interfaces import IAuthorizationPolicy
+
         config = self._makeOne()
         authn_policy = object()
         authz_policy = object()
@@ -31,11 +35,13 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase):
         config.set_authentication_policy(authn_policy)
         config.commit()
         self.assertEqual(
-            config.registry.getUtility(IAuthenticationPolicy), authn_policy)
+            config.registry.getUtility(IAuthenticationPolicy), authn_policy
+        )
 
     def test_set_authentication_policy_with_authz_policy_autocommit(self):
         from pyramid.interfaces import IAuthenticationPolicy
         from pyramid.interfaces import IAuthorizationPolicy
+
         config = self._makeOne(autocommit=True)
         authn_policy = object()
         authz_policy = object()
@@ -43,7 +49,8 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase):
         config.set_authentication_policy(authn_policy)
         config.commit()
         self.assertEqual(
-            config.registry.getUtility(IAuthenticationPolicy), authn_policy)
+            config.registry.getUtility(IAuthenticationPolicy), authn_policy
+        )
 
     def test_set_authorization_policy_no_authn_policy(self):
         config = self._makeOne()
@@ -53,15 +60,18 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase):
 
     def test_set_authorization_policy_no_authn_policy_autocommit(self):
         from pyramid.interfaces import IAuthorizationPolicy
+
         config = self._makeOne(autocommit=True)
         policy = object()
         config.set_authorization_policy(policy)
         self.assertEqual(
-            config.registry.getUtility(IAuthorizationPolicy), policy)
+            config.registry.getUtility(IAuthorizationPolicy), policy
+        )
 
     def test_set_authorization_policy_with_authn_policy(self):
         from pyramid.interfaces import IAuthorizationPolicy
         from pyramid.interfaces import IAuthenticationPolicy
+
         config = self._makeOne()
         authn_policy = object()
         authz_policy = object()
@@ -69,25 +79,30 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase):
         config.set_authorization_policy(authz_policy)
         config.commit()
         self.assertEqual(
-            config.registry.getUtility(IAuthorizationPolicy), authz_policy)
+            config.registry.getUtility(IAuthorizationPolicy), authz_policy
+        )
 
     def test_set_authorization_policy_with_authn_policy_autocommit(self):
         from pyramid.interfaces import IAuthorizationPolicy
         from pyramid.interfaces import IAuthenticationPolicy
+
         config = self._makeOne(autocommit=True)
         authn_policy = object()
         authz_policy = object()
         config.registry.registerUtility(authn_policy, IAuthenticationPolicy)
         config.set_authorization_policy(authz_policy)
         self.assertEqual(
-            config.registry.getUtility(IAuthorizationPolicy), authz_policy)
+            config.registry.getUtility(IAuthorizationPolicy), authz_policy
+        )
 
     def test_set_default_permission(self):
         from pyramid.interfaces import IDefaultPermission
+
         config = self._makeOne(autocommit=True)
         config.set_default_permission('view')
-        self.assertEqual(config.registry.getUtility(IDefaultPermission),
-                         'view')
+        self.assertEqual(
+            config.registry.getUtility(IDefaultPermission), 'view'
+        )
 
     def test_add_permission(self):
         config = self._makeOne(autocommit=True)
@@ -100,23 +115,34 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase):
 
     def test_set_default_csrf_options(self):
         from pyramid.interfaces import IDefaultCSRFOptions
+
         config = self._makeOne(autocommit=True)
         config.set_default_csrf_options()
         result = config.registry.getUtility(IDefaultCSRFOptions)
         self.assertEqual(result.require_csrf, True)
         self.assertEqual(result.token, 'csrf_token')
         self.assertEqual(result.header, 'X-CSRF-Token')
-        self.assertEqual(list(sorted(result.safe_methods)),
-                         ['GET', 'HEAD', 'OPTIONS', 'TRACE'])
+        self.assertEqual(
+            list(sorted(result.safe_methods)),
+            ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
+        )
         self.assertTrue(result.callback is None)
 
     def test_changing_set_default_csrf_options(self):
         from pyramid.interfaces import IDefaultCSRFOptions
+
         config = self._makeOne(autocommit=True)
-        def callback(request): return True
+
+        def callback(request):
+            return True
+
         config.set_default_csrf_options(
-            require_csrf=False, token='DUMMY', header=None,
-            safe_methods=('PUT',), callback=callback)
+            require_csrf=False,
+            token='DUMMY',
+            header=None,
+            safe_methods=('PUT',),
+            callback=callback,
+        )
         result = config.registry.getUtility(IDefaultCSRFOptions)
         self.assertEqual(result.require_csrf, False)
         self.assertEqual(result.token, 'DUMMY')
diff --git a/tests/test_config/test_settings.py b/tests/test_config/test_settings.py
index a3afd24e7..2fe769add 100644
--- a/tests/test_config/test_settings.py
+++ b/tests/test_config/test_settings.py
@@ -4,6 +4,7 @@ import unittest
 class TestSettingsConfiguratorMixin(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
@@ -21,27 +22,29 @@ class TestSettingsConfiguratorMixin(unittest.TestCase):
 
     def test__set_settings_as_dictwithvalues(self):
         config = self._makeOne()
-        settings = config._set_settings({'a':'1'})
+        settings = config._set_settings({'a': '1'})
         self.assertEqual(settings['a'], '1')
 
     def test_get_settings_nosettings(self):
         from pyramid.registry import Registry
+
         reg = Registry()
         config = self._makeOne(reg)
         self.assertEqual(config.get_settings(), None)
 
     def test_get_settings_withsettings(self):
-        settings = {'a':1}
+        settings = {'a': 1}
         config = self._makeOne()
         config.registry.settings = settings
         self.assertEqual(config.get_settings(), settings)
 
     def test_add_settings_settings_already_registered(self):
         from pyramid.registry import Registry
+
         reg = Registry()
         config = self._makeOne(reg)
-        config._set_settings({'a':1})
-        config.add_settings({'b':2})
+        config._set_settings({'a': 1})
+        config.add_settings({'b': 2})
         settings = reg.settings
         self.assertEqual(settings['a'], 1)
         self.assertEqual(settings['b'], 2)
@@ -49,15 +52,17 @@ class TestSettingsConfiguratorMixin(unittest.TestCase):
     def test_add_settings_settings_not_yet_registered(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import ISettings
+
         reg = Registry()
         config = self._makeOne(reg)
-        config.add_settings({'a':1})
+        config.add_settings({'a': 1})
         settings = reg.getUtility(ISettings)
         self.assertEqual(settings['a'], 1)
 
     def test_add_settings_settings_None(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import ISettings
+
         reg = Registry()
         config = self._makeOne(reg)
         config.add_settings(None, a=1)
@@ -68,6 +73,7 @@ class TestSettingsConfiguratorMixin(unittest.TestCase):
         class ReadOnlyDict(dict):
             def __readonly__(self, *args, **kwargs):  # pragma: no cover
                 raise RuntimeError("Cannot modify ReadOnlyDict")
+
             __setitem__ = __readonly__
             __delitem__ = __readonly__
             pop = __readonly__
@@ -83,9 +89,9 @@ class TestSettingsConfiguratorMixin(unittest.TestCase):
 
 
 class TestSettings(unittest.TestCase):
-
     def _getTargetClass(self):
         from pyramid.config.settings import Settings
+
         return Settings
 
     def _makeOne(self, d=None, environ=None):
@@ -112,28 +118,30 @@ class TestSettings(unittest.TestCase):
         settings = self._makeOne({})
         self.assertEqual(settings['prevent_http_cache'], False)
         self.assertEqual(settings['pyramid.prevent_http_cache'], False)
-        result = self._makeOne({'prevent_http_cache':'false'})
+        result = self._makeOne({'prevent_http_cache': 'false'})
         self.assertEqual(result['prevent_http_cache'], False)
         self.assertEqual(result['pyramid.prevent_http_cache'], False)
-        result = self._makeOne({'prevent_http_cache':'t'})
+        result = self._makeOne({'prevent_http_cache': 't'})
         self.assertEqual(result['prevent_http_cache'], True)
         self.assertEqual(result['pyramid.prevent_http_cache'], True)
-        result = self._makeOne({'prevent_http_cache':'1'})
+        result = self._makeOne({'prevent_http_cache': '1'})
         self.assertEqual(result['prevent_http_cache'], True)
         self.assertEqual(result['pyramid.prevent_http_cache'], True)
-        result = self._makeOne({'pyramid.prevent_http_cache':'t'})
+        result = self._makeOne({'pyramid.prevent_http_cache': 't'})
         self.assertEqual(result['prevent_http_cache'], True)
         self.assertEqual(result['pyramid.prevent_http_cache'], True)
-        result = self._makeOne({}, {'PYRAMID_PREVENT_HTTP_CACHE':'1'})
+        result = self._makeOne({}, {'PYRAMID_PREVENT_HTTP_CACHE': '1'})
         self.assertEqual(result['prevent_http_cache'], True)
         self.assertEqual(result['pyramid.prevent_http_cache'], True)
-        result = self._makeOne({'prevent_http_cache':'false',
-                                'pyramid.prevent_http_cache':'1'})
+        result = self._makeOne(
+            {'prevent_http_cache': 'false', 'pyramid.prevent_http_cache': '1'}
+        )
         self.assertEqual(result['prevent_http_cache'], True)
         self.assertEqual(result['pyramid.prevent_http_cache'], True)
-        result = self._makeOne({'prevent_http_cache':'false',
-                                'pyramid.prevent_http_cache':'f'},
-                               {'PYRAMID_PREVENT_HTTP_CACHE':'1'})
+        result = self._makeOne(
+            {'prevent_http_cache': 'false', 'pyramid.prevent_http_cache': 'f'},
+            {'PYRAMID_PREVENT_HTTP_CACHE': '1'},
+        )
         self.assertEqual(result['prevent_http_cache'], True)
         self.assertEqual(result['pyramid.prevent_http_cache'], True)
 
@@ -141,28 +149,30 @@ class TestSettings(unittest.TestCase):
         settings = self._makeOne({})
         self.assertEqual(settings['prevent_cachebust'], False)
         self.assertEqual(settings['pyramid.prevent_cachebust'], False)
-        result = self._makeOne({'prevent_cachebust':'false'})
+        result = self._makeOne({'prevent_cachebust': 'false'})
         self.assertEqual(result['prevent_cachebust'], False)
         self.assertEqual(result['pyramid.prevent_cachebust'], False)
-        result = self._makeOne({'prevent_cachebust':'t'})
+        result = self._makeOne({'prevent_cachebust': 't'})
         self.assertEqual(result['prevent_cachebust'], True)
         self.assertEqual(result['pyramid.prevent_cachebust'], True)
-        result = self._makeOne({'prevent_cachebust':'1'})
+        result = self._makeOne({'prevent_cachebust': '1'})
         self.assertEqual(result['prevent_cachebust'], True)
         self.assertEqual(result['pyramid.prevent_cachebust'], True)
-        result = self._makeOne({'pyramid.prevent_cachebust':'t'})
+        result = self._makeOne({'pyramid.prevent_cachebust': 't'})
         self.assertEqual(result['prevent_cachebust'], True)
         self.assertEqual(result['pyramid.prevent_cachebust'], True)
-        result = self._makeOne({}, {'PYRAMID_PREVENT_CACHEBUST':'1'})
+        result = self._makeOne({}, {'PYRAMID_PREVENT_CACHEBUST': '1'})
         self.assertEqual(result['prevent_cachebust'], True)
         self.assertEqual(result['pyramid.prevent_cachebust'], True)
-        result = self._makeOne({'prevent_cachebust':'false',
-                                'pyramid.prevent_cachebust':'1'})
+        result = self._makeOne(
+            {'prevent_cachebust': 'false', 'pyramid.prevent_cachebust': '1'}
+        )
         self.assertEqual(result['prevent_cachebust'], True)
         self.assertEqual(result['pyramid.prevent_cachebust'], True)
-        result = self._makeOne({'prevent_cachebust':'false',
-                                'pyramid.prevent_cachebust':'f'},
-                               {'PYRAMID_PREVENT_CACHEBUST':'1'})
+        result = self._makeOne(
+            {'prevent_cachebust': 'false', 'pyramid.prevent_cachebust': 'f'},
+            {'PYRAMID_PREVENT_CACHEBUST': '1'},
+        )
         self.assertEqual(result['prevent_cachebust'], True)
         self.assertEqual(result['pyramid.prevent_cachebust'], True)
 
@@ -170,27 +180,29 @@ class TestSettings(unittest.TestCase):
         settings = self._makeOne({})
         self.assertEqual(settings['reload_templates'], False)
         self.assertEqual(settings['pyramid.reload_templates'], False)
-        result = self._makeOne({'reload_templates':'false'})
+        result = self._makeOne({'reload_templates': 'false'})
         self.assertEqual(result['reload_templates'], False)
         self.assertEqual(result['pyramid.reload_templates'], False)
-        result = self._makeOne({'reload_templates':'t'})
+        result = self._makeOne({'reload_templates': 't'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
-        result = self._makeOne({'reload_templates':'1'})
+        result = self._makeOne({'reload_templates': '1'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
-        result = self._makeOne({'pyramid.reload_templates':'1'})
+        result = self._makeOne({'pyramid.reload_templates': '1'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
-        result = self._makeOne({}, {'PYRAMID_RELOAD_TEMPLATES':'1'})
+        result = self._makeOne({}, {'PYRAMID_RELOAD_TEMPLATES': '1'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
-        result = self._makeOne({'reload_templates':'false',
-                                'pyramid.reload_templates':'1'})
+        result = self._makeOne(
+            {'reload_templates': 'false', 'pyramid.reload_templates': '1'}
+        )
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
-        result = self._makeOne({'reload_templates':'false'},
-                               {'PYRAMID_RELOAD_TEMPLATES':'1'})
+        result = self._makeOne(
+            {'reload_templates': 'false'}, {'PYRAMID_RELOAD_TEMPLATES': '1'}
+        )
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
 
@@ -201,40 +213,42 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['reload_assets'], False)
         self.assertEqual(result['pyramid.reload_resources'], False)
         self.assertEqual(result['pyramid.reload_assets'], False)
-        result = self._makeOne({'reload_resources':'false'})
+        result = self._makeOne({'reload_resources': 'false'})
         self.assertEqual(result['reload_resources'], False)
         self.assertEqual(result['reload_assets'], False)
         self.assertEqual(result['pyramid.reload_resources'], False)
         self.assertEqual(result['pyramid.reload_assets'], False)
-        result = self._makeOne({'reload_resources':'t'})
+        result = self._makeOne({'reload_resources': 't'})
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({'reload_resources':'1'})
+        result = self._makeOne({'reload_resources': '1'})
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({'pyramid.reload_resources':'1'})
+        result = self._makeOne({'pyramid.reload_resources': '1'})
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({}, {'PYRAMID_RELOAD_RESOURCES':'1'})
+        result = self._makeOne({}, {'PYRAMID_RELOAD_RESOURCES': '1'})
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({'reload_resources':'false',
-                                'pyramid.reload_resources':'1'})
+        result = self._makeOne(
+            {'reload_resources': 'false', 'pyramid.reload_resources': '1'}
+        )
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({'reload_resources':'false',
-                                'pyramid.reload_resources':'false'},
-                               {'PYRAMID_RELOAD_RESOURCES':'1'})
+        result = self._makeOne(
+            {'reload_resources': 'false', 'pyramid.reload_resources': 'false'},
+            {'PYRAMID_RELOAD_RESOURCES': '1'},
+        )
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
@@ -247,40 +261,42 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['reload_resources'], False)
         self.assertEqual(result['pyramid.reload_assets'], False)
         self.assertEqual(result['pyramid.reload_resources'], False)
-        result = self._makeOne({'reload_assets':'false'})
+        result = self._makeOne({'reload_assets': 'false'})
         self.assertEqual(result['reload_resources'], False)
         self.assertEqual(result['reload_assets'], False)
         self.assertEqual(result['pyramid.reload_assets'], False)
         self.assertEqual(result['pyramid.reload_resources'], False)
-        result = self._makeOne({'reload_assets':'t'})
+        result = self._makeOne({'reload_assets': 't'})
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
-        result = self._makeOne({'reload_assets':'1'})
+        result = self._makeOne({'reload_assets': '1'})
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
-        result = self._makeOne({'pyramid.reload_assets':'1'})
+        result = self._makeOne({'pyramid.reload_assets': '1'})
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
-        result = self._makeOne({}, {'PYRAMID_RELOAD_ASSETS':'1'})
+        result = self._makeOne({}, {'PYRAMID_RELOAD_ASSETS': '1'})
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
-        result = self._makeOne({'reload_assets':'false',
-                                'pyramid.reload_assets':'1'})
+        result = self._makeOne(
+            {'reload_assets': 'false', 'pyramid.reload_assets': '1'}
+        )
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
-        result = self._makeOne({'reload_assets':'false',
-                                'pyramid.reload_assets':'false'},
-                               {'PYRAMID_RELOAD_ASSETS':'1'})
+        result = self._makeOne(
+            {'reload_assets': 'false', 'pyramid.reload_assets': 'false'},
+            {'PYRAMID_RELOAD_ASSETS': '1'},
+        )
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
@@ -294,52 +310,54 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['pyramid.reload_templates'], False)
         self.assertEqual(result['pyramid.reload_resources'], False)
         self.assertEqual(result['pyramid.reload_assets'], False)
-        result = self._makeOne({'reload_all':'false'})
+        result = self._makeOne({'reload_all': 'false'})
         self.assertEqual(result['reload_templates'], False)
         self.assertEqual(result['reload_resources'], False)
         self.assertEqual(result['reload_assets'], False)
         self.assertEqual(result['pyramid.reload_templates'], False)
         self.assertEqual(result['pyramid.reload_resources'], False)
         self.assertEqual(result['pyramid.reload_assets'], False)
-        result = self._makeOne({'reload_all':'t'})
+        result = self._makeOne({'reload_all': 't'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({'reload_all':'1'})
+        result = self._makeOne({'reload_all': '1'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({'pyramid.reload_all':'1'})
+        result = self._makeOne({'pyramid.reload_all': '1'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({}, {'PYRAMID_RELOAD_ALL':'1'})
+        result = self._makeOne({}, {'PYRAMID_RELOAD_ALL': '1'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({'reload_all':'false',
-                                'pyramid.reload_all':'1'})
+        result = self._makeOne(
+            {'reload_all': 'false', 'pyramid.reload_all': '1'}
+        )
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
         self.assertEqual(result['pyramid.reload_templates'], True)
         self.assertEqual(result['pyramid.reload_resources'], True)
         self.assertEqual(result['pyramid.reload_assets'], True)
-        result = self._makeOne({'reload_all':'false',
-                                'pyramid.reload_all':'false'},
-                               {'PYRAMID_RELOAD_ALL':'1'})
+        result = self._makeOne(
+            {'reload_all': 'false', 'pyramid.reload_all': 'false'},
+            {'PYRAMID_RELOAD_ALL': '1'},
+        )
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
         self.assertEqual(result['reload_assets'], True)
@@ -351,28 +369,36 @@ class TestSettings(unittest.TestCase):
         result = self._makeOne({})
         self.assertEqual(result['debug_authorization'], False)
         self.assertEqual(result['pyramid.debug_authorization'], False)
-        result = self._makeOne({'debug_authorization':'false'})
+        result = self._makeOne({'debug_authorization': 'false'})
         self.assertEqual(result['debug_authorization'], False)
         self.assertEqual(result['pyramid.debug_authorization'], False)
-        result = self._makeOne({'debug_authorization':'t'})
+        result = self._makeOne({'debug_authorization': 't'})
         self.assertEqual(result['debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
-        result = self._makeOne({'debug_authorization':'1'})
+        result = self._makeOne({'debug_authorization': '1'})
         self.assertEqual(result['debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
-        result = self._makeOne({'pyramid.debug_authorization':'1'})
+        result = self._makeOne({'pyramid.debug_authorization': '1'})
         self.assertEqual(result['debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
-        result = self._makeOne({}, {'PYRAMID_DEBUG_AUTHORIZATION':'1'})
+        result = self._makeOne({}, {'PYRAMID_DEBUG_AUTHORIZATION': '1'})
         self.assertEqual(result['debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
-        result = self._makeOne({'debug_authorization':'false',
-                                'pyramid.debug_authorization':'1'})
+        result = self._makeOne(
+            {
+                'debug_authorization': 'false',
+                'pyramid.debug_authorization': '1',
+            }
+        )
         self.assertEqual(result['debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
-        result = self._makeOne({'debug_authorization':'false',
-                                'pyramid.debug_authorization':'false'},
-                               {'PYRAMID_DEBUG_AUTHORIZATION':'1'})
+        result = self._makeOne(
+            {
+                'debug_authorization': 'false',
+                'pyramid.debug_authorization': 'false',
+            },
+            {'PYRAMID_DEBUG_AUTHORIZATION': '1'},
+        )
         self.assertEqual(result['debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
 
@@ -380,28 +406,30 @@ class TestSettings(unittest.TestCase):
         result = self._makeOne({})
         self.assertEqual(result['debug_notfound'], False)
         self.assertEqual(result['pyramid.debug_notfound'], False)
-        result = self._makeOne({'debug_notfound':'false'})
+        result = self._makeOne({'debug_notfound': 'false'})
         self.assertEqual(result['debug_notfound'], False)
         self.assertEqual(result['pyramid.debug_notfound'], False)
-        result = self._makeOne({'debug_notfound':'t'})
+        result = self._makeOne({'debug_notfound': 't'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['pyramid.debug_notfound'], True)
-        result = self._makeOne({'debug_notfound':'1'})
+        result = self._makeOne({'debug_notfound': '1'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['pyramid.debug_notfound'], True)
-        result = self._makeOne({'pyramid.debug_notfound':'1'})
+        result = self._makeOne({'pyramid.debug_notfound': '1'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['pyramid.debug_notfound'], True)
-        result = self._makeOne({}, {'PYRAMID_DEBUG_NOTFOUND':'1'})
+        result = self._makeOne({}, {'PYRAMID_DEBUG_NOTFOUND': '1'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['pyramid.debug_notfound'], True)
-        result = self._makeOne({'debug_notfound':'false',
-                                'pyramid.debug_notfound':'1'})
+        result = self._makeOne(
+            {'debug_notfound': 'false', 'pyramid.debug_notfound': '1'}
+        )
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['pyramid.debug_notfound'], True)
-        result = self._makeOne({'debug_notfound':'false',
-                                'pyramid.debug_notfound':'false'},
-                               {'PYRAMID_DEBUG_NOTFOUND':'1'})
+        result = self._makeOne(
+            {'debug_notfound': 'false', 'pyramid.debug_notfound': 'false'},
+            {'PYRAMID_DEBUG_NOTFOUND': '1'},
+        )
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['pyramid.debug_notfound'], True)
 
@@ -409,28 +437,30 @@ class TestSettings(unittest.TestCase):
         result = self._makeOne({})
         self.assertEqual(result['debug_routematch'], False)
         self.assertEqual(result['pyramid.debug_routematch'], False)
-        result = self._makeOne({'debug_routematch':'false'})
+        result = self._makeOne({'debug_routematch': 'false'})
         self.assertEqual(result['debug_routematch'], False)
         self.assertEqual(result['pyramid.debug_routematch'], False)
-        result = self._makeOne({'debug_routematch':'t'})
+        result = self._makeOne({'debug_routematch': 't'})
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_routematch'], True)
-        result = self._makeOne({'debug_routematch':'1'})
+        result = self._makeOne({'debug_routematch': '1'})
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_routematch'], True)
-        result = self._makeOne({'pyramid.debug_routematch':'1'})
+        result = self._makeOne({'pyramid.debug_routematch': '1'})
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_routematch'], True)
-        result = self._makeOne({}, {'PYRAMID_DEBUG_ROUTEMATCH':'1'})
+        result = self._makeOne({}, {'PYRAMID_DEBUG_ROUTEMATCH': '1'})
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_routematch'], True)
-        result = self._makeOne({'debug_routematch':'false',
-                                'pyramid.debug_routematch':'1'})
+        result = self._makeOne(
+            {'debug_routematch': 'false', 'pyramid.debug_routematch': '1'}
+        )
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_routematch'], True)
-        result = self._makeOne({'debug_routematch':'false',
-                                'pyramid.debug_routematch':'false'},
-                               {'PYRAMID_DEBUG_ROUTEMATCH':'1'})
+        result = self._makeOne(
+            {'debug_routematch': 'false', 'pyramid.debug_routematch': 'false'},
+            {'PYRAMID_DEBUG_ROUTEMATCH': '1'},
+        )
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_routematch'], True)
 
@@ -438,28 +468,30 @@ class TestSettings(unittest.TestCase):
         result = self._makeOne({})
         self.assertEqual(result['debug_templates'], False)
         self.assertEqual(result['pyramid.debug_templates'], False)
-        result = self._makeOne({'debug_templates':'false'})
+        result = self._makeOne({'debug_templates': 'false'})
         self.assertEqual(result['debug_templates'], False)
         self.assertEqual(result['pyramid.debug_templates'], False)
-        result = self._makeOne({'debug_templates':'t'})
+        result = self._makeOne({'debug_templates': 't'})
         self.assertEqual(result['debug_templates'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({'debug_templates':'1'})
+        result = self._makeOne({'debug_templates': '1'})
         self.assertEqual(result['debug_templates'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({'pyramid.debug_templates':'1'})
+        result = self._makeOne({'pyramid.debug_templates': '1'})
         self.assertEqual(result['debug_templates'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({}, {'PYRAMID_DEBUG_TEMPLATES':'1'})
+        result = self._makeOne({}, {'PYRAMID_DEBUG_TEMPLATES': '1'})
         self.assertEqual(result['debug_templates'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({'debug_templates':'false',
-                                'pyramid.debug_templates':'1'})
+        result = self._makeOne(
+            {'debug_templates': 'false', 'pyramid.debug_templates': '1'}
+        )
         self.assertEqual(result['debug_templates'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({'debug_templates':'false',
-                                'pyramid.debug_templates':'false'},
-                               {'PYRAMID_DEBUG_TEMPLATES':'1'})
+        result = self._makeOne(
+            {'debug_templates': 'false', 'pyramid.debug_templates': 'false'},
+            {'PYRAMID_DEBUG_TEMPLATES': '1'},
+        )
         self.assertEqual(result['debug_templates'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
 
@@ -473,7 +505,7 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['pyramid.debug_routematch'], False)
         self.assertEqual(result['pyramid.debug_authorization'], False)
         self.assertEqual(result['pyramid.debug_templates'], False)
-        result = self._makeOne({'debug_all':'false'})
+        result = self._makeOne({'debug_all': 'false'})
         self.assertEqual(result['debug_notfound'], False)
         self.assertEqual(result['debug_routematch'], False)
         self.assertEqual(result['debug_authorization'], False)
@@ -482,7 +514,7 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['pyramid.debug_routematch'], False)
         self.assertEqual(result['pyramid.debug_authorization'], False)
         self.assertEqual(result['pyramid.debug_templates'], False)
-        result = self._makeOne({'debug_all':'t'})
+        result = self._makeOne({'debug_all': 't'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['debug_authorization'], True)
@@ -491,7 +523,7 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['pyramid.debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({'debug_all':'1'})
+        result = self._makeOne({'debug_all': '1'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['debug_authorization'], True)
@@ -500,7 +532,7 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['pyramid.debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({'pyramid.debug_all':'1'})
+        result = self._makeOne({'pyramid.debug_all': '1'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['debug_authorization'], True)
@@ -509,7 +541,7 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['pyramid.debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({}, {'PYRAMID_DEBUG_ALL':'1'})
+        result = self._makeOne({}, {'PYRAMID_DEBUG_ALL': '1'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['debug_authorization'], True)
@@ -518,8 +550,9 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['pyramid.debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({'debug_all':'false',
-                                'pyramid.debug_all':'1'})
+        result = self._makeOne(
+            {'debug_all': 'false', 'pyramid.debug_all': '1'}
+        )
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['debug_authorization'], True)
@@ -528,9 +561,10 @@ class TestSettings(unittest.TestCase):
         self.assertEqual(result['pyramid.debug_routematch'], True)
         self.assertEqual(result['pyramid.debug_authorization'], True)
         self.assertEqual(result['pyramid.debug_templates'], True)
-        result = self._makeOne({'debug_all':'false',
-                                'pyramid.debug_all':'false'},
-                               {'PYRAMID_DEBUG_ALL':'1'})
+        result = self._makeOne(
+            {'debug_all': 'false', 'pyramid.debug_all': 'false'},
+            {'PYRAMID_DEBUG_ALL': '1'},
+        )
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_routematch'], True)
         self.assertEqual(result['debug_authorization'], True)
@@ -544,22 +578,30 @@ class TestSettings(unittest.TestCase):
         result = self._makeOne({})
         self.assertEqual(result['default_locale_name'], 'en')
         self.assertEqual(result['pyramid.default_locale_name'], 'en')
-        result = self._makeOne({'default_locale_name':'abc'})
+        result = self._makeOne({'default_locale_name': 'abc'})
         self.assertEqual(result['default_locale_name'], 'abc')
         self.assertEqual(result['pyramid.default_locale_name'], 'abc')
-        result = self._makeOne({'pyramid.default_locale_name':'abc'})
+        result = self._makeOne({'pyramid.default_locale_name': 'abc'})
         self.assertEqual(result['default_locale_name'], 'abc')
         self.assertEqual(result['pyramid.default_locale_name'], 'abc')
-        result = self._makeOne({}, {'PYRAMID_DEFAULT_LOCALE_NAME':'abc'})
+        result = self._makeOne({}, {'PYRAMID_DEFAULT_LOCALE_NAME': 'abc'})
         self.assertEqual(result['default_locale_name'], 'abc')
         self.assertEqual(result['pyramid.default_locale_name'], 'abc')
-        result = self._makeOne({'default_locale_name':'def',
-                                'pyramid.default_locale_name':'abc'})
+        result = self._makeOne(
+            {
+                'default_locale_name': 'def',
+                'pyramid.default_locale_name': 'abc',
+            }
+        )
         self.assertEqual(result['default_locale_name'], 'abc')
         self.assertEqual(result['pyramid.default_locale_name'], 'abc')
-        result = self._makeOne({'default_locale_name':'def',
-                                'pyramid.default_locale_name':'ghi'},
-                               {'PYRAMID_DEFAULT_LOCALE_NAME':'abc'})
+        result = self._makeOne(
+            {
+                'default_locale_name': 'def',
+                'pyramid.default_locale_name': 'ghi',
+            },
+            {'PYRAMID_DEFAULT_LOCALE_NAME': 'abc'},
+        )
         self.assertEqual(result['default_locale_name'], 'abc')
         self.assertEqual(result['pyramid.default_locale_name'], 'abc')
 
@@ -567,16 +609,27 @@ class TestSettings(unittest.TestCase):
         result = self._makeOne({})
         self.assertEqual(result['pyramid.csrf_trusted_origins'], [])
         result = self._makeOne({'pyramid.csrf_trusted_origins': 'example.com'})
-        self.assertEqual(result['pyramid.csrf_trusted_origins'], ['example.com'])
-        result = self._makeOne({'pyramid.csrf_trusted_origins': ['example.com']})
-        self.assertEqual(result['pyramid.csrf_trusted_origins'], ['example.com'])
-        result = self._makeOne({'pyramid.csrf_trusted_origins': (
-            'example.com foo.example.com\nasdf.example.com')})
-        self.assertEqual(result['pyramid.csrf_trusted_origins'], [
-            'example.com', 'foo.example.com', 'asdf.example.com'])
+        self.assertEqual(
+            result['pyramid.csrf_trusted_origins'], ['example.com']
+        )
+        result = self._makeOne(
+            {'pyramid.csrf_trusted_origins': ['example.com']}
+        )
+        self.assertEqual(
+            result['pyramid.csrf_trusted_origins'], ['example.com']
+        )
+        result = self._makeOne(
+            {
+                'pyramid.csrf_trusted_origins': (
+                    'example.com foo.example.com\nasdf.example.com'
+                )
+            }
+        )
+        self.assertEqual(
+            result['pyramid.csrf_trusted_origins'],
+            ['example.com', 'foo.example.com', 'asdf.example.com'],
+        )
 
     def test_originals_kept(self):
-        result = self._makeOne({'a':'i am so a'})
+        result = self._makeOne({'a': 'i am so a'})
         self.assertEqual(result['a'], 'i am so a')
-
-
diff --git a/tests/test_config/test_testing.py b/tests/test_config/test_testing.py
index 5be4e48d3..c0a98f9ad 100644
--- a/tests/test_config/test_testing.py
+++ b/tests/test_config/test_testing.py
@@ -4,19 +4,24 @@ from pyramid.compat import text_
 from pyramid.security import AuthenticationAPIMixin, AuthorizationAPIMixin
 from . import IDummy
 
+
 class TestingConfiguratorMixinTests(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def test_testing_securitypolicy(self):
         from pyramid.testing import DummySecurityPolicy
+
         config = self._makeOne(autocommit=True)
-        config.testing_securitypolicy('user', ('group1', 'group2'),
-                                      permissive=False)
+        config.testing_securitypolicy(
+            'user', ('group1', 'group2'), permissive=False
+        )
         from pyramid.interfaces import IAuthenticationPolicy
         from pyramid.interfaces import IAuthorizationPolicy
+
         ut = config.registry.getUtility(IAuthenticationPolicy)
         self.assertTrue(isinstance(ut, DummySecurityPolicy))
         ut = config.registry.getUtility(IAuthorizationPolicy)
@@ -26,10 +31,14 @@ class TestingConfiguratorMixinTests(unittest.TestCase):
 
     def test_testing_securitypolicy_remember_result(self):
         from pyramid.security import remember
+
         config = self._makeOne(autocommit=True)
         pol = config.testing_securitypolicy(
-            'user', ('group1', 'group2'),
-            permissive=False, remember_result=True)
+            'user',
+            ('group1', 'group2'),
+            permissive=False,
+            remember_result=True,
+        )
         request = DummyRequest()
         request.registry = config.registry
         val = remember(request, 'fred')
@@ -38,10 +47,11 @@ class TestingConfiguratorMixinTests(unittest.TestCase):
 
     def test_testing_securitypolicy_forget_result(self):
         from pyramid.security import forget
+
         config = self._makeOne(autocommit=True)
         pol = config.testing_securitypolicy(
-            'user', ('group1', 'group2'),
-            permissive=False, forget_result=True)
+            'user', ('group1', 'group2'), permissive=False, forget_result=True
+        )
         request = DummyRequest()
         request.registry = config.registry
         val = forget(request)
@@ -51,27 +61,30 @@ class TestingConfiguratorMixinTests(unittest.TestCase):
     def test_testing_resources(self):
         from pyramid.traversal import find_resource
         from pyramid.interfaces import ITraverser
+
         ob1 = object()
         ob2 = object()
-        resources = {'/ob1':ob1, '/ob2':ob2}
+        resources = {'/ob1': ob1, '/ob2': ob2}
         config = self._makeOne(autocommit=True)
         config.testing_resources(resources)
         adapter = config.registry.getAdapter(None, ITraverser)
-        result = adapter(DummyRequest({'PATH_INFO':'/ob1'}))
+        result = adapter(DummyRequest({'PATH_INFO': '/ob1'}))
         self.assertEqual(result['context'], ob1)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
         self.assertEqual(result['traversed'], (text_('ob1'),))
         self.assertEqual(result['virtual_root'], ob1)
         self.assertEqual(result['virtual_root_path'], ())
-        result = adapter(DummyRequest({'PATH_INFO':'/ob2'}))
+        result = adapter(DummyRequest({'PATH_INFO': '/ob2'}))
         self.assertEqual(result['context'], ob2)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
         self.assertEqual(result['traversed'], (text_('ob2'),))
         self.assertEqual(result['virtual_root'], ob2)
         self.assertEqual(result['virtual_root_path'], ())
-        self.assertRaises(KeyError, adapter, DummyRequest({'PATH_INFO':'/ob3'}))
+        self.assertRaises(
+            KeyError, adapter, DummyRequest({'PATH_INFO': '/ob3'})
+        )
         try:
             config.begin()
             self.assertEqual(find_resource(None, '/ob1'), ob1)
@@ -90,8 +103,7 @@ class TestingConfiguratorMixinTests(unittest.TestCase):
 
     def test_testing_add_subscriber_dottedname(self):
         config = self._makeOne(autocommit=True)
-        L = config.testing_add_subscriber(
-            'tests.test_config.test_init.IDummy')
+        L = config.testing_add_subscriber('tests.test_config.test_init.IDummy')
         event = DummyEvent()
         config.registry.notify(event)
         self.assertEqual(len(L), 1)
@@ -101,6 +113,7 @@ class TestingConfiguratorMixinTests(unittest.TestCase):
 
     def test_testing_add_subscriber_multiple(self):
         from zope.interface import Interface
+
         config = self._makeOne(autocommit=True)
         L = config.testing_add_subscriber((Interface, IDummy))
         event = DummyEvent()
@@ -125,13 +138,16 @@ class TestingConfiguratorMixinTests(unittest.TestCase):
         config = self._makeOne(autocommit=True)
         renderer = config.testing_add_renderer('templates/foo.pt')
         from pyramid.testing import DummyTemplateRenderer
+
         self.assertTrue(isinstance(renderer, DummyTemplateRenderer))
         from pyramid.renderers import render_to_response
+
         # must provide request to pass in registry (this is a functest)
         request = DummyRequest()
         request.registry = config.registry
         render_to_response(
-            'templates/foo.pt', {'foo':1, 'bar':2}, request=request)
+            'templates/foo.pt', {'foo': 1, 'bar': 2}, request=request
+        )
         renderer.assert_(foo=1)
         renderer.assert_(bar=2)
         renderer.assert_(request=request)
@@ -141,65 +157,81 @@ class TestingConfiguratorMixinTests(unittest.TestCase):
         renderer1 = config.testing_add_renderer('templates/foo.pt')
         renderer2 = config.testing_add_renderer('templates/bar.pt')
         from pyramid.testing import DummyTemplateRenderer
+
         self.assertTrue(isinstance(renderer1, DummyTemplateRenderer))
         self.assertTrue(isinstance(renderer2, DummyTemplateRenderer))
         from pyramid.renderers import render_to_response
+
         # must provide request to pass in registry (this is a functest)
         request = DummyRequest()
         request.registry = config.registry
         render_to_response(
-            'templates/foo.pt', {'foo':1, 'bar':2}, request=request)
+            'templates/foo.pt', {'foo': 1, 'bar': 2}, request=request
+        )
         renderer1.assert_(foo=1)
         renderer1.assert_(bar=2)
         renderer1.assert_(request=request)
         render_to_response(
-            'templates/bar.pt', {'foo':1, 'bar':2}, request=request)
+            'templates/bar.pt', {'foo': 1, 'bar': 2}, request=request
+        )
         renderer2.assert_(foo=1)
         renderer2.assert_(bar=2)
         renderer2.assert_(request=request)
 
     def test_testing_add_renderer_explicitrenderer(self):
         config = self._makeOne(autocommit=True)
-        class E(Exception): pass
+
+        class E(Exception):
+            pass
+
         def renderer(kw, system):
-            self.assertEqual(kw, {'foo':1, 'bar':2})
+            self.assertEqual(kw, {'foo': 1, 'bar': 2})
             raise E
+
         renderer = config.testing_add_renderer('templates/foo.pt', renderer)
         from pyramid.renderers import render_to_response
+
         # must provide request to pass in registry (this is a functest)
         request = DummyRequest()
         request.registry = config.registry
         try:
             render_to_response(
-                'templates/foo.pt', {'foo':1, 'bar':2}, request=request)
+                'templates/foo.pt', {'foo': 1, 'bar': 2}, request=request
+            )
         except E:
             pass
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_testing_add_template(self):
         config = self._makeOne(autocommit=True)
         renderer = config.testing_add_template('templates/foo.pt')
         from pyramid.testing import DummyTemplateRenderer
+
         self.assertTrue(isinstance(renderer, DummyTemplateRenderer))
         from pyramid.renderers import render_to_response
+
         # must provide request to pass in registry (this is a functest)
         request = DummyRequest()
         request.registry = config.registry
-        render_to_response('templates/foo.pt', dict(foo=1, bar=2),
-                           request=request)
+        render_to_response(
+            'templates/foo.pt', dict(foo=1, bar=2), request=request
+        )
         renderer.assert_(foo=1)
         renderer.assert_(bar=2)
         renderer.assert_(request=request)
 
+
 from zope.interface import implementer
+
+
 @implementer(IDummy)
 class DummyEvent:
     pass
 
+
 class DummyRequest(AuthenticationAPIMixin, AuthorizationAPIMixin):
     def __init__(self, environ=None):
         if environ is None:
             environ = {}
         self.environ = environ
-        
diff --git a/tests/test_config/test_tweens.py b/tests/test_config/test_tweens.py
index 25615c699..ed41c9a43 100644
--- a/tests/test_config/test_tweens.py
+++ b/tests/test_config/test_tweens.py
@@ -5,81 +5,101 @@ from . import dummy_tween_factory2
 
 from pyramid.exceptions import ConfigurationConflictError
 
+
 class TestTweensConfiguratorMixin(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
     def test_add_tweens_names_distinct(self):
         from pyramid.interfaces import ITweens
         from pyramid.tweens import excview_tween_factory
-        def factory1(handler, registry): return handler
-        def factory2(handler, registry): return handler
+
+        def factory1(handler, registry):
+            return handler
+
+        def factory2(handler, registry):
+            return handler
+
         config = self._makeOne()
-        config.add_tween(
-            'tests.test_config.dummy_tween_factory')
-        config.add_tween(
-            'tests.test_config.dummy_tween_factory2')
+        config.add_tween('tests.test_config.dummy_tween_factory')
+        config.add_tween('tests.test_config.dummy_tween_factory2')
         config.commit()
         tweens = config.registry.queryUtility(ITweens)
         implicit = tweens.implicit()
         self.assertEqual(
             implicit,
             [
-                ('tests.test_config.dummy_tween_factory2',
-                 dummy_tween_factory2),
-                ('tests.test_config.dummy_tween_factory',
-                 dummy_tween_factory),
-                ('pyramid.tweens.excview_tween_factory',
-                 excview_tween_factory),
-                ]
-            )
+                (
+                    'tests.test_config.dummy_tween_factory2',
+                    dummy_tween_factory2,
+                ),
+                ('tests.test_config.dummy_tween_factory', dummy_tween_factory),
+                (
+                    'pyramid.tweens.excview_tween_factory',
+                    excview_tween_factory,
+                ),
+            ],
+        )
 
     def test_add_tweens_names_with_underover(self):
         from pyramid.interfaces import ITweens
         from pyramid.tweens import excview_tween_factory
         from pyramid.tweens import MAIN
+
         config = self._makeOne()
-        config.add_tween(
-            'tests.test_config.dummy_tween_factory',
-            over=MAIN)
+        config.add_tween('tests.test_config.dummy_tween_factory', over=MAIN)
         config.add_tween(
             'tests.test_config.dummy_tween_factory2',
             over=MAIN,
-            under='tests.test_config.dummy_tween_factory')
+            under='tests.test_config.dummy_tween_factory',
+        )
         config.commit()
         tweens = config.registry.queryUtility(ITweens)
         implicit = tweens.implicit()
         self.assertEqual(
             implicit,
             [
-                ('pyramid.tweens.excview_tween_factory', excview_tween_factory),
-                ('tests.test_config.dummy_tween_factory',
-                 dummy_tween_factory),
-                ('tests.test_config.dummy_tween_factory2',
-                 dummy_tween_factory2),
-             ])
+                (
+                    'pyramid.tweens.excview_tween_factory',
+                    excview_tween_factory,
+                ),
+                ('tests.test_config.dummy_tween_factory', dummy_tween_factory),
+                (
+                    'tests.test_config.dummy_tween_factory2',
+                    dummy_tween_factory2,
+                ),
+            ],
+        )
 
     def test_add_tweens_names_with_under_nonstringoriter(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
         self.assertRaises(
-            ConfigurationError, config.add_tween,
+            ConfigurationError,
+            config.add_tween,
             'tests.test_config.dummy_tween_factory',
-            under=False)
+            under=False,
+        )
 
     def test_add_tweens_names_with_over_nonstringoriter(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne()
         self.assertRaises(
-            ConfigurationError, config.add_tween,
+            ConfigurationError,
+            config.add_tween,
             'tests.test_config.dummy_tween_factory',
-            over=False)
+            over=False,
+        )
 
     def test_add_tween_dottedname(self):
         from pyramid.interfaces import ITweens
         from pyramid.tweens import excview_tween_factory
+
         config = self._makeOne()
         config.add_tween('tests.test_config.dummy_tween_factory')
         config.commit()
@@ -87,15 +107,20 @@ class TestTweensConfiguratorMixin(unittest.TestCase):
         self.assertEqual(
             tweens.implicit(),
             [
-                ('tests.test_config.dummy_tween_factory',
-                 dummy_tween_factory),
-                ('pyramid.tweens.excview_tween_factory',
-                 excview_tween_factory),
-                ])
+                ('tests.test_config.dummy_tween_factory', dummy_tween_factory),
+                (
+                    'pyramid.tweens.excview_tween_factory',
+                    excview_tween_factory,
+                ),
+            ],
+        )
 
     def test_add_tween_instance(self):
         from pyramid.exceptions import ConfigurationError
-        class ATween(object): pass
+
+        class ATween(object):
+            pass
+
         atween = ATween()
         config = self._makeOne()
         self.assertRaises(ConfigurationError, config.add_tween, atween)
@@ -103,19 +128,23 @@ class TestTweensConfiguratorMixin(unittest.TestCase):
     def test_add_tween_unsuitable(self):
         from pyramid.exceptions import ConfigurationError
         import tests.test_config
+
         config = self._makeOne()
-        self.assertRaises(ConfigurationError, config.add_tween,
-                          tests.test_config)
+        self.assertRaises(
+            ConfigurationError, config.add_tween, tests.test_config
+        )
 
     def test_add_tween_name_ingress(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.tweens import INGRESS
+
         config = self._makeOne()
         self.assertRaises(ConfigurationError, config.add_tween, INGRESS)
 
     def test_add_tween_name_main(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.tweens import MAIN
+
         config = self._makeOne()
         self.assertRaises(ConfigurationError, config.add_tween, MAIN)
 
@@ -128,79 +157,97 @@ class TestTweensConfiguratorMixin(unittest.TestCase):
     def test_add_tween_over_ingress(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.tweens import INGRESS
+
         config = self._makeOne()
         self.assertRaises(
             ConfigurationError,
             config.add_tween,
             'tests.test_config.dummy_tween_factory',
-            over=INGRESS)
+            over=INGRESS,
+        )
 
     def test_add_tween_over_ingress_iterable(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.tweens import INGRESS
+
         config = self._makeOne()
         self.assertRaises(
             ConfigurationError,
             config.add_tween,
             'tests.test_config.dummy_tween_factory',
-            over=('a', INGRESS))
+            over=('a', INGRESS),
+        )
 
     def test_add_tween_under_main(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.tweens import MAIN
+
         config = self._makeOne()
         self.assertRaises(
             ConfigurationError,
             config.add_tween,
             'tests.test_config.dummy_tween_factory',
-            under=MAIN)
+            under=MAIN,
+        )
 
     def test_add_tween_under_main_iterable(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.tweens import MAIN
+
         config = self._makeOne()
         self.assertRaises(
             ConfigurationError,
             config.add_tween,
             'tests.test_config.dummy_tween_factory',
-            under=('a', MAIN))
+            under=('a', MAIN),
+        )
+
 
 class TestTweens(unittest.TestCase):
     def _makeOne(self):
         from pyramid.config.tweens import Tweens
+
         return Tweens()
 
     def test_add_explicit(self):
         tweens = self._makeOne()
         tweens.add_explicit('name', 'factory')
-        self.assertEqual(tweens.explicit, [('name',  'factory')])
+        self.assertEqual(tweens.explicit, [('name', 'factory')])
         tweens.add_explicit('name2', 'factory2')
-        self.assertEqual(tweens.explicit, [('name',  'factory'),
-                                           ('name2', 'factory2')])
+        self.assertEqual(
+            tweens.explicit, [('name', 'factory'), ('name2', 'factory2')]
+        )
 
     def test_add_implicit(self):
         tweens = self._makeOne()
         tweens.add_implicit('name', 'factory')
         tweens.add_implicit('name2', 'factory2')
-        self.assertEqual(tweens.sorter.sorted(),
-                         [('name2',  'factory2'),
-                          ('name', 'factory')])
+        self.assertEqual(
+            tweens.sorter.sorted(),
+            [('name2', 'factory2'), ('name', 'factory')],
+        )
 
     def test___call___explicit(self):
         tweens = self._makeOne()
+
         def factory1(handler, registry):
             return handler
+
         def factory2(handler, registry):
             return '123'
+
         tweens.explicit = [('name', factory1), ('name', factory2)]
         self.assertEqual(tweens(None, None), '123')
 
     def test___call___implicit(self):
         tweens = self._makeOne()
+
         def factory1(handler, registry):
             return handler
+
         def factory2(handler, registry):
             return '123'
+
         tweens.add_implicit('name2', factory2)
         tweens.add_implicit('name1', factory1)
         self.assertEqual(tweens(None, None), '123')
@@ -209,45 +256,46 @@ class TestTweens(unittest.TestCase):
         tweens = self._makeOne()
         tweens.add_implicit('name1', 'factory1')
         tweens.add_implicit('name2', 'factory2')
-        self.assertEqual(tweens.implicit(),
-                         [
-                             ('name2', 'factory2'),
-                             ('name1', 'factory1'),
-                             ])
+        self.assertEqual(
+            tweens.implicit(), [('name2', 'factory2'), ('name1', 'factory1')]
+        )
 
     def test_implicit_ordering_2(self):
         from pyramid.tweens import MAIN
+
         tweens = self._makeOne()
         tweens.add_implicit('name1', 'factory1')
         tweens.add_implicit('name2', 'factory2', over=MAIN)
-        self.assertEqual(tweens.implicit(),
-                         [
-                             ('name1', 'factory1'),
-                             ('name2', 'factory2'),
-                             ])
+        self.assertEqual(
+            tweens.implicit(), [('name1', 'factory1'), ('name2', 'factory2')]
+        )
 
     def test_implicit_ordering_3(self):
         from pyramid.tweens import MAIN
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('auth', 'auth_factory', under='browserid')
-        add('dbt', 'dbt_factory') 
+        add('dbt', 'dbt_factory')
         add('retry', 'retry_factory', over='txnmgr', under='exceptionview')
         add('browserid', 'browserid_factory')
         add('txnmgr', 'txnmgr_factory', under='exceptionview')
         add('exceptionview', 'excview_factory', over=MAIN)
-        self.assertEqual(tweens.implicit(),
-                         [
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ('dbt', 'dbt_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ('txnmgr', 'txnmgr_factory'),
-                             ])
+        self.assertEqual(
+            tweens.implicit(),
+            [
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+                ('dbt', 'dbt_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+                ('txnmgr', 'txnmgr_factory'),
+            ],
+        )
 
     def test_implicit_ordering_4(self):
         from pyramid.tweens import MAIN
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('exceptionview', 'excview_factory', over=MAIN)
@@ -255,19 +303,22 @@ class TestTweens(unittest.TestCase):
         add('retry', 'retry_factory', over='txnmgr', under='exceptionview')
         add('browserid', 'browserid_factory')
         add('txnmgr', 'txnmgr_factory', under='exceptionview')
-        add('dbt', 'dbt_factory') 
-        self.assertEqual(tweens.implicit(),
-                         [
-                             ('dbt', 'dbt_factory'),
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ('txnmgr', 'txnmgr_factory'),
-                             ])
+        add('dbt', 'dbt_factory')
+        self.assertEqual(
+            tweens.implicit(),
+            [
+                ('dbt', 'dbt_factory'),
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+                ('txnmgr', 'txnmgr_factory'),
+            ],
+        )
 
     def test_implicit_ordering_5(self):
         from pyramid.tweens import MAIN, INGRESS
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('exceptionview', 'excview_factory', over=MAIN)
@@ -275,19 +326,22 @@ class TestTweens(unittest.TestCase):
         add('retry', 'retry_factory', over='txnmgr', under='exceptionview')
         add('browserid', 'browserid_factory', under=INGRESS)
         add('txnmgr', 'txnmgr_factory', under='exceptionview', over=MAIN)
-        add('dbt', 'dbt_factory') 
-        self.assertEqual(tweens.implicit(),
-                         [
-                             ('dbt', 'dbt_factory'),
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ('txnmgr', 'txnmgr_factory'),
-                             ])
+        add('dbt', 'dbt_factory')
+        self.assertEqual(
+            tweens.implicit(),
+            [
+                ('dbt', 'dbt_factory'),
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+                ('txnmgr', 'txnmgr_factory'),
+            ],
+        )
 
     def test_implicit_ordering_missing_over_partial(self):
         from pyramid.exceptions import ConfigurationError
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('dbt', 'dbt_factory')
@@ -298,6 +352,7 @@ class TestTweens(unittest.TestCase):
 
     def test_implicit_ordering_missing_under_partial(self):
         from pyramid.exceptions import ConfigurationError
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('dbt', 'dbt_factory')
@@ -308,6 +363,7 @@ class TestTweens(unittest.TestCase):
 
     def test_implicit_ordering_missing_over_and_under_partials(self):
         from pyramid.exceptions import ConfigurationError
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('dbt', 'dbt_factory')
@@ -318,72 +374,89 @@ class TestTweens(unittest.TestCase):
 
     def test_implicit_ordering_missing_over_partial_with_fallback(self):
         from pyramid.tweens import MAIN
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('exceptionview', 'excview_factory', over=MAIN)
         add('auth', 'auth_factory', under='browserid')
-        add('retry', 'retry_factory', over=('txnmgr',MAIN),
-                                      under='exceptionview')
+        add(
+            'retry',
+            'retry_factory',
+            over=('txnmgr', MAIN),
+            under='exceptionview',
+        )
         add('browserid', 'browserid_factory')
-        add('dbt', 'dbt_factory') 
-        self.assertEqual(tweens.implicit(),
-                         [
-                             ('dbt', 'dbt_factory'),
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ])
+        add('dbt', 'dbt_factory')
+        self.assertEqual(
+            tweens.implicit(),
+            [
+                ('dbt', 'dbt_factory'),
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+            ],
+        )
 
     def test_implicit_ordering_missing_under_partial_with_fallback(self):
         from pyramid.tweens import MAIN
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('exceptionview', 'excview_factory', over=MAIN)
-        add('auth', 'auth_factory', under=('txnmgr','browserid'))
+        add('auth', 'auth_factory', under=('txnmgr', 'browserid'))
         add('retry', 'retry_factory', under='exceptionview')
         add('browserid', 'browserid_factory')
         add('dbt', 'dbt_factory')
-        self.assertEqual(tweens.implicit(),
-                         [
-                             ('dbt', 'dbt_factory'),
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ])
+        self.assertEqual(
+            tweens.implicit(),
+            [
+                ('dbt', 'dbt_factory'),
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+            ],
+        )
 
     def test_implicit_ordering_with_partial_fallbacks(self):
         from pyramid.tweens import MAIN
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('exceptionview', 'excview_factory', over=('wontbethere', MAIN))
         add('retry', 'retry_factory', under='exceptionview')
         add('browserid', 'browserid_factory', over=('wont2', 'exceptionview'))
-        self.assertEqual(tweens.implicit(),
-                         [
-                             ('browserid', 'browserid_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ])
+        self.assertEqual(
+            tweens.implicit(),
+            [
+                ('browserid', 'browserid_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+            ],
+        )
 
     def test_implicit_ordering_with_multiple_matching_fallbacks(self):
         from pyramid.tweens import MAIN
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('exceptionview', 'excview_factory', over=MAIN)
         add('retry', 'retry_factory', under='exceptionview')
         add('browserid', 'browserid_factory', over=('retry', 'exceptionview'))
-        self.assertEqual(tweens.implicit(),
-                         [
-                             ('browserid', 'browserid_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ])
+        self.assertEqual(
+            tweens.implicit(),
+            [
+                ('browserid', 'browserid_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+            ],
+        )
 
     def test_implicit_ordering_with_missing_fallbacks(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.tweens import MAIN
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('exceptionview', 'excview_factory', over=MAIN)
@@ -393,6 +466,7 @@ class TestTweens(unittest.TestCase):
 
     def test_implicit_ordering_conflict_direct(self):
         from pyramid.exceptions import CyclicDependencyError
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('browserid', 'browserid_factory')
@@ -401,10 +475,10 @@ class TestTweens(unittest.TestCase):
 
     def test_implicit_ordering_conflict_indirect(self):
         from pyramid.exceptions import CyclicDependencyError
+
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('browserid', 'browserid_factory')
         add('auth', 'auth_factory', over='browserid')
         add('dbt', 'dbt_factory', under='browserid', over='auth')
         self.assertRaises(CyclicDependencyError, tweens.implicit)
-
diff --git a/tests/test_config/test_util.py b/tests/test_config/test_util.py
index 540f3d14c..a56c00082 100644
--- a/tests/test_config/test_util.py
+++ b/tests/test_config/test_util.py
@@ -2,9 +2,11 @@ import unittest
 
 from pyramid.compat import text_
 
+
 class TestActionInfo(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.config.util import ActionInfo
+
         return ActionInfo
 
     def _makeOne(self, filename, lineno, function, linerepr):
@@ -13,11 +15,13 @@ class TestActionInfo(unittest.TestCase):
     def test_class_conforms(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IActionInfo
+
         verifyClass(IActionInfo, self._getTargetClass())
 
     def test_instance_conforms(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IActionInfo
+
         verifyObject(IActionInfo, self._makeOne('f', 0, 'f', 'f'))
 
     def test_ctor(self):
@@ -29,15 +33,16 @@ class TestActionInfo(unittest.TestCase):
 
     def test___str__(self):
         inst = self._makeOne('filename', 0, 'function', '   linerepr  ')
-        self.assertEqual(str(inst),
-                         "Line 0 of file filename:\n       linerepr  ")
+        self.assertEqual(
+            str(inst), "Line 0 of file filename:\n       linerepr  "
+        )
 
 
 class TestPredicateList(unittest.TestCase):
-
     def _makeOne(self):
         from pyramid.config.util import PredicateList
         from pyramid import predicates
+
         inst = PredicateList()
         for name, factory in (
             ('xhr', predicates.XHRPredicate),
@@ -51,7 +56,7 @@ class TestPredicateList(unittest.TestCase):
             ('match_param', predicates.MatchParamPredicate),
             ('custom', predicates.CustomPredicate),
             ('traverse', predicates.TraversePredicate),
-            ):
+        ):
             inst.add(name, factory)
         return inst
 
@@ -67,6 +72,7 @@ class TestPredicateList(unittest.TestCase):
 
     def test_ordering_number_of_predicates(self):
         from pyramid.config.util import predvalseq
+
         order1, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
@@ -78,7 +84,7 @@ class TestPredicateList(unittest.TestCase):
             containment='containment',
             request_type='request_type',
             custom=predvalseq([DummyCustomPredicate()]),
-            )
+        )
         order2, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
@@ -90,7 +96,7 @@ class TestPredicateList(unittest.TestCase):
             containment='containment',
             request_type='request_type',
             custom=predvalseq([DummyCustomPredicate()]),
-            )
+        )
         order3, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
@@ -101,7 +107,7 @@ class TestPredicateList(unittest.TestCase):
             accept='accept',
             containment='containment',
             request_type='request_type',
-            )
+        )
         order4, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
@@ -111,7 +117,7 @@ class TestPredicateList(unittest.TestCase):
             header='header',
             accept='accept',
             containment='containment',
-            )
+        )
         order5, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
@@ -120,7 +126,7 @@ class TestPredicateList(unittest.TestCase):
             match_param='foo=bar',
             header='header',
             accept='accept',
-            )
+        )
         order6, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
@@ -128,34 +134,28 @@ class TestPredicateList(unittest.TestCase):
             request_param='param',
             match_param='foo=bar',
             header='header',
-            )
+        )
         order7, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
             path_info='path_info',
             request_param='param',
             match_param='foo=bar',
-            )
+        )
         order8, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
             path_info='path_info',
             request_param='param',
-            )
+        )
         order9, _, _ = self._callFUT(
-            xhr='xhr',
-            request_method='request_method',
-            path_info='path_info',
-            )
+            xhr='xhr', request_method='request_method', path_info='path_info'
+        )
         order10, _, _ = self._callFUT(
-            xhr='xhr',
-            request_method='request_method',
-            )
-        order11, _, _ = self._callFUT(
-            xhr='xhr',
-            )
-        order12, _, _ = self._callFUT(
-            )
+            xhr='xhr', request_method='request_method'
+        )
+        order11, _, _ = self._callFUT(xhr='xhr')
+        order12, _, _ = self._callFUT()
         self.assertEqual(order1, order2)
         self.assertTrue(order3 > order2)
         self.assertTrue(order4 > order3)
@@ -170,36 +170,19 @@ class TestPredicateList(unittest.TestCase):
 
     def test_ordering_importance_of_predicates(self):
         from pyramid.config.util import predvalseq
-        order1, _, _ = self._callFUT(
-            xhr='xhr',
-            )
-        order2, _, _ = self._callFUT(
-            request_method='request_method',
-            )
-        order3, _, _ = self._callFUT(
-            path_info='path_info',
-            )
-        order4, _, _ = self._callFUT(
-            request_param='param',
-            )
-        order5, _, _ = self._callFUT(
-            header='header',
-            )
-        order6, _, _ = self._callFUT(
-            accept='accept',
-            )
-        order7, _, _ = self._callFUT(
-            containment='containment',
-            )
-        order8, _, _ = self._callFUT(
-            request_type='request_type',
-            )
-        order9, _, _ = self._callFUT(
-            match_param='foo=bar',
-            )
+
+        order1, _, _ = self._callFUT(xhr='xhr')
+        order2, _, _ = self._callFUT(request_method='request_method')
+        order3, _, _ = self._callFUT(path_info='path_info')
+        order4, _, _ = self._callFUT(request_param='param')
+        order5, _, _ = self._callFUT(header='header')
+        order6, _, _ = self._callFUT(accept='accept')
+        order7, _, _ = self._callFUT(containment='containment')
+        order8, _, _ = self._callFUT(request_type='request_type')
+        order9, _, _ = self._callFUT(match_param='foo=bar')
         order10, _, _ = self._callFUT(
-            custom=predvalseq([DummyCustomPredicate()]),
-            )
+            custom=predvalseq([DummyCustomPredicate()])
+        )
         self.assertTrue(order1 > order2)
         self.assertTrue(order2 > order3)
         self.assertTrue(order3 > order4)
@@ -212,53 +195,50 @@ class TestPredicateList(unittest.TestCase):
 
     def test_ordering_importance_and_number(self):
         from pyramid.config.util import predvalseq
+
         order1, _, _ = self._callFUT(
-            xhr='xhr',
-            request_method='request_method',
-            )
+            xhr='xhr', request_method='request_method'
+        )
         order2, _, _ = self._callFUT(
-            custom=predvalseq([DummyCustomPredicate()]),
-            )
+            custom=predvalseq([DummyCustomPredicate()])
+        )
         self.assertTrue(order1 < order2)
 
         order1, _, _ = self._callFUT(
-            xhr='xhr',
-            request_method='request_method',
-            )
+            xhr='xhr', request_method='request_method'
+        )
         order2, _, _ = self._callFUT(
             request_method='request_method',
             custom=predvalseq([DummyCustomPredicate()]),
-            )
+        )
         self.assertTrue(order1 > order2)
 
         order1, _, _ = self._callFUT(
-            xhr='xhr',
-            request_method='request_method',
-            path_info='path_info',
-            )
+            xhr='xhr', request_method='request_method', path_info='path_info'
+        )
         order2, _, _ = self._callFUT(
             request_method='request_method',
             custom=predvalseq([DummyCustomPredicate()]),
-            )
+        )
         self.assertTrue(order1 < order2)
 
         order1, _, _ = self._callFUT(
-            xhr='xhr',
-            request_method='request_method',
-            path_info='path_info',
-            )
+            xhr='xhr', request_method='request_method', path_info='path_info'
+        )
         order2, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
             custom=predvalseq([DummyCustomPredicate()]),
-            )
+        )
         self.assertTrue(order1 > order2)
 
     def test_different_custom_predicates_with_same_hash(self):
         from pyramid.config.util import predvalseq
+
         class PredicateWithHash(object):
             def __hash__(self):
                 return 1
+
         a = PredicateWithHash()
         b = PredicateWithHash()
         _, _, a_phash = self._callFUT(custom=predvalseq([a]))
@@ -269,57 +249,71 @@ class TestPredicateList(unittest.TestCase):
         order, predicates, phash = self._callFUT(traverse='/1/:a/:b')
         self.assertEqual(len(predicates), 1)
         pred = predicates[0]
-        info = {'traverse':'abc'}
+        info = {'traverse': 'abc'}
         request = DummyRequest()
         result = pred(info, request)
         self.assertEqual(result, True)
-        self.assertEqual(info, {'traverse':'abc'})
+        self.assertEqual(info, {'traverse': 'abc'})
 
     def test_traverse_matches(self):
         order, predicates, phash = self._callFUT(traverse='/1/:a/:b')
         self.assertEqual(len(predicates), 1)
         pred = predicates[0]
-        info = {'match':{'a':'a', 'b':'b'}}
+        info = {'match': {'a': 'a', 'b': 'b'}}
         request = DummyRequest()
         result = pred(info, request)
         self.assertEqual(result, True)
-        self.assertEqual(info, {'match':
-                                {'a':'a', 'b':'b', 'traverse':('1', 'a', 'b')}})
+        self.assertEqual(
+            info, {'match': {'a': 'a', 'b': 'b', 'traverse': ('1', 'a', 'b')}}
+        )
 
     def test_traverse_matches_with_highorder_chars(self):
         order, predicates, phash = self._callFUT(
-            traverse=text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8'))
+            traverse=text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8')
+        )
         self.assertEqual(len(predicates), 1)
         pred = predicates[0]
-        info = {'match':{'x':text_(b'Qu\xc3\xa9bec', 'utf-8')}}
+        info = {'match': {'x': text_(b'Qu\xc3\xa9bec', 'utf-8')}}
         request = DummyRequest()
         result = pred(info, request)
         self.assertEqual(result, True)
         self.assertEqual(
             info['match']['traverse'],
-            (text_(b'La Pe\xc3\xb1a', 'utf-8'),
-             text_(b'Qu\xc3\xa9bec', 'utf-8'))
-             )
+            (
+                text_(b'La Pe\xc3\xb1a', 'utf-8'),
+                text_(b'Qu\xc3\xa9bec', 'utf-8'),
+            ),
+        )
 
     def test_custom_predicates_can_affect_traversal(self):
         from pyramid.config.util import predvalseq
+
         def custom(info, request):
             m = info['match']
             m['dummy'] = 'foo'
             return True
+
         _, predicates, _ = self._callFUT(
-            custom=predvalseq([custom]),
-            traverse='/1/:dummy/:a')
+            custom=predvalseq([custom]), traverse='/1/:dummy/:a'
+        )
         self.assertEqual(len(predicates), 2)
-        info = {'match':{'a':'a'}}
+        info = {'match': {'a': 'a'}}
         request = DummyRequest()
         self.assertTrue(all([p(info, request) for p in predicates]))
-        self.assertEqual(info, {'match':
-                                {'a':'a', 'dummy':'foo',
-                                 'traverse':('1', 'foo', 'a')}})
+        self.assertEqual(
+            info,
+            {
+                'match': {
+                    'a': 'a',
+                    'dummy': 'foo',
+                    'traverse': ('1', 'foo', 'a'),
+                }
+            },
+        )
 
     def test_predicate_text_is_correct(self):
         from pyramid.config.util import predvalseq
+
         _, predicates, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
@@ -336,10 +330,12 @@ class TestPredicateList(unittest.TestCase):
                     DummyCustomPredicate.classmethod_predicate_no_text,
                 ]
             ),
-            match_param='foo=bar')
+            match_param='foo=bar',
+        )
         self.assertEqual(predicates[0].text(), 'xhr = True')
-        self.assertEqual(predicates[1].text(),
-                         "request_method = request_method")
+        self.assertEqual(
+            predicates[1].text(), "request_method = request_method"
+        )
         self.assertEqual(predicates[2].text(), 'path_info = path_info')
         self.assertEqual(predicates[3].text(), 'request_param param')
         self.assertEqual(predicates[4].text(), 'header header')
@@ -354,25 +350,25 @@ class TestPredicateList(unittest.TestCase):
     def test_match_param_from_string(self):
         _, predicates, _ = self._callFUT(match_param='foo=bar')
         request = DummyRequest()
-        request.matchdict = {'foo':'bar', 'baz':'bum'}
+        request.matchdict = {'foo': 'bar', 'baz': 'bum'}
         self.assertTrue(predicates[0](Dummy(), request))
 
     def test_match_param_from_string_fails(self):
         _, predicates, _ = self._callFUT(match_param='foo=bar')
         request = DummyRequest()
-        request.matchdict = {'foo':'bum', 'baz':'bum'}
+        request.matchdict = {'foo': 'bum', 'baz': 'bum'}
         self.assertFalse(predicates[0](Dummy(), request))
 
     def test_match_param_from_dict(self):
-        _, predicates, _ = self._callFUT(match_param=('foo=bar','baz=bum'))
+        _, predicates, _ = self._callFUT(match_param=('foo=bar', 'baz=bum'))
         request = DummyRequest()
-        request.matchdict = {'foo':'bar', 'baz':'bum'}
+        request.matchdict = {'foo': 'bar', 'baz': 'bum'}
         self.assertTrue(predicates[0](Dummy(), request))
 
     def test_match_param_from_dict_fails(self):
-        _, predicates, _ = self._callFUT(match_param=('foo=bar','baz=bum'))
+        _, predicates, _ = self._callFUT(match_param=('foo=bar', 'baz=bum'))
         request = DummyRequest()
-        request.matchdict = {'foo':'bar', 'baz':'foo'}
+        request.matchdict = {'foo': 'bar', 'baz': 'foo'}
         self.assertFalse(predicates[0](Dummy(), request))
 
     def test_request_method_sequence(self):
@@ -386,20 +382,22 @@ class TestPredicateList(unittest.TestCase):
         self.assertFalse(predicates[0](Dummy(), request))
 
     def test_request_method_ordering_hashes_same(self):
-        hash1, _, __= self._callFUT(request_method=('GET', 'HEAD'))
-        hash2, _, __= self._callFUT(request_method=('HEAD', 'GET'))
+        hash1, _, __ = self._callFUT(request_method=('GET', 'HEAD'))
+        hash2, _, __ = self._callFUT(request_method=('HEAD', 'GET'))
         self.assertEqual(hash1, hash2)
-        hash1, _, __= self._callFUT(request_method=('GET',))
-        hash2, _, __= self._callFUT(request_method='GET')
+        hash1, _, __ = self._callFUT(request_method=('GET',))
+        hash2, _, __ = self._callFUT(request_method='GET')
         self.assertEqual(hash1, hash2)
 
     def test_unknown_predicate(self):
         from pyramid.exceptions import ConfigurationError
+
         self.assertRaises(ConfigurationError, self._callFUT, unknown=1)
 
     def test_predicate_close_matches(self):
         from pyramid.exceptions import ConfigurationError
-        with  self.assertRaises(ConfigurationError) as context:
+
+        with self.assertRaises(ConfigurationError) as context:
             self._callFUT(method='GET')
         expected_msg = (
             "Unknown predicate values: {'method': 'GET'} "
@@ -410,81 +408,111 @@ class TestPredicateList(unittest.TestCase):
     def test_notted(self):
         from pyramid.config import not_
         from pyramid.testing import DummyRequest
+
         request = DummyRequest()
         _, predicates, _ = self._callFUT(
-            xhr='xhr',
-            request_method=not_('POST'),
-            header=not_('header'),
-            )
+            xhr='xhr', request_method=not_('POST'), header=not_('header')
+        )
         self.assertEqual(predicates[0].text(), 'xhr = True')
-        self.assertEqual(predicates[1].text(),
-                         "!request_method = POST")
+        self.assertEqual(predicates[1].text(), "!request_method = POST")
         self.assertEqual(predicates[2].text(), '!header header')
         self.assertEqual(predicates[1](None, request), True)
         self.assertEqual(predicates[2](None, request), True)
 
+
 class TestDeprecatedPredicates(unittest.TestCase):
     def test_it(self):
         import warnings
+
         with warnings.catch_warnings(record=True) as w:
             warnings.filterwarnings('always')
             from pyramid.config.predicates import XHRPredicate
+
             self.assertEqual(len(w), 1)
 
+
 class Test_sort_accept_offers(unittest.TestCase):
     def _callFUT(self, offers, order=None):
         from pyramid.config.util import sort_accept_offers
+
         return sort_accept_offers(offers, order)
 
     def test_default_specificities(self):
         result = self._callFUT(['text/html', 'text/html;charset=utf8'])
-        self.assertEqual(result, [
-            'text/html;charset=utf8', 'text/html',
-        ])
+        self.assertEqual(result, ['text/html;charset=utf8', 'text/html'])
 
     def test_specific_type_order(self):
         result = self._callFUT(
-            ['text/html', 'application/json', 'text/html;charset=utf8', 'text/plain'],
+            [
+                'text/html',
+                'application/json',
+                'text/html;charset=utf8',
+                'text/plain',
+            ],
             ['application/json', 'text/html'],
         )
-        self.assertEqual(result, [
-            'application/json', 'text/html;charset=utf8', 'text/html', 'text/plain',
-        ])
+        self.assertEqual(
+            result,
+            [
+                'application/json',
+                'text/html;charset=utf8',
+                'text/html',
+                'text/plain',
+            ],
+        )
 
     def test_params_order(self):
         result = self._callFUT(
-            ['text/html;charset=utf8', 'text/html;charset=latin1', 'text/html;foo=bar'],
+            [
+                'text/html;charset=utf8',
+                'text/html;charset=latin1',
+                'text/html;foo=bar',
+            ],
             ['text/html;charset=latin1', 'text/html;charset=utf8'],
         )
-        self.assertEqual(result, [
-            'text/html;charset=latin1', 'text/html;charset=utf8', 'text/html;foo=bar',
-        ])
+        self.assertEqual(
+            result,
+            [
+                'text/html;charset=latin1',
+                'text/html;charset=utf8',
+                'text/html;foo=bar',
+            ],
+        )
 
     def test_params_inherit_type_prefs(self):
         result = self._callFUT(
             ['text/html;charset=utf8', 'text/plain;charset=latin1'],
             ['text/plain', 'text/html'],
         )
-        self.assertEqual(result, ['text/plain;charset=latin1', 'text/html;charset=utf8'])
+        self.assertEqual(
+            result, ['text/plain;charset=latin1', 'text/html;charset=utf8']
+        )
+
 
 class DummyCustomPredicate(object):
     def __init__(self):
         self.__text__ = 'custom predicate'
 
-    def classmethod_predicate(*args): pass
+    def classmethod_predicate(*args):
+        pass
+
     classmethod_predicate.__text__ = 'classmethod predicate'
     classmethod_predicate = classmethod(classmethod_predicate)
 
     @classmethod
-    def classmethod_predicate_no_text(*args): pass # pragma: no cover
+    def classmethod_predicate_no_text(*args):
+        pass  # pragma: no cover
+
 
 class Dummy(object):
     def __init__(self, **kw):
         self.__dict__.update(**kw)
 
+
 class DummyRequest:
     subpath = ()
     matchdict = None
+
     def __init__(self, environ=None):
         if environ is None:
             environ = {}
@@ -492,6 +520,7 @@ class DummyRequest:
         self.params = {}
         self.cookies = {}
 
+
 class DummyConfigurator(object):
     def maybe_dotted(self, thing):
         return thing
diff --git a/tests/test_config/test_views.py b/tests/test_config/test_views.py
index 1af3f66bc..9b2a306f6 100644
--- a/tests/test_config/test_views.py
+++ b/tests/test_config/test_views.py
@@ -6,28 +6,34 @@ from . import IDummy
 
 from . import dummy_view
 
-from pyramid.compat import (
-    im_func,
-    text_,
-    )
+from pyramid.compat import im_func, text_
 from pyramid.exceptions import ConfigurationError
 from pyramid.exceptions import ConfigurationExecutionError
 from pyramid.exceptions import ConfigurationConflictError
 
+
 class TestViewsConfigurationMixin(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         config.set_default_csrf_options(require_csrf=False)
         return config
 
-    def _getViewCallable(self, config, ctx_iface=None, exc_iface=None,
-                         request_iface=None, name=''):
+    def _getViewCallable(
+        self,
+        config,
+        ctx_iface=None,
+        exc_iface=None,
+        request_iface=None,
+        name='',
+    ):
         from zope.interface import Interface
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         if exc_iface:
             classifier = IExceptionViewClassifier
             ctx_iface = exc_iface
@@ -38,16 +44,22 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         if request_iface is None:
             request_iface = IRequest
         return config.registry.adapters.lookup(
-            (classifier, request_iface, ctx_iface), IView, name=name,
-            default=None)
+            (classifier, request_iface, ctx_iface),
+            IView,
+            name=name,
+            default=None,
+        )
 
     def _registerRenderer(self, config, name='.txt'):
         from pyramid.interfaces import IRendererFactory
+
         class Renderer:
             def __init__(self, info):
                 self.__class__.info = info
+
             def __call__(self, *arg):
                 return b'Hello!'
+
         config.registry.registerUtility(Renderer, IRendererFactory, name=name)
         return Renderer
 
@@ -58,15 +70,18 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def _assertNotFound(self, wrapper, *arg):
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, wrapper, *arg)
 
     def _getRouteRequestIface(self, config, name):
         from pyramid.interfaces import IRouteRequest
+
         iface = config.registry.getUtility(IRouteRequest, name)
         return iface
 
     def _assertRoute(self, config, name, path, num_predicates=0):
         from pyramid.interfaces import IRoutesMapper
+
         mapper = config.registry.getUtility(IRoutesMapper)
         routes = mapper.get_routes()
         route = routes[0]
@@ -83,18 +98,29 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_request_type_and_route_name(self):
         config = self._makeOne(autocommit=True)
         view = lambda *arg: 'OK'
-        self.assertRaises(ConfigurationError, config.add_view, view, '', None,
-                          None, True, True)
+        self.assertRaises(
+            ConfigurationError,
+            config.add_view,
+            view,
+            '',
+            None,
+            None,
+            True,
+            True,
+        )
 
     def test_add_view_with_request_type(self):
         from pyramid.renderers import null_renderer
         from zope.interface import directlyProvides
         from pyramid.interfaces import IRequest
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view,
-                        request_type='pyramid.interfaces.IRequest',
-                        renderer=null_renderer)
+        config.add_view(
+            view=view,
+            request_type='pyramid.interfaces.IRequest',
+            renderer=null_renderer,
+        )
         wrapper = self._getViewCallable(config)
         request = DummyRequest()
         self._assertNotFound(wrapper, None, request)
@@ -122,8 +148,9 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         introspector = DummyIntrospector()
         config.introspector = introspector
         config.add_view(renderer='dummy.pt')
-        self.assertFalse(('renderer factories', '.pt') in
-                         introspector.related[-1])
+        self.assertFalse(
+            ('renderer factories', '.pt') in introspector.related[-1]
+        )
         view = self._getViewCallable(config)
         self.assertRaises(ValueError, view, None, None)
 
@@ -131,37 +158,45 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         config = self._makeOne(autocommit=True)
         introspector = DummyIntrospector(True)
         config.introspector = introspector
+
         def dummy_factory(helper):
             return lambda val, system_vals: 'Hello!'
+
         config.add_renderer('.pt', dummy_factory)
         config.add_view(renderer='dummy.pt')
         self.assertTrue(
-            ('renderer factories', '.pt') in introspector.related[-1])
+            ('renderer factories', '.pt') in introspector.related[-1]
+        )
         view = self._getViewCallable(config)
         self.assertTrue(b'Hello!' in view(None, None).body)
 
     def test_add_view_wrapped_view_is_decorated(self):
-        def view(request): # request-only wrapper
+        def view(request):  # request-only wrapper
             """ """
+
         config = self._makeOne(autocommit=True)
         config.add_view(view=view)
         wrapper = self._getViewCallable(config)
         self.assertEqual(wrapper.__module__, view.__module__)
         self.assertEqual(wrapper.__name__, view.__name__)
         self.assertEqual(wrapper.__doc__, view.__doc__)
-        self.assertEqual(wrapper.__discriminator__(None, None).resolve()[0],
-                         'view')
+        self.assertEqual(
+            wrapper.__discriminator__(None, None).resolve()[0], 'view'
+        )
 
     def test_add_view_view_callable_dottedname(self):
         from pyramid.renderers import null_renderer
+
         config = self._makeOne(autocommit=True)
-        config.add_view(view='tests.test_config.dummy_view',
-                        renderer=null_renderer)
+        config.add_view(
+            view='tests.test_config.dummy_view', renderer=null_renderer
+        )
         wrapper = self._getViewCallable(config)
         self.assertEqual(wrapper(None, None), 'OK')
 
     def test_add_view_with_function_callable(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, renderer=null_renderer)
@@ -171,8 +206,10 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_function_callable_requestonly(self):
         from pyramid.renderers import null_renderer
+
         def view(request):
             return 'OK'
+
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
@@ -181,6 +218,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_name(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, name='abc', renderer=null_renderer)
@@ -190,6 +228,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_name_unicode(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         name = text_(b'La Pe\xc3\xb1a', 'utf-8')
@@ -200,16 +239,21 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_decorator(self):
         from pyramid.renderers import null_renderer
+
         def view(request):
             """ ABC """
             return 'OK'
+
         def view_wrapper(fn):
             def inner(context, request):
                 return fn(context, request)
+
             return inner
+
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view, decorator=view_wrapper,
-                        renderer=null_renderer)
+        config.add_view(
+            view=view, decorator=view_wrapper, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(config)
         self.assertFalse(wrapper is view)
         self.assertEqual(wrapper.__doc__, view.__doc__)
@@ -218,20 +262,29 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_decorator_tuple(self):
         from pyramid.renderers import null_renderer
+
         def view(request):
             """ ABC """
             return 'OK'
+
         def view_wrapper1(fn):
             def inner(context, request):
                 return 'wrapped1' + fn(context, request)
+
             return inner
+
         def view_wrapper2(fn):
             def inner(context, request):
                 return 'wrapped2' + fn(context, request)
+
             return inner
+
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view, decorator=(view_wrapper2, view_wrapper1),
-                        renderer=null_renderer)
+        config.add_view(
+            view=view,
+            decorator=(view_wrapper2, view_wrapper1),
+            renderer=null_renderer,
+        )
         wrapper = self._getViewCallable(config)
         self.assertFalse(wrapper is view)
         self.assertEqual(wrapper.__doc__, view.__doc__)
@@ -241,12 +294,15 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_http_cache(self):
         import datetime
         from pyramid.response import Response
+
         response = Response('OK')
+
         def view(request):
             """ ABC """
             return response
+
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view, http_cache=(86400, {'public':True}))
+        config.add_view(view=view, http_cache=(86400, {'public': True}))
         wrapper = self._getViewCallable(config)
         self.assertFalse(wrapper is view)
         self.assertEqual(wrapper.__doc__, view.__doc__)
@@ -261,10 +317,12 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_as_instance(self):
         from pyramid.renderers import null_renderer
+
         class AView:
             def __call__(self, context, request):
                 """ """
                 return 'OK'
+
         view = AView()
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, renderer=null_renderer)
@@ -274,11 +332,13 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_as_instancemethod(self):
         from pyramid.renderers import null_renderer
+
         class View:
             def index(self, context, request):
                 return 'OK'
+
         view = View()
-        config=self._makeOne(autocommit=True)
+        config = self._makeOne(autocommit=True)
         config.add_view(view=view.index, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         result = wrapper(None, None)
@@ -286,11 +346,13 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_as_instancemethod_requestonly(self):
         from pyramid.renderers import null_renderer
+
         class View:
             def index(self, request):
                 return 'OK'
+
         view = View()
-        config=self._makeOne(autocommit=True)
+        config = self._makeOne(autocommit=True)
         config.add_view(view=view.index, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         result = wrapper(None, None)
@@ -298,10 +360,12 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_as_instance_requestonly(self):
         from pyramid.renderers import null_renderer
+
         class AView:
             def __call__(self, request):
                 """ """
                 return 'OK'
+
         view = AView()
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, renderer=null_renderer)
@@ -311,6 +375,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_as_oldstyle_class(self):
         from pyramid.renderers import null_renderer
+
         class view:
             def __init__(self, context, request):
                 self.context = context
@@ -318,6 +383,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
             def __call__(self):
                 return 'OK'
+
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
@@ -328,12 +394,14 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_as_oldstyle_class_requestonly(self):
         from pyramid.renderers import null_renderer
+
         class view:
             def __init__(self, request):
                 self.request = request
 
             def __call__(self):
                 return 'OK'
+
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
@@ -346,9 +414,12 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_context_as_class(self):
         from pyramid.renderers import null_renderer
         from zope.interface import implementedBy
+
         view = lambda *arg: 'OK'
+
         class Foo:
             pass
+
         config = self._makeOne(autocommit=True)
         config.add_view(context=Foo, view=view, renderer=null_renderer)
         foo = implementedBy(Foo)
@@ -357,6 +428,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_context_as_iface(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(context=IDummy, view=view, renderer=null_renderer)
@@ -365,19 +437,25 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_context_as_dottedname(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(context='tests.test_config.IDummy',
-                        view=view,  renderer=null_renderer)
+        config.add_view(
+            context='tests.test_config.IDummy',
+            view=view,
+            renderer=null_renderer,
+        )
         wrapper = self._getViewCallable(config, IDummy)
         self.assertEqual(wrapper, view)
 
     def test_add_view_for__as_dottedname(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(for_='tests.test_config.IDummy',
-                        view=view, renderer=null_renderer)
+        config.add_view(
+            for_='tests.test_config.IDummy', view=view, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(config, IDummy)
         self.assertEqual(wrapper, view)
 
@@ -385,9 +463,12 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         # ``for_`` is older spelling for ``context``
         from pyramid.renderers import null_renderer
         from zope.interface import implementedBy
+
         view = lambda *arg: 'OK'
+
         class Foo:
             pass
+
         config = self._makeOne(autocommit=True)
         config.add_view(for_=Foo, view=view, renderer=null_renderer)
         foo = implementedBy(Foo)
@@ -397,6 +478,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_for_as_iface(self):
         # ``for_`` is older spelling for ``context``
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(for_=IDummy, view=view, renderer=null_renderer)
@@ -406,12 +488,16 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_context_trumps_for(self):
         # ``for_`` is older spelling for ``context``
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
+
         class Foo:
             pass
-        config.add_view(context=IDummy, for_=Foo, view=view,
-                        renderer=null_renderer)
+
+        config.add_view(
+            context=IDummy, for_=Foo, view=view, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(config, IDummy)
         self.assertEqual(wrapper, view)
 
@@ -421,13 +507,17 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import ISecuredView
         from pyramid.interfaces import IViewClassifier
+
         view = lambda *arg: 'OK'
         view.__call_permissive__ = view
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, renderer=null_renderer)
         wrapper = config.registry.adapters.lookup(
             (IViewClassifier, IRequest, Interface),
-            ISecuredView, name='', default=None)
+            ISecuredView,
+            name='',
+            default=None,
+        )
         self.assertEqual(wrapper, view)
 
     def test_add_view_exception_register_secured_view(self):
@@ -436,13 +526,19 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IView
         from pyramid.interfaces import IExceptionViewClassifier
+
         view = lambda *arg: 'OK'
         view.__call_permissive__ = view
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view, context=RuntimeError, renderer=null_renderer)
+        config.add_view(
+            view=view, context=RuntimeError, renderer=null_renderer
+        )
         wrapper = config.registry.adapters.lookup(
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='', default=None)
+            IView,
+            name='',
+            default=None,
+        )
         self.assertEqual(wrapper, view)
 
     def test_add_view_same_phash_overrides_existing_single_view(self):
@@ -453,15 +549,19 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IMultiView
+
         phash = md5()
         phash.update(b'xhr = True')
         view = lambda *arg: 'NOT OK'
         view.__phash__ = phash.hexdigest()
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Interface), IView, name='')
+            view, (IViewClassifier, IRequest, Interface), IView, name=''
+        )
+
         def newview(context, request):
             return 'OK'
+
         config.add_view(view=newview, xhr=True, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         self.assertFalse(IMultiView.providedBy(wrapper))
@@ -477,6 +577,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IMultiView
+
         phash = md5()
         phash.update(b'xhr = True')
         view = lambda *arg: 'NOT OK'
@@ -485,13 +586,22 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         config.registry.registerAdapter(
             view,
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='')
+            IView,
+            name='',
+        )
+
         def newview(context, request):
             return 'OK'
-        config.add_view(view=newview, xhr=True, context=RuntimeError,
-                        renderer=null_renderer)
+
+        config.add_view(
+            view=newview,
+            xhr=True,
+            context=RuntimeError,
+            renderer=null_renderer,
+        )
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError))
+            config, exc_iface=implementedBy(RuntimeError)
+        )
         self.assertFalse(IMultiView.providedBy(wrapper))
         request = DummyRequest()
         request.is_xhr = True
@@ -504,12 +614,16 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IMultiView
+
         view = lambda *arg: 'NOT OK'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Interface), IView, name='')
+            view, (IViewClassifier, IRequest, Interface), IView, name=''
+        )
+
         def newview(context, request):
             return 'OK'
+
         config.add_view(view=newview, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         self.assertFalse(IMultiView.providedBy(wrapper))
@@ -524,18 +638,25 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IMultiView
+
         view = lambda *arg: 'NOT OK'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
             view,
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='')
+            IView,
+            name='',
+        )
+
         def newview(context, request):
             return 'OK'
-        config.add_view(view=newview, context=RuntimeError,
-                        renderer=null_renderer)
+
+        config.add_view(
+            view=newview, context=RuntimeError, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError))
+            config, exc_iface=implementedBy(RuntimeError)
+        )
         self.assertFalse(IMultiView.providedBy(wrapper))
         request = DummyRequest()
         request.is_xhr = True
@@ -549,13 +670,17 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IMultiView
+
         view = lambda *arg: 'NOT OK'
         view.__phash__ = DEFAULT_PHASH
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Interface), IView, name='')
+            view, (IViewClassifier, IRequest, Interface), IView, name=''
+        )
+
         def newview(context, request):
             return 'OK'
+
         config.add_view(view=newview, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         self.assertFalse(IMultiView.providedBy(wrapper))
@@ -571,19 +696,26 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IMultiView
+
         view = lambda *arg: 'NOT OK'
         view.__phash__ = DEFAULT_PHASH
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
             view,
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='')
+            IView,
+            name='',
+        )
+
         def newview(context, request):
             return 'OK'
-        config.add_view(view=newview, context=RuntimeError,
-                        renderer=null_renderer)
+
+        config.add_view(
+            view=newview, context=RuntimeError, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError))
+            config, exc_iface=implementedBy(RuntimeError)
+        )
         self.assertFalse(IMultiView.providedBy(wrapper))
         request = DummyRequest()
         request.is_xhr = True
@@ -596,11 +728,13 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IMultiView
+
         view = lambda *arg: 'OK'
         view.__phash__ = 'abc'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Interface), IView, name='')
+            view, (IViewClassifier, IRequest, Interface), IView, name=''
+        )
         config.add_view(view=view, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         self.assertTrue(IMultiView.providedBy(wrapper))
@@ -614,21 +748,28 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IMultiView
+
         view = lambda *arg: 'OK'
         view.__phash__ = 'abc'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
             view,
             (IViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='')
+            IView,
+            name='',
+        )
         config.registry.registerAdapter(
             view,
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='')
-        config.add_view(view=view, context=RuntimeError,
-                        renderer=null_renderer)
+            IView,
+            name='',
+        )
+        config.add_view(
+            view=view, context=RuntimeError, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError))
+            config, exc_iface=implementedBy(RuntimeError)
+        )
         self.assertTrue(IMultiView.providedBy(wrapper))
         self.assertEqual(wrapper(None, None), 'OK')
 
@@ -639,12 +780,13 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import ISecuredView
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
+
         view = lambda *arg: 'OK'
         view.__phash__ = 'abc'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Interface),
-            ISecuredView, name='')
+            view, (IViewClassifier, IRequest, Interface), ISecuredView, name=''
+        )
         config.add_view(view=view, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         self.assertTrue(IMultiView.providedBy(wrapper))
@@ -658,20 +800,28 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         view = lambda *arg: 'OK'
         view.__phash__ = 'abc'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
             view,
             (IViewClassifier, IRequest, implementedBy(RuntimeError)),
-            ISecuredView, name='')
+            ISecuredView,
+            name='',
+        )
         config.registry.registerAdapter(
             view,
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            ISecuredView, name='')
-        config.add_view(view=view, context=RuntimeError, renderer=null_renderer)
+            ISecuredView,
+            name='',
+        )
+        config.add_view(
+            view=view, context=RuntimeError, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError))
+            config, exc_iface=implementedBy(RuntimeError)
+        )
         self.assertTrue(IMultiView.providedBy(wrapper))
         self.assertEqual(wrapper(None, None), 'OK')
 
@@ -682,13 +832,17 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
+
         def view(context, request):
             return 'OK'
+
         def view2(context, request):
             return 'OK2'
+
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Interface), IView, name='')
+            view, (IViewClassifier, IRequest, Interface), IView, name=''
+        )
         config.add_view(view=view2, accept='text/html', renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         self.assertTrue(IMultiView.providedBy(wrapper))
@@ -701,16 +855,23 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_mixed_case_replaces_existing_view(self):
         from pyramid.renderers import null_renderer
-        def view(context, request): return 'OK'
-        def view2(context, request): return 'OK2'
-        def view3(context, request): return 'OK3'
+
+        def view(context, request):
+            return 'OK'
+
+        def view2(context, request):
+            return 'OK2'
+
+        def view3(context, request):
+            return 'OK3'
+
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, renderer=null_renderer)
         config.add_view(view=view2, accept='text/html', renderer=null_renderer)
         config.add_view(view=view3, accept='text/HTML', renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         self.assertTrue(IMultiView.providedBy(wrapper))
-        self.assertEqual(len(wrapper.media_views.items()),1)
+        self.assertEqual(len(wrapper.media_views.items()), 1)
         self.assertFalse('text/HTML' in wrapper.media_views)
         self.assertEqual(wrapper(None, None), 'OK')
         request = DummyRequest()
@@ -719,9 +880,16 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_views_with_accept_multiview_replaces_existing(self):
         from pyramid.renderers import null_renderer
-        def view(context, request): return 'OK'
-        def view2(context, request): return 'OK2'
-        def view3(context, request): return 'OK3'
+
+        def view(context, request):
+            return 'OK'
+
+        def view2(context, request):
+            return 'OK2'
+
+        def view3(context, request):
+            return 'OK3'
+
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, renderer=null_renderer)
         config.add_view(view=view2, accept='text/html', renderer=null_renderer)
@@ -741,23 +909,35 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         def view(context, request):
             return 'OK'
+
         def view2(context, request):
             return 'OK2'
+
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
             view,
             (IViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='')
+            IView,
+            name='',
+        )
         config.registry.registerAdapter(
             view,
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='')
-        config.add_view(view=view2, accept='text/html', context=RuntimeError,
-                        renderer=null_renderer)
+            IView,
+            name='',
+        )
+        config.add_view(
+            view=view2,
+            accept='text/html',
+            context=RuntimeError,
+            renderer=null_renderer,
+        )
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError))
+            config, exc_iface=implementedBy(RuntimeError)
+        )
         self.assertTrue(IMultiView.providedBy(wrapper))
         self.assertEqual(len(wrapper.views), 1)
         self.assertEqual(len(wrapper.media_views), 1)
@@ -773,15 +953,19 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
+
         def view(context, request):
             return 'OK'
+
         def view2(context, request):
             return 'OK2'
+
         view.__accept__ = 'text/html'
         view.__phash__ = 'abc'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Interface), IView, name='')
+            view, (IViewClassifier, IRequest, Interface), IView, name=''
+        )
         config.add_view(view=view2, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         self.assertTrue(IMultiView.providedBy(wrapper))
@@ -800,25 +984,34 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         def view(context, request):
             return 'OK'
+
         def view2(context, request):
             return 'OK2'
+
         view.__accept__ = 'text/html'
         view.__phash__ = 'abc'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
             view,
             (IViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='')
+            IView,
+            name='',
+        )
         config.registry.registerAdapter(
             view,
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IView, name='')
-        config.add_view(view=view2, context=RuntimeError,
-                        renderer=null_renderer)
+            IView,
+            name='',
+        )
+        config.add_view(
+            view=view2, context=RuntimeError, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError))
+            config, exc_iface=implementedBy(RuntimeError)
+        )
         self.assertTrue(IMultiView.providedBy(wrapper))
         self.assertEqual(len(wrapper.views), 1)
         self.assertEqual(len(wrapper.media_views), 1)
@@ -833,16 +1026,19 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
+
         view = DummyMultiView()
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Interface),
-            IMultiView, name='')
+            view, (IViewClassifier, IRequest, Interface), IMultiView, name=''
+        )
         view2 = lambda *arg: 'OK2'
         config.add_view(view=view2, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         self.assertTrue(IMultiView.providedBy(wrapper))
-        self.assertEqual([(x[0], x[2]) for x in wrapper.views], [(view2, None)])
+        self.assertEqual(
+            [(x[0], x[2]) for x in wrapper.views], [(view2, None)]
+        )
         self.assertEqual(wrapper(None, None), 'OK1')
 
     def test_add_view_exc_multiview_replaces_multiviews(self):
@@ -852,30 +1048,42 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         hot_view = DummyMultiView()
         exc_view = DummyMultiView()
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
             hot_view,
             (IViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IMultiView, name='')
+            IMultiView,
+            name='',
+        )
         config.registry.registerAdapter(
             exc_view,
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IMultiView, name='')
+            IMultiView,
+            name='',
+        )
         view2 = lambda *arg: 'OK2'
-        config.add_view(view=view2, context=RuntimeError,
-                        renderer=null_renderer)
+        config.add_view(
+            view=view2, context=RuntimeError, renderer=null_renderer
+        )
         hot_wrapper = self._getViewCallable(
-            config, ctx_iface=implementedBy(RuntimeError))
+            config, ctx_iface=implementedBy(RuntimeError)
+        )
         self.assertTrue(IMultiView.providedBy(hot_wrapper))
-        self.assertEqual([(x[0], x[2]) for x in hot_wrapper.views], [(view2, None)])
+        self.assertEqual(
+            [(x[0], x[2]) for x in hot_wrapper.views], [(view2, None)]
+        )
         self.assertEqual(hot_wrapper(None, None), 'OK1')
 
         exc_wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError))
+            config, exc_iface=implementedBy(RuntimeError)
+        )
         self.assertTrue(IMultiView.providedBy(exc_wrapper))
-        self.assertEqual([(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)])
+        self.assertEqual(
+            [(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)]
+        )
         self.assertEqual(exc_wrapper(None, None), 'OK1')
 
     def test_add_view_exc_multiview_replaces_only_exc_multiview(self):
@@ -885,30 +1093,43 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         hot_view = DummyMultiView()
         exc_view = DummyMultiView()
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
             hot_view,
             (IViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IMultiView, name='')
+            IMultiView,
+            name='',
+        )
         config.registry.registerAdapter(
             exc_view,
             (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)),
-            IMultiView, name='')
+            IMultiView,
+            name='',
+        )
         view2 = lambda *arg: 'OK2'
-        config.add_view(view=view2, context=RuntimeError, exception_only=True,
-                        renderer=null_renderer)
+        config.add_view(
+            view=view2,
+            context=RuntimeError,
+            exception_only=True,
+            renderer=null_renderer,
+        )
         hot_wrapper = self._getViewCallable(
-            config, ctx_iface=implementedBy(RuntimeError))
+            config, ctx_iface=implementedBy(RuntimeError)
+        )
         self.assertTrue(IMultiView.providedBy(hot_wrapper))
         self.assertEqual(len(hot_wrapper.views), 0)
         self.assertEqual(hot_wrapper(None, None), 'OK1')
 
         exc_wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError))
+            config, exc_iface=implementedBy(RuntimeError)
+        )
         self.assertTrue(IMultiView.providedBy(exc_wrapper))
-        self.assertEqual([(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)])
+        self.assertEqual(
+            [(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)]
+        )
         self.assertEqual(exc_wrapper(None, None), 'OK1')
 
     def test_add_view_multiview_context_superclass_then_subclass(self):
@@ -918,22 +1139,28 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
+
         class ISuper(Interface):
             pass
+
         class ISub(ISuper):
             pass
+
         view = lambda *arg: 'OK'
         view2 = lambda *arg: 'OK2'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, ISuper), IView, name='')
+            view, (IViewClassifier, IRequest, ISuper), IView, name=''
+        )
         config.add_view(view=view2, for_=ISub, renderer=null_renderer)
-        wrapper = self._getViewCallable(config, ctx_iface=ISuper,
-                                        request_iface=IRequest)
+        wrapper = self._getViewCallable(
+            config, ctx_iface=ISuper, request_iface=IRequest
+        )
         self.assertFalse(IMultiView.providedBy(wrapper))
         self.assertEqual(wrapper(None, None), 'OK')
-        wrapper = self._getViewCallable(config, ctx_iface=ISub,
-                                        request_iface=IRequest)
+        wrapper = self._getViewCallable(
+            config, ctx_iface=ISub, request_iface=IRequest
+        )
         self.assertFalse(IMultiView.providedBy(wrapper))
         self.assertEqual(wrapper(None, None), 'OK2')
 
@@ -945,29 +1172,38 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         class Super(Exception):
             pass
+
         class Sub(Super):
             pass
+
         view = lambda *arg: 'OK'
         view2 = lambda *arg: 'OK2'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Super), IView, name='')
+            view, (IViewClassifier, IRequest, Super), IView, name=''
+        )
         config.registry.registerAdapter(
-            view, (IExceptionViewClassifier, IRequest, Super), IView, name='')
+            view, (IExceptionViewClassifier, IRequest, Super), IView, name=''
+        )
         config.add_view(view=view2, for_=Sub, renderer=null_renderer)
         wrapper = self._getViewCallable(
-            config, ctx_iface=implementedBy(Super), request_iface=IRequest)
+            config, ctx_iface=implementedBy(Super), request_iface=IRequest
+        )
         wrapper_exc_view = self._getViewCallable(
-            config, exc_iface=implementedBy(Super), request_iface=IRequest)
+            config, exc_iface=implementedBy(Super), request_iface=IRequest
+        )
         self.assertEqual(wrapper_exc_view, wrapper)
         self.assertFalse(IMultiView.providedBy(wrapper_exc_view))
         self.assertEqual(wrapper_exc_view(None, None), 'OK')
         wrapper = self._getViewCallable(
-            config, ctx_iface=implementedBy(Sub), request_iface=IRequest)
+            config, ctx_iface=implementedBy(Sub), request_iface=IRequest
+        )
         wrapper_exc_view = self._getViewCallable(
-            config, exc_iface=implementedBy(Sub), request_iface=IRequest)
+            config, exc_iface=implementedBy(Sub), request_iface=IRequest
+        )
         self.assertEqual(wrapper_exc_view, wrapper)
         self.assertFalse(IMultiView.providedBy(wrapper_exc_view))
         self.assertEqual(wrapper_exc_view(None, None), 'OK2')
@@ -975,28 +1211,55 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_multiview_call_ordering(self):
         from pyramid.renderers import null_renderer as nr
         from zope.interface import directlyProvides
-        def view1(context, request): return 'view1'
-        def view2(context, request): return 'view2'
-        def view3(context, request): return 'view3'
-        def view4(context, request): return 'view4'
-        def view5(context, request): return 'view5'
-        def view6(context, request): return 'view6'
-        def view7(context, request): return 'view7'
-        def view8(context, request): return 'view8'
+
+        def view1(context, request):
+            return 'view1'
+
+        def view2(context, request):
+            return 'view2'
+
+        def view3(context, request):
+            return 'view3'
+
+        def view4(context, request):
+            return 'view4'
+
+        def view5(context, request):
+            return 'view5'
+
+        def view6(context, request):
+            return 'view6'
+
+        def view7(context, request):
+            return 'view7'
+
+        def view8(context, request):
+            return 'view8'
+
         config = self._makeOne(autocommit=True)
         config.add_view(view=view1, renderer=nr)
         config.add_view(view=view2, request_method='POST', renderer=nr)
-        config.add_view(view=view3,request_param='param', renderer=nr)
+        config.add_view(view=view3, request_param='param', renderer=nr)
         config.add_view(view=view4, containment=IDummy, renderer=nr)
-        config.add_view(view=view5, request_method='POST',
-                        request_param='param',  renderer=nr)
-        config.add_view(view=view6, request_method='POST', containment=IDummy,
-                        renderer=nr)
-        config.add_view(view=view7, request_param='param', containment=IDummy,
-                        renderer=nr)
-        config.add_view(view=view8, request_method='POST',request_param='param',
-                        containment=IDummy, renderer=nr)
-
+        config.add_view(
+            view=view5,
+            request_method='POST',
+            request_param='param',
+            renderer=nr,
+        )
+        config.add_view(
+            view=view6, request_method='POST', containment=IDummy, renderer=nr
+        )
+        config.add_view(
+            view=view7, request_param='param', containment=IDummy, renderer=nr
+        )
+        config.add_view(
+            view=view8,
+            request_method='POST',
+            request_param='param',
+            containment=IDummy,
+            renderer=nr,
+        )
 
         wrapper = self._getViewCallable(config)
 
@@ -1014,7 +1277,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
         ctx = DummyContext()
         request = self._makeRequest(config)
-        request.params = {'param':'1'}
+        request.params = {'param': '1'}
         request.method = 'GET'
         self.assertEqual(wrapper(ctx, request), 'view3')
 
@@ -1028,7 +1291,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         ctx = DummyContext()
         request = self._makeRequest(config)
         request.method = 'POST'
-        request.params = {'param':'1'}
+        request.params = {'param': '1'}
         self.assertEqual(wrapper(ctx, request), 'view5')
 
         ctx = DummyContext()
@@ -1042,40 +1305,55 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         directlyProvides(ctx, IDummy)
         request = self._makeRequest(config)
         request.method = 'GET'
-        request.params = {'param':'1'}
+        request.params = {'param': '1'}
         self.assertEqual(wrapper(ctx, request), 'view7')
 
         ctx = DummyContext()
         directlyProvides(ctx, IDummy)
         request = self._makeRequest(config)
         request.method = 'POST'
-        request.params = {'param':'1'}
+        request.params = {'param': '1'}
         self.assertEqual(wrapper(ctx, request), 'view8')
 
     def test_view_with_most_specific_predicate(self):
         from pyramid.renderers import null_renderer as nr
         from pyramid.router import Router
 
-        class OtherBase(object): pass
-        class Int1(object): pass
-        class Int2(object): pass
+        class OtherBase(object):
+            pass
+
+        class Int1(object):
+            pass
+
+        class Int2(object):
+            pass
 
         class Resource(OtherBase, Int1, Int2):
-            def __init__(self, request): pass
+            def __init__(self, request):
+                pass
 
-        def unknown(context, request): return 'unknown'
-        def view(context, request): return 'hello'
+        def unknown(context, request):
+            return 'unknown'
+
+        def view(context, request):
+            return 'hello'
 
         config = self._makeOne(autocommit=True)
         config.add_route('root', '/', factory=Resource)
         config.add_view(unknown, route_name='root', renderer=nr)
         config.add_view(
-            view, renderer=nr, route_name='root',
-            context=Int1, request_method='GET'
+            view,
+            renderer=nr,
+            route_name='root',
+            context=Int1,
+            request_method='GET',
         )
         config.add_view(
-            view=view, renderer=nr, route_name='root',
-            context=Int2, request_method='POST'
+            view=view,
+            renderer=nr,
+            route_name='root',
+            context=Int2,
+            request_method='POST',
         )
         request = self._makeRequest(config)
         request.method = 'POST'
@@ -1088,15 +1366,24 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.renderers import null_renderer as nr
         from pyramid.router import Router
 
-        class OtherBase(object): pass
-        class Int1(object): pass
-        class Int2(object): pass
+        class OtherBase(object):
+            pass
+
+        class Int1(object):
+            pass
+
+        class Int2(object):
+            pass
 
         class Resource(OtherBase, Int1, Int2):
-            def __init__(self, request): pass
+            def __init__(self, request):
+                pass
+
+        def unknown(context, request):
+            return 'unknown'
 
-        def unknown(context, request): return 'unknown'
-        def view(context, request): return 'hello'
+        def view(context, request):
+            return 'hello'
 
         config = self._makeOne(autocommit=True)
         config.add_route('root', '/', factory=Resource)
@@ -1110,12 +1397,18 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         )
 
         config.add_view(
-            view, renderer=nr, route_name='root',
-            context=Int1, request_method='GET'
+            view,
+            renderer=nr,
+            route_name='root',
+            context=Int1,
+            request_method='GET',
         )
         config.add_view(
-            view=view, renderer=nr, route_name='root',
-            context=Int2, request_method='POST'
+            view=view,
+            renderer=nr,
+            route_name='root',
+            context=Int2,
+            request_method='POST',
         )
         request = self._makeRequest(config)
         request.method = 'POST'
@@ -1127,16 +1420,21 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_multiview___discriminator__(self):
         from pyramid.renderers import null_renderer
         from zope.interface import Interface
+
         class IFoo(Interface):
             pass
+
         class IBar(Interface):
             pass
+
         @implementer(IFoo)
         class Foo(object):
             pass
+
         @implementer(IBar)
         class Bar(object):
             pass
+
         foo = Foo()
         bar = Bar()
 
@@ -1144,33 +1442,35 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IMultiView
+
         view = lambda *arg: 'OK'
         view.__phash__ = 'abc'
         config = self._makeOne(autocommit=True)
         config.registry.registerAdapter(
-            view, (IViewClassifier, IRequest, Interface), IView, name='')
-        config.add_view(view=view, renderer=null_renderer,
-                        containment=IFoo)
-        config.add_view(view=view, renderer=null_renderer,
-                        containment=IBar)
+            view, (IViewClassifier, IRequest, Interface), IView, name=''
+        )
+        config.add_view(view=view, renderer=null_renderer, containment=IFoo)
+        config.add_view(view=view, renderer=null_renderer, containment=IBar)
         wrapper = self._getViewCallable(config)
         self.assertTrue(IMultiView.providedBy(wrapper))
         request = self._makeRequest(config)
         self.assertNotEqual(
             wrapper.__discriminator__(foo, request),
             wrapper.__discriminator__(bar, request),
-            )
+        )
 
     def test_add_view_with_template_renderer(self):
         from tests import test_config
         from pyramid.interfaces import ISettings
+
         class view(object):
             def __init__(self, context, request):
                 self.request = request
                 self.context = context
 
             def __call__(self):
-                return {'a':'1'}
+                return {'a': '1'}
+
         config = self._makeOne(autocommit=True)
         renderer = self._registerRenderer(config)
         fixture = 'tests.test_config:files/minimal.txt'
@@ -1195,13 +1495,17 @@ class TestViewsConfigurationMixin(unittest.TestCase):
                 self.context = context
 
             def __call__(self):
-                return {'a':'1'}
+                return {'a': '1'}
+
         config = self._makeOne(autocommit=True)
+
         class moo(object):
             def __init__(self, *arg, **kw):
                 pass
+
             def __call__(self, *arg, **kw):
                 return b'moo'
+
         config.add_renderer(None, moo)
         config.add_view(view=view)
         wrapper = self._getViewCallable(config)
@@ -1212,6 +1516,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_template_renderer_no_callable(self):
         from tests import test_config
         from pyramid.interfaces import ISettings
+
         config = self._makeOne(autocommit=True)
         renderer = self._registerRenderer(config)
         fixture = 'tests.test_config:files/minimal.txt'
@@ -1232,8 +1537,10 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_request_type_as_iface(self):
         from pyramid.renderers import null_renderer
         from zope.interface import directlyProvides
+
         def view(context, request):
             return 'OK'
+
         config = self._makeOne(autocommit=True)
         config.add_view(request_type=IDummy, view=view, renderer=null_renderer)
         wrapper = self._getViewCallable(config, None)
@@ -1245,11 +1552,13 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_request_type_as_noniface(self):
         view = lambda *arg: 'OK'
         config = self._makeOne()
-        self.assertRaises(ConfigurationError,
-                          config.add_view, view, '', None, None, object)
+        self.assertRaises(
+            ConfigurationError, config.add_view, view, '', None, None, object
+        )
 
     def test_add_view_with_route_name(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_route('foo', '/a/b')
@@ -1262,6 +1571,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_nonexistant_route_name(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne()
         config.add_view(view=view, route_name='foo', renderer=null_renderer)
@@ -1270,28 +1580,39 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_route_name_exception(self):
         from pyramid.renderers import null_renderer
         from zope.interface import implementedBy
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_route('foo', '/a/b')
-        config.add_view(view=view, route_name='foo', context=RuntimeError,
-                        renderer=null_renderer)
+        config.add_view(
+            view=view,
+            route_name='foo',
+            context=RuntimeError,
+            renderer=null_renderer,
+        )
         request_iface = self._getRouteRequestIface(config, 'foo')
         wrapper_exc_view = self._getViewCallable(
-            config, exc_iface=implementedBy(RuntimeError),
-            request_iface=request_iface)
+            config,
+            exc_iface=implementedBy(RuntimeError),
+            request_iface=request_iface,
+        )
         self.assertNotEqual(wrapper_exc_view, None)
         wrapper = self._getViewCallable(
-            config, ctx_iface=implementedBy(RuntimeError),
-            request_iface=request_iface)
+            config,
+            ctx_iface=implementedBy(RuntimeError),
+            request_iface=request_iface,
+        )
         self.assertEqual(wrapper_exc_view, wrapper)
         self.assertEqual(wrapper_exc_view(None, None), 'OK')
 
     def test_add_view_with_request_method_true(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view, request_method='POST',
-                        renderer=null_renderer)
+        config.add_view(
+            view=view, request_method='POST', renderer=null_renderer
+        )
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
         request.method = 'POST'
@@ -1308,10 +1629,12 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_request_method_sequence_true(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view, request_method=('POST', 'GET'),
-                        renderer=null_renderer)
+        config.add_view(
+            view=view, request_method=('POST', 'GET'), renderer=null_renderer
+        )
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
         request.method = 'POST'
@@ -1319,12 +1642,15 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_request_method_sequence_conflict(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne()
-        config.add_view(view=view, request_method=('POST', 'GET'),
-                        renderer=null_renderer)
-        config.add_view(view=view, request_method=('GET', 'POST'),
-                        renderer=null_renderer)
+        config.add_view(
+            view=view, request_method=('POST', 'GET'), renderer=null_renderer
+        )
+        config.add_view(
+            view=view, request_method=('GET', 'POST'), renderer=null_renderer
+        )
         self.assertRaises(ConfigurationConflictError, config.commit)
 
     def test_add_view_with_request_method_sequence_false(self):
@@ -1338,9 +1664,12 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_request_method_get_implies_head(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view, request_method='GET', renderer=null_renderer)
+        config.add_view(
+            view=view, request_method='GET', renderer=null_renderer
+        )
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
         request.method = 'HEAD'
@@ -1348,12 +1677,13 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_request_param_noval_true(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, request_param='abc', renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
-        request.params = {'abc':''}
+        request.params = {'abc': ''}
         self.assertEqual(wrapper(None, request), 'OK')
 
     def test_add_view_with_request_param_noval_false(self):
@@ -1367,13 +1697,15 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_request_param_val_true(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view, request_param='abc=123',
-                        renderer=null_renderer)
+        config.add_view(
+            view=view, request_param='abc=123', renderer=null_renderer
+        )
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
-        request.params = {'abc':'123'}
+        request.params = {'abc': '123'}
         self.assertEqual(wrapper(None, request), 'OK')
 
     def test_add_view_with_request_param_val_false(self):
@@ -1382,11 +1714,12 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         config.add_view(view=view, request_param='abc=123')
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
-        request.params = {'abc':''}
+        request.params = {'abc': ''}
         self._assertNotFound(wrapper, None, request)
 
     def test_add_view_with_xhr_true(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, xhr=True, renderer=null_renderer)
@@ -1412,12 +1745,13 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_header_noval_match(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, header='Host', renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
-        request.headers = {'Host':'whatever'}
+        request.headers = {'Host': 'whatever'}
         self.assertEqual(wrapper(None, request), 'OK')
 
     def test_add_view_with_header_noval_nomatch(self):
@@ -1426,17 +1760,18 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         config.add_view(view=view, header='Host')
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
-        request.headers = {'NotHost':'whatever'}
+        request.headers = {'NotHost': 'whatever'}
         self._assertNotFound(wrapper, None, request)
 
     def test_add_view_with_header_val_match(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, header=r'Host:\d', renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
-        request.headers = {'Host':'1'}
+        request.headers = {'Host': '1'}
         self.assertEqual(wrapper(None, request), 'OK')
 
     def test_add_view_with_header_val_nomatch(self):
@@ -1445,21 +1780,23 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         config.add_view(view=view, header=r'Host:\d')
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
-        request.headers = {'Host':'abc'}
+        request.headers = {'Host': 'abc'}
         self._assertNotFound(wrapper, None, request)
 
     def test_add_view_with_header_val_missing(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, header=r'Host:\d')
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
-        request.headers = {'NoHost':'1'}
+        request.headers = {'NoHost': '1'}
         self.assertRaises(HTTPNotFound, wrapper, None, request)
 
     def test_add_view_with_accept_match(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, accept='text/xml', renderer=null_renderer)
@@ -1479,6 +1816,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_range_accept_match(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, accept='text/*', renderer=null_renderer)
@@ -1499,6 +1837,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_containment_true(self):
         from pyramid.renderers import null_renderer
         from zope.interface import directlyProvides
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, containment=IDummy, renderer=null_renderer)
@@ -1518,12 +1857,14 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_containment_dottedname(self):
         from pyramid.renderers import null_renderer
         from zope.interface import directlyProvides
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(
             view=view,
             containment='tests.test_config.IDummy',
-            renderer=null_renderer)
+            renderer=null_renderer,
+        )
         wrapper = self._getViewCallable(config)
         context = DummyContext()
         directlyProvides(context, IDummy)
@@ -1537,6 +1878,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_path_info_match(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_view(view=view, path_info='/foo', renderer=null_renderer)
@@ -1557,6 +1899,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_check_csrf_predicates_match(self):
         import warnings
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         with warnings.catch_warnings(record=True) as w:
@@ -1574,17 +1917,22 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_custom_predicates_match(self):
         import warnings
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
+
         def pred1(context, request):
             return True
+
         def pred2(context, request):
             return True
+
         predicates = (pred1, pred2)
         with warnings.catch_warnings(record=True) as w:
             warnings.filterwarnings('always')
-            config.add_view(view=view, custom_predicates=predicates,
-                            renderer=null_renderer)
+            config.add_view(
+                view=view, custom_predicates=predicates, renderer=null_renderer
+            )
             self.assertEqual(len(w), 1)
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
@@ -1592,12 +1940,16 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_custom_predicates_nomatch(self):
         import warnings
+
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
+
         def pred1(context, request):
             return True
+
         def pred2(context, request):
             return False
+
         predicates = (pred1, pred2)
         with warnings.catch_warnings(record=True) as w:
             warnings.filterwarnings('always')
@@ -1610,17 +1962,22 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_custom_predicate_bests_standard_predicate(self):
         import warnings
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         view2 = lambda *arg: 'NOT OK'
         config = self._makeOne(autocommit=True)
+
         def pred1(context, request):
             return True
+
         with warnings.catch_warnings(record=True) as w:
             warnings.filterwarnings('always')
-            config.add_view(view=view, custom_predicates=(pred1,),
-                        renderer=null_renderer)
-            config.add_view(view=view2, request_method='GET',
-                            renderer=null_renderer)
+            config.add_view(
+                view=view, custom_predicates=(pred1,), renderer=null_renderer
+            )
+            config.add_view(
+                view=view2, request_method='GET', renderer=null_renderer
+            )
             self.assertEqual(len(w), 1)
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
@@ -1629,13 +1986,16 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_custom_more_preds_first_bests_fewer_preds_last(self):
         from pyramid.renderers import null_renderer
+
         view = lambda *arg: 'OK'
         view2 = lambda *arg: 'NOT OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view, request_method='GET', xhr=True,
-                        renderer=null_renderer)
-        config.add_view(view=view2, request_method='GET',
-                        renderer=null_renderer)
+        config.add_view(
+            view=view, request_method='GET', xhr=True, renderer=null_renderer
+        )
+        config.add_view(
+            view=view2, request_method='GET', renderer=null_renderer
+        )
         wrapper = self._getViewCallable(config)
         request = self._makeRequest(config)
         request.method = 'GET'
@@ -1652,8 +2012,10 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_csrf_param(self):
         from pyramid.renderers import null_renderer
+
         def view(request):
             return 'OK'
+
         config = self._makeOne(autocommit=True)
         config.add_view(view, require_csrf='st', renderer=null_renderer)
         view = self._getViewCallable(config)
@@ -1667,8 +2029,10 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_csrf_header(self):
         from pyramid.renderers import null_renderer
+
         def view(request):
             return 'OK'
+
         config = self._makeOne(autocommit=True)
         config.add_view(view, require_csrf=True, renderer=null_renderer)
         view = self._getViewCallable(config)
@@ -1683,7 +2047,10 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_with_missing_csrf_header(self):
         from pyramid.exceptions import BadCSRFToken
         from pyramid.renderers import null_renderer
-        def view(request): return 'OK'
+
+        def view(request):
+            return 'OK'
+
         config = self._makeOne(autocommit=True)
         config.add_view(view, require_csrf=True, renderer=null_renderer)
         view = self._getViewCallable(config)
@@ -1697,21 +2064,27 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_permission(self):
         from pyramid.renderers import null_renderer
+
         view1 = lambda *arg: 'OK'
         outerself = self
+
         class DummyPolicy(object):
             def effective_principals(self, r):
                 outerself.assertEqual(r, request)
                 return ['abc']
+
             def permits(self, context, principals, permission):
                 outerself.assertEqual(context, None)
                 outerself.assertEqual(principals, ['abc'])
                 outerself.assertEqual(permission, 'view')
                 return True
+
         policy = DummyPolicy()
-        config = self._makeOne(authorization_policy=policy,
-                               authentication_policy=policy,
-                               autocommit=True)
+        config = self._makeOne(
+            authorization_policy=policy,
+            authentication_policy=policy,
+            autocommit=True,
+        )
         config.add_view(view=view1, permission='view', renderer=null_renderer)
         view = self._getViewCallable(config)
         request = self._makeRequest(config)
@@ -1719,22 +2092,28 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_default_permission_no_explicit_permission(self):
         from pyramid.renderers import null_renderer
+
         view1 = lambda *arg: 'OK'
         outerself = self
+
         class DummyPolicy(object):
             def effective_principals(self, r):
                 outerself.assertEqual(r, request)
                 return ['abc']
+
             def permits(self, context, principals, permission):
                 outerself.assertEqual(context, None)
                 outerself.assertEqual(principals, ['abc'])
                 outerself.assertEqual(permission, 'view')
                 return True
+
         policy = DummyPolicy()
-        config = self._makeOne(authorization_policy=policy,
-                               authentication_policy=policy,
-                               default_permission='view',
-                               autocommit=True)
+        config = self._makeOne(
+            authorization_policy=policy,
+            authentication_policy=policy,
+            default_permission='view',
+            autocommit=True,
+        )
         config.add_view(view=view1, renderer=null_renderer)
         view = self._getViewCallable(config)
         request = self._makeRequest(config)
@@ -1742,12 +2121,18 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_no_default_permission_no_explicit_permission(self):
         from pyramid.renderers import null_renderer
+
         view1 = lambda *arg: 'OK'
-        class DummyPolicy(object): pass # wont be called
+
+        class DummyPolicy(object):
+            pass  # wont be called
+
         policy = DummyPolicy()
-        config = self._makeOne(authorization_policy=policy,
-                               authentication_policy=policy,
-                               autocommit=True)
+        config = self._makeOne(
+            authorization_policy=policy,
+            authentication_policy=policy,
+            autocommit=True,
+        )
         config.add_view(view=view1, renderer=null_renderer)
         view = self._getViewCallable(config)
         request = self._makeRequest(config)
@@ -1755,13 +2140,19 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_mapper(self):
         from pyramid.renderers import null_renderer
+
         class Mapper(object):
             def __init__(self, **kw):
                 self.__class__.kw = kw
+
             def __call__(self, view):
                 return view
+
         config = self._makeOne(autocommit=True)
-        def view(context, request): return 'OK'
+
+        def view(context, request):
+            return 'OK'
+
         config.add_view(view=view, mapper=Mapper, renderer=null_renderer)
         view = self._getViewCallable(config)
         self.assertEqual(view(None, None), 'OK')
@@ -1771,18 +2162,18 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.renderers import null_renderer
         from pyramid.exceptions import PredicateMismatch
         from zope.interface import directlyProvides
+
         class view(object):
-            __view_defaults__ = {
-                'containment':'tests.test_config.IDummy'
-                }
+            __view_defaults__ = {'containment': 'tests.test_config.IDummy'}
+
             def __init__(self, request):
                 pass
+
             def __call__(self):
                 return 'OK'
+
         config = self._makeOne(autocommit=True)
-        config.add_view(
-            view=view,
-            renderer=null_renderer)
+        config.add_view(view=view, renderer=null_renderer)
         wrapper = self._getViewCallable(config)
         context = DummyContext()
         directlyProvides(context, IDummy)
@@ -1796,10 +2187,12 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.renderers import null_renderer
         from pyramid.exceptions import PredicateMismatch
         from zope.interface import directlyProvides
+
         config = self._makeOne(autocommit=True)
         config.add_view(
             view='tests.test_config.test_views.DummyViewDefaultsClass',
-            renderer=null_renderer)
+            renderer=null_renderer,
+        )
         wrapper = self._getViewCallable(config)
         context = DummyContext()
         directlyProvides(context, IDummy)
@@ -1813,10 +2206,12 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.renderers import null_renderer
         from pyramid.exceptions import PredicateMismatch
         from zope.interface import directlyProvides
+
         config = self._makeOne(autocommit=True)
         config.add_view(
             'tests.test_config.test_views.DummyViewDefaultsClass',
-            renderer=null_renderer)
+            renderer=null_renderer,
+        )
         wrapper = self._getViewCallable(config)
         context = DummyContext()
         directlyProvides(context, IDummy)
@@ -1828,40 +2223,30 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_with_view_config_and_view_defaults_doesnt_conflict(self):
         from pyramid.renderers import null_renderer
+
         class view(object):
-            __view_defaults__ = {
-                'containment':'tests.test_config.IDummy'
-                }
+            __view_defaults__ = {'containment': 'tests.test_config.IDummy'}
+
         class view2(object):
-            __view_defaults__ = {
-                'containment':'tests.test_config.IFactory'
-                }
+            __view_defaults__ = {'containment': 'tests.test_config.IFactory'}
+
         config = self._makeOne(autocommit=False)
-        config.add_view(
-            view=view,
-            renderer=null_renderer)
-        config.add_view(
-            view=view2,
-            renderer=null_renderer)
-        config.commit() # does not raise
+        config.add_view(view=view, renderer=null_renderer)
+        config.add_view(view=view2, renderer=null_renderer)
+        config.commit()  # does not raise
 
     def test_add_view_with_view_config_and_view_defaults_conflicts(self):
         from pyramid.renderers import null_renderer
+
         class view(object):
-            __view_defaults__ = {
-                'containment':'tests.test_config.IDummy'
-                }
+            __view_defaults__ = {'containment': 'tests.test_config.IDummy'}
+
         class view2(object):
-            __view_defaults__ = {
-                'containment':'tests.test_config.IDummy'
-                }
+            __view_defaults__ = {'containment': 'tests.test_config.IDummy'}
+
         config = self._makeOne(autocommit=False)
-        config.add_view(
-            view=view,
-            renderer=null_renderer)
-        config.add_view(
-            view=view2,
-            renderer=null_renderer)
+        config.add_view(view=view, renderer=null_renderer)
+        config.add_view(view=view2, renderer=null_renderer)
         self.assertRaises(ConfigurationConflictError, config.commit)
 
     def test_add_view_class_method_no_attr(self):
@@ -1870,8 +2255,10 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.exceptions import ConfigurationError
 
         config = self._makeOne(autocommit=True)
+
         class DummyViewClass(object):
-            def run(self): pass
+            def run(self):
+                pass
 
         def configure_view():
             config.add_view(view=DummyViewClass.run, renderer=null_renderer)
@@ -1881,41 +2268,62 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_view_exception_only_no_regular_view(self):
         from zope.interface import implementedBy
         from pyramid.renderers import null_renderer
+
         view1 = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view1, context=Exception, exception_only=True,
-                        renderer=null_renderer)
-        view = self._getViewCallable(config, ctx_iface=implementedBy(Exception))
+        config.add_view(
+            view=view1,
+            context=Exception,
+            exception_only=True,
+            renderer=null_renderer,
+        )
+        view = self._getViewCallable(
+            config, ctx_iface=implementedBy(Exception)
+        )
         self.assertTrue(view is None)
 
     def test_add_view_exception_only(self):
         from zope.interface import implementedBy
         from pyramid.renderers import null_renderer
+
         view1 = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_view(view=view1, context=Exception, exception_only=True,
-                        renderer=null_renderer)
+        config.add_view(
+            view=view1,
+            context=Exception,
+            exception_only=True,
+            renderer=null_renderer,
+        )
         view = self._getViewCallable(
-            config, exc_iface=implementedBy(Exception))
+            config, exc_iface=implementedBy(Exception)
+        )
         self.assertEqual(view1, view)
 
     def test_add_view_exception_only_misconfiguration(self):
         view = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
+
         class NotAnException(object):
             pass
+
         self.assertRaises(
             ConfigurationError,
-            config.add_view, view, context=NotAnException, exception_only=True)
+            config.add_view,
+            view,
+            context=NotAnException,
+            exception_only=True,
+        )
 
     def test_add_exception_view(self):
         from zope.interface import implementedBy
         from pyramid.renderers import null_renderer
+
         view1 = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
         config.add_exception_view(view=view1, renderer=null_renderer)
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(Exception))
+            config, exc_iface=implementedBy(Exception)
+        )
         context = Exception()
         request = self._makeRequest(config)
         self.assertEqual(wrapper(context, request), 'OK')
@@ -1923,71 +2331,86 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     def test_add_exception_view_with_subclass(self):
         from zope.interface import implementedBy
         from pyramid.renderers import null_renderer
+
         view1 = lambda *arg: 'OK'
         config = self._makeOne(autocommit=True)
-        config.add_exception_view(view=view1, context=ValueError,
-                                  renderer=null_renderer)
+        config.add_exception_view(
+            view=view1, context=ValueError, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(ValueError))
+            config, exc_iface=implementedBy(ValueError)
+        )
         context = ValueError()
         request = self._makeRequest(config)
         self.assertEqual(wrapper(context, request), 'OK')
 
     def test_add_exception_view_disallows_name(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_exception_view,
-                          context=Exception(),
-                          name='foo')
+        self.assertRaises(
+            ConfigurationError,
+            config.add_exception_view,
+            context=Exception(),
+            name='foo',
+        )
 
     def test_add_exception_view_disallows_permission(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_exception_view,
-                          context=Exception(),
-                          permission='foo')
+        self.assertRaises(
+            ConfigurationError,
+            config.add_exception_view,
+            context=Exception(),
+            permission='foo',
+        )
 
     def test_add_exception_view_disallows_require_csrf(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_exception_view,
-                          context=Exception(),
-                          require_csrf=True)
+        self.assertRaises(
+            ConfigurationError,
+            config.add_exception_view,
+            context=Exception(),
+            require_csrf=True,
+        )
 
     def test_add_exception_view_disallows_for_(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_exception_view,
-                          context=Exception(),
-                          for_='foo')
+        self.assertRaises(
+            ConfigurationError,
+            config.add_exception_view,
+            context=Exception(),
+            for_='foo',
+        )
 
     def test_add_exception_view_disallows_exception_only(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_exception_view,
-                          context=Exception(),
-                          exception_only=True)
+        self.assertRaises(
+            ConfigurationError,
+            config.add_exception_view,
+            context=Exception(),
+            exception_only=True,
+        )
 
     def test_add_exception_view_with_view_defaults(self):
         from pyramid.renderers import null_renderer
         from pyramid.exceptions import PredicateMismatch
         from zope.interface import directlyProvides
         from zope.interface import implementedBy
+
         class view(object):
-            __view_defaults__ = {
-                'containment': 'tests.test_config.IDummy'
-                }
+            __view_defaults__ = {'containment': 'tests.test_config.IDummy'}
+
             def __init__(self, request):
                 pass
+
             def __call__(self):
                 return 'OK'
+
         config = self._makeOne(autocommit=True)
         config.add_exception_view(
-            view=view,
-            context=Exception,
-            renderer=null_renderer)
+            view=view, context=Exception, renderer=null_renderer
+        )
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(Exception))
+            config, exc_iface=implementedBy(Exception)
+        )
         context = DummyContext()
         directlyProvides(context, IDummy)
         request = self._makeRequest(config)
@@ -1998,8 +2421,10 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_derive_view_function(self):
         from pyramid.renderers import null_renderer
+
         def view(request):
             return 'OK'
+
         config = self._makeOne()
         result = config.derive_view(view, renderer=null_renderer)
         self.assertFalse(result is view)
@@ -2007,37 +2432,48 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_derive_view_dottedname(self):
         from pyramid.renderers import null_renderer
+
         config = self._makeOne()
         result = config.derive_view(
-            'tests.test_config.dummy_view',
-            renderer=null_renderer)
+            'tests.test_config.dummy_view', renderer=null_renderer
+        )
         self.assertFalse(result is dummy_view)
         self.assertEqual(result(None, None), 'OK')
 
     def test_derive_view_with_default_renderer_no_explicit_renderer(self):
         config = self._makeOne()
+
         class moo(object):
             def __init__(self, view):
                 pass
+
             def __call__(self, *arg, **kw):
                 return 'moo'
+
         config.add_renderer(None, moo)
         config.commit()
+
         def view(request):
             return 'OK'
+
         result = config.derive_view(view)
         self.assertFalse(result is view)
         self.assertEqual(result(None, None).body, b'moo')
 
     def test_derive_view_with_default_renderer_with_explicit_renderer(self):
-        class moo(object): pass
+        class moo(object):
+            pass
+
         class foo(object):
             def __init__(self, view):
                 pass
+
             def __call__(self, *arg, **kw):
                 return b'foo'
+
         def view(request):
             return 'OK'
+
         config = self._makeOne()
         config.add_renderer(None, moo)
         config.add_renderer('foo', foo)
@@ -2052,64 +2488,71 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from zope.interface import Interface
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
+
         config = self._makeOne(autocommit=True)
         config.add_static_view('static', 'files', renderer=null_renderer)
         request_type = self._getRouteRequestIface(config, '__static/')
         self._assertRoute(config, '__static/', 'static/*subpath')
         wrapped = config.registry.adapters.lookup(
-            (IViewClassifier, request_type, Interface), IView, name='')
+            (IViewClassifier, request_type, Interface), IView, name=''
+        )
         from pyramid.request import Request
+
         request = Request.blank('/static/minimal.txt')
-        request.subpath = ('minimal.txt', )
+        request.subpath = ('minimal.txt',)
         result = wrapped(None, request)
         self.assertEqual(result.status, '200 OK')
         self.assertTrue(result.body.startswith(b'<div'))
 
     def test_add_static_view_package_relative(self):
         from pyramid.interfaces import IStaticURLInfo
+
         info = DummyStaticURLInfo()
         config = self._makeOne(autocommit=True)
         config.registry.registerUtility(info, IStaticURLInfo)
-        config.add_static_view('static',
-                               'tests.test_config:files')
+        config.add_static_view('static', 'tests.test_config:files')
         self.assertEqual(
-            info.added,
-            [(config, 'static', 'tests.test_config:files', {})])
+            info.added, [(config, 'static', 'tests.test_config:files', {})]
+        )
 
     def test_add_static_view_package_here_relative(self):
         from pyramid.interfaces import IStaticURLInfo
+
         info = DummyStaticURLInfo()
         config = self._makeOne(autocommit=True)
         config.registry.registerUtility(info, IStaticURLInfo)
         config.add_static_view('static', 'files')
         self.assertEqual(
-            info.added,
-            [(config, 'static', 'tests.test_config:files', {})])
+            info.added, [(config, 'static', 'tests.test_config:files', {})]
+        )
 
     def test_add_static_view_absolute(self):
         import os
         from pyramid.interfaces import IStaticURLInfo
+
         info = DummyStaticURLInfo()
         config = self._makeOne(autocommit=True)
         config.registry.registerUtility(info, IStaticURLInfo)
         here = os.path.dirname(__file__)
         static_path = os.path.join(here, 'files')
         config.add_static_view('static', static_path)
-        self.assertEqual(info.added,
-                         [(config, 'static', static_path, {})])
+        self.assertEqual(info.added, [(config, 'static', static_path, {})])
 
     def test_add_forbidden_view(self):
         from pyramid.renderers import null_renderer
         from zope.interface import implementedBy
         from pyramid.interfaces import IRequest
         from pyramid.httpexceptions import HTTPForbidden
+
         config = self._makeOne(autocommit=True)
         view = lambda *arg: 'OK'
         config.add_forbidden_view(view, renderer=null_renderer)
         request = self._makeRequest(config)
-        view = self._getViewCallable(config,
-                                     exc_iface=implementedBy(HTTPForbidden),
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config,
+            exc_iface=implementedBy(HTTPForbidden),
+            request_iface=IRequest,
+        )
         result = view(None, request)
         self.assertEqual(result, 'OK')
 
@@ -2117,19 +2560,23 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from zope.interface import implementedBy
         from pyramid.interfaces import IRequest
         from pyramid.httpexceptions import HTTPForbidden
+
         config = self._makeOne(autocommit=True)
         config.setup_registry()
         config.add_forbidden_view()
         request = self._makeRequest(config)
-        view = self._getViewCallable(config,
-                                     exc_iface=implementedBy(HTTPForbidden),
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config,
+            exc_iface=implementedBy(HTTPForbidden),
+            request_iface=IRequest,
+        )
         context = HTTPForbidden()
         result = view(context, request)
         self.assertEqual(result, context)
 
     def test_add_forbidden_view_allows_other_predicates(self):
         from pyramid.renderers import null_renderer
+
         config = self._makeOne(autocommit=True)
         # doesnt blow up
         config.add_view_predicate('dummy', DummyPredicate)
@@ -2137,28 +2584,33 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_forbidden_view_disallows_name(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_forbidden_view, name='foo')
+        self.assertRaises(
+            ConfigurationError, config.add_forbidden_view, name='foo'
+        )
 
     def test_add_forbidden_view_disallows_permission(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_forbidden_view, permission='foo')
+        self.assertRaises(
+            ConfigurationError, config.add_forbidden_view, permission='foo'
+        )
 
     def test_add_forbidden_view_disallows_require_csrf(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_forbidden_view, require_csrf=True)
+        self.assertRaises(
+            ConfigurationError, config.add_forbidden_view, require_csrf=True
+        )
 
     def test_add_forbidden_view_disallows_context(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_forbidden_view, context='foo')
+        self.assertRaises(
+            ConfigurationError, config.add_forbidden_view, context='foo'
+        )
 
     def test_add_forbidden_view_disallows_for_(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_forbidden_view, for_='foo')
+        self.assertRaises(
+            ConfigurationError, config.add_forbidden_view, for_='foo'
+        )
 
     def test_add_forbidden_view_with_view_defaults(self):
         from pyramid.interfaces import IRequest
@@ -2167,21 +2619,23 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.httpexceptions import HTTPForbidden
         from zope.interface import directlyProvides
         from zope.interface import implementedBy
+
         class view(object):
-            __view_defaults__ = {
-                'containment':'tests.test_config.IDummy'
-                }
+            __view_defaults__ = {'containment': 'tests.test_config.IDummy'}
+
             def __init__(self, request):
                 pass
+
             def __call__(self):
                 return 'OK'
+
         config = self._makeOne(autocommit=True)
-        config.add_forbidden_view(
-            view=view,
-            renderer=null_renderer)
+        config.add_forbidden_view(view=view, renderer=null_renderer)
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(HTTPForbidden),
-            request_iface=IRequest)
+            config,
+            exc_iface=implementedBy(HTTPForbidden),
+            request_iface=IRequest,
+        )
         context = DummyContext()
         directlyProvides(context, IDummy)
         request = self._makeRequest(config)
@@ -2195,13 +2649,16 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from zope.interface import implementedBy
         from pyramid.interfaces import IRequest
         from pyramid.httpexceptions import HTTPNotFound
+
         config = self._makeOne(autocommit=True)
         view = lambda *arg: arg
         config.add_notfound_view(view, renderer=null_renderer)
         request = self._makeRequest(config)
-        view = self._getViewCallable(config,
-                                     exc_iface=implementedBy(HTTPNotFound),
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config,
+            exc_iface=implementedBy(HTTPNotFound),
+            request_iface=IRequest,
+        )
         result = view(None, request)
         self.assertEqual(result, (None, request))
 
@@ -2209,19 +2666,23 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from zope.interface import implementedBy
         from pyramid.interfaces import IRequest
         from pyramid.httpexceptions import HTTPNotFound
+
         config = self._makeOne(autocommit=True)
         config.setup_registry()
         config.add_notfound_view()
         request = self._makeRequest(config)
-        view = self._getViewCallable(config,
-                                     exc_iface=implementedBy(HTTPNotFound),
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config,
+            exc_iface=implementedBy(HTTPNotFound),
+            request_iface=IRequest,
+        )
         context = HTTPNotFound()
         result = view(context, request)
         self.assertEqual(result, context)
 
     def test_add_notfound_view_allows_other_predicates(self):
         from pyramid.renderers import null_renderer
+
         config = self._makeOne(autocommit=True)
         # doesnt blow up
         config.add_view_predicate('dummy', DummyPredicate)
@@ -2229,28 +2690,33 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_notfound_view_disallows_name(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_notfound_view, name='foo')
+        self.assertRaises(
+            ConfigurationError, config.add_notfound_view, name='foo'
+        )
 
     def test_add_notfound_view_disallows_permission(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_notfound_view, permission='foo')
+        self.assertRaises(
+            ConfigurationError, config.add_notfound_view, permission='foo'
+        )
 
     def test_add_notfound_view_disallows_require_csrf(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_notfound_view, require_csrf=True)
+        self.assertRaises(
+            ConfigurationError, config.add_notfound_view, require_csrf=True
+        )
 
     def test_add_notfound_view_disallows_context(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_notfound_view, context='foo')
+        self.assertRaises(
+            ConfigurationError, config.add_notfound_view, context='foo'
+        )
 
     def test_add_notfound_view_disallows_for_(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(ConfigurationError,
-                          config.add_notfound_view, for_='foo')
+        self.assertRaises(
+            ConfigurationError, config.add_notfound_view, for_='foo'
+        )
 
     def test_add_notfound_view_append_slash(self):
         from pyramid.response import Response
@@ -2258,17 +2724,25 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from zope.interface import implementedBy
         from pyramid.interfaces import IRequest
         from pyramid.httpexceptions import HTTPTemporaryRedirect, HTTPNotFound
+
         config = self._makeOne(autocommit=True)
         config.add_route('foo', '/foo/')
-        def view(request): return Response('OK')
-        config.add_notfound_view(view, renderer=null_renderer,append_slash=True)
+
+        def view(request):
+            return Response('OK')
+
+        config.add_notfound_view(
+            view, renderer=null_renderer, append_slash=True
+        )
         request = self._makeRequest(config)
         request.environ['PATH_INFO'] = '/foo'
         request.query_string = 'a=1&b=2'
         request.path = '/scriptname/foo'
-        view = self._getViewCallable(config,
-                                     exc_iface=implementedBy(HTTPNotFound),
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config,
+            exc_iface=implementedBy(HTTPNotFound),
+            request_iface=IRequest,
+        )
         result = view(None, request)
         self.assertTrue(isinstance(result, HTTPTemporaryRedirect))
         self.assertEqual(result.location, '/scriptname/foo/?a=1&b=2')
@@ -2279,19 +2753,25 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from zope.interface import implementedBy
         from pyramid.interfaces import IRequest
         from pyramid.httpexceptions import HTTPMovedPermanently, HTTPNotFound
+
         config = self._makeOne(autocommit=True)
         config.add_route('foo', '/foo/')
-        def view(request): return Response('OK')
+
+        def view(request):
+            return Response('OK')
+
         config.add_notfound_view(
-            view, renderer=null_renderer,append_slash=HTTPMovedPermanently
+            view, renderer=null_renderer, append_slash=HTTPMovedPermanently
         )
         request = self._makeRequest(config)
         request.environ['PATH_INFO'] = '/foo'
         request.query_string = 'a=1&b=2'
         request.path = '/scriptname/foo'
-        view = self._getViewCallable(config,
-                                     exc_iface=implementedBy(HTTPNotFound),
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config,
+            exc_iface=implementedBy(HTTPNotFound),
+            request_iface=IRequest,
+        )
         result = view(None, request)
         self.assertTrue(isinstance(result, HTTPMovedPermanently))
         self.assertEqual(result.location, '/scriptname/foo/?a=1&b=2')
@@ -2303,21 +2783,23 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from pyramid.httpexceptions import HTTPNotFound
         from zope.interface import directlyProvides
         from zope.interface import implementedBy
+
         class view(object):
-            __view_defaults__ = {
-                'containment':'tests.test_config.IDummy'
-                }
+            __view_defaults__ = {'containment': 'tests.test_config.IDummy'}
+
             def __init__(self, request):
                 pass
+
             def __call__(self):
                 return 'OK'
+
         config = self._makeOne(autocommit=True)
-        config.add_notfound_view(
-            view=view,
-            renderer=null_renderer)
+        config.add_notfound_view(view=view, renderer=null_renderer)
         wrapper = self._getViewCallable(
-            config, exc_iface=implementedBy(HTTPNotFound),
-            request_iface=IRequest)
+            config,
+            exc_iface=implementedBy(HTTPNotFound),
+            request_iface=IRequest,
+        )
         context = DummyContext()
         directlyProvides(context, IDummy)
         request = self._makeRequest(config)
@@ -2329,6 +2811,7 @@ class TestViewsConfigurationMixin(unittest.TestCase):
     # Since Python 3 has to be all cool and fancy and different...
     def _assertBody(self, response, value):
         from pyramid.compat import text_type
+
         if isinstance(value, text_type):  # pragma: no cover
             self.assertEqual(response.text, value)
         else:  # pragma: no cover
@@ -2338,16 +2821,17 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from zope.interface import implementedBy
         from pyramid.interfaces import IRequest
         from pyramid.httpexceptions import HTTPNotFound
+
         config = self._makeOne(autocommit=True)
         view = lambda *arg: {}
         config.introspection = False
-        config.add_notfound_view(
-            view,
-            renderer='json')
+        config.add_notfound_view(view, renderer='json')
         request = self._makeRequest(config)
-        view = self._getViewCallable(config,
-                                     exc_iface=implementedBy(HTTPNotFound),
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config,
+            exc_iface=implementedBy(HTTPNotFound),
+            request_iface=IRequest,
+        )
         result = view(None, request)
         self._assertBody(result, '{}')
 
@@ -2355,21 +2839,23 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         from zope.interface import implementedBy
         from pyramid.interfaces import IRequest
         from pyramid.httpexceptions import HTTPForbidden
+
         config = self._makeOne(autocommit=True)
         view = lambda *arg: {}
         config.introspection = False
-        config.add_forbidden_view(
-            view,
-            renderer='json')
+        config.add_forbidden_view(view, renderer='json')
         request = self._makeRequest(config)
-        view = self._getViewCallable(config,
-                                     exc_iface=implementedBy(HTTPForbidden),
-                                     request_iface=IRequest)
+        view = self._getViewCallable(
+            config,
+            exc_iface=implementedBy(HTTPForbidden),
+            request_iface=IRequest,
+        )
         result = view(None, request)
         self._assertBody(result, '{}')
 
     def test_set_view_mapper(self):
         from pyramid.interfaces import IViewMapperFactory
+
         config = self._makeOne(autocommit=True)
         mapper = object()
         config.set_view_mapper(mapper)
@@ -2378,15 +2864,18 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_set_view_mapper_dottedname(self):
         from pyramid.interfaces import IViewMapperFactory
+
         config = self._makeOne(autocommit=True)
         config.set_view_mapper('tests.test_config')
         result = config.registry.getUtility(IViewMapperFactory)
         from tests import test_config
+
         self.assertEqual(result, test_config)
 
     def test_add_normal_and_exception_view_intr_derived_callable(self):
         from pyramid.renderers import null_renderer
         from pyramid.exceptions import BadCSRFToken
+
         config = self._makeOne(autocommit=True)
         introspector = DummyIntrospector()
         config.introspector = introspector
@@ -2410,27 +2899,33 @@ class TestViewsConfigurationMixin(unittest.TestCase):
 
     def test_add_view_does_not_accept_iterable_accept(self):
         from pyramid.exceptions import ConfigurationError
+
         config = self._makeOne(autocommit=True)
         self.assertRaises(
-            ConfigurationError, config.add_view, accept=['image/*', 'text/*'],
+            ConfigurationError, config.add_view, accept=['image/*', 'text/*']
         )
 
     def test_default_accept_view_order(self):
         from pyramid.interfaces import IAcceptOrder
+
         config = self._makeOne(autocommit=True)
         order = config.registry.getUtility(IAcceptOrder)
         result = [v for _, v in order.sorted()]
-        self.assertEqual(result, [
-            'text/html',
-            'application/xhtml+xml',
-            'application/xml',
-            'text/xml',
-            'text/plain',
-            'application/json',
-        ])
+        self.assertEqual(
+            result,
+            [
+                'text/html',
+                'application/xhtml+xml',
+                'application/xml',
+                'text/xml',
+                'text/plain',
+                'application/json',
+            ],
+        )
 
     def test_add_accept_view_order_override(self):
         from pyramid.interfaces import IAcceptOrder
+
         config = self._makeOne(autocommit=False)
         config.add_accept_view_order(
             'text/html',
@@ -2440,57 +2935,75 @@ class TestViewsConfigurationMixin(unittest.TestCase):
         config.commit()
         order = config.registry.getUtility(IAcceptOrder)
         result = [v for _, v in order.sorted()]
-        self.assertEqual(result, [
-            'application/xhtml+xml',
-            'application/xml',
-            'text/html',
-            'text/xml',
-            'text/plain',
-            'application/json',
-        ])
+        self.assertEqual(
+            result,
+            [
+                'application/xhtml+xml',
+                'application/xml',
+                'text/html',
+                'text/xml',
+                'text/plain',
+                'application/json',
+            ],
+        )
 
     def test_add_accept_view_order_throws_on_wildcard(self):
         config = self._makeOne(autocommit=True)
-        self.assertRaises(
-            ValueError, config.add_accept_view_order, '*/*',
-        )
+        self.assertRaises(ValueError, config.add_accept_view_order, '*/*')
 
     def test_add_accept_view_order_throws_on_type_mismatch(self):
         config = self._makeOne(autocommit=True)
         self.assertRaises(
-            ValueError, config.add_accept_view_order,
-            'text/*', weighs_more_than='text/html',
+            ValueError,
+            config.add_accept_view_order,
+            'text/*',
+            weighs_more_than='text/html',
         )
         self.assertRaises(
-            ValueError, config.add_accept_view_order,
-            'text/html', weighs_less_than='application/*',
+            ValueError,
+            config.add_accept_view_order,
+            'text/html',
+            weighs_less_than='application/*',
         )
         self.assertRaises(
-            ConfigurationError, config.add_accept_view_order,
-            'text/html', weighs_more_than='text/html;charset=utf8',
+            ConfigurationError,
+            config.add_accept_view_order,
+            'text/html',
+            weighs_more_than='text/html;charset=utf8',
         )
         self.assertRaises(
-            ConfigurationError, config.add_accept_view_order,
+            ConfigurationError,
+            config.add_accept_view_order,
             'text/html;charset=utf8',
             weighs_more_than='text/plain;charset=utf8',
         )
 
+
 class Test_runtime_exc_view(unittest.TestCase):
     def _makeOne(self, view1, view2):
         from pyramid.config.views import runtime_exc_view
+
         return runtime_exc_view(view1, view2)
 
     def test_call(self):
-        def view1(context, request): return 'OK'
-        def view2(context, request): raise AssertionError
+        def view1(context, request):
+            return 'OK'
+
+        def view2(context, request):
+            raise AssertionError
+
         result_view = self._makeOne(view1, view2)
         request = DummyRequest()
         result = result_view(None, request)
         self.assertEqual(result, 'OK')
 
     def test_call_dispatches_on_exception(self):
-        def view1(context, request): raise AssertionError
-        def view2(context, request): return 'OK'
+        def view1(context, request):
+            raise AssertionError
+
+        def view2(context, request):
+            return 'OK'
+
         result_view = self._makeOne(view1, view2)
         request = DummyRequest()
         request.exception = Exception()
@@ -2498,10 +3011,17 @@ class Test_runtime_exc_view(unittest.TestCase):
         self.assertEqual(result, 'OK')
 
     def test_permitted(self):
-        def errfn(context, request): raise AssertionError
-        def view1(context, request): raise AssertionError
+        def errfn(context, request):
+            raise AssertionError
+
+        def view1(context, request):
+            raise AssertionError
+
         view1.__permitted__ = lambda c, r: 'OK'
-        def view2(context, request): raise AssertionError
+
+        def view2(context, request):
+            raise AssertionError
+
         view2.__permitted__ = errfn
         result_view = self._makeOne(view1, view2)
         request = DummyRequest()
@@ -2509,10 +3029,17 @@ class Test_runtime_exc_view(unittest.TestCase):
         self.assertEqual(result, 'OK')
 
     def test_permitted_dispatches_on_exception(self):
-        def errfn(context, request): raise AssertionError
-        def view1(context, request): raise AssertionError
+        def errfn(context, request):
+            raise AssertionError
+
+        def view1(context, request):
+            raise AssertionError
+
         view1.__permitted__ = errfn
-        def view2(context, request): raise AssertionError
+
+        def view2(context, request):
+            raise AssertionError
+
         view2.__permitted__ = lambda c, r: 'OK'
         result_view = self._makeOne(view1, view2)
         request = DummyRequest()
@@ -2520,50 +3047,67 @@ class Test_runtime_exc_view(unittest.TestCase):
         result = result_view.__permitted__(None, request)
         self.assertEqual(result, 'OK')
 
+
 class Test_requestonly(unittest.TestCase):
     def _callFUT(self, view, attr=None):
         from pyramid.config.views import requestonly
+
         return requestonly(view, attr=attr)
 
     def test_defaults(self):
-        def aview(request, a=1, b=2): pass
+        def aview(request, a=1, b=2):
+            pass
+
         self.assertTrue(self._callFUT(aview))
 
     def test_otherattr(self):
         class AView(object):
-            def __init__(self, request, a=1, b=2): pass
-            def bleh(self): pass
+            def __init__(self, request, a=1, b=2):
+                pass
+
+            def bleh(self):
+                pass
+
         self.assertTrue(self._callFUT(AView, 'bleh'))
 
+
 class Test_isexception(unittest.TestCase):
     def _callFUT(self, ob):
         from pyramid.config.views import isexception
+
         return isexception(ob)
 
     def test_is_exception_instance(self):
         class E(Exception):
             pass
+
         e = E()
         self.assertEqual(self._callFUT(e), True)
 
     def test_is_exception_class(self):
         class E(Exception):
             pass
+
         self.assertEqual(self._callFUT(E), True)
 
     def test_is_IException(self):
         from pyramid.interfaces import IException
+
         self.assertEqual(self._callFUT(IException), True)
 
     def test_is_IException_subinterface(self):
         from pyramid.interfaces import IException
+
         class ISubException(IException):
             pass
+
         self.assertEqual(self._callFUT(ISubException), True)
 
+
 class TestMultiView(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.config.views import MultiView
+
         return MultiView
 
     def _makeOne(self, name='name'):
@@ -2572,11 +3116,13 @@ class TestMultiView(unittest.TestCase):
     def test_class_implements_ISecuredView(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import ISecuredView
+
         verifyClass(ISecuredView, self._getTargetClass())
 
     def test_instance_implements_ISecuredView(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import ISecuredView
+
         verifyObject(ISecuredView, self._makeOne())
 
     def test_add(self):
@@ -2588,15 +3134,19 @@ class TestMultiView(unittest.TestCase):
         mv.add('view3', 100, accept='text/html')
         self.assertEqual(mv.media_views['text/html'], [(100, 'view3', None)])
         mv.add('view4', 99, 'abc', accept='text/html')
-        self.assertEqual(mv.media_views['text/html'],
-                         [(99, 'view4', 'abc'), (100, 'view3', None)])
+        self.assertEqual(
+            mv.media_views['text/html'],
+            [(99, 'view4', 'abc'), (100, 'view3', None)],
+        )
         mv.add('view5', 100, accept='text/xml')
         self.assertEqual(mv.media_views['text/xml'], [(100, 'view5', None)])
         self.assertEqual(set(mv.accepts), set(['text/xml', 'text/html']))
         self.assertEqual(mv.views, [(99, 'view2', None), (100, 'view', None)])
         mv.add('view6', 98, accept='text/*')
-        self.assertEqual(mv.views, [
-            (98, 'view6', None), (99, 'view2', None), (100, 'view', None)])
+        self.assertEqual(
+            mv.views,
+            [(98, 'view6', None), (99, 'view2', None), (100, 'view', None)],
+        )
 
     def test_add_with_phash(self):
         mv = self._makeOne()
@@ -2605,43 +3155,64 @@ class TestMultiView(unittest.TestCase):
         mv.add('view', 100, phash='abc')
         self.assertEqual(mv.views, [(100, 'view', 'abc')])
         mv.add('view', 100, phash='def')
-        self.assertEqual(mv.views, [(100, 'view', 'abc'),
-                                    (100, 'view', 'def')])
+        self.assertEqual(
+            mv.views, [(100, 'view', 'abc'), (100, 'view', 'def')]
+        )
         mv.add('view', 100, phash='abc')
-        self.assertEqual(mv.views, [(100, 'view', 'abc'),
-                                    (100, 'view', 'def')])
+        self.assertEqual(
+            mv.views, [(100, 'view', 'abc'), (100, 'view', 'def')]
+        )
 
     def test_add_with_phash_override_accept(self):
         mv = self._makeOne()
-        def view1(): pass
-        def view2(): pass
-        def view3(): pass
+
+        def view1():
+            pass
+
+        def view2():
+            pass
+
+        def view3():
+            pass
+
         mv.add(view1, 100, accept='text/html', phash='abc')
         mv.add(view2, 100, accept='text/html', phash='abc')
         mv.add(view3, 99, accept='text/html', phash='def')
-        self.assertEqual(mv.media_views['text/html'],
-                         [(99, view3, 'def'), (100, view2, 'abc')])
+        self.assertEqual(
+            mv.media_views['text/html'],
+            [(99, view3, 'def'), (100, view2, 'abc')],
+        )
 
     def test_add_with_phash_override_accept2(self):
         mv = self._makeOne()
-        def view1(): pass
-        def view2(): pass
-        def view3(): pass
+
+        def view1():
+            pass
+
+        def view2():
+            pass
+
+        def view3():
+            pass
+
         mv.add(view1, 100, accept='text/html', phash='abc')
         mv.add(view2, 100, accept='text/html', phash='def')
         mv.add(view3, 99, accept='text/html', phash='ghi')
-        self.assertEqual(mv.media_views['text/html'],
-                         [(99, view3, 'ghi'),
-                          (100, view1, 'abc'),
-                          (100, view2, 'def')]
-                         )
+        self.assertEqual(
+            mv.media_views['text/html'],
+            [(99, view3, 'ghi'), (100, view1, 'abc'), (100, view2, 'def')],
+        )
 
     def test_multiple_with_functions_as_views(self):
         # this failed on py3 at one point, because functions aren't orderable
         # and we were sorting the views via a plain sort() rather than
         # sort(key=itemgetter(0)).
-        def view1(request): pass
-        def view2(request): pass
+        def view1(request):
+            pass
+
+        def view2(request):
+            pass
+
         mv = self._makeOne()
         mv.add(view1, 100, None)
         self.assertEqual(mv.views, [(100, view1, None)])
@@ -2682,6 +3253,7 @@ class TestMultiView(unittest.TestCase):
 
     def test_match_not_found(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         mv = self._makeOne()
         context = DummyContext()
         request = DummyRequest()
@@ -2689,9 +3261,12 @@ class TestMultiView(unittest.TestCase):
 
     def test_match_predicate_fails(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         mv = self._makeOne()
+
         def view(context, request):
             """ """
+
         view.__predicated__ = lambda *arg: False
         mv.views = [(100, view, None)]
         context = DummyContext()
@@ -2700,8 +3275,10 @@ class TestMultiView(unittest.TestCase):
 
     def test_match_predicate_succeeds(self):
         mv = self._makeOne()
+
         def view(context, request):
             """ """
+
         view.__predicated__ = lambda *arg: True
         mv.views = [(100, view, None)]
         context = DummyContext()
@@ -2711,6 +3288,7 @@ class TestMultiView(unittest.TestCase):
 
     def test_permitted_no_views(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         mv = self._makeOne()
         context = DummyContext()
         request = DummyRequest()
@@ -2718,17 +3296,22 @@ class TestMultiView(unittest.TestCase):
 
     def test_permitted_no_match_with__permitted__(self):
         mv = self._makeOne()
+
         def view(context, request):
             """ """
+
         mv.views = [(100, view, None)]
         self.assertEqual(mv.__permitted__(None, None), True)
 
     def test_permitted(self):
         mv = self._makeOne()
+
         def view(context, request):
             """ """
+
         def permitted(context, request):
             return False
+
         view.__permitted__ = permitted
         mv.views = [(100, view, None)]
         context = DummyContext()
@@ -2738,6 +3321,7 @@ class TestMultiView(unittest.TestCase):
 
     def test__call__not_found(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         mv = self._makeOne()
         context = DummyContext()
         request = DummyRequest()
@@ -2745,29 +3329,37 @@ class TestMultiView(unittest.TestCase):
 
     def test___call__intermediate_not_found(self):
         from pyramid.exceptions import PredicateMismatch
+
         mv = self._makeOne()
         context = DummyContext()
         request = DummyRequest()
         request.view_name = ''
         expected_response = DummyResponse()
+
         def view1(context, request):
             raise PredicateMismatch
+
         def view2(context, request):
             return expected_response
+
         mv.views = [(100, view1, None), (99, view2, None)]
         response = mv(context, request)
         self.assertEqual(response, expected_response)
 
     def test___call__raise_not_found_isnt_interpreted_as_pred_mismatch(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         mv = self._makeOne()
         context = DummyContext()
         request = DummyRequest()
         request.view_name = ''
+
         def view1(context, request):
-            raise  HTTPNotFound
+            raise HTTPNotFound
+
         def view2(context, request):
             """ """
+
         mv.views = [(100, view1, None), (99, view2, None)]
         self.assertRaises(HTTPNotFound, mv, context, request)
 
@@ -2777,14 +3369,17 @@ class TestMultiView(unittest.TestCase):
         request = DummyRequest()
         request.view_name = ''
         expected_response = DummyResponse()
+
         def view(context, request):
             return expected_response
+
         mv.views = [(100, view, None)]
         response = mv(context, request)
         self.assertEqual(response, expected_response)
 
     def test__call_permissive__not_found(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         mv = self._makeOne()
         context = DummyContext()
         request = DummyRequest()
@@ -2796,10 +3391,13 @@ class TestMultiView(unittest.TestCase):
         request = DummyRequest()
         request.view_name = ''
         expected_response = DummyResponse()
+
         def view(context, request):
             """ """
+
         def permissive(context, request):
             return expected_response
+
         view.__call_permissive__ = permissive
         mv.views = [(100, view, None)]
         response = mv.__call_permissive__(context, request)
@@ -2811,8 +3409,10 @@ class TestMultiView(unittest.TestCase):
         request = DummyRequest()
         request.view_name = ''
         expected_response = DummyResponse()
+
         def view(context, request):
             return expected_response
+
         mv.views = [(100, view, None)]
         response = mv.__call_permissive__(context, request)
         self.assertEqual(response, expected_response)
@@ -2823,8 +3423,10 @@ class TestMultiView(unittest.TestCase):
         request = DummyRequest()
         request.accept = DummyAccept('text/html', 'text/xml')
         expected_response = DummyResponse()
+
         def view(context, request):
             return expected_response
+
         mv.views = [(100, None)]
         mv.media_views['text/xml'] = [(100, view, None)]
         mv.accepts = ['text/xml']
@@ -2837,8 +3439,10 @@ class TestMultiView(unittest.TestCase):
         request = DummyRequest()
         request.accept = DummyAccept('text/plain', 'text/html')
         expected_response = DummyResponse()
+
         def view(context, request):
             return expected_response
+
         mv.views = [(100, view, None)]
         mv.media_views['text/xml'] = [(100, None, None)]
         mv.accepts = ['text/xml']
@@ -2846,7 +3450,6 @@ class TestMultiView(unittest.TestCase):
         self.assertEqual(response, expected_response)
 
 
-
 class TestDefaultViewMapper(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -2858,6 +3461,7 @@ class TestDefaultViewMapper(unittest.TestCase):
 
     def _makeOne(self, **kw):
         from pyramid.config.views import DefaultViewMapper
+
         kw['registry'] = self.registry
         return DefaultViewMapper(**kw)
 
@@ -2869,6 +3473,7 @@ class TestDefaultViewMapper(unittest.TestCase):
     def test_view_as_function_context_and_request(self):
         def view(context, request):
             return 'OK'
+
         mapper = self._makeOne()
         result = mapper(view)
         self.assertTrue(result is view)
@@ -2878,6 +3483,7 @@ class TestDefaultViewMapper(unittest.TestCase):
     def test__view_as_function_with_attr(self):
         def view(context, request):
             """ """
+
         mapper = self._makeOne(attr='__name__')
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2887,6 +3493,7 @@ class TestDefaultViewMapper(unittest.TestCase):
     def test_view_as_function_requestonly(self):
         def view(request):
             return 'OK'
+
         mapper = self._makeOne()
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2896,6 +3503,7 @@ class TestDefaultViewMapper(unittest.TestCase):
     def test_view_as_function_requestonly_with_attr(self):
         def view(request):
             """ """
+
         mapper = self._makeOne(attr='__name__')
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2906,8 +3514,10 @@ class TestDefaultViewMapper(unittest.TestCase):
         class view(object):
             def __init__(self, context, request):
                 pass
+
             def __call__(self):
                 return 'OK'
+
         mapper = self._makeOne()
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2918,8 +3528,10 @@ class TestDefaultViewMapper(unittest.TestCase):
         class view(object):
             def __init__(self, context, request):
                 pass
+
             def index(self):
                 return 'OK'
+
         mapper = self._makeOne(attr='index')
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2930,8 +3542,10 @@ class TestDefaultViewMapper(unittest.TestCase):
         class view(object):
             def __init__(self, request):
                 pass
+
             def __call__(self):
                 return 'OK'
+
         mapper = self._makeOne()
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2942,8 +3556,10 @@ class TestDefaultViewMapper(unittest.TestCase):
         class view(object):
             def __init__(self, request):
                 pass
+
             def index(self):
                 return 'OK'
+
         mapper = self._makeOne(attr='index')
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2954,8 +3570,10 @@ class TestDefaultViewMapper(unittest.TestCase):
         class view:
             def __init__(self, context, request):
                 pass
+
             def __call__(self):
                 return 'OK'
+
         mapper = self._makeOne()
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2966,8 +3584,10 @@ class TestDefaultViewMapper(unittest.TestCase):
         class view:
             def __init__(self, context, request):
                 pass
+
             def index(self):
                 return 'OK'
+
         mapper = self._makeOne(attr='index')
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2978,8 +3598,10 @@ class TestDefaultViewMapper(unittest.TestCase):
         class view:
             def __init__(self, request):
                 pass
+
             def __call__(self):
                 return 'OK'
+
         mapper = self._makeOne()
         result = mapper(view)
         self.assertFalse(result is view)
@@ -2990,8 +3612,10 @@ class TestDefaultViewMapper(unittest.TestCase):
         class view:
             def __init__(self, request):
                 pass
+
             def index(self):
                 return 'OK'
+
         mapper = self._makeOne(attr='index')
         result = mapper(view)
         self.assertFalse(result is view)
@@ -3002,6 +3626,7 @@ class TestDefaultViewMapper(unittest.TestCase):
         class View:
             def __call__(self, context, request):
                 return 'OK'
+
         view = View()
         mapper = self._makeOne()
         result = mapper(view)
@@ -3013,6 +3638,7 @@ class TestDefaultViewMapper(unittest.TestCase):
         class View:
             def index(self, context, request):
                 return 'OK'
+
         view = View()
         mapper = self._makeOne(attr='index')
         result = mapper(view)
@@ -3024,6 +3650,7 @@ class TestDefaultViewMapper(unittest.TestCase):
         class View:
             def __call__(self, request):
                 return 'OK'
+
         view = View()
         mapper = self._makeOne()
         result = mapper(view)
@@ -3035,6 +3662,7 @@ class TestDefaultViewMapper(unittest.TestCase):
         class View:
             def index(self, request):
                 return 'OK'
+
         view = View()
         mapper = self._makeOne(attr='index')
         result = mapper(view)
@@ -3042,27 +3670,36 @@ class TestDefaultViewMapper(unittest.TestCase):
         request = self._makeRequest()
         self.assertEqual(result(None, request), 'OK')
 
+
 class Test_preserve_view_attrs(unittest.TestCase):
     def _callFUT(self, view, wrapped_view):
         from pyramid.config.views import preserve_view_attrs
+
         return preserve_view_attrs(view, wrapped_view)
 
     def test_it_same(self):
         def view(context, request):
             """ """
+
         result = self._callFUT(view, view)
         self.assertTrue(result is view)
 
     def test_it_view_is_None(self):
         def view(context, request):
             """ """
+
         result = self._callFUT(None, view)
         self.assertTrue(result is view)
 
     def test_it_different_with_existing_original_view(self):
-        def view1(context, request): pass
+        def view1(context, request):
+            pass
+
         view1.__original_view__ = 'abc'
-        def view2(context, request): pass
+
+        def view2(context, request):
+            pass
+
         result = self._callFUT(view1, view2)
         self.assertEqual(result.__original_view__, 'abc')
         self.assertFalse(result is view1)
@@ -3070,28 +3707,40 @@ class Test_preserve_view_attrs(unittest.TestCase):
     def test_it_different(self):
         class DummyView1:
             """ 1 """
+
             __name__ = '1'
             __module__ = '1'
+
             def __call__(self, context, request):
                 """ """
+
             def __call_permissive__(self, context, request):
                 """ """
+
             def __predicated__(self, context, request):
                 """ """
+
             def __permitted__(self, context, request):
                 """ """
+
         class DummyView2:
             """ 2 """
+
             __name__ = '2'
             __module__ = '2'
+
             def __call__(self, context, request):
                 """ """
+
             def __call_permissive__(self, context, request):
                 """ """
+
             def __predicated__(self, context, request):
                 """ """
+
             def __permitted__(self, context, request):
                 """ """
+
         view1 = DummyView1()
         view2 = DummyView2()
         result = self._callFUT(view2, view1)
@@ -3100,17 +3749,24 @@ class Test_preserve_view_attrs(unittest.TestCase):
         self.assertTrue(view1.__doc__ is view2.__doc__)
         self.assertTrue(view1.__module__ is view2.__module__)
         self.assertTrue(view1.__name__ is view2.__name__)
-        self.assertTrue(getattr(view1.__call_permissive__, im_func) is
-                        getattr(view2.__call_permissive__, im_func))
-        self.assertTrue(getattr(view1.__permitted__, im_func) is
-                        getattr(view2.__permitted__, im_func))
-        self.assertTrue(getattr(view1.__predicated__, im_func) is
-                        getattr(view2.__predicated__, im_func))
+        self.assertTrue(
+            getattr(view1.__call_permissive__, im_func)
+            is getattr(view2.__call_permissive__, im_func)
+        )
+        self.assertTrue(
+            getattr(view1.__permitted__, im_func)
+            is getattr(view2.__permitted__, im_func)
+        )
+        self.assertTrue(
+            getattr(view1.__predicated__, im_func)
+            is getattr(view2.__predicated__, im_func)
+        )
 
 
 class TestStaticURLInfo(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.config.views import StaticURLInfo
+
         return StaticURLInfo
 
     def _makeOne(self):
@@ -3124,11 +3780,13 @@ class TestStaticURLInfo(unittest.TestCase):
     def test_verifyClass(self):
         from pyramid.interfaces import IStaticURLInfo
         from zope.interface.verify import verifyClass
+
         verifyClass(IStaticURLInfo, self._getTargetClass())
 
     def test_verifyObject(self):
         from pyramid.interfaces import IStaticURLInfo
         from zope.interface.verify import verifyObject
+
         verifyObject(IStaticURLInfo, self._makeOne())
 
     def test_generate_missing(self):
@@ -3140,27 +3798,33 @@ class TestStaticURLInfo(unittest.TestCase):
         inst = self._makeOne()
         inst.registrations = [
             (None, 'spec', 'route_name'),
-            ('http://example.com/foo/', 'package:path/', None)]
+            ('http://example.com/foo/', 'package:path/', None),
+        ]
         request = self._makeRequest()
         result = inst.generate('package:path/abc', request)
         self.assertEqual(result, 'http://example.com/foo/abc')
 
     def test_generate_slash_in_name1(self):
         inst = self._makeOne()
-        inst.registrations = [('http://example.com/foo/', 'package:path/', None)]
+        inst.registrations = [
+            ('http://example.com/foo/', 'package:path/', None)
+        ]
         request = self._makeRequest()
         result = inst.generate('package:path/abc', request)
         self.assertEqual(result, 'http://example.com/foo/abc')
 
     def test_generate_slash_in_name2(self):
         inst = self._makeOne()
-        inst.registrations = [('http://example.com/foo/', 'package:path/', None)]
+        inst.registrations = [
+            ('http://example.com/foo/', 'package:path/', None)
+        ]
         request = self._makeRequest()
         result = inst.generate('package:path/', request)
         self.assertEqual(result, 'http://example.com/foo/')
 
     def test_generate_quoting(self):
         from pyramid.interfaces import IStaticURLInfo
+
         config = testing.setUp()
         try:
             config.add_static_view('images', path='mypkg:templates')
@@ -3175,10 +3839,12 @@ class TestStaticURLInfo(unittest.TestCase):
     def test_generate_route_url(self):
         inst = self._makeOne()
         inst.registrations = [(None, 'package:path/', '__viewname/')]
+
         def route_url(n, **kw):
             self.assertEqual(n, '__viewname/')
-            self.assertEqual(kw, {'subpath':'abc', 'a':1})
+            self.assertEqual(kw, {'subpath': 'abc', 'a': 1})
             return 'url'
+
         request = self._makeRequest()
         request.route_url = route_url
         result = inst.generate('package:path/abc', request, a=1)
@@ -3187,10 +3853,12 @@ class TestStaticURLInfo(unittest.TestCase):
     def test_generate_url_unquoted_local(self):
         inst = self._makeOne()
         inst.registrations = [(None, 'package:path/', '__viewname/')]
+
         def route_url(n, **kw):
             self.assertEqual(n, '__viewname/')
-            self.assertEqual(kw, {'subpath':'abc def', 'a':1})
+            self.assertEqual(kw, {'subpath': 'abc def', 'a': 1})
             return 'url'
+
         request = self._makeRequest()
         request.route_url = route_url
         result = inst.generate('package:path/abc def', request, a=1)
@@ -3208,72 +3876,101 @@ class TestStaticURLInfo(unittest.TestCase):
         registrations = [('http://example.com/', 'package:path/', None)]
         inst.registrations = registrations
         request = self._makeRequest()
-        result = inst.generate('package:path/abc def', request, a=1,
-                               _query='(openlayers)')
-        self.assertEqual(result,
-                         'http://example.com/abc%20def?(openlayers)')
+        result = inst.generate(
+            'package:path/abc def', request, a=1, _query='(openlayers)'
+        )
+        self.assertEqual(result, 'http://example.com/abc%20def?(openlayers)')
 
     def test_generate_url_with_custom_anchor(self):
         inst = self._makeOne()
         inst.registrations = [('http://example.com/', 'package:path/', None)]
         request = self._makeRequest()
         uc = text_(b'La Pe\xc3\xb1a', 'utf-8')
-        result = inst.generate('package:path/abc def', request, a=1, _anchor=uc)
-        self.assertEqual(result,
-                         'http://example.com/abc%20def#La%20Pe%C3%B1a')
+        result = inst.generate(
+            'package:path/abc def', request, a=1, _anchor=uc
+        )
+        self.assertEqual(result, 'http://example.com/abc%20def#La%20Pe%C3%B1a')
 
     def test_generate_url_cachebust(self):
         def cachebust(request, subpath, kw):
             kw['foo'] = 'bar'
             return 'foo' + '/' + subpath, kw
+
         inst = self._makeOne()
         inst.registrations = [(None, 'package:path/', '__viewname')]
         inst.cache_busters = [('package:path/', cachebust, False)]
         request = self._makeRequest()
         called = [False]
+
         def route_url(n, **kw):
             called[0] = True
             self.assertEqual(n, '__viewname')
-            self.assertEqual(kw, {'subpath': 'foo/abc', 'foo': 'bar',
-                                  'pathspec': 'package:path/abc',
-                                  'rawspec': 'package:path/abc'})
+            self.assertEqual(
+                kw,
+                {
+                    'subpath': 'foo/abc',
+                    'foo': 'bar',
+                    'pathspec': 'package:path/abc',
+                    'rawspec': 'package:path/abc',
+                },
+            )
+
         request.route_url = route_url
         inst.generate('package:path/abc', request)
         self.assertTrue(called[0])
 
     def test_generate_url_cachebust_abspath(self):
         here = os.path.dirname(__file__) + os.sep
+
         def cachebust(pathspec, subpath, kw):
             kw['foo'] = 'bar'
             return 'foo' + '/' + subpath, kw
+
         inst = self._makeOne()
         inst.registrations = [(None, here, '__viewname')]
         inst.cache_busters = [(here, cachebust, False)]
         request = self._makeRequest()
         called = [False]
+
         def route_url(n, **kw):
             called[0] = True
             self.assertEqual(n, '__viewname')
-            self.assertEqual(kw, {'subpath': 'foo/abc', 'foo': 'bar',
-                                  'pathspec': here + 'abc',
-                                  'rawspec': here + 'abc'})
+            self.assertEqual(
+                kw,
+                {
+                    'subpath': 'foo/abc',
+                    'foo': 'bar',
+                    'pathspec': here + 'abc',
+                    'rawspec': here + 'abc',
+                },
+            )
+
         request.route_url = route_url
         inst.generate(here + 'abc', request)
         self.assertTrue(called[0])
 
     def test_generate_url_cachebust_nomatch(self):
-        def fake_cb(*a, **kw): raise AssertionError
+        def fake_cb(*a, **kw):
+            raise AssertionError
+
         inst = self._makeOne()
         inst.registrations = [(None, 'package:path/', '__viewname')]
         inst.cache_busters = [('package:path2/', fake_cb, False)]
         request = self._makeRequest()
         called = [False]
+
         def route_url(n, **kw):
             called[0] = True
             self.assertEqual(n, '__viewname')
-            self.assertEqual(kw, {'subpath': 'abc',
-                                  'pathspec': 'package:path/abc',
-                                  'rawspec': 'package:path/abc'})
+            self.assertEqual(
+                kw,
+                {
+                    'subpath': 'abc',
+                    'pathspec': 'package:path/abc',
+                    'rawspec': 'package:path/abc',
+                },
+            )
+
         request.route_url = route_url
         inst.generate('package:path/abc', request)
         self.assertTrue(called[0])
@@ -3284,13 +3981,16 @@ class TestStaticURLInfo(unittest.TestCase):
             request = testing.DummyRequest()
             config.add_static_view('static', 'path')
             config.override_asset(
-                'tests.test_config:path/',
-                'tests.test_config:other_path/')
+                'tests.test_config:path/', 'tests.test_config:other_path/'
+            )
+
             def cb(val):
                 def cb_(request, subpath, kw):
                     kw['_query'] = {'x': val}
                     return subpath, kw
+
                 return cb_
+
             config.add_cache_buster('path', cb('foo'))
             result = request.static_url('path/foo.png')
             self.assertEqual(result, 'http://example.com/static/foo.png?x=foo')
@@ -3339,6 +4039,7 @@ class TestStaticURLInfo(unittest.TestCase):
     def test_add_viewname(self):
         from pyramid.security import NO_PERMISSION_REQUIRED
         from pyramid.static import static_view
+
         config = DummyConfig()
         inst = self._makeOne()
         inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1)
@@ -3352,7 +4053,7 @@ class TestStaticURLInfo(unittest.TestCase):
         config = DummyConfig()
         config.route_prefix = '/abc'
         inst = self._makeOne()
-        inst.add(config, 'view', 'anotherpackage:path',)
+        inst.add(config, 'view', 'anotherpackage:path')
         expected = [(None, 'anotherpackage:path/', '__/abc/view/')]
         self.assertEqual(inst.registrations, expected)
         self.assertEqual(config.route_args, ('__/abc/view/', 'view/*subpath'))
@@ -3360,31 +4061,52 @@ class TestStaticURLInfo(unittest.TestCase):
     def test_add_viewname_with_permission(self):
         config = DummyConfig()
         inst = self._makeOne()
-        inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1,
-                 permission='abc')
+        inst.add(
+            config,
+            'view',
+            'anotherpackage:path',
+            cache_max_age=1,
+            permission='abc',
+        )
         self.assertEqual(config.view_kw['permission'], 'abc')
 
     def test_add_viewname_with_context(self):
         config = DummyConfig()
         inst = self._makeOne()
-        inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1,
-                 context=DummyContext)
+        inst.add(
+            config,
+            'view',
+            'anotherpackage:path',
+            cache_max_age=1,
+            context=DummyContext,
+        )
         self.assertEqual(config.view_kw['context'], DummyContext)
 
     def test_add_viewname_with_for_(self):
         config = DummyConfig()
         inst = self._makeOne()
-        inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1,
-                 for_=DummyContext)
+        inst.add(
+            config,
+            'view',
+            'anotherpackage:path',
+            cache_max_age=1,
+            for_=DummyContext,
+        )
         self.assertEqual(config.view_kw['context'], DummyContext)
 
     def test_add_viewname_with_renderer(self):
         config = DummyConfig()
         inst = self._makeOne()
-        inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1,
-                 renderer='mypackage:templates/index.pt')
-        self.assertEqual(config.view_kw['renderer'],
-                         'mypackage:templates/index.pt')
+        inst.add(
+            config,
+            'view',
+            'anotherpackage:path',
+            cache_max_age=1,
+            renderer='mypackage:templates/index.pt',
+        )
+        self.assertEqual(
+            config.view_kw['renderer'], 'mypackage:templates/index.pt'
+        )
 
     def test_add_cachebust_prevented(self):
         config = DummyConfig()
@@ -3397,7 +4119,9 @@ class TestStaticURLInfo(unittest.TestCase):
     def test_add_cachebuster(self):
         config = DummyConfig()
         inst = self._makeOne()
-        inst.add_cache_buster(config, 'mypackage:path', DummyCacheBuster('foo'))
+        inst.add_cache_buster(
+            config, 'mypackage:path', DummyCacheBuster('foo')
+        )
         cachebust = inst.cache_busters[-1][1]
         subpath, kw = cachebust(None, 'some/path', {})
         self.assertEqual(subpath, 'some/path')
@@ -3418,8 +4142,7 @@ class TestStaticURLInfo(unittest.TestCase):
         cb2 = DummyCacheBuster('bar')
         inst.add_cache_buster(config, 'mypackage:path/', cb1)
         inst.add_cache_buster(config, 'mypackage:path', cb2)
-        self.assertEqual(inst.cache_busters,
-                         [('mypackage:path/', cb2, False)])
+        self.assertEqual(inst.cache_busters, [('mypackage:path/', cb2, False)])
 
     def test_add_cachebuster_overwrite_explicit(self):
         config = DummyConfig()
@@ -3428,9 +4151,10 @@ class TestStaticURLInfo(unittest.TestCase):
         cb2 = DummyCacheBuster('bar')
         inst.add_cache_buster(config, 'mypackage:path/', cb1)
         inst.add_cache_buster(config, 'mypackage:path', cb2, True)
-        self.assertEqual(inst.cache_busters,
-                         [('mypackage:path/', cb1, False),
-                          ('mypackage:path/', cb2, True)])
+        self.assertEqual(
+            inst.cache_busters,
+            [('mypackage:path/', cb1, False), ('mypackage:path/', cb2, True)],
+        )
 
     def test_add_cachebuster_for_more_specific_path(self):
         config = DummyConfig()
@@ -3447,36 +4171,47 @@ class TestStaticURLInfo(unittest.TestCase):
         inst.add_cache_buster(config, 'mypackage:path/sub/less', cb5, True)
         self.assertEqual(
             inst.cache_busters,
-            [('mypackage:path/', cb1, False),
-             ('mypackage:path/sub/other/', cb3, False),
-             ('mypackage:path/sub/', cb2, True),
-             ('mypackage:path/sub/less/', cb5, True),
-             ('mypackage:path/sub/other/', cb4, True)])
+            [
+                ('mypackage:path/', cb1, False),
+                ('mypackage:path/sub/other/', cb3, False),
+                ('mypackage:path/sub/', cb2, True),
+                ('mypackage:path/sub/less/', cb5, True),
+                ('mypackage:path/sub/other/', cb4, True),
+            ],
+        )
+
 
 class Test_view_description(unittest.TestCase):
     def _callFUT(self, view):
         from pyramid.config.views import view_description
+
         return view_description(view)
 
     def test_with_text(self):
-        def view(): pass
+        def view():
+            pass
+
         view.__text__ = 'some text'
         result = self._callFUT(view)
         self.assertEqual(result, 'some text')
 
     def test_without_text(self):
-        def view(): pass
+        def view():
+            pass
+
         result = self._callFUT(view)
-        self.assertEqual(result,
-                         'function tests.test_config.test_views.view')
+        self.assertEqual(result, 'function tests.test_config.test_views.view')
+
 
 class Test_viewdefaults(unittest.TestCase):
     def _makeOne(self, wrapped):
         from pyramid.decorator import reify
+
         return reify(wrapped)
 
     def test_dunder_attrs_copied(self):
         from pyramid.config.views import viewdefaults
+
         decorator = self._makeOne(viewdefaults)
         self.assertEqual(decorator.__doc__, viewdefaults.__doc__)
         self.assertEqual(decorator.__name__, viewdefaults.__name__)
@@ -3492,11 +4227,10 @@ class DummyRegistry:
     def queryUtility(self, type_or_iface, name=None, default=None):
         return self.utility or default
 
+
 from zope.interface import implementer
-from pyramid.interfaces import (
-    IResponse,
-    IRequest,
-    )
+from pyramid.interfaces import IResponse, IRequest
+
 
 @implementer(IResponse)
 class DummyResponse(object):
@@ -3504,10 +4238,11 @@ class DummyResponse(object):
     default_content_type = None
     body = None
 
+
 class DummyRequest:
     subpath = ()
     matchdict = None
-    request_iface  = IRequest
+    request_iface = IRequest
     application_url = 'http://example.com/foo'
 
     def __init__(self, environ=None):
@@ -3518,9 +4253,11 @@ class DummyRequest:
         self.cookies = {}
         self.response = DummyResponse()
 
+
 class DummyContext:
     pass
 
+
 class DummyAccept(object):
     def __init__(self, *matches, **kw):
         self.matches = list(matches)
@@ -3536,11 +4273,13 @@ class DummyAccept(object):
     def __contains__(self, value):
         return self.contains
 
+
 class DummyConfig:
     def __init__(self):
         self.registry = DummyRegistry()
 
     route_prefix = ''
+
     def add_route(self, *args, **kw):
         self.route_args = args
         self.route_kw = kw
@@ -3555,20 +4294,27 @@ class DummyConfig:
     def introspectable(self, *arg):
         return {}
 
+
 from zope.interface import implementer
 from pyramid.interfaces import IMultiView
+
+
 @implementer(IMultiView)
 class DummyMultiView:
     def __init__(self):
         self.views = []
         self.name = 'name'
+
     def add(self, view, order, phash=None, accept=None, accept_order=None):
         self.views.append((view, phash, accept, accept_order))
+
     def __call__(self, context, request):
         return 'OK1'
+
     def __permitted__(self, context, request):
         """ """
 
+
 class DummyCacheBuster(object):
     def __init__(self, token):
         self.token = token
@@ -3577,19 +4323,23 @@ class DummyCacheBuster(object):
         kw['x'] = self.token
         return subpath, kw
 
+
 def parse_httpdate(s):
     import datetime
+
     # cannot use %Z, must use literal GMT; Jython honors timezone
     # but CPython does not
     return datetime.datetime.strptime(s, "%a, %d %b %Y %H:%M:%S GMT")
 
+
 def assert_similar_datetime(one, two):
     for attr in ('year', 'month', 'day', 'hour', 'minute'):
         one_attr = getattr(one, attr)
         two_attr = getattr(two, attr)
-        if not one_attr == two_attr: # pragma: no cover
+        if not one_attr == two_attr:  # pragma: no cover
             raise AssertionError('%r != %r in %s' % (one_attr, two_attr, attr))
 
+
 class DummyStaticURLInfo:
     def __init__(self):
         self.added = []
@@ -3597,15 +4347,17 @@ class DummyStaticURLInfo:
     def add(self, config, name, spec, **kw):
         self.added.append((config, name, spec, kw))
 
+
 class DummyViewDefaultsClass(object):
-    __view_defaults__ = {
-        'containment':'tests.test_config.IDummy'
-        }
+    __view_defaults__ = {'containment': 'tests.test_config.IDummy'}
+
     def __init__(self, request):
         pass
+
     def __call__(self):
         return 'OK'
 
+
 class DummyPredicate(object):
     def __init__(self, val, config):
         self.val = val
@@ -3615,18 +4367,23 @@ class DummyPredicate(object):
 
     phash = text
 
+
 class DummyIntrospector(object):
     def __init__(self, getval=None):
         self.related = []
         self.introspectables = []
         self.getval = getval
+
     def add(self, introspectable):
         self.introspectables.append(introspectable)
+
     def get(self, name, discrim):
         return self.getval
+
     def relate(self, a, b):
         self.related.append((a, b))
 
+
 class DummySession(dict):
     def get_csrf_token(self):
         return self['csrf_token']
diff --git a/tests/test_csrf.py b/tests/test_csrf.py
index a224d928f..d1b569c32 100644
--- a/tests/test_csrf.py
+++ b/tests/test_csrf.py
@@ -18,6 +18,7 @@ class TestLegacySessionCSRFStoragePolicy(unittest.TestCase):
 
     def _makeOne(self):
         from pyramid.csrf import LegacySessionCSRFStoragePolicy
+
         return LegacySessionCSRFStoragePolicy()
 
     def test_register_session_csrf_policy(self):
@@ -37,12 +38,10 @@ class TestLegacySessionCSRFStoragePolicy(unittest.TestCase):
         request = DummyRequest(session=self.MockSession())
 
         self.assertEqual(
-            policy.get_csrf_token(request),
-            '02821185e4c94269bdc38e6eeae0a2f8'
+            policy.get_csrf_token(request), '02821185e4c94269bdc38e6eeae0a2f8'
         )
         self.assertEqual(
-            policy.new_csrf_token(request),
-            'e5e9e30a08b34ff9842ff7d2b958c14b'
+            policy.new_csrf_token(request), 'e5e9e30a08b34ff9842ff7d2b958c14b'
         )
 
     def test_check_csrf_token(self):
@@ -56,6 +55,7 @@ class TestLegacySessionCSRFStoragePolicy(unittest.TestCase):
 class TestSessionCSRFStoragePolicy(unittest.TestCase):
     def _makeOne(self, **kw):
         from pyramid.csrf import SessionCSRFStoragePolicy
+
         return SessionCSRFStoragePolicy(**kw)
 
     def test_register_session_csrf_policy(self):
@@ -101,6 +101,7 @@ class TestSessionCSRFStoragePolicy(unittest.TestCase):
 class TestCookieCSRFStoragePolicy(unittest.TestCase):
     def _makeOne(self, **kw):
         from pyramid.csrf import CookieCSRFStoragePolicy
+
         return CookieCSRFStoragePolicy(**kw)
 
     def test_register_cookie_csrf_policy(self):
@@ -124,8 +125,12 @@ class TestCookieCSRFStoragePolicy(unittest.TestCase):
         request.response_callback(request, response)
         self.assertEqual(
             response.headerlist,
-            [('Set-Cookie', 'csrf_token={}; Path=/; SameSite=Lax'.format(
-                token))]
+            [
+                (
+                    'Set-Cookie',
+                    'csrf_token={}; Path=/; SameSite=Lax'.format(token),
+                )
+            ],
         )
 
     def test_get_cookie_csrf_nondefault_samesite(self):
@@ -137,7 +142,7 @@ class TestCookieCSRFStoragePolicy(unittest.TestCase):
         request.response_callback(request, response)
         self.assertEqual(
             response.headerlist,
-            [('Set-Cookie', 'csrf_token={}; Path=/'.format(token))]
+            [('Set-Cookie', 'csrf_token={}; Path=/'.format(token))],
         )
 
     def test_existing_cookie_csrf_does_not_set_cookie(self):
@@ -147,10 +152,7 @@ class TestCookieCSRFStoragePolicy(unittest.TestCase):
         policy = self._makeOne()
         token = policy.get_csrf_token(request)
 
-        self.assertEqual(
-            token,
-            'e6f325fee5974f3da4315a8ccf4513d2'
-        )
+        self.assertEqual(token, 'e6f325fee5974f3da4315a8ccf4513d2')
         self.assertIsNone(request.response_callback)
 
     def test_new_cookie_csrf_with_existing_cookie_sets_cookies(self):
@@ -164,8 +166,12 @@ class TestCookieCSRFStoragePolicy(unittest.TestCase):
         request.response_callback(request, response)
         self.assertEqual(
             response.headerlist,
-            [('Set-Cookie', 'csrf_token={}; Path=/; SameSite=Lax'.format(token)
-            )]
+            [
+                (
+                    'Set-Cookie',
+                    'csrf_token={}; Path=/; SameSite=Lax'.format(token),
+                )
+            ],
         )
 
     def test_get_csrf_token_returns_the_new_token(self):
@@ -189,12 +195,14 @@ class TestCookieCSRFStoragePolicy(unittest.TestCase):
         self.assertTrue(policy.check_csrf_token(request, 'foo'))
         self.assertFalse(policy.check_csrf_token(request, 'bar'))
 
+
 class Test_get_csrf_token(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
 
     def _callFUT(self, *args, **kwargs):
         from pyramid.csrf import get_csrf_token
+
         return get_csrf_token(*args, **kwargs)
 
     def test_no_override_csrf_utility_registered(self):
@@ -216,6 +224,7 @@ class Test_new_csrf_token(unittest.TestCase):
 
     def _callFUT(self, *args, **kwargs):
         from pyramid.csrf import new_csrf_token
+
         return new_csrf_token(*args, **kwargs)
 
     def test_no_override_csrf_utility_registered(self):
@@ -240,6 +249,7 @@ class Test_check_csrf_token(unittest.TestCase):
 
     def _callFUT(self, *args, **kwargs):
         from pyramid.csrf import check_csrf_token
+
         return check_csrf_token(*args, **kwargs)
 
     def test_success_token(self):
@@ -266,9 +276,9 @@ class Test_check_csrf_token(unittest.TestCase):
 
     def test_failure_raises(self):
         from pyramid.exceptions import BadCSRFToken
+
         request = testing.DummyRequest()
-        self.assertRaises(BadCSRFToken, self._callFUT, request,
-                          'csrf_token')
+        self.assertRaises(BadCSRFToken, self._callFUT, request, 'csrf_token')
 
     def test_failure_no_raises(self):
         request = testing.DummyRequest()
@@ -282,6 +292,7 @@ class Test_check_csrf_token_without_defaults_configured(unittest.TestCase):
 
     def _callFUT(self, *args, **kwargs):
         from pyramid.csrf import check_csrf_token
+
         return check_csrf_token(*args, **kwargs)
 
     def test_success_token(self):
@@ -292,9 +303,9 @@ class Test_check_csrf_token_without_defaults_configured(unittest.TestCase):
 
     def test_failure_raises(self):
         from pyramid.exceptions import BadCSRFToken
+
         request = testing.DummyRequest()
-        self.assertRaises(BadCSRFToken, self._callFUT, request,
-                          'csrf_token')
+        self.assertRaises(BadCSRFToken, self._callFUT, request, 'csrf_token')
 
     def test_failure_no_raises(self):
         request = testing.DummyRequest()
@@ -305,6 +316,7 @@ class Test_check_csrf_token_without_defaults_configured(unittest.TestCase):
 class Test_check_csrf_origin(unittest.TestCase):
     def _callFUT(self, *args, **kwargs):
         from pyramid.csrf import check_csrf_origin
+
         return check_csrf_origin(*args, **kwargs)
 
     def test_success_with_http(self):
@@ -338,7 +350,7 @@ class Test_check_csrf_origin(unittest.TestCase):
         request.host_port = "443"
         request.referrer = "https://not-example.com/login/"
         request.registry.settings = {
-            "pyramid.csrf_trusted_origins": ["not-example.com"],
+            "pyramid.csrf_trusted_origins": ["not-example.com"]
         }
         self.assertTrue(self._callFUT(request))
 
@@ -353,6 +365,7 @@ class Test_check_csrf_origin(unittest.TestCase):
 
     def test_fails_with_wrong_host(self):
         from pyramid.exceptions import BadCSRFOrigin
+
         request = testing.DummyRequest()
         request.scheme = "https"
         request.host = "example.com"
@@ -364,6 +377,7 @@ class Test_check_csrf_origin(unittest.TestCase):
 
     def test_fails_with_no_origin(self):
         from pyramid.exceptions import BadCSRFOrigin
+
         request = testing.DummyRequest()
         request.scheme = "https"
         request.referrer = None
@@ -372,6 +386,7 @@ class Test_check_csrf_origin(unittest.TestCase):
 
     def test_fails_when_http_to_https(self):
         from pyramid.exceptions import BadCSRFOrigin
+
         request = testing.DummyRequest()
         request.scheme = "https"
         request.host = "example.com"
@@ -383,6 +398,7 @@ class Test_check_csrf_origin(unittest.TestCase):
 
     def test_fails_with_nonstandard_port(self):
         from pyramid.exceptions import BadCSRFOrigin
+
         request = testing.DummyRequest()
         request.scheme = "https"
         request.host = "example.com:8080"
diff --git a/tests/test_decorator.py b/tests/test_decorator.py
index 4b9313e06..2dcc9b4d3 100644
--- a/tests/test_decorator.py
+++ b/tests/test_decorator.py
@@ -1,13 +1,16 @@
 import unittest
 
+
 class TestReify(unittest.TestCase):
     def _makeOne(self, wrapped):
         from pyramid.decorator import reify
+
         return reify(wrapped)
 
     def test___get__withinst(self):
         def wrapped(inst):
             return 'a'
+
         decorator = self._makeOne(wrapped)
         inst = Dummy()
         result = decorator.__get__(inst)
@@ -17,6 +20,7 @@ class TestReify(unittest.TestCase):
     def test___get__noinst(self):
         def wrapped(inst):
             return 'a'  # pragma: no cover
+
         decorator = self._makeOne(wrapped)
         result = decorator.__get__(None)
         self.assertEqual(result, decorator)
diff --git a/tests/test_docs.py b/tests/test_docs.py
index 0735a494a..46c9ed765 100644
--- a/tests/test_docs.py
+++ b/tests/test_docs.py
@@ -15,6 +15,7 @@ if 0:
             import manuel.codeblock
             import manuel.capture
             import manuel.ignore
+
             m = manuel.ignore.Manuel()
             m += manuel.codeblock.Manuel()
             m += manuel.capture.Manuel()
diff --git a/tests/test_encode.py b/tests/test_encode.py
index d3a9f7095..f70050cac 100644
--- a/tests/test_encode.py
+++ b/tests/test_encode.py
@@ -1,31 +1,30 @@
 import unittest
-from pyramid.compat import (
-    text_,
-    native_,
-    )
+from pyramid.compat import text_, native_
+
 
 class UrlEncodeTests(unittest.TestCase):
     def _callFUT(self, query, doseq=False, **kw):
         from pyramid.encode import urlencode
+
         return urlencode(query, doseq, **kw)
 
     def test_ascii_only(self):
-        result = self._callFUT([('a',1), ('b',2)])
+        result = self._callFUT([('a', 1), ('b', 2)])
         self.assertEqual(result, 'a=1&b=2')
 
     def test_unicode_key(self):
         la = text_(b'LaPe\xc3\xb1a', 'utf-8')
-        result = self._callFUT([(la, 1), ('b',2)])
+        result = self._callFUT([(la, 1), ('b', 2)])
         self.assertEqual(result, 'LaPe%C3%B1a=1&b=2')
 
     def test_unicode_val_single(self):
         la = text_(b'LaPe\xc3\xb1a', 'utf-8')
-        result = self._callFUT([('a', la), ('b',2)])
+        result = self._callFUT([('a', la), ('b', 2)])
         self.assertEqual(result, 'a=LaPe%C3%B1a&b=2')
 
     def test_unicode_val_multiple(self):
         la = [text_(b'LaPe\xc3\xb1a', 'utf-8')] * 2
-        result = self._callFUT([('a', la), ('b',2)], doseq=True)
+        result = self._callFUT([('a', la), ('b', 2)], doseq=True)
         self.assertEqual(result, 'a=LaPe%C3%B1a&a=LaPe%C3%B1a&b=2')
 
     def test_int_val_multiple(self):
@@ -38,7 +37,7 @@ class UrlEncodeTests(unittest.TestCase):
         self.assertEqual(result, 'a=123+456')
 
     def test_dict(self):
-        result = self._callFUT({'a':1})
+        result = self._callFUT({'a': 1})
         self.assertEqual(result, 'a=1')
 
     def test_None_value(self):
@@ -56,20 +55,24 @@ class UrlEncodeTests(unittest.TestCase):
     def test_quote_via(self):
         def my_quoter(value):
             return 'xxx' + value
-        result = self._callFUT([('a', '1'), ('b', None), ('c', None)],
-                               quote_via=my_quoter)
+
+        result = self._callFUT(
+            [('a', '1'), ('b', None), ('c', None)], quote_via=my_quoter
+        )
         self.assertEqual(result, 'xxxa=xxx1&xxxb=&xxxc=')
 
+
 class URLQuoteTests(unittest.TestCase):
     def _callFUT(self, val, safe=''):
         from pyramid.encode import url_quote
+
         return url_quote(val, safe)
 
     def test_it_bytes(self):
         la = b'La/Pe\xc3\xb1a'
         result = self._callFUT(la)
         self.assertEqual(result, 'La%2FPe%C3%B1a')
-        
+
     def test_it_native(self):
         la = native_(b'La/Pe\xc3\xb1a', 'utf-8')
         result = self._callFUT(la)
diff --git a/tests/test_events.py b/tests/test_events.py
index 793ac329f..a08cab637 100644
--- a/tests/test_events.py
+++ b/tests/test_events.py
@@ -1,9 +1,11 @@
 import unittest
 from pyramid import testing
 
+
 class NewRequestEventTests(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.events import NewRequest
+
         return NewRequest
 
     def _makeOne(self, request):
@@ -12,12 +14,14 @@ class NewRequestEventTests(unittest.TestCase):
     def test_class_conforms_to_INewRequest(self):
         from pyramid.interfaces import INewRequest
         from zope.interface.verify import verifyClass
+
         klass = self._getTargetClass()
         verifyClass(INewRequest, klass)
 
     def test_instance_conforms_to_INewRequest(self):
         from pyramid.interfaces import INewRequest
         from zope.interface.verify import verifyObject
+
         request = DummyRequest()
         inst = self._makeOne(request)
         verifyObject(INewRequest, inst)
@@ -27,9 +31,11 @@ class NewRequestEventTests(unittest.TestCase):
         inst = self._makeOne(request)
         self.assertEqual(inst.request, request)
 
+
 class NewResponseEventTests(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.events import NewResponse
+
         return NewResponse
 
     def _makeOne(self, request, response):
@@ -38,12 +44,14 @@ class NewResponseEventTests(unittest.TestCase):
     def test_class_conforms_to_INewResponse(self):
         from pyramid.interfaces import INewResponse
         from zope.interface.verify import verifyClass
+
         klass = self._getTargetClass()
         verifyClass(INewResponse, klass)
 
     def test_instance_conforms_to_INewResponse(self):
         from pyramid.interfaces import INewResponse
         from zope.interface.verify import verifyObject
+
         request = DummyRequest()
         response = DummyResponse()
         inst = self._makeOne(request, response)
@@ -56,9 +64,11 @@ class NewResponseEventTests(unittest.TestCase):
         self.assertEqual(inst.request, request)
         self.assertEqual(inst.response, response)
 
+
 class ApplicationCreatedEventTests(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.events import ApplicationCreated
+
         return ApplicationCreated
 
     def _makeOne(self, context=object()):
@@ -67,31 +77,39 @@ class ApplicationCreatedEventTests(unittest.TestCase):
     def test_class_conforms_to_IApplicationCreated(self):
         from pyramid.interfaces import IApplicationCreated
         from zope.interface.verify import verifyClass
+
         verifyClass(IApplicationCreated, self._getTargetClass())
 
     def test_object_conforms_to_IApplicationCreated(self):
         from pyramid.interfaces import IApplicationCreated
         from zope.interface.verify import verifyObject
+
         verifyObject(IApplicationCreated, self._makeOne())
 
+
 class WSGIApplicationCreatedEventTests(ApplicationCreatedEventTests):
     def _getTargetClass(self):
         from pyramid.events import WSGIApplicationCreatedEvent
+
         return WSGIApplicationCreatedEvent
 
     def test_class_conforms_to_IWSGIApplicationCreatedEvent(self):
         from pyramid.interfaces import IWSGIApplicationCreatedEvent
         from zope.interface.verify import verifyClass
+
         verifyClass(IWSGIApplicationCreatedEvent, self._getTargetClass())
 
     def test_object_conforms_to_IWSGIApplicationCreatedEvent(self):
         from pyramid.interfaces import IWSGIApplicationCreatedEvent
         from zope.interface.verify import verifyObject
+
         verifyObject(IWSGIApplicationCreatedEvent, self._makeOne())
 
+
 class ContextFoundEventTests(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.events import ContextFound
+
         return ContextFound
 
     def _makeOne(self, request=None):
@@ -102,31 +120,39 @@ class ContextFoundEventTests(unittest.TestCase):
     def test_class_conforms_to_IContextFound(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IContextFound
+
         verifyClass(IContextFound, self._getTargetClass())
 
     def test_instance_conforms_to_IContextFound(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IContextFound
+
         verifyObject(IContextFound, self._makeOne())
 
+
 class AfterTraversalEventTests(ContextFoundEventTests):
     def _getTargetClass(self):
         from pyramid.events import AfterTraversal
+
         return AfterTraversal
 
     def test_class_conforms_to_IAfterTraversal(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IAfterTraversal
+
         verifyClass(IAfterTraversal, self._getTargetClass())
 
     def test_instance_conforms_to_IAfterTraversal(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IAfterTraversal
+
         verifyObject(IAfterTraversal, self._makeOne())
 
+
 class BeforeTraversalEventTests(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.events import BeforeTraversal
+
         return BeforeTraversal
 
     def _makeOne(self, request=None):
@@ -137,11 +163,13 @@ class BeforeTraversalEventTests(unittest.TestCase):
     def test_class_conforms_to_IBeforeTraversal(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IBeforeTraversal
+
         verifyClass(IBeforeTraversal, self._getTargetClass())
 
     def test_instance_conforms_to_IBeforeTraversal(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IBeforeTraversal
+
         verifyObject(IBeforeTraversal, self._makeOne())
 
 
@@ -154,14 +182,23 @@ class TestSubscriber(unittest.TestCase):
 
     def _makeOne(self, *ifaces, **predicates):
         from pyramid.events import subscriber
+
         return subscriber(*ifaces, **predicates)
 
     def test_register_single(self):
         from zope.interface import Interface
-        class IFoo(Interface): pass
-        class IBar(Interface): pass
+
+        class IFoo(Interface):
+            pass
+
+        class IBar(Interface):
+            pass
+
         dec = self._makeOne(IFoo)
-        def foo(): pass
+
+        def foo():
+            pass
+
         config = DummyConfigurator()
         scanner = Dummy()
         scanner.config = config
@@ -170,10 +207,18 @@ class TestSubscriber(unittest.TestCase):
 
     def test_register_multi(self):
         from zope.interface import Interface
-        class IFoo(Interface): pass
-        class IBar(Interface): pass
+
+        class IFoo(Interface):
+            pass
+
+        class IBar(Interface):
+            pass
+
         dec = self._makeOne(IFoo, IBar)
-        def foo(): pass
+
+        def foo():
+            pass
+
         config = DummyConfigurator()
         scanner = Dummy()
         scanner.config = config
@@ -182,8 +227,12 @@ class TestSubscriber(unittest.TestCase):
 
     def test_register_none_means_all(self):
         from zope.interface import Interface
+
         dec = self._makeOne()
-        def foo(): pass
+
+        def foo():
+            pass
+
         config = DummyConfigurator()
         scanner = Dummy()
         scanner.config = config
@@ -192,10 +241,18 @@ class TestSubscriber(unittest.TestCase):
 
     def test_register_objectevent(self):
         from zope.interface import Interface
-        class IFoo(Interface): pass
-        class IBar(Interface): pass
+
+        class IFoo(Interface):
+            pass
+
+        class IBar(Interface):
+            pass
+
         dec = self._makeOne([IFoo, IBar])
-        def foo(): pass
+
+        def foo():
+            pass
+
         config = DummyConfigurator()
         scanner = Dummy()
         scanner.config = config
@@ -206,67 +263,84 @@ class TestSubscriber(unittest.TestCase):
         dec = self._makeOne()
         dummy_venusian = DummyVenusian()
         dec.venusian = dummy_venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         dec(foo)
-        self.assertEqual(dummy_venusian.attached,
-                         [(foo, dec.register, 'pyramid', 1)])
+        self.assertEqual(
+            dummy_venusian.attached, [(foo, dec.register, 'pyramid', 1)]
+        )
 
     def test___call___with_venusian_args(self):
         dec = self._makeOne(_category='foo', _depth=1)
         dummy_venusian = DummyVenusian()
         dec.venusian = dummy_venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         dec(foo)
-        self.assertEqual(dummy_venusian.attached,
-                         [(foo, dec.register, 'foo', 2)])
+        self.assertEqual(
+            dummy_venusian.attached, [(foo, dec.register, 'foo', 2)]
+        )
 
     def test_regsister_with_predicates(self):
         from zope.interface import Interface
+
         dec = self._makeOne(a=1)
-        def foo(): pass
+
+        def foo():
+            pass
+
         config = DummyConfigurator()
         scanner = Dummy()
         scanner.config = config
         dec.register(scanner, None, foo)
-        self.assertEqual(config.subscribed, [(foo, Interface, {'a':1})])
+        self.assertEqual(config.subscribed, [(foo, Interface, {'a': 1})])
+
 
 class TestBeforeRender(unittest.TestCase):
     def _makeOne(self, system, val=None):
         from pyramid.events import BeforeRender
+
         return BeforeRender(system, val)
 
-    @testing.skip_on('pypy') # see https://github.com/Pylons/pyramid/issues/3237
+    @testing.skip_on(
+        'pypy'
+    )  # see https://github.com/Pylons/pyramid/issues/3237
     def test_instance_conforms(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IBeforeRender
+
         event = self._makeOne({})
         verifyObject(IBeforeRender, event)
 
     def test_setitem_success(self):
         event = self._makeOne({})
         event['a'] = 1
-        self.assertEqual(event, {'a':1})
+        self.assertEqual(event, {'a': 1})
 
     def test_setdefault_fail(self):
         event = self._makeOne({})
         result = event.setdefault('a', 1)
         self.assertEqual(result, 1)
-        self.assertEqual(event, {'a':1})
+        self.assertEqual(event, {'a': 1})
 
     def test_setdefault_success(self):
         event = self._makeOne({})
         event['a'] = 1
         result = event.setdefault('a', 2)
         self.assertEqual(result, 1)
-        self.assertEqual(event, {'a':1})
+        self.assertEqual(event, {'a': 1})
 
     def test_update_success(self):
-        event = self._makeOne({'a':1})
-        event.update({'b':2})
-        self.assertEqual(event, {'a':1, 'b':2})
+        event = self._makeOne({'a': 1})
+        event.update({'b': 2})
+        self.assertEqual(event, {'a': 1, 'b': 2})
 
     def test__contains__True(self):
-        system = {'a':1}
+        system = {'a': 1}
         event = self._makeOne(system)
         self.assertTrue('a' in event)
 
@@ -276,7 +350,7 @@ class TestBeforeRender(unittest.TestCase):
         self.assertFalse('a' in event)
 
     def test__getitem__success(self):
-        system = {'a':1}
+        system = {'a': 1}
         event = self._makeOne(system)
         self.assertEqual(event['a'], 1)
 
@@ -286,7 +360,7 @@ class TestBeforeRender(unittest.TestCase):
         self.assertRaises(KeyError, event.__getitem__, 'a')
 
     def test_get_success(self):
-        system = {'a':1}
+        system = {'a': 1}
         event = self._makeOne(system)
         self.assertEqual(event.get('a'), 1)
 
@@ -301,6 +375,7 @@ class TestBeforeRender(unittest.TestCase):
         event = self._makeOne(system, val)
         self.assertTrue(event.rendering_val is val)
 
+
 class DummyConfigurator(object):
     def __init__(self):
         self.subscribed = []
@@ -311,9 +386,11 @@ class DummyConfigurator(object):
         else:
             self.subscribed.append((wrapped, ifaces, predicates))
 
+
 class DummyRegistry(object):
     pass
 
+
 class DummyVenusian(object):
     def __init__(self):
         self.attached = []
@@ -321,12 +398,14 @@ class DummyVenusian(object):
     def attach(self, wrapped, fn, category=None, depth=None):
         self.attached.append((wrapped, fn, category, depth))
 
+
 class Dummy:
     pass
 
+
 class DummyRequest:
     pass
 
+
 class DummyResponse:
     pass
-
diff --git a/tests/test_exceptions.py b/tests/test_exceptions.py
index 9cb0f58d1..399940c05 100644
--- a/tests/test_exceptions.py
+++ b/tests/test_exceptions.py
@@ -1,29 +1,37 @@
 import unittest
 
+
 class TestBWCompat(unittest.TestCase):
     def test_bwcompat_notfound(self):
         from pyramid.exceptions import NotFound as one
         from pyramid.httpexceptions import HTTPNotFound as two
+
         self.assertTrue(one is two)
 
     def test_bwcompat_forbidden(self):
         from pyramid.exceptions import Forbidden as one
         from pyramid.httpexceptions import HTTPForbidden as two
+
         self.assertTrue(one is two)
 
+
 class TestBadCSRFToken(unittest.TestCase):
     def test_response_equivalence(self):
         from pyramid.exceptions import BadCSRFToken
         from pyramid.httpexceptions import HTTPBadRequest
+
         self.assertTrue(isinstance(BadCSRFToken(), HTTPBadRequest))
 
+
 class TestNotFound(unittest.TestCase):
     def _makeOne(self, message):
         from pyramid.exceptions import NotFound
+
         return NotFound(message)
 
     def test_it(self):
         from pyramid.interfaces import IExceptionResponse
+
         e = self._makeOne('notfound')
         self.assertTrue(IExceptionResponse.providedBy(e))
         self.assertEqual(e.status, '404 Not Found')
@@ -32,15 +40,19 @@ class TestNotFound(unittest.TestCase):
     def test_response_equivalence(self):
         from pyramid.exceptions import NotFound
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertTrue(NotFound is HTTPNotFound)
 
+
 class TestForbidden(unittest.TestCase):
     def _makeOne(self, message):
         from pyramid.exceptions import Forbidden
+
         return Forbidden(message)
 
     def test_it(self):
         from pyramid.interfaces import IExceptionResponse
+
         e = self._makeOne('forbidden')
         self.assertTrue(IExceptionResponse.providedBy(e))
         self.assertEqual(e.status, '403 Forbidden')
@@ -49,18 +61,22 @@ class TestForbidden(unittest.TestCase):
     def test_response_equivalence(self):
         from pyramid.exceptions import Forbidden
         from pyramid.httpexceptions import HTTPForbidden
+
         self.assertTrue(Forbidden is HTTPForbidden)
 
+
 class TestConfigurationConflictError(unittest.TestCase):
     def _makeOne(self, conflicts):
         from pyramid.exceptions import ConfigurationConflictError
+
         return ConfigurationConflictError(conflicts)
 
     def test_str(self):
-        conflicts = {'a':('1', '2', '3'), 'b':('4', '5', '6')}
+        conflicts = {'a': ('1', '2', '3'), 'b': ('4', '5', '6')}
         exc = self._makeOne(conflicts)
-        self.assertEqual(str(exc),
-"""\
+        self.assertEqual(
+            str(exc),
+            """\
 Conflicting configuration actions
   For: a
     1
@@ -69,24 +85,29 @@ Conflicting configuration actions
   For: b
     4
     5
-    6""")
+    6""",
+        )
+
 
 class TestConfigurationExecutionError(unittest.TestCase):
     def _makeOne(self, etype, evalue, info):
         from pyramid.exceptions import ConfigurationExecutionError
+
         return ConfigurationExecutionError(etype, evalue, info)
 
     def test_str(self):
         exc = self._makeOne('etype', 'evalue', 'info')
         self.assertEqual(str(exc), 'etype: evalue\n  in:\n  info')
-        
+
+
 class TestCyclicDependencyError(unittest.TestCase):
     def _makeOne(self, cycles):
         from pyramid.exceptions import CyclicDependencyError
+
         return CyclicDependencyError(cycles)
 
     def test___str__(self):
-        exc = self._makeOne({'a':['c', 'd'], 'c':['a']})
+        exc = self._makeOne({'a': ['c', 'd'], 'c': ['a']})
         result = str(exc)
         self.assertTrue("'a' sorts before ['c', 'd']" in result)
         self.assertTrue("'c' sorts before ['a']" in result)
diff --git a/tests/test_httpexceptions.py b/tests/test_httpexceptions.py
index ed6c41e0e..4c13e096d 100644
--- a/tests/test_httpexceptions.py
+++ b/tests/test_httpexceptions.py
@@ -1,40 +1,45 @@
 import unittest
 
-from pyramid.compat import (
-    bytes_,
-    string_types,
-    text_,
-    )
+from pyramid.compat import bytes_, string_types, text_
+
 
 class Test_exception_response(unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from pyramid.httpexceptions import exception_response
+
         return exception_response(*arg, **kw)
 
     def test_status_400(self):
         from pyramid.httpexceptions import HTTPBadRequest
+
         self.assertTrue(isinstance(self._callFUT(400), HTTPBadRequest))
 
     def test_status_404(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertTrue(isinstance(self._callFUT(404), HTTPNotFound))
 
     def test_status_500(self):
         from pyramid.httpexceptions import HTTPInternalServerError
-        self.assertTrue(isinstance(self._callFUT(500),
-                        HTTPInternalServerError))
+
+        self.assertTrue(
+            isinstance(self._callFUT(500), HTTPInternalServerError)
+        )
 
     def test_status_201(self):
         from pyramid.httpexceptions import HTTPCreated
+
         self.assertTrue(isinstance(self._callFUT(201), HTTPCreated))
 
     def test_extra_kw(self):
         resp = self._callFUT(404, headers=[('abc', 'def')])
         self.assertEqual(resp.headers['abc'], 'def')
 
+
 class Test_default_exceptionresponse_view(unittest.TestCase):
     def _callFUT(self, context, request):
         from pyramid.httpexceptions import default_exceptionresponse_view
+
         return default_exceptionresponse_view(context, request)
 
     def test_call_with_exception(self):
@@ -49,9 +54,11 @@ class Test_default_exceptionresponse_view(unittest.TestCase):
         result = self._callFUT(None, request)
         self.assertEqual(result, context)
 
+
 class Test__no_escape(unittest.TestCase):
     def _callFUT(self, val):
         from pyramid.httpexceptions import _no_escape
+
         return _no_escape(val)
 
     def test_null(self):
@@ -64,19 +71,29 @@ class Test__no_escape(unittest.TestCase):
         class DummyUnicodeObject(object):
             def __unicode__(self):
                 return text_('42')
+
         duo = DummyUnicodeObject()
         self.assertEqual(self._callFUT(duo), text_('42'))
 
+
 class TestHTTPException(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.httpexceptions import HTTPException
+
         return HTTPException
 
-    def _getTargetSubclass(self, code='200', title='OK',
-                           explanation='explanation', empty_body=False):
+    def _getTargetSubclass(
+        self,
+        code='200',
+        title='OK',
+        explanation='explanation',
+        empty_body=False,
+    ):
         cls = self._getTargetClass()
+
         class Subclass(cls):
             pass
+
         Subclass.empty_body = empty_body
         Subclass.code = code
         Subclass.title = title
@@ -89,21 +106,25 @@ class TestHTTPException(unittest.TestCase):
 
     def test_implements_IResponse(self):
         from pyramid.interfaces import IResponse
+
         cls = self._getTargetClass()
         self.assertTrue(IResponse.implementedBy(cls))
 
     def test_provides_IResponse(self):
         from pyramid.interfaces import IResponse
+
         inst = self._getTargetClass()()
         self.assertTrue(IResponse.providedBy(inst))
 
     def test_implements_IExceptionResponse(self):
         from pyramid.interfaces import IExceptionResponse
+
         cls = self._getTargetClass()
         self.assertTrue(IExceptionResponse.implementedBy(cls))
 
     def test_provides_IExceptionResponse(self):
         from pyramid.interfaces import IExceptionResponse
+
         inst = self._getTargetClass()()
         self.assertTrue(IExceptionResponse.providedBy(inst))
 
@@ -130,7 +151,8 @@ class TestHTTPException(unittest.TestCase):
     def test_ctor_sets_body_template_obj(self):
         exc = self._makeOne(body_template='${foo}')
         self.assertEqual(
-            exc.body_template_obj.substitute({'foo': 'foo'}), 'foo')
+            exc.body_template_obj.substitute({'foo': 'foo'}), 'foo'
+        )
 
     def test_ctor_with_empty_body(self):
         cls = self._getTargetSubclass(empty_body=True)
@@ -323,17 +345,20 @@ class TestHTTPException(unittest.TestCase):
         start_response = DummyStartResponse()
         body = list(exc(environ, start_response))[0]
         import json
+
         retval = json.loads(body.decode('UTF-8'))
         self.assertEqual(retval['code'], '200 OK')
         self.assertEqual(retval['title'], 'OK')
 
     def test__default_app_iter_with_custom_json(self):
         def json_formatter(status, body, title, environ):
-            return {'message': body,
-                    'code': status,
-                    'title': title,
-                    'custom': environ['CUSTOM_VARIABLE']
-                    }
+            return {
+                'message': body,
+                'code': status,
+                'title': title,
+                'custom': environ['CUSTOM_VARIABLE'],
+            }
+
         cls = self._getTargetSubclass()
         exc = cls(comment='comment', json_formatter=json_formatter)
         environ = _makeEnviron()
@@ -342,6 +367,7 @@ class TestHTTPException(unittest.TestCase):
         start_response = DummyStartResponse()
         body = list(exc(environ, start_response))[0]
         import json
+
         retval = json.loads(body.decode('UTF-8'))
         self.assertEqual(retval['code'], '200 OK')
         self.assertEqual(retval['title'], 'OK')
@@ -359,9 +385,11 @@ class TestHTTPException(unittest.TestCase):
         cls = self._getTargetSubclass()
         exc = cls(body_template='${REQUEST_METHOD}')
         environ = _makeEnviron()
+
         class Choke(object):
             def __str__(self):  # pragma no cover
                 raise ValueError
+
         environ['gardentheory.user'] = Choke()
         start_response = DummyStartResponse()
         body = list(exc(environ, start_response))[0]
@@ -384,6 +412,7 @@ class TestHTTPException(unittest.TestCase):
 class TestRenderAllExceptionsWithoutArguments(unittest.TestCase):
     def _doit(self, content_type):
         from pyramid.httpexceptions import status_map
+
         L = []
         self.assertTrue(status_map)
         for v in status_map.values():
@@ -405,9 +434,11 @@ class TestRenderAllExceptionsWithoutArguments(unittest.TestCase):
     def test_it_html(self):
         self._doit('text/html')
 
+
 class Test_HTTPMove(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.httpexceptions import _HTTPMove
+
         return _HTTPMove(*arg, **kw)
 
     def test_it_location_none_valueerrors(self):
@@ -433,13 +464,19 @@ class Test_HTTPMove(unittest.TestCase):
         environ = _makeEnviron()
         start_response = DummyStartResponse()
         app_iter = exc(environ, start_response)
-        self.assertEqual(app_iter[0],
-                         (b'520 Unknown Error\n\nThe resource has been moved to foo; '
-                          b'you should be redirected automatically.\n\n'))
+        self.assertEqual(
+            app_iter[0],
+            (
+                b'520 Unknown Error\n\nThe resource has been moved to foo; '
+                b'you should be redirected automatically.\n\n'
+            ),
+        )
+
 
 class TestHTTPForbidden(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.httpexceptions import HTTPForbidden
+
         return HTTPForbidden(*arg, **kw)
 
     def test_it_result_not_passed(self):
@@ -450,9 +487,11 @@ class TestHTTPForbidden(unittest.TestCase):
         exc = self._makeOne(result='foo')
         self.assertEqual(exc.result, 'foo')
 
+
 class TestHTTPMethodNotAllowed(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.httpexceptions import HTTPMethodNotAllowed
+
         return HTTPMethodNotAllowed(*arg, **kw)
 
     def test_it_with_default_body_tmpl(self):
@@ -460,23 +499,31 @@ class TestHTTPMethodNotAllowed(unittest.TestCase):
         environ = _makeEnviron()
         start_response = DummyStartResponse()
         app_iter = exc(environ, start_response)
-        self.assertEqual(app_iter[0],
-                         (b'405 Method Not Allowed\n\nThe method GET is not '
-                          b'allowed for this resource. \n\n\n'))
+        self.assertEqual(
+            app_iter[0],
+            (
+                b'405 Method Not Allowed\n\nThe method GET is not '
+                b'allowed for this resource. \n\n\n'
+            ),
+        )
 
 
 class DummyRequest(object):
     exception = None
 
+
 class DummyStartResponse(object):
     def __call__(self, status, headerlist):
         self.status = status
         self.headerlist = headerlist
 
+
 def _makeEnviron(**kw):
-    environ = {'REQUEST_METHOD': 'GET',
-               'wsgi.url_scheme': 'http',
-               'SERVER_NAME': 'localhost',
-               'SERVER_PORT': '80'}
+    environ = {
+        'REQUEST_METHOD': 'GET',
+        'wsgi.url_scheme': 'http',
+        'SERVER_NAME': 'localhost',
+        'SERVER_PORT': '80',
+    }
     environ.update(kw)
     return environ
diff --git a/tests/test_i18n.py b/tests/test_i18n.py
index d72d0d480..a830b8e0f 100644
--- a/tests/test_i18n.py
+++ b/tests/test_i18n.py
@@ -8,9 +8,11 @@ localedir = os.path.join(here, 'pkgs', 'localeapp', 'locale')
 import unittest
 from pyramid import testing
 
+
 class TestTranslationString(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.i18n import TranslationString
+
         return TranslationString(*arg, **kw)
 
     def test_it(self):
@@ -19,9 +21,11 @@ class TestTranslationString(unittest.TestCase):
         ts = self._makeOne('a')
         self.assertEqual(ts, 'a')
 
+
 class TestTranslationStringFactory(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.i18n import TranslationStringFactory
+
         return TranslationStringFactory(*arg, **kw)
 
     def test_it(self):
@@ -30,9 +34,11 @@ class TestTranslationStringFactory(unittest.TestCase):
         factory = self._makeOne('a')
         self.assertEqual(factory('').domain, 'a')
 
+
 class TestLocalizer(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.i18n import Localizer
+
         return Localizer(*arg, **kw)
 
     def test_ctor(self):
@@ -43,30 +49,34 @@ class TestLocalizer(unittest.TestCase):
     def test_translate(self):
         translations = DummyTranslations()
         localizer = self._makeOne(None, translations)
-        self.assertEqual(localizer.translate('123', domain='1',
-                                             mapping={}), '123')
+        self.assertEqual(
+            localizer.translate('123', domain='1', mapping={}), '123'
+        )
         self.assertTrue(localizer.translator)
 
     def test_pluralize(self):
         translations = DummyTranslations()
         localizer = self._makeOne(None, translations)
-        result = localizer.pluralize('singular', 'plural', 1,
-                                     domain='1', mapping={})
+        result = localizer.pluralize(
+            'singular', 'plural', 1, domain='1', mapping={}
+        )
         self.assertEqual(result, 'singular')
         self.assertTrue(localizer.pluralizer)
 
     def test_pluralize_pluralizer_already_added(self):
         translations = DummyTranslations()
         localizer = self._makeOne(None, translations)
+
         def pluralizer(*arg, **kw):
             return arg, kw
+
         localizer.pluralizer = pluralizer
-        result = localizer.pluralize('singular', 'plural', 1, domain='1',
-                                     mapping={})
+        result = localizer.pluralize(
+            'singular', 'plural', 1, domain='1', mapping={}
+        )
         self.assertEqual(
-            result,
-            (('singular', 'plural', 1), {'domain': '1', 'mapping': {}})
-            )
+            result, (('singular', 'plural', 1), {'domain': '1', 'mapping': {}})
+        )
         self.assertTrue(localizer.pluralizer is pluralizer)
 
     def test_pluralize_default_translations(self):
@@ -75,13 +85,16 @@ class TestLocalizer(unittest.TestCase):
         # "translations object has no attr 'plural' error; see
         # see https://github.com/Pylons/pyramid/issues/235
         from pyramid.i18n import Translations
+
         translations = Translations()
         translations._catalog = {}
         localizer = self._makeOne(None, translations)
-        result = localizer.pluralize('singular', 'plural', 2, domain='1',
-                                     mapping={})
+        result = localizer.pluralize(
+            'singular', 'plural', 2, domain='1', mapping={}
+        )
         self.assertEqual(result, 'plural')
 
+
 class Test_negotiate_locale_name(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -91,12 +104,15 @@ class Test_negotiate_locale_name(unittest.TestCase):
 
     def _callFUT(self, request):
         from pyramid.i18n import negotiate_locale_name
+
         return negotiate_locale_name(request)
 
     def _registerImpl(self, impl):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         from pyramid.interfaces import ILocaleNegotiator
+
         registry.registerUtility(impl, ILocaleNegotiator)
 
     def test_no_registry_on_request(self):
@@ -107,6 +123,7 @@ class Test_negotiate_locale_name(unittest.TestCase):
 
     def test_with_registry_on_request(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         self._registerImpl(dummy_negotiator)
         request = DummyRequest()
@@ -116,8 +133,9 @@ class Test_negotiate_locale_name(unittest.TestCase):
 
     def test_default_from_settings(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
-        settings = {'default_locale_name':'settings'}
+        settings = {'default_locale_name': 'settings'}
         registry.settings = settings
         request = DummyRequest()
         request.registry = registry
@@ -126,6 +144,7 @@ class Test_negotiate_locale_name(unittest.TestCase):
 
     def test_use_default_locale_negotiator(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         request = DummyRequest()
         request.registry = registry
@@ -138,6 +157,7 @@ class Test_negotiate_locale_name(unittest.TestCase):
         result = self._callFUT(request)
         self.assertEqual(result, 'en')
 
+
 class Test_get_locale_name(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -147,6 +167,7 @@ class Test_get_locale_name(unittest.TestCase):
 
     def _callFUT(self, request):
         from pyramid.i18n import get_locale_name
+
         return get_locale_name(request)
 
     def test_name_on_request(self):
@@ -155,6 +176,7 @@ class Test_get_locale_name(unittest.TestCase):
         result = self._callFUT(request)
         self.assertEqual(result, 'ie')
 
+
 class Test_make_localizer(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -164,47 +186,54 @@ class Test_make_localizer(unittest.TestCase):
 
     def _callFUT(self, locale, tdirs):
         from pyramid.i18n import make_localizer
+
         return make_localizer(locale, tdirs)
 
     def test_locale_from_mo(self):
         from pyramid.i18n import Localizer
+
         localedirs = [localedir]
         locale_name = 'de'
         result = self._callFUT(locale_name, localedirs)
         self.assertEqual(result.__class__, Localizer)
-        self.assertEqual(result.translate('Approve', 'deformsite'),
-                         'Genehmigen')
+        self.assertEqual(
+            result.translate('Approve', 'deformsite'), 'Genehmigen'
+        )
         self.assertEqual(result.translate('Approve'), 'Approve')
         self.assertTrue(hasattr(result, 'pluralize'))
 
     def test_locale_from_mo_bad_mo(self):
         from pyramid.i18n import Localizer
+
         localedirs = [localedir]
         locale_name = 'be'
         result = self._callFUT(locale_name, localedirs)
         self.assertEqual(result.__class__, Localizer)
-        self.assertEqual(result.translate('Approve', 'deformsite'),
-                         'Approve')
+        self.assertEqual(result.translate('Approve', 'deformsite'), 'Approve')
 
     def test_locale_from_mo_mo_isdir(self):
         from pyramid.i18n import Localizer
+
         localedirs = [localedir]
         locale_name = 'gb'
         result = self._callFUT(locale_name, localedirs)
         self.assertEqual(result.__class__, Localizer)
-        self.assertEqual(result.translate('Approve', 'deformsite'),
-                         'Approve')
+        self.assertEqual(result.translate('Approve', 'deformsite'), 'Approve')
 
     def test_territory_fallback(self):
         from pyramid.i18n import Localizer
+
         localedirs = [localedir]
         locale_name = 'de_DE'
         result = self._callFUT(locale_name, localedirs)
         self.assertEqual(result.__class__, Localizer)
-        self.assertEqual(result.translate('Submit', 'deformsite'),
-                         'different') # prefer translations from de_DE locale
-        self.assertEqual(result.translate('Approve', 'deformsite'),
-                         'Genehmigen') # missing from de_DE locale, but in de
+        self.assertEqual(
+            result.translate('Submit', 'deformsite'), 'different'
+        )  # prefer translations from de_DE locale
+        self.assertEqual(
+            result.translate('Approve', 'deformsite'), 'Genehmigen'
+        )  # missing from de_DE locale, but in de
+
 
 class Test_get_localizer(unittest.TestCase):
     def setUp(self):
@@ -215,6 +244,7 @@ class Test_get_localizer(unittest.TestCase):
 
     def _callFUT(self, request):
         from pyramid.i18n import get_localizer
+
         return get_localizer(request)
 
     def test_it(self):
@@ -222,6 +252,7 @@ class Test_get_localizer(unittest.TestCase):
         request.localizer = 'localizer'
         self.assertEqual(self._callFUT(request), 'localizer')
 
+
 class Test_default_locale_negotiator(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -231,6 +262,7 @@ class Test_default_locale_negotiator(unittest.TestCase):
 
     def _callFUT(self, request):
         from pyramid.i18n import default_locale_negotiator
+
         return default_locale_negotiator(request)
 
     def test_from_none(self):
@@ -256,23 +288,19 @@ class Test_default_locale_negotiator(unittest.TestCase):
         result = self._callFUT(request)
         self.assertEqual(result, 'foo')
 
+
 class TestTranslations(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.i18n import Translations
+
         return Translations
-        
+
     def _makeOne(self):
-        messages1 = [
-            ('foo', 'Voh'),
-            (('foo1', 1), 'Voh1'),
-        ]
-        messages2 = [
-            ('foo', 'VohD'),
-            (('foo1', 1), 'VohD1'),
-        ]
+        messages1 = [('foo', 'Voh'), (('foo1', 1), 'Voh1')]
+        messages2 = [('foo', 'VohD'), (('foo1', 1), 'VohD1')]
 
         klass = self._getTargetClass()
-        
+
         translations1 = klass(None, domain='messages')
         translations1._catalog = dict(messages1)
         translations1.plural = lambda *arg: 1
@@ -284,12 +312,14 @@ class TestTranslations(unittest.TestCase):
 
     def test_load_locales_None(self):
         import gettext
+
         klass = self._getTargetClass()
         result = klass.load(localedir, None, domain=None)
         self.assertEqual(result.__class__, gettext.NullTranslations)
 
     def test_load_domain_None(self):
         import gettext
+
         locales = ['de', 'en']
         klass = self._getTargetClass()
         result = klass.load(localedir, locales, domain=None)
@@ -325,8 +355,9 @@ class TestTranslations(unittest.TestCase):
 
     def test_merge_gnutranslations_not_translations(self):
         import gettext
+
         t = gettext.GNUTranslations()
-        t._catalog = {'a':'b'}
+        t._catalog = {'a': 'b'}
         inst = self._makeOne()
         inst.merge(t)
         self.assertEqual(inst._catalog['a'], 'b')
@@ -406,16 +437,20 @@ class TestTranslations(unittest.TestCase):
         t = self._makeOne()
         self.assertEqual(t.dngettext('messages', 'foo1', 'foos1', 1), 'Voh1')
         self.assertEqual(t.dngettext('messages1', 'foo1', 'foos1', 1), 'VohD1')
-        
+
     def test_ldngettext(self):
         t = self._makeOne()
         self.assertEqual(t.ldngettext('messages', 'foo1', 'foos1', 1), b'Voh1')
-        self.assertEqual(t.ldngettext('messages1', 'foo1', 'foos1', 1),b'VohD1')
+        self.assertEqual(
+            t.ldngettext('messages1', 'foo1', 'foos1', 1), b'VohD1'
+        )
 
     def test_dungettext(self):
         t = self._makeOne()
         self.assertEqual(t.dungettext('messages', 'foo1', 'foos1', 1), 'Voh1')
-        self.assertEqual(t.dungettext('messages1', 'foo1', 'foos1', 1), 'VohD1')
+        self.assertEqual(
+            t.dungettext('messages1', 'foo1', 'foos1', 1), 'VohD1'
+        )
 
     def test_default_germanic_pluralization(self):
         t = self._getTargetClass()()
@@ -423,6 +458,7 @@ class TestTranslations(unittest.TestCase):
         result = t.dungettext('messages', 'foo1', 'foos1', 2)
         self.assertEqual(result, 'foos1')
 
+
 class TestLocalizerRequestMixin(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -432,6 +468,7 @@ class TestLocalizerRequestMixin(unittest.TestCase):
 
     def _makeOne(self):
         from pyramid.i18n import LocalizerRequestMixin
+
         request = LocalizerRequestMixin()
         request.registry = self.config.registry
         request.cookies = {}
@@ -441,12 +478,14 @@ class TestLocalizerRequestMixin(unittest.TestCase):
     def test_default_localizer(self):
         # `localizer` returns a default localizer for `en`
         from pyramid.i18n import Localizer
+
         request = self._makeOne()
         self.assertEqual(request.localizer.__class__, Localizer)
         self.assertEqual(request.locale_name, 'en')
 
     def test_custom_localizer_for_default_locale(self):
         from pyramid.interfaces import ILocalizer
+
         dummy = object()
         self.config.registry.registerUtility(dummy, ILocalizer, name='en')
         request = self._makeOne()
@@ -454,6 +493,7 @@ class TestLocalizerRequestMixin(unittest.TestCase):
 
     def test_custom_localizer_for_custom_locale(self):
         from pyramid.interfaces import ILocalizer
+
         dummy = object()
         self.config.registry.registerUtility(dummy, ILocalizer, name='ie')
         request = self._makeOne()
@@ -463,39 +503,46 @@ class TestLocalizerRequestMixin(unittest.TestCase):
     def test_localizer_from_mo(self):
         from pyramid.interfaces import ITranslationDirectories
         from pyramid.i18n import Localizer
+
         localedirs = [localedir]
         self.config.registry.registerUtility(
-            localedirs, ITranslationDirectories)
+            localedirs, ITranslationDirectories
+        )
         request = self._makeOne()
         request._LOCALE_ = 'de'
         result = request.localizer
         self.assertEqual(result.__class__, Localizer)
-        self.assertEqual(result.translate('Approve', 'deformsite'),
-                         'Genehmigen')
+        self.assertEqual(
+            result.translate('Approve', 'deformsite'), 'Genehmigen'
+        )
         self.assertEqual(result.translate('Approve'), 'Approve')
         self.assertTrue(hasattr(result, 'pluralize'))
 
     def test_localizer_from_mo_bad_mo(self):
         from pyramid.interfaces import ITranslationDirectories
         from pyramid.i18n import Localizer
+
         localedirs = [localedir]
         self.config.registry.registerUtility(
-            localedirs, ITranslationDirectories)
+            localedirs, ITranslationDirectories
+        )
         request = self._makeOne()
         request._LOCALE_ = 'be'
         result = request.localizer
         self.assertEqual(result.__class__, Localizer)
-        self.assertEqual(result.translate('Approve', 'deformsite'),
-                         'Approve')
+        self.assertEqual(result.translate('Approve', 'deformsite'), 'Approve')
+
 
 class DummyRequest(object):
     def __init__(self):
         self.params = {}
         self.cookies = {}
 
+
 def dummy_negotiator(request):
     return 'bogus'
 
+
 class DummyTranslations(object):
     def ugettext(self, text):
         return text
diff --git a/tests/test_integration.py b/tests/test_integration.py
index 741c7599f..250d6790d 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -10,32 +10,33 @@ from pyramid.wsgi import wsgiapp
 from pyramid.view import view_config
 from pyramid.static import static_view
 from pyramid.testing import skip_on
-from pyramid.compat import (
-    text_,
-    url_quote,
-    )
+from pyramid.compat import text_, url_quote
 
 from zope.interface import Interface
 from webtest import TestApp
 
 # 5 years from now (more or less)
-fiveyrsfuture = datetime.datetime.utcnow() + datetime.timedelta(5*365)
+fiveyrsfuture = datetime.datetime.utcnow() + datetime.timedelta(5 * 365)
 
 defaultlocale = locale.getdefaultlocale()[1]
 
+
 class INothing(Interface):
     pass
 
+
 @view_config(for_=INothing)
 @wsgiapp
 def wsgiapptest(environ, start_response):
     """ """
     return '123'
 
+
 class WGSIAppPlusViewConfigTests(unittest.TestCase):
     def test_it(self):
         from venusian import ATTACH_ATTR
         import types
+
         self.assertTrue(getattr(wsgiapptest, ATTACH_ATTR))
         self.assertTrue(type(wsgiapptest) is types.FunctionType)
         context = DummyContext()
@@ -49,21 +50,27 @@ class WGSIAppPlusViewConfigTests(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.config import Configurator
         from . import test_integration
+
         config = Configurator()
         config.scan(test_integration)
         config.commit()
         reg = config.registry
         view = reg.adapters.lookup(
-            (IViewClassifier, IRequest, INothing), IView, name='')
+            (IViewClassifier, IRequest, INothing), IView, name=''
+        )
         self.assertEqual(view.__original_view__, wsgiapptest)
 
+
 class IntegrationBase(object):
     root_factory = None
     package = None
+
     def setUp(self):
         from pyramid.config import Configurator
-        config = Configurator(root_factory=self.root_factory,
-                              package=self.package)
+
+        config = Configurator(
+            root_factory=self.root_factory, package=self.package
+        )
         config.include(self.package)
         app = config.make_wsgi_app()
         self.testapp = TestApp(app)
@@ -72,8 +79,10 @@ class IntegrationBase(object):
     def tearDown(self):
         self.config.end()
 
+
 here = os.path.dirname(__file__)
 
+
 class StaticAppBase(IntegrationBase):
     def test_basic(self):
         res = self.testapp.get('/minimal.txt', status=200)
@@ -81,16 +90,18 @@ class StaticAppBase(IntegrationBase):
 
     def test_hidden(self):
         res = self.testapp.get('/static/.hiddenfile', status=200)
-        _assertBody(res.body, os.path.join(here, 'fixtures/static/.hiddenfile'))
+        _assertBody(
+            res.body, os.path.join(here, 'fixtures/static/.hiddenfile')
+        )
 
-    if defaultlocale is not None: # pragma: no cover
+    if defaultlocale is not None:  # pragma: no cover
         # These tests are expected to fail on LANG=C systems due to decode
         # errors and on non-Linux systems due to git highchar handling
         # vagaries
         def test_highchars_in_pathelement(self):
             path = os.path.join(
-                here,
-                text_('fixtures/static/héhé/index.html', 'utf-8'))
+                here, text_('fixtures/static/héhé/index.html', 'utf-8')
+            )
             pathdir = os.path.dirname(path)
             body = b'<html>hehe</html>\n'
             try:
@@ -106,8 +117,8 @@ class StaticAppBase(IntegrationBase):
 
         def test_highchars_in_filename(self):
             path = os.path.join(
-                here,
-                text_('fixtures/static/héhé.html', 'utf-8'))
+                here, text_('fixtures/static/héhé.html', 'utf-8')
+            )
             body = b'<html>hehe file</html>\n'
             with open(path, 'wb') as fp:
                 fp.write(body)
@@ -120,7 +131,8 @@ class StaticAppBase(IntegrationBase):
 
     def test_not_modified(self):
         self.testapp.extra_environ = {
-            'HTTP_IF_MODIFIED_SINCE':httpdate(fiveyrsfuture)}
+            'HTTP_IF_MODIFIED_SINCE': httpdate(fiveyrsfuture)
+        }
         res = self.testapp.get('/minimal.txt', status=304)
         self.assertEqual(res.body, b'')
 
@@ -135,14 +147,16 @@ class StaticAppBase(IntegrationBase):
 
     def test_directory_noslash_redir_preserves_qs(self):
         res = self.testapp.get('/static?a=1&b=2', status=301)
-        self.assertEqual(res.headers['Location'],
-                         'http://localhost/static/?a=1&b=2')
+        self.assertEqual(
+            res.headers['Location'], 'http://localhost/static/?a=1&b=2'
+        )
 
     def test_directory_noslash_redir_with_scriptname(self):
-        self.testapp.extra_environ = {'SCRIPT_NAME':'/script_name'}
+        self.testapp.extra_environ = {'SCRIPT_NAME': '/script_name'}
         res = self.testapp.get('/static', status=301)
-        self.assertEqual(res.headers['Location'],
-                         'http://localhost/script_name/static/')
+        self.assertEqual(
+            res.headers['Location'], 'http://localhost/script_name/static/'
+        )
 
     def test_directory_withslash(self):
         fn = os.path.join(here, 'fixtures/static/index.html')
@@ -150,30 +164,30 @@ class StaticAppBase(IntegrationBase):
         _assertBody(res.body, fn)
 
     def test_range_inclusive(self):
-        self.testapp.extra_environ = {'HTTP_RANGE':'bytes=1-2'}
+        self.testapp.extra_environ = {'HTTP_RANGE': 'bytes=1-2'}
         res = self.testapp.get('/static/index.html', status=206)
         self.assertEqual(res.body, b'ht')
 
     def test_range_tilend(self):
-        self.testapp.extra_environ = {'HTTP_RANGE':'bytes=-5'}
+        self.testapp.extra_environ = {'HTTP_RANGE': 'bytes=-5'}
         res = self.testapp.get('/static/index.html', status=206)
         self.assertEqual(res.body, b'html>')
 
     def test_range_notbytes(self):
-        self.testapp.extra_environ = {'HTTP_RANGE':'kHz=-5'}
+        self.testapp.extra_environ = {'HTTP_RANGE': 'kHz=-5'}
         res = self.testapp.get('/static/index.html', status=200)
-        _assertBody(res.body,
-                    os.path.join(here, 'fixtures/static/index.html'))
+        _assertBody(res.body, os.path.join(here, 'fixtures/static/index.html'))
 
     def test_range_multiple(self):
-        res = self.testapp.get('/static/index.html',
-                               [('HTTP_RANGE', 'bytes=10-11,11-12')],
-                               status=200)
-        _assertBody(res.body,
-                    os.path.join(here, 'fixtures/static/index.html'))
+        res = self.testapp.get(
+            '/static/index.html',
+            [('HTTP_RANGE', 'bytes=10-11,11-12')],
+            status=200,
+        )
+        _assertBody(res.body, os.path.join(here, 'fixtures/static/index.html'))
 
     def test_range_oob(self):
-        self.testapp.extra_environ = {'HTTP_RANGE':'bytes=1000-1002'}
+        self.testapp.extra_environ = {'HTTP_RANGE': 'bytes=1000-1002'}
         self.testapp.get('/static/index.html', status=416)
 
     def test_notfound(self):
@@ -188,6 +202,7 @@ class StaticAppBase(IntegrationBase):
     def test_oob_slash(self):
         self.testapp.get('/%2F/test_integration.py', status=404)
 
+
 class TestEventOnlySubscribers(IntegrationBase, unittest.TestCase):
     package = 'tests.pkgs.eventonly'
 
@@ -197,55 +212,64 @@ class TestEventOnlySubscribers(IntegrationBase, unittest.TestCase):
 
     def test_sendfoobar(self):
         res = self.testapp.get('/sendfoobar', status=200)
-        self.assertEqual(sorted(res.body.split()),
-                         [b'foobar', b'foobar2', b'foobaryup', b'foobaryup2'])
+        self.assertEqual(
+            sorted(res.body.split()),
+            [b'foobar', b'foobar2', b'foobaryup', b'foobaryup2'],
+        )
+
 
 class TestStaticAppUsingAbsPath(StaticAppBase, unittest.TestCase):
     package = 'tests.pkgs.static_abspath'
 
+
 class TestStaticAppUsingAssetSpec(StaticAppBase, unittest.TestCase):
     package = 'tests.pkgs.static_assetspec'
 
+
 class TestStaticAppNoSubpath(unittest.TestCase):
     staticapp = static_view(os.path.join(here, 'fixtures'), use_subpath=False)
+
     def _makeRequest(self, extra):
         from pyramid.request import Request
         from io import BytesIO
-        kw = {'PATH_INFO':'',
-              'SCRIPT_NAME':'',
-              'SERVER_NAME':'localhost',
-              'SERVER_PORT':'80',
-              'REQUEST_METHOD':'GET',
-              'wsgi.version':(1,0),
-              'wsgi.url_scheme':'http',
-              'wsgi.input':BytesIO()}
+
+        kw = {
+            'PATH_INFO': '',
+            'SCRIPT_NAME': '',
+            'SERVER_NAME': 'localhost',
+            'SERVER_PORT': '80',
+            'REQUEST_METHOD': 'GET',
+            'wsgi.version': (1, 0),
+            'wsgi.url_scheme': 'http',
+            'wsgi.input': BytesIO(),
+        }
         kw.update(extra)
         request = Request(kw)
         return request
 
     def test_basic(self):
-        request = self._makeRequest({'PATH_INFO':'/minimal.txt'})
+        request = self._makeRequest({'PATH_INFO': '/minimal.txt'})
         context = DummyContext()
         result = self.staticapp(context, request)
         self.assertEqual(result.status, '200 OK')
         _assertBody(result.body, os.path.join(here, 'fixtures/minimal.txt'))
 
+
 class TestStaticAppWithRoutePrefix(IntegrationBase, unittest.TestCase):
     package = 'tests.pkgs.static_routeprefix'
 
     def test_includelevel1(self):
         res = self.testapp.get('/static/minimal.txt', status=200)
-        _assertBody(res.body,
-                    os.path.join(here, 'fixtures/minimal.txt'))
+        _assertBody(res.body, os.path.join(here, 'fixtures/minimal.txt'))
 
     def test_includelevel2(self):
         res = self.testapp.get('/prefix/static/index.html', status=200)
-        _assertBody(res.body,
-                    os.path.join(here, 'fixtures/static/index.html'))
+        _assertBody(res.body, os.path.join(here, 'fixtures/static/index.html'))
 
 
 class TestFixtureApp(IntegrationBase, unittest.TestCase):
     package = 'tests.pkgs.fixtureapp'
+
     def test_another(self):
         res = self.testapp.get('/another.html', status=200)
         self.assertEqual(res.body, b'fixture')
@@ -264,38 +288,45 @@ class TestFixtureApp(IntegrationBase, unittest.TestCase):
     def test_protected(self):
         self.testapp.get('/protected.html', status=403)
 
+
 class TestStaticPermApp(IntegrationBase, unittest.TestCase):
     package = 'tests.pkgs.staticpermapp'
     root_factory = 'tests.pkgs.staticpermapp:RootFactory'
+
     def test_allowed(self):
         result = self.testapp.get('/allowed/index.html', status=200)
-        _assertBody(result.body,
-                    os.path.join(here, 'fixtures/static/index.html'))
+        _assertBody(
+            result.body, os.path.join(here, 'fixtures/static/index.html')
+        )
 
     def test_denied_via_acl_global_root_factory(self):
-        self.testapp.extra_environ = {'REMOTE_USER':'bob'}
+        self.testapp.extra_environ = {'REMOTE_USER': 'bob'}
         self.testapp.get('/protected/index.html', status=403)
 
     def test_allowed_via_acl_global_root_factory(self):
-        self.testapp.extra_environ = {'REMOTE_USER':'fred'}
+        self.testapp.extra_environ = {'REMOTE_USER': 'fred'}
         result = self.testapp.get('/protected/index.html', status=200)
-        _assertBody(result.body, 
-                    os.path.join(here, 'fixtures/static/index.html'))
+        _assertBody(
+            result.body, os.path.join(here, 'fixtures/static/index.html')
+        )
 
     def test_denied_via_acl_local_root_factory(self):
-        self.testapp.extra_environ = {'REMOTE_USER':'fred'}
+        self.testapp.extra_environ = {'REMOTE_USER': 'fred'}
         self.testapp.get('/factory_protected/index.html', status=403)
 
     def test_allowed_via_acl_local_root_factory(self):
-        self.testapp.extra_environ = {'REMOTE_USER':'bob'}
+        self.testapp.extra_environ = {'REMOTE_USER': 'bob'}
         result = self.testapp.get('/factory_protected/index.html', status=200)
-        _assertBody(result.body,
-                    os.path.join(here, 'fixtures/static/index.html'))
+        _assertBody(
+            result.body, os.path.join(here, 'fixtures/static/index.html')
+        )
+
 
 class TestCCBug(IntegrationBase, unittest.TestCase):
     # "unordered" as reported in IRC by author of
     # http://labs.creativecommons.org/2010/01/13/cc-engine-and-web-non-frameworks/
     package = 'tests.pkgs.ccbugapp'
+
     def test_rdf(self):
         res = self.testapp.get('/licenses/1/v1/rdf', status=200)
         self.assertEqual(res.body, b'rdf')
@@ -304,11 +335,13 @@ class TestCCBug(IntegrationBase, unittest.TestCase):
         res = self.testapp.get('/licenses/1/v1/juri', status=200)
         self.assertEqual(res.body, b'juri')
 
+
 class TestHybridApp(IntegrationBase, unittest.TestCase):
     # make sure views registered for a route "win" over views registered
     # without one, even though the context of the non-route view may
     # be more specific than the route view.
     package = 'tests.pkgs.hybridapp'
+
     def test_root(self):
         res = self.testapp.get('/', status=200)
         self.assertEqual(res.body, b'global')
@@ -347,27 +380,34 @@ class TestHybridApp(IntegrationBase, unittest.TestCase):
         res = self.testapp.get('/error_sub', status=200)
         self.assertEqual(res.body, b'supressed2')
 
+
 class TestRestBugApp(IntegrationBase, unittest.TestCase):
     # test bug reported by delijati 2010/2/3 (http://pastebin.com/d4cc15515)
     package = 'tests.pkgs.restbugapp'
+
     def test_it(self):
         res = self.testapp.get('/pet', status=200)
         self.assertEqual(res.body, b'gotten')
 
+
 class TestForbiddenAppHasResult(IntegrationBase, unittest.TestCase):
     # test that forbidden exception has ACLDenied result attached
     package = 'tests.pkgs.forbiddenapp'
+
     def test_it(self):
         res = self.testapp.get('/x', status=403)
         message, result = [x.strip() for x in res.body.split(b'\n')]
         self.assertTrue(message.endswith(b'failed permission check'))
         self.assertTrue(
-            result.startswith(b"ACLDenied permission 'private' via ACE "
-                              b"'<default deny>' in ACL "
-                              b"'<No ACL found on any object in resource "
-                              b"lineage>' on context"))
-        self.assertTrue(
-            result.endswith(b"for principals ['system.Everyone']"))
+            result.startswith(
+                b"ACLDenied permission 'private' via ACE "
+                b"'<default deny>' in ACL "
+                b"'<No ACL found on any object in resource "
+                b"lineage>' on context"
+            )
+        )
+        self.assertTrue(result.endswith(b"for principals ['system.Everyone']"))
+
 
 class TestViewDecoratorApp(IntegrationBase, unittest.TestCase):
     package = 'tests.pkgs.viewdecoratorapp'
@@ -380,6 +420,7 @@ class TestViewDecoratorApp(IntegrationBase, unittest.TestCase):
         res = self.testapp.get('/second', status=200)
         self.assertTrue(b'OK2' in res.body)
 
+
 class TestNotFoundView(IntegrationBase, unittest.TestCase):
     package = 'tests.pkgs.notfoundview'
 
@@ -397,6 +438,7 @@ class TestNotFoundView(IntegrationBase, unittest.TestCase):
         res = self.testapp.get('/baz', status=200)
         self.assertTrue(b'baz_notfound' in res.body)
 
+
 class TestForbiddenView(IntegrationBase, unittest.TestCase):
     package = 'tests.pkgs.forbiddenview'
 
@@ -405,10 +447,12 @@ class TestForbiddenView(IntegrationBase, unittest.TestCase):
         self.assertTrue(b'foo_forbidden' in res.body)
         res = self.testapp.get('/bar', status=200)
         self.assertTrue(b'generic_forbidden' in res.body)
-        
+
+
 class TestViewPermissionBug(IntegrationBase, unittest.TestCase):
     # view_execution_permitted bug as reported by Shane at http://lists.repoze.org/pipermail/repoze-dev/2010-October/003603.html
     package = 'tests.pkgs.permbugapp'
+
     def test_test(self):
         res = self.testapp.get('/test', status=200)
         self.assertTrue(b'ACLDenied' in res.body)
@@ -416,9 +460,11 @@ class TestViewPermissionBug(IntegrationBase, unittest.TestCase):
     def test_x(self):
         self.testapp.get('/x', status=403)
 
+
 class TestDefaultViewPermissionBug(IntegrationBase, unittest.TestCase):
     # default_view_permission bug as reported by Wiggy at http://lists.repoze.org/pipermail/repoze-dev/2010-October/003602.html
     package = 'tests.pkgs.defpermbugapp'
+
     def test_x(self):
         res = self.testapp.get('/x', status=403)
         self.assertTrue(b'failed permission check' in res.body)
@@ -431,13 +477,16 @@ class TestDefaultViewPermissionBug(IntegrationBase, unittest.TestCase):
         res = self.testapp.get('/z', status=200)
         self.assertTrue(b'public' in res.body)
 
+
 from .pkgs.exceptionviewapp.models import AnException, NotAnException
-excroot = {'anexception':AnException(),
-           'notanexception':NotAnException()}
+
+excroot = {'anexception': AnException(), 'notanexception': NotAnException()}
+
 
 class TestExceptionViewsApp(IntegrationBase, unittest.TestCase):
     package = 'tests.pkgs.exceptionviewapp'
     root_factory = lambda *arg: excroot
+
     def test_root(self):
         res = self.testapp.get('/', status=200)
         self.assertTrue(b'maybe' in res.body)
@@ -469,11 +518,14 @@ class TestExceptionViewsApp(IntegrationBase, unittest.TestCase):
     def test_raise_httpexception(self):
         res = self.testapp.get('/route_raise_httpexception', status=200)
         self.assertTrue(b'caught' in res.body)
-        
+
+
 class TestConflictApp(unittest.TestCase):
     package = 'tests.pkgs.conflictapp'
+
     def _makeConfig(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         return config
 
@@ -489,10 +541,13 @@ class TestConflictApp(unittest.TestCase):
 
     def test_overridden_autoresolved_view(self):
         from pyramid.response import Response
+
         config = self._makeConfig()
         config.include(self.package)
+
         def thisview(request):
             return Response('this view')
+
         config.add_view(thisview)
         app = config.make_wsgi_app()
         self.testapp = TestApp(app)
@@ -501,10 +556,13 @@ class TestConflictApp(unittest.TestCase):
 
     def test_overridden_route_view(self):
         from pyramid.response import Response
+
         config = self._makeConfig()
         config.include(self.package)
+
         def thisview(request):
             return Response('this view')
+
         config.add_view(thisview, route_name='aroute')
         app = config.make_wsgi_app()
         self.testapp = TestApp(app)
@@ -523,6 +581,7 @@ class TestConflictApp(unittest.TestCase):
         config = self._makeConfig()
         config.include(self.package)
         from pyramid.testing import DummySecurityPolicy
+
         config.set_authorization_policy(DummySecurityPolicy('fred'))
         config.set_authentication_policy(DummySecurityPolicy(permissive=True))
         app = config.make_wsgi_app()
@@ -530,11 +589,14 @@ class TestConflictApp(unittest.TestCase):
         res = self.testapp.get('/protected', status=200)
         self.assertTrue('protected view' in res)
 
+
 class ImperativeIncludeConfigurationTest(unittest.TestCase):
     def setUp(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         from .pkgs.includeapp1.root import configure
+
         configure(config)
         app = config.make_wsgi_app()
         self.testapp = TestApp(app)
@@ -555,9 +617,11 @@ class ImperativeIncludeConfigurationTest(unittest.TestCase):
         res = self.testapp.get('/three', status=200)
         self.assertTrue(b'three' in res.body)
 
+
 class SelfScanAppTest(unittest.TestCase):
     def setUp(self):
         from .test_config.pkgs.selfscan import main
+
         config = main()
         app = config.make_wsgi_app()
         self.testapp = TestApp(app)
@@ -574,9 +638,11 @@ class SelfScanAppTest(unittest.TestCase):
         res = self.testapp.get('/two', status=200)
         self.assertTrue(b'two' in res.body)
 
+
 class WSGIApp2AppTest(unittest.TestCase):
     def setUp(self):
         from .pkgs.wsgiapp2app import main
+
         config = main()
         app = config.make_wsgi_app()
         self.testapp = TestApp(app)
@@ -589,9 +655,11 @@ class WSGIApp2AppTest(unittest.TestCase):
         res = self.testapp.get('/hello', status=200)
         self.assertTrue(b'Hello' in res.body)
 
+
 class SubrequestAppTest(unittest.TestCase):
     def setUp(self):
         from .pkgs.subrequestapp import main
+
         config = main()
         app = config.make_wsgi_app()
         self.testapp = TestApp(app)
@@ -612,8 +680,10 @@ class SubrequestAppTest(unittest.TestCase):
         res = self.testapp.get('/view_five', status=200)
         self.assertTrue(b'Value error raised' in res.body)
 
+
 class RendererScanAppTest(IntegrationBase, unittest.TestCase):
     package = 'tests.pkgs.rendererscanapp'
+
     def test_root(self):
         res = self.testapp.get('/one', status=200)
         self.assertTrue(b'One!' in res.body)
@@ -631,9 +701,11 @@ class RendererScanAppTest(IntegrationBase, unittest.TestCase):
         res = testapp.get('/two', status=200)
         self.assertTrue(b'Two!' in res.body)
 
+
 class UnicodeInURLTest(unittest.TestCase):
     def _makeConfig(self):
         from pyramid.config import Configurator
+
         config = Configurator()
         return config
 
@@ -643,7 +715,9 @@ class UnicodeInURLTest(unittest.TestCase):
 
     def test_unicode_in_url_404(self):
         request_path = '/avalia%C3%A7%C3%A3o_participante'
-        request_path_unicode = b'/avalia\xc3\xa7\xc3\xa3o_participante'.decode('utf-8')
+        request_path_unicode = b'/avalia\xc3\xa7\xc3\xa3o_participante'.decode(
+            'utf-8'
+        )
 
         config = self._makeConfig()
         testapp = self._makeTestApp(config)
@@ -657,7 +731,9 @@ class UnicodeInURLTest(unittest.TestCase):
 
     def test_unicode_in_url_200(self):
         request_path = '/avalia%C3%A7%C3%A3o_participante'
-        request_path_unicode = b'/avalia\xc3\xa7\xc3\xa3o_participante'.decode('utf-8')
+        request_path_unicode = b'/avalia\xc3\xa7\xc3\xa3o_participante'.decode(
+            'utf-8'
+        )
 
         def myview(request):
             return 'XXX'
@@ -676,18 +752,31 @@ class AcceptContentTypeTest(unittest.TestCase):
     def _makeConfig(self):
         def hello_view(request):
             return {'message': 'Hello!'}
+
         from pyramid.config import Configurator
+
         config = Configurator()
         config.add_route('hello', '/hello')
-        config.add_view(hello_view, route_name='hello',
-                        accept='text/plain', renderer='string')
-        config.add_view(hello_view, route_name='hello',
-                        accept='application/json', renderer='json')
+        config.add_view(
+            hello_view,
+            route_name='hello',
+            accept='text/plain',
+            renderer='string',
+        )
+        config.add_view(
+            hello_view,
+            route_name='hello',
+            accept='application/json',
+            renderer='json',
+        )
+
         def hello_fallback_view(request):
             request.response.content_type = 'text/x-fallback'
             return 'hello fallback'
-        config.add_view(hello_fallback_view, route_name='hello',
-                        renderer='string')
+
+        config.add_view(
+            hello_fallback_view, route_name='hello', renderer='string'
+        )
         return config
 
     def _makeTestApp(self, config):
@@ -696,36 +785,49 @@ class AcceptContentTypeTest(unittest.TestCase):
 
     def tearDown(self):
         import pyramid.config
+
         pyramid.config.global_registries.empty()
 
     def test_client_side_ordering(self):
         config = self._makeConfig()
         app = self._makeTestApp(config)
-        res = app.get('/hello', headers={
-            'Accept': 'application/json; q=1.0, text/plain; q=0.9',
-        }, status=200)
+        res = app.get(
+            '/hello',
+            headers={'Accept': 'application/json; q=1.0, text/plain; q=0.9'},
+            status=200,
+        )
         self.assertEqual(res.content_type, 'application/json')
-        res = app.get('/hello', headers={
-            'Accept': 'text/plain; q=0.9, application/json; q=1.0',
-        }, status=200)
+        res = app.get(
+            '/hello',
+            headers={'Accept': 'text/plain; q=0.9, application/json; q=1.0'},
+            status=200,
+        )
         self.assertEqual(res.content_type, 'application/json')
-        res = app.get('/hello', headers={'Accept': 'application/*'}, status=200)
+        res = app.get(
+            '/hello', headers={'Accept': 'application/*'}, status=200
+        )
         self.assertEqual(res.content_type, 'application/json')
         res = app.get('/hello', headers={'Accept': 'text/*'}, status=200)
         self.assertEqual(res.content_type, 'text/plain')
-        res = app.get('/hello', headers={'Accept': 'something/else'}, status=200)
+        res = app.get(
+            '/hello', headers={'Accept': 'something/else'}, status=200
+        )
         self.assertEqual(res.content_type, 'text/x-fallback')
 
     def test_default_server_side_ordering(self):
         config = self._makeConfig()
         app = self._makeTestApp(config)
-        res = app.get('/hello', headers={
-            'Accept': 'application/json, text/plain',
-        }, status=200)
+        res = app.get(
+            '/hello',
+            headers={'Accept': 'application/json, text/plain'},
+            status=200,
+        )
         self.assertEqual(res.content_type, 'text/plain')
-        res = app.get('/hello', headers={
-            'Accept': 'text/plain, application/json',
-        }, status=200)
+        res = app.get(
+            '/hello',
+            headers={'Accept': 'text/plain, application/json'},
+            status=200,
+        )
         self.assertEqual(res.content_type, 'text/plain')
         res = app.get('/hello', headers={'Accept': '*/*'}, status=200)
         self.assertEqual(res.content_type, 'text/plain')
@@ -733,21 +835,28 @@ class AcceptContentTypeTest(unittest.TestCase):
         self.assertEqual(res.content_type, 'text/plain')
         res = app.get('/hello', headers={'Accept': 'invalid'}, status=200)
         self.assertEqual(res.content_type, 'text/plain')
-        res = app.get('/hello', headers={'Accept': 'something/else'}, status=200)
+        res = app.get(
+            '/hello', headers={'Accept': 'something/else'}, status=200
+        )
         self.assertEqual(res.content_type, 'text/x-fallback')
 
     def test_custom_server_side_ordering(self):
         config = self._makeConfig()
         config.add_accept_view_order(
-            'application/json', weighs_more_than='text/plain')
+            'application/json', weighs_more_than='text/plain'
+        )
         app = self._makeTestApp(config)
-        res = app.get('/hello', headers={
-            'Accept': 'application/json, text/plain',
-        }, status=200)
+        res = app.get(
+            '/hello',
+            headers={'Accept': 'application/json, text/plain'},
+            status=200,
+        )
         self.assertEqual(res.content_type, 'application/json')
-        res = app.get('/hello', headers={
-            'Accept': 'text/plain, application/json',
-        }, status=200)
+        res = app.get(
+            '/hello',
+            headers={'Accept': 'text/plain, application/json'},
+            status=200,
+        )
         self.assertEqual(res.content_type, 'application/json')
         res = app.get('/hello', headers={'Accept': '*/*'}, status=200)
         self.assertEqual(res.content_type, 'application/json')
@@ -755,7 +864,9 @@ class AcceptContentTypeTest(unittest.TestCase):
         self.assertEqual(res.content_type, 'application/json')
         res = app.get('/hello', headers={'Accept': 'invalid'}, status=200)
         self.assertEqual(res.content_type, 'application/json')
-        res = app.get('/hello', headers={'Accept': 'something/else'}, status=200)
+        res = app.get(
+            '/hello', headers={'Accept': 'something/else'}, status=200
+        )
         self.assertEqual(res.content_type, 'text/x-fallback')
 
     def test_deprecated_ranges_in_route_predicate(self):
@@ -763,53 +874,66 @@ class AcceptContentTypeTest(unittest.TestCase):
         config.add_route('foo', '/foo', accept='text/*')
         config.add_view(lambda r: 'OK', route_name='foo', renderer='string')
         app = self._makeTestApp(config)
-        res = app.get('/foo', headers={
-            'Accept': 'application/json; q=1.0, text/plain; q=0.9',
-        }, status=200)
+        res = app.get(
+            '/foo',
+            headers={'Accept': 'application/json; q=1.0, text/plain; q=0.9'},
+            status=200,
+        )
         self.assertEqual(res.content_type, 'text/plain')
         self.assertEqual(res.body, b'OK')
-        res = app.get('/foo', headers={
-            'Accept': 'application/json',
-        }, status=404)
+        res = app.get(
+            '/foo', headers={'Accept': 'application/json'}, status=404
+        )
         self.assertEqual(res.content_type, 'application/json')
 
     def test_deprecated_ranges_in_view_predicate(self):
         config = self._makeConfig()
         config.add_route('foo', '/foo')
-        config.add_view(lambda r: 'OK', route_name='foo',
-                        accept='text/*', renderer='string')
+        config.add_view(
+            lambda r: 'OK',
+            route_name='foo',
+            accept='text/*',
+            renderer='string',
+        )
         app = self._makeTestApp(config)
-        res = app.get('/foo', headers={
-            'Accept': 'application/json; q=1.0, text/plain; q=0.9',
-        }, status=200)
+        res = app.get(
+            '/foo',
+            headers={'Accept': 'application/json; q=1.0, text/plain; q=0.9'},
+            status=200,
+        )
         self.assertEqual(res.content_type, 'text/plain')
         self.assertEqual(res.body, b'OK')
-        res = app.get('/foo', headers={
-            'Accept': 'application/json',
-        }, status=404)
+        res = app.get(
+            '/foo', headers={'Accept': 'application/json'}, status=404
+        )
         self.assertEqual(res.content_type, 'application/json')
 
 
 class DummyContext(object):
     pass
 
+
 class DummyRequest:
     subpath = ('__init__.py',)
     traversed = None
-    environ = {'REQUEST_METHOD':'GET', 'wsgi.version':(1,0)}
+    environ = {'REQUEST_METHOD': 'GET', 'wsgi.version': (1, 0)}
+
     def get_response(self, application):
         return application(None, None)
 
+
 def httpdate(ts):
     return ts.strftime("%a, %d %b %Y %H:%M:%S GMT")
 
+
 def read_(filename):
     with open(filename, 'rb') as fp:
         val = fp.read()
         return val
-    
+
+
 def _assertBody(body, filename):
-    if defaultlocale is None: # pragma: no cover
+    if defaultlocale is None:  # pragma: no cover
         # If system locale does not have an encoding then default to utf-8
         filename = filename.encode('utf-8')
     # strip both \n and \r for windows
@@ -818,13 +942,13 @@ def _assertBody(body, filename):
     data = read_(filename)
     data = data.replace(b'\r', b'')
     data = data.replace(b'\n', b'')
-    assert(body == data)
+    assert body == data
 
 
 class MemoryLeaksTest(unittest.TestCase):
-
     def tearDown(self):
         import pyramid.config
+
         pyramid.config.global_registries.empty()
 
     def get_gc_count(self):
@@ -839,6 +963,7 @@ class MemoryLeaksTest(unittest.TestCase):
     @skip_on('pypy')
     def test_memory_leaks(self):
         from pyramid.config import Configurator
+
         Configurator().make_wsgi_app()  # Initialize all global objects
 
         initial_count = self.get_gc_count()
diff --git a/tests/test_location.py b/tests/test_location.py
index e1f47f4ab..b48b7bdaa 100644
--- a/tests/test_location.py
+++ b/tests/test_location.py
@@ -1,15 +1,20 @@
 import unittest
 
+
 class TestInside(unittest.TestCase):
     def _callFUT(self, one, two):
         from pyramid.location import inside
+
         return inside(one, two)
-    
+
     def test_inside(self):
         o1 = Location()
-        o2 = Location(); o2.__parent__ = o1
-        o3 = Location(); o3.__parent__ = o2
-        o4 = Location(); o4.__parent__ = o3
+        o2 = Location()
+        o2.__parent__ = o1
+        o3 = Location()
+        o3.__parent__ = o2
+        o4 = Location()
+        o4.__parent__ = o3
 
         self.assertEqual(self._callFUT(o1, o1), True)
         self.assertEqual(self._callFUT(o2, o1), True)
@@ -18,23 +23,31 @@ class TestInside(unittest.TestCase):
         self.assertEqual(self._callFUT(o1, o4), False)
         self.assertEqual(self._callFUT(o1, None), False)
 
+
 class TestLineage(unittest.TestCase):
     def _callFUT(self, context):
         from pyramid.location import lineage
+
         return lineage(context)
 
     def test_lineage(self):
         o1 = Location()
-        o2 = Location(); o2.__parent__ = o1
-        o3 = Location(); o3.__parent__ = o2
-        o4 = Location(); o4.__parent__ = o3
+        o2 = Location()
+        o2.__parent__ = o1
+        o3 = Location()
+        o3.__parent__ = o2
+        o4 = Location()
+        o4.__parent__ = o3
         result = list(self._callFUT(o3))
         self.assertEqual(result, [o3, o2, o1])
         result = list(self._callFUT(o1))
         self.assertEqual(result, [o1])
 
+
 from pyramid.interfaces import ILocation
 from zope.interface import implementer
+
+
 @implementer(ILocation)
 class Location(object):
     __name__ = __parent__ = None
diff --git a/tests/test_paster.py b/tests/test_paster.py
index dd296d03e..dd53195c7 100644
--- a/tests/test_paster.py
+++ b/tests/test_paster.py
@@ -4,15 +4,18 @@ from .test_scripts.dummy import DummyLoader
 
 here = os.path.dirname(__file__)
 
+
 class Test_get_app(unittest.TestCase):
     def _callFUT(self, config_file, section_name, options=None, _loader=None):
         import pyramid.paster
+
         old_loader = pyramid.paster.get_config_loader
         try:
             if _loader is not None:
                 pyramid.paster.get_config_loader = _loader
-            return pyramid.paster.get_app(config_file, section_name,
-                                          options=options)
+            return pyramid.paster.get_app(
+                config_file, section_name, options=options
+            )
         finally:
             pyramid.paster.get_config_loader = old_loader
 
@@ -20,8 +23,8 @@ class Test_get_app(unittest.TestCase):
         app = DummyApp()
         loader = DummyLoader(app=app)
         result = self._callFUT(
-            '/foo/bar/myapp.ini', 'myapp', options={'a': 'b'},
-            _loader=loader)
+            '/foo/bar/myapp.ini', 'myapp', options={'a': 'b'}, _loader=loader
+        )
         self.assertEqual(loader.uri.path, '/foo/bar/myapp.ini')
         self.assertEqual(len(loader.calls), 1)
         self.assertEqual(loader.calls[0]['op'], 'app')
@@ -33,18 +36,23 @@ class Test_get_app(unittest.TestCase):
         options = {'bar': 'baz'}
         app = self._callFUT(
             os.path.join(here, 'fixtures', 'dummy.ini'),
-            'myapp', options=options)
+            'myapp',
+            options=options,
+        )
         self.assertEqual(app.settings['foo'], 'baz')
 
+
 class Test_get_appsettings(unittest.TestCase):
     def _callFUT(self, config_file, section_name, options=None, _loader=None):
         import pyramid.paster
+
         old_loader = pyramid.paster.get_config_loader
         try:
             if _loader is not None:
                 pyramid.paster.get_config_loader = _loader
-            return pyramid.paster.get_appsettings(config_file, section_name,
-                                                  options=options)
+            return pyramid.paster.get_appsettings(
+                config_file, section_name, options=options
+            )
         finally:
             pyramid.paster.get_config_loader = old_loader
 
@@ -52,8 +60,8 @@ class Test_get_appsettings(unittest.TestCase):
         values = {'a': 1}
         loader = DummyLoader(app_settings=values)
         result = self._callFUT(
-            '/foo/bar/myapp.ini', 'myapp', options={'a': 'b'},
-            _loader=loader)
+            '/foo/bar/myapp.ini', 'myapp', options={'a': 'b'}, _loader=loader
+        )
         self.assertEqual(loader.uri.path, '/foo/bar/myapp.ini')
         self.assertEqual(len(loader.calls), 1)
         self.assertEqual(loader.calls[0]['op'], 'app_settings')
@@ -65,12 +73,16 @@ class Test_get_appsettings(unittest.TestCase):
         options = {'bar': 'baz'}
         result = self._callFUT(
             os.path.join(here, 'fixtures', 'dummy.ini'),
-            'myapp', options=options)
+            'myapp',
+            options=options,
+        )
         self.assertEqual(result['foo'], 'baz')
 
+
 class Test_setup_logging(unittest.TestCase):
     def _callFUT(self, config_file, global_conf=None, _loader=None):
         import pyramid.paster
+
         old_loader = pyramid.paster.get_config_loader
         try:
             if _loader is not None:
@@ -103,13 +115,16 @@ class Test_setup_logging(unittest.TestCase):
         self.assertEqual(loader.calls[0]['op'], 'logging')
         self.assertEqual(loader.calls[0]['defaults'], {'key': 'val'})
 
+
 class Test_bootstrap(unittest.TestCase):
     def _callFUT(self, config_uri, request=None):
         from pyramid.paster import bootstrap
+
         return bootstrap(config_uri, request)
 
     def setUp(self):
         import pyramid.paster
+
         self.original_get_app = pyramid.paster.get_app
         self.original_prepare = pyramid.paster.prepare
         self.app = app = DummyApp()
@@ -120,17 +135,20 @@ class Test_bootstrap(unittest.TestCase):
                 self.a = a
                 self.kw = kw
                 return app
+
         self.get_app = pyramid.paster.get_app = DummyGetApp()
 
         class DummyPrepare(object):
             def __call__(self, *a, **kw):
                 self.a = a
                 self.kw = kw
-                return {'root':root, 'closer':lambda: None}
+                return {'root': root, 'closer': lambda: None}
+
         self.getroot = pyramid.paster.prepare = DummyPrepare()
 
     def tearDown(self):
         import pyramid.paster
+
         pyramid.paster.get_app = self.original_get_app
         pyramid.paster.prepare = self.original_prepare
 
@@ -142,27 +160,34 @@ class Test_bootstrap(unittest.TestCase):
         self.assertEqual(result['root'], self.root)
         self.assertTrue('closer' in result)
 
+
 class Dummy:
     pass
 
+
 class DummyRegistry(object):
     settings = {}
 
+
 dummy_registry = DummyRegistry()
 
+
 class DummyApp:
     def __init__(self):
         self.registry = dummy_registry
 
+
 def make_dummyapp(global_conf, **settings):
     app = DummyApp()
     app.settings = settings
     app.global_conf = global_conf
     return app
 
+
 class DummyRequest:
     application_url = 'http://example.com:5432'
     script_name = ''
+
     def __init__(self, environ):
         self.environ = environ
         self.matchdict = {}
diff --git a/tests/test_path.py b/tests/test_path.py
index 4ab314f17..626bb1139 100644
--- a/tests/test_path.py
+++ b/tests/test_path.py
@@ -4,14 +4,17 @@ from pyramid.compat import PY2
 
 here = os.path.abspath(os.path.dirname(__file__))
 
+
 class TestCallerPath(unittest.TestCase):
     def tearDown(self):
         from . import test_path
+
         if hasattr(test_path, '__abspath__'):
             del test_path.__abspath__
 
     def _callFUT(self, path, level=2):
         from pyramid.path import caller_path
+
         return caller_path(path, level)
 
     def test_isabs(self):
@@ -20,12 +23,14 @@ class TestCallerPath(unittest.TestCase):
 
     def test_pkgrelative(self):
         import os
+
         result = self._callFUT('a/b/c')
         self.assertEqual(result, os.path.join(here, 'a/b/c'))
 
     def test_memoization_has_abspath(self):
         import os
         from . import test_path
+
         test_path.__abspath__ = '/foo/bar'
         result = self._callFUT('a/b/c')
         self.assertEqual(result, os.path.join('/foo/bar', 'a/b/c'))
@@ -33,37 +38,46 @@ class TestCallerPath(unittest.TestCase):
     def test_memoization_success(self):
         import os
         from . import test_path
+
         result = self._callFUT('a/b/c')
         self.assertEqual(result, os.path.join(here, 'a/b/c'))
         self.assertEqual(test_path.__abspath__, here)
 
+
 class TestCallerModule(unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from pyramid.path import caller_module
+
         return caller_module(*arg, **kw)
 
     def test_it_level_1(self):
         from . import test_path
+
         result = self._callFUT(1)
         self.assertEqual(result, test_path)
 
     def test_it_level_2(self):
         from . import test_path
+
         result = self._callFUT(2)
         self.assertEqual(result, test_path)
 
     def test_it_level_3(self):
         from . import test_path
+
         result = self._callFUT(3)
         self.assertNotEqual(result, test_path)
 
     def test_it_no___name__(self):
         class DummyFrame(object):
             f_globals = {}
+
         class DummySys(object):
             def _getframe(self, level):
                 return DummyFrame()
-            modules = {'__main__':'main'}
+
+            modules = {'__main__': 'main'}
+
         dummy_sys = DummySys()
         result = self._callFUT(3, sys=dummy_sys)
         self.assertEqual(result, 'main')
@@ -72,67 +86,82 @@ class TestCallerModule(unittest.TestCase):
 class TestCallerPackage(unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from pyramid.path import caller_package
+
         return caller_package(*arg, **kw)
 
     def test_it_level_1(self):
         import tests
+
         result = self._callFUT(1)
         self.assertEqual(result, tests)
 
     def test_it_level_2(self):
         import tests
+
         result = self._callFUT(2)
         self.assertEqual(result, tests)
 
     def test_it_level_3(self):
         import unittest
+
         result = self._callFUT(3)
         self.assertEqual(result, unittest)
 
     def test_it_package(self):
         import tests
+
         def dummy_caller_module(*arg):
             return tests
+
         result = self._callFUT(1, caller_module=dummy_caller_module)
         self.assertEqual(result, tests)
-        
+
+
 class TestPackagePath(unittest.TestCase):
     def _callFUT(self, package):
         from pyramid.path import package_path
+
         return package_path(package)
 
     def test_it_package(self):
         import tests
+
         package = DummyPackageOrModule(tests)
         result = self._callFUT(package)
         self.assertEqual(result, package.package_path)
-        
+
     def test_it_module(self):
         from . import test_path
+
         module = DummyPackageOrModule(test_path)
         result = self._callFUT(module)
         self.assertEqual(result, module.package_path)
 
     def test_memoization_success(self):
         from . import test_path
+
         module = DummyPackageOrModule(test_path)
         self._callFUT(module)
         self.assertEqual(module.__abspath__, module.package_path)
-        
+
     def test_memoization_fail(self):
         from . import test_path
+
         module = DummyPackageOrModule(test_path, raise_exc=TypeError)
         result = self._callFUT(module)
         self.assertFalse(hasattr(module, '__abspath__'))
         self.assertEqual(result, module.package_path)
 
+
 class TestPackageOf(unittest.TestCase):
     def _callFUT(self, package):
         from pyramid.path import package_of
+
         return package_of(package)
 
     def test_it_package(self):
         import tests
+
         package = DummyPackageOrModule(tests)
         result = self._callFUT(package)
         self.assertEqual(result, tests)
@@ -140,29 +169,35 @@ class TestPackageOf(unittest.TestCase):
     def test_it_module(self):
         import tests.test_path
         import tests
+
         package = DummyPackageOrModule(tests.test_path)
         result = self._callFUT(package)
         self.assertEqual(result, tests)
 
+
 class TestPackageName(unittest.TestCase):
     def _callFUT(self, package):
         from pyramid.path import package_name
+
         return package_name(package)
 
     def test_it_package(self):
         import tests
+
         package = DummyPackageOrModule(tests)
         result = self._callFUT(package)
         self.assertEqual(result, 'tests')
 
     def test_it_namespace_package(self):
         import tests
+
         package = DummyNamespacePackage(tests)
         result = self._callFUT(package)
         self.assertEqual(result, 'tests')
-        
+
     def test_it_module(self):
         from . import test_path
+
         module = DummyPackageOrModule(test_path)
         result = self._callFUT(module)
         self.assertEqual(result, 'tests')
@@ -173,12 +208,15 @@ class TestPackageName(unittest.TestCase):
 
     def test_it_main(self):
         import __main__
+
         result = self._callFUT(__main__)
         self.assertEqual(result, '__main__')
 
+
 class TestResolver(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.path import Resolver
+
         return Resolver
 
     def _makeOne(self, package):
@@ -187,26 +225,29 @@ class TestResolver(unittest.TestCase):
     def test_get_package_caller_package(self):
         import tests
         from pyramid.path import CALLER_PACKAGE
-        self.assertEqual(self._makeOne(CALLER_PACKAGE).get_package(),
-                         tests)
+
+        self.assertEqual(self._makeOne(CALLER_PACKAGE).get_package(), tests)
 
     def test_get_package_name_caller_package(self):
         from pyramid.path import CALLER_PACKAGE
-        self.assertEqual(self._makeOne(CALLER_PACKAGE).get_package_name(),
-                         'tests')
+
+        self.assertEqual(
+            self._makeOne(CALLER_PACKAGE).get_package_name(), 'tests'
+        )
 
     def test_get_package_string(self):
         import tests
-        self.assertEqual(self._makeOne('tests').get_package(),
-                         tests)
+
+        self.assertEqual(self._makeOne('tests').get_package(), tests)
 
     def test_get_package_name_string(self):
-        self.assertEqual(self._makeOne('tests').get_package_name(),
-                         'tests')
+        self.assertEqual(self._makeOne('tests').get_package_name(), 'tests')
+
 
 class TestAssetResolver(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.path import AssetResolver
+
         return AssetResolver
 
     def _makeOne(self, package='tests'):
@@ -214,18 +255,21 @@ class TestAssetResolver(unittest.TestCase):
 
     def test_ctor_as_package(self):
         import sys
+
         tests = sys.modules['tests']
         inst = self._makeOne(tests)
         self.assertEqual(inst.package, tests)
 
     def test_ctor_as_str(self):
         import sys
+
         tests = sys.modules['tests']
         inst = self._makeOne('tests')
         self.assertEqual(inst.package, tests)
 
     def test_resolve_abspath(self):
         from pyramid.path import FSAssetDescriptor
+
         inst = self._makeOne(None)
         r = inst.resolve(os.path.join(here, 'test_asset.py'))
         self.assertEqual(r.__class__, FSAssetDescriptor)
@@ -233,6 +277,7 @@ class TestAssetResolver(unittest.TestCase):
 
     def test_resolve_absspec(self):
         from pyramid.path import PkgResourcesAssetDescriptor
+
         inst = self._makeOne(None)
         r = inst.resolve('tests:test_asset.py')
         self.assertEqual(r.__class__, PkgResourcesAssetDescriptor)
@@ -240,6 +285,7 @@ class TestAssetResolver(unittest.TestCase):
 
     def test_resolve_relspec_with_pkg(self):
         from pyramid.path import PkgResourcesAssetDescriptor
+
         inst = self._makeOne('tests')
         r = inst.resolve('test_asset.py')
         self.assertEqual(r.__class__, PkgResourcesAssetDescriptor)
@@ -252,14 +298,17 @@ class TestAssetResolver(unittest.TestCase):
     def test_resolve_relspec_caller_package(self):
         from pyramid.path import PkgResourcesAssetDescriptor
         from pyramid.path import CALLER_PACKAGE
+
         inst = self._makeOne(CALLER_PACKAGE)
         r = inst.resolve('test_asset.py')
         self.assertEqual(r.__class__, PkgResourcesAssetDescriptor)
         self.assertTrue(r.exists())
-        
+
+
 class TestPkgResourcesAssetDescriptor(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.path import PkgResourcesAssetDescriptor
+
         return PkgResourcesAssetDescriptor
 
     def _makeOne(self, pkg='tests', path='test_asset.py'):
@@ -268,11 +317,13 @@ class TestPkgResourcesAssetDescriptor(unittest.TestCase):
     def test_class_conforms_to_IAssetDescriptor(self):
         from pyramid.interfaces import IAssetDescriptor
         from zope.interface.verify import verifyClass
+
         verifyClass(IAssetDescriptor, self._getTargetClass())
-        
+
     def test_instance_conforms_to_IAssetDescriptor(self):
         from pyramid.interfaces import IAssetDescriptor
         from zope.interface.verify import verifyObject
+
         verifyObject(IAssetDescriptor, self._makeOne())
 
     def test_absspec(self):
@@ -288,33 +339,31 @@ class TestPkgResourcesAssetDescriptor(unittest.TestCase):
         inst.pkg_resources = DummyPkgResource()
         inst.pkg_resources.resource_stream = lambda x, y: '%s:%s' % (x, y)
         s = inst.stream()
-        self.assertEqual(s,
-                         '%s:%s' % ('tests', 'test_asset.py'))
+        self.assertEqual(s, '%s:%s' % ('tests', 'test_asset.py'))
 
     def test_isdir(self):
         inst = self._makeOne()
         inst.pkg_resources = DummyPkgResource()
         inst.pkg_resources.resource_isdir = lambda x, y: '%s:%s' % (x, y)
-        self.assertEqual(inst.isdir(),
-                         '%s:%s' % ('tests', 'test_asset.py'))
+        self.assertEqual(inst.isdir(), '%s:%s' % ('tests', 'test_asset.py'))
 
     def test_listdir(self):
         inst = self._makeOne()
         inst.pkg_resources = DummyPkgResource()
         inst.pkg_resources.resource_listdir = lambda x, y: '%s:%s' % (x, y)
-        self.assertEqual(inst.listdir(),
-                         '%s:%s' % ('tests', 'test_asset.py'))
+        self.assertEqual(inst.listdir(), '%s:%s' % ('tests', 'test_asset.py'))
 
     def test_exists(self):
         inst = self._makeOne()
         inst.pkg_resources = DummyPkgResource()
         inst.pkg_resources.resource_exists = lambda x, y: '%s:%s' % (x, y)
-        self.assertEqual(inst.exists(),
-                         '%s:%s' % ('tests', 'test_asset.py'))
+        self.assertEqual(inst.exists(), '%s:%s' % ('tests', 'test_asset.py'))
+
 
 class TestFSAssetDescriptor(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.path import FSAssetDescriptor
+
         return FSAssetDescriptor
 
     def _makeOne(self, path=os.path.join(here, 'test_asset.py')):
@@ -323,11 +372,13 @@ class TestFSAssetDescriptor(unittest.TestCase):
     def test_class_conforms_to_IAssetDescriptor(self):
         from pyramid.interfaces import IAssetDescriptor
         from zope.interface.verify import verifyClass
+
         verifyClass(IAssetDescriptor, self._getTargetClass())
-        
+
     def test_instance_conforms_to_IAssetDescriptor(self):
         from pyramid.interfaces import IAssetDescriptor
         from zope.interface.verify import verifyObject
+
         verifyObject(IAssetDescriptor, self._makeOne())
 
     def test_absspec(self):
@@ -361,9 +412,11 @@ class TestFSAssetDescriptor(unittest.TestCase):
         inst = self._makeOne()
         self.assertTrue(inst.exists())
 
+
 class TestDottedNameResolver(unittest.TestCase):
     def _makeOne(self, package=None):
         from pyramid.path import DottedNameResolver
+
         return DottedNameResolver(package)
 
     def config_exc(self, func, *arg, **kw):
@@ -372,7 +425,7 @@ class TestDottedNameResolver(unittest.TestCase):
         except ValueError as e:
             return e
         else:
-            raise AssertionError('Invalid not raised') # pragma: no cover
+            raise AssertionError('Invalid not raised')  # pragma: no cover
 
     def test_zope_dottedname_style_resolve_builtin(self):
         typ = self._makeOne()
@@ -385,30 +438,40 @@ class TestDottedNameResolver(unittest.TestCase):
     def test_zope_dottedname_style_resolve_absolute(self):
         typ = self._makeOne()
         result = typ._zope_dottedname_style(
-            'tests.test_path.TestDottedNameResolver', None)
+            'tests.test_path.TestDottedNameResolver', None
+        )
         self.assertEqual(result, self.__class__)
 
     def test_zope_dottedname_style_irrresolveable_absolute(self):
         typ = self._makeOne()
-        self.assertRaises(ImportError, typ._zope_dottedname_style,
-            'pyramid.test_path.nonexisting_name', None)
+        self.assertRaises(
+            ImportError,
+            typ._zope_dottedname_style,
+            'pyramid.test_path.nonexisting_name',
+            None,
+        )
 
     def test__zope_dottedname_style_resolve_relative(self):
         import tests
+
         typ = self._makeOne()
         result = typ._zope_dottedname_style(
-            '.test_path.TestDottedNameResolver', tests)
+            '.test_path.TestDottedNameResolver', tests
+        )
         self.assertEqual(result, self.__class__)
 
     def test__zope_dottedname_style_resolve_relative_leading_dots(self):
         import tests.test_path
+
         typ = self._makeOne()
         result = typ._zope_dottedname_style(
-            '..tests.test_path.TestDottedNameResolver', tests)
+            '..tests.test_path.TestDottedNameResolver', tests
+        )
         self.assertEqual(result, self.__class__)
 
     def test__zope_dottedname_style_resolve_relative_is_dot(self):
         import tests
+
         typ = self._makeOne()
         result = typ._zope_dottedname_style('.', tests)
         self.assertEqual(result, tests)
@@ -417,24 +480,28 @@ class TestDottedNameResolver(unittest.TestCase):
         typ = self._makeOne()
         e = self.config_exc(typ._zope_dottedname_style, '.', None)
         self.assertEqual(
-            e.args[0],
-            "relative name '.' irresolveable without package")
+            e.args[0], "relative name '.' irresolveable without package"
+        )
 
     def test_zope_dottedname_style_resolve_relative_nocurrentpackage(self):
         typ = self._makeOne()
         e = self.config_exc(typ._zope_dottedname_style, '.whatever', None)
         self.assertEqual(
             e.args[0],
-            "relative name '.whatever' irresolveable without package")
+            "relative name '.whatever' irresolveable without package",
+        )
 
     def test_zope_dottedname_style_irrresolveable_relative(self):
         import tests
+
         typ = self._makeOne()
-        self.assertRaises(ImportError, typ._zope_dottedname_style,
-                          '.notexisting', tests)
+        self.assertRaises(
+            ImportError, typ._zope_dottedname_style, '.notexisting', tests
+        )
 
     def test__zope_dottedname_style_resolveable_relative(self):
         import tests
+
         typ = self._makeOne()
         result = typ._zope_dottedname_style('.', tests)
         self.assertEqual(result, tests)
@@ -442,49 +509,58 @@ class TestDottedNameResolver(unittest.TestCase):
     def test__zope_dottedname_style_irresolveable_absolute(self):
         typ = self._makeOne()
         self.assertRaises(
-            ImportError,
-            typ._zope_dottedname_style, 'pyramid.fudge.bar', None)
+            ImportError, typ._zope_dottedname_style, 'pyramid.fudge.bar', None
+        )
 
     def test__zope_dottedname_style_resolveable_absolute(self):
         typ = self._makeOne()
         result = typ._zope_dottedname_style(
-            'tests.test_path.TestDottedNameResolver', None)
+            'tests.test_path.TestDottedNameResolver', None
+        )
         self.assertEqual(result, self.__class__)
 
     def test__pkg_resources_style_resolve_absolute(self):
         typ = self._makeOne()
         result = typ._pkg_resources_style(
-            'tests.test_path:TestDottedNameResolver', None)
+            'tests.test_path:TestDottedNameResolver', None
+        )
         self.assertEqual(result, self.__class__)
 
     def test__pkg_resources_style_irrresolveable_absolute(self):
         typ = self._makeOne()
-        self.assertRaises(ImportError, typ._pkg_resources_style,
-            'tests:nonexisting', None)
+        self.assertRaises(
+            ImportError, typ._pkg_resources_style, 'tests:nonexisting', None
+        )
 
     def test__pkg_resources_style_resolve_relative(self):
         import tests
+
         typ = self._makeOne()
         result = typ._pkg_resources_style(
-            '.test_path:TestDottedNameResolver', tests)
+            '.test_path:TestDottedNameResolver', tests
+        )
         self.assertEqual(result, self.__class__)
 
     def test__pkg_resources_style_resolve_relative_is_dot(self):
         import tests
+
         typ = self._makeOne()
         result = typ._pkg_resources_style('.', tests)
         self.assertEqual(result, tests)
 
     def test__pkg_resources_style_resolve_relative_nocurrentpackage(self):
         typ = self._makeOne()
-        self.assertRaises(ValueError, typ._pkg_resources_style,
-                          '.whatever', None)
+        self.assertRaises(
+            ValueError, typ._pkg_resources_style, '.whatever', None
+        )
 
     def test__pkg_resources_style_irrresolveable_relative(self):
         import pyramid
+
         typ = self._makeOne()
-        self.assertRaises(ImportError, typ._pkg_resources_style,
-                          ':notexisting', pyramid)
+        self.assertRaises(
+            ImportError, typ._pkg_resources_style, ':notexisting', pyramid
+        )
 
     def test_resolve_not_a_string(self):
         typ = self._makeOne()
@@ -493,14 +569,12 @@ class TestDottedNameResolver(unittest.TestCase):
 
     def test_resolve_using_pkgresources_style(self):
         typ = self._makeOne()
-        result = typ.resolve(
-            'tests.test_path:TestDottedNameResolver')
+        result = typ.resolve('tests.test_path:TestDottedNameResolver')
         self.assertEqual(result, self.__class__)
 
     def test_resolve_using_zope_dottedname_style(self):
         typ = self._makeOne()
-        result = typ.resolve(
-            'tests.test_path:TestDottedNameResolver')
+        result = typ.resolve('tests.test_path:TestDottedNameResolver')
         self.assertEqual(result, self.__class__)
 
     def test_resolve_missing_raises(self):
@@ -509,23 +583,30 @@ class TestDottedNameResolver(unittest.TestCase):
 
     def test_resolve_caller_package(self):
         from pyramid.path import CALLER_PACKAGE
+
         typ = self._makeOne(CALLER_PACKAGE)
-        self.assertEqual(typ.resolve('.test_path.TestDottedNameResolver'),
-                         self.__class__)
+        self.assertEqual(
+            typ.resolve('.test_path.TestDottedNameResolver'), self.__class__
+        )
 
     def test_maybe_resolve_caller_package(self):
         from pyramid.path import CALLER_PACKAGE
+
         typ = self._makeOne(CALLER_PACKAGE)
-        self.assertEqual(typ.maybe_resolve('.test_path.TestDottedNameResolver'),
-                         self.__class__)
+        self.assertEqual(
+            typ.maybe_resolve('.test_path.TestDottedNameResolver'),
+            self.__class__,
+        )
 
     def test_ctor_string_module_resolveable(self):
         import tests
+
         typ = self._makeOne('tests.test_path')
         self.assertEqual(typ.package, tests)
 
     def test_ctor_string_package_resolveable(self):
         import tests
+
         typ = self._makeOne('tests')
         self.assertEqual(typ.package, tests)
 
@@ -535,11 +616,13 @@ class TestDottedNameResolver(unittest.TestCase):
     def test_ctor_module(self):
         import tests
         from . import test_path
+
         typ = self._makeOne(test_path)
         self.assertEqual(typ.package, tests)
 
     def test_ctor_package(self):
         import tests
+
         typ = self._makeOne(tests)
         self.assertEqual(typ.package, tests)
 
@@ -547,16 +630,20 @@ class TestDottedNameResolver(unittest.TestCase):
         typ = self._makeOne(None)
         self.assertEqual(typ.package, None)
 
+
 class DummyPkgResource(object):
     pass
 
+
 class DummyPackageOrModule:
     def __init__(self, real_package_or_module, raise_exc=None):
         self.__dict__['raise_exc'] = raise_exc
         self.__dict__['__name__'] = real_package_or_module.__name__
         import os
+
         self.__dict__['package_path'] = os.path.dirname(
-            os.path.abspath(real_package_or_module.__file__))
+            os.path.abspath(real_package_or_module.__file__)
+        )
         self.__dict__['__file__'] = real_package_or_module.__file__
 
     def __setattr__(self, key, val):
@@ -564,12 +651,15 @@ class DummyPackageOrModule:
             raise self.raise_exc
         self.__dict__[key] = val
 
+
 class DummyNamespacePackage:
     """Has no __file__ attribute.
     """
-    
+
     def __init__(self, real_package_or_module):
         self.__name__ = real_package_or_module.__name__
         import os
+
         self.package_path = os.path.dirname(
-            os.path.abspath(real_package_or_module.__file__))
+            os.path.abspath(real_package_or_module.__file__)
+        )
diff --git a/tests/test_predicates.py b/tests/test_predicates.py
index da0b44708..c072b4229 100644
--- a/tests/test_predicates.py
+++ b/tests/test_predicates.py
@@ -4,18 +4,20 @@ from pyramid import testing
 
 from pyramid.compat import text_
 
+
 class TestXHRPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import XHRPredicate
+
         return XHRPredicate(val, None)
-    
+
     def test___call___true(self):
         inst = self._makeOne(True)
         request = Dummy()
         request.is_xhr = True
         result = inst(None, request)
         self.assertTrue(result)
-        
+
     def test___call___false(self):
         inst = self._makeOne(True)
         request = Dummy()
@@ -31,60 +33,65 @@ class TestXHRPredicate(unittest.TestCase):
         inst = self._makeOne(True)
         self.assertEqual(inst.phash(), 'xhr = True')
 
+
 class TestRequestMethodPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import RequestMethodPredicate
+
         return RequestMethodPredicate(val, None)
 
     def test_ctor_get_but_no_head(self):
         inst = self._makeOne('GET')
         self.assertEqual(inst.val, ('GET', 'HEAD'))
-    
+
     def test___call___true_single(self):
         inst = self._makeOne('GET')
         request = Dummy()
         request.method = 'GET'
         result = inst(None, request)
         self.assertTrue(result)
-        
+
     def test___call___true_multi(self):
-        inst = self._makeOne(('GET','HEAD'))
+        inst = self._makeOne(('GET', 'HEAD'))
         request = Dummy()
         request.method = 'GET'
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___false(self):
-        inst = self._makeOne(('GET','HEAD'))
+        inst = self._makeOne(('GET', 'HEAD'))
         request = Dummy()
         request.method = 'POST'
         result = inst(None, request)
         self.assertFalse(result)
 
     def test_text(self):
-        inst = self._makeOne(('HEAD','GET'))
+        inst = self._makeOne(('HEAD', 'GET'))
         self.assertEqual(inst.text(), 'request_method = GET,HEAD')
 
     def test_phash(self):
-        inst = self._makeOne(('HEAD','GET'))
+        inst = self._makeOne(('HEAD', 'GET'))
         self.assertEqual(inst.phash(), 'request_method = GET,HEAD')
 
+
 class TestPathInfoPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import PathInfoPredicate
+
         return PathInfoPredicate(val, None)
 
     def test_ctor_compilefail(self):
         from pyramid.exceptions import ConfigurationError
+
         self.assertRaises(ConfigurationError, self._makeOne, '\\')
-    
+
     def test___call___true(self):
         inst = self._makeOne(r'/\d{2}')
         request = Dummy()
         request.upath_info = text_('/12')
         result = inst(None, request)
         self.assertTrue(result)
-        
+
     def test___call___false(self):
         inst = self._makeOne(r'/\d{2}')
         request = Dummy()
@@ -100,36 +107,38 @@ class TestPathInfoPredicate(unittest.TestCase):
         inst = self._makeOne('/')
         self.assertEqual(inst.phash(), 'path_info = /')
 
+
 class TestRequestParamPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import RequestParamPredicate
+
         return RequestParamPredicate(val, None)
 
     def test___call___true_exists(self):
         inst = self._makeOne('abc')
         request = Dummy()
-        request.params = {'abc':1}
+        request.params = {'abc': 1}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___true_withval(self):
         inst = self._makeOne('abc=1')
         request = Dummy()
-        request.params = {'abc':'1'}
+        request.params = {'abc': '1'}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___true_multi(self):
         inst = self._makeOne(('abc', '=def =2= '))
         request = Dummy()
-        request.params = {'abc':'1', '=def': '2='}
+        request.params = {'abc': '1', '=def': '2='}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___false_multi(self):
         inst = self._makeOne(('abc=3', 'def =2 '))
         request = Dummy()
-        request.params = {'abc':'3', 'def': '1'}
+        request.params = {'abc': '3', 'def': '1'}
         result = inst(None, request)
         self.assertFalse(result)
 
@@ -172,26 +181,27 @@ class TestRequestParamPredicate(unittest.TestCase):
         inst = self._makeOne('abc=   1')
         self.assertEqual(inst.phash(), "request_param abc=1")
 
+
 class TestMatchParamPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import MatchParamPredicate
+
         return MatchParamPredicate(val, None)
 
     def test___call___true_single(self):
         inst = self._makeOne('abc=1')
         request = Dummy()
-        request.matchdict = {'abc':'1'}
+        request.matchdict = {'abc': '1'}
         result = inst(None, request)
         self.assertTrue(result)
 
-
     def test___call___true_multi(self):
         inst = self._makeOne(('abc=1', 'def=2'))
         request = Dummy()
-        request.matchdict = {'abc':'1', 'def':'2'}
+        request.matchdict = {'abc': '1', 'def': '2'}
         result = inst(None, request)
         self.assertTrue(result)
-        
+
     def test___call___false(self):
         inst = self._makeOne('abc=1')
         request = Dummy()
@@ -214,9 +224,11 @@ class TestMatchParamPredicate(unittest.TestCase):
         inst = self._makeOne(('def=  1', 'abc =2'))
         self.assertEqual(inst.phash(), 'match_param abc=2,def=1')
 
+
 class TestCustomPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import CustomPredicate
+
         return CustomPredicate(val, None)
 
     def test___call___true(self):
@@ -224,15 +236,17 @@ class TestCustomPredicate(unittest.TestCase):
             self.assertEqual(context, None)
             self.assertEqual(request, None)
             return True
+
         inst = self._makeOne(func)
         result = inst(None, None)
         self.assertTrue(result)
-    
+
     def test___call___false(self):
         def func(context, request):
             self.assertEqual(context, None)
             self.assertEqual(request, None)
             return False
+
         inst = self._makeOne(func)
         result = inst(None, None)
         self.assertFalse(result)
@@ -242,7 +256,7 @@ class TestCustomPredicate(unittest.TestCase):
         pred.__text__ = 'text'
         inst = self._makeOne(pred)
         self.assertEqual(inst.text(), 'text')
-         
+
     def test_text_func_repr(self):
         pred = predicate()
         inst = self._makeOne(pred)
@@ -253,39 +267,44 @@ class TestCustomPredicate(unittest.TestCase):
         inst = self._makeOne(pred)
         self.assertEqual(inst.phash(), 'custom:1')
 
+
 class TestTraversePredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import TraversePredicate
+
         return TraversePredicate(val, None)
-    
+
     def test___call__traverse_has_remainder_already(self):
         inst = self._makeOne('/1/:a/:b')
-        info = {'traverse':'abc'}
+        info = {'traverse': 'abc'}
         request = Dummy()
         result = inst(info, request)
         self.assertEqual(result, True)
-        self.assertEqual(info, {'traverse':'abc'})
+        self.assertEqual(info, {'traverse': 'abc'})
 
     def test___call__traverse_matches(self):
         inst = self._makeOne('/1/:a/:b')
-        info = {'match':{'a':'a', 'b':'b'}}
+        info = {'match': {'a': 'a', 'b': 'b'}}
         request = Dummy()
         result = inst(info, request)
         self.assertEqual(result, True)
-        self.assertEqual(info, {'match':
-                                {'a':'a', 'b':'b', 'traverse':('1', 'a', 'b')}})
+        self.assertEqual(
+            info, {'match': {'a': 'a', 'b': 'b', 'traverse': ('1', 'a', 'b')}}
+        )
 
     def test___call__traverse_matches_with_highorder_chars(self):
         inst = self._makeOne(text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8'))
-        info = {'match':{'x':text_(b'Qu\xc3\xa9bec', 'utf-8')}}
+        info = {'match': {'x': text_(b'Qu\xc3\xa9bec', 'utf-8')}}
         request = Dummy()
         result = inst(info, request)
         self.assertEqual(result, True)
         self.assertEqual(
             info['match']['traverse'],
-            (text_(b'La Pe\xc3\xb1a', 'utf-8'),
-             text_(b'Qu\xc3\xa9bec', 'utf-8'))
-             )
+            (
+                text_(b'La Pe\xc3\xb1a', 'utf-8'),
+                text_(b'Qu\xc3\xa9bec', 'utf-8'),
+            ),
+        )
 
     def test_text(self):
         inst = self._makeOne('/abc')
@@ -295,9 +314,11 @@ class TestTraversePredicate(unittest.TestCase):
         inst = self._makeOne('/abc')
         self.assertEqual(inst.phash(), '')
 
+
 class Test_CheckCSRFTokenPredicate(unittest.TestCase):
     def _makeOne(self, val, config):
         from pyramid.predicates import CheckCSRFTokenPredicate
+
         return CheckCSRFTokenPredicate(val, config)
 
     def test_text(self):
@@ -307,28 +328,32 @@ class Test_CheckCSRFTokenPredicate(unittest.TestCase):
     def test_phash(self):
         inst = self._makeOne(True, None)
         self.assertEqual(inst.phash(), 'check_csrf = True')
-        
+
     def test_it_call_val_True(self):
         inst = self._makeOne(True, None)
         request = Dummy()
+
         def check_csrf_token(req, val, raises=True):
             self.assertEqual(req, request)
             self.assertEqual(val, 'csrf_token')
             self.assertEqual(raises, False)
             return True
-        inst.check_csrf_token  = check_csrf_token
+
+        inst.check_csrf_token = check_csrf_token
         result = inst(None, request)
         self.assertEqual(result, True)
 
     def test_it_call_val_str(self):
         inst = self._makeOne('abc', None)
         request = Dummy()
+
         def check_csrf_token(req, val, raises=True):
             self.assertEqual(req, request)
             self.assertEqual(val, 'abc')
             self.assertEqual(raises, False)
             return True
-        inst.check_csrf_token  = check_csrf_token
+
+        inst.check_csrf_token = check_csrf_token
         result = inst(None, request)
         self.assertEqual(result, True)
 
@@ -338,36 +363,38 @@ class Test_CheckCSRFTokenPredicate(unittest.TestCase):
         result = inst(None, request)
         self.assertEqual(result, True)
 
+
 class TestHeaderPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import HeaderPredicate
+
         return HeaderPredicate(val, None)
 
     def test___call___true_exists(self):
         inst = self._makeOne('abc')
         request = Dummy()
-        request.headers = {'abc':1}
+        request.headers = {'abc': 1}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___true_withval(self):
         inst = self._makeOne('abc:1')
         request = Dummy()
-        request.headers = {'abc':'1'}
+        request.headers = {'abc': '1'}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___true_withregex(self):
         inst = self._makeOne(r'abc:\d+')
         request = Dummy()
-        request.headers = {'abc':'1'}
+        request.headers = {'abc': '1'}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___false_withregex(self):
         inst = self._makeOne(r'abc:\d+')
         request = Dummy()
-        request.headers = {'abc':'a'}
+        request.headers = {'abc': 'a'}
         result = inst(None, request)
         self.assertFalse(result)
 
@@ -402,9 +429,11 @@ class TestHeaderPredicate(unittest.TestCase):
         inst = self._makeOne(r'abc:\d+')
         self.assertEqual(inst.phash(), r'header abc=\d+')
 
+
 class Test_PhysicalPathPredicate(unittest.TestCase):
     def _makeOne(self, val, config):
         from pyramid.predicates import PhysicalPathPredicate
+
         return PhysicalPathPredicate(val, config)
 
     def test_text(self):
@@ -414,7 +443,7 @@ class Test_PhysicalPathPredicate(unittest.TestCase):
     def test_phash(self):
         inst = self._makeOne('/', None)
         self.assertEqual(inst.phash(), "physical_path = ('',)")
-        
+
     def test_it_call_val_tuple_True(self):
         inst = self._makeOne(('', 'abc'), None)
         root = Dummy()
@@ -460,31 +489,34 @@ class Test_PhysicalPathPredicate(unittest.TestCase):
         context = Dummy()
         self.assertFalse(inst(context, None))
 
+
 class Test_EffectivePrincipalsPredicate(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
 
     def tearDown(self):
         testing.tearDown()
-        
+
     def _makeOne(self, val, config):
         from pyramid.predicates import EffectivePrincipalsPredicate
+
         return EffectivePrincipalsPredicate(val, config)
 
     def test_text(self):
         inst = self._makeOne(('verna', 'fred'), None)
-        self.assertEqual(inst.text(),
-                         "effective_principals = ['fred', 'verna']")
+        self.assertEqual(
+            inst.text(), "effective_principals = ['fred', 'verna']"
+        )
 
     def test_text_noniter(self):
         inst = self._makeOne('verna', None)
-        self.assertEqual(inst.text(),
-                         "effective_principals = ['verna']")
+        self.assertEqual(inst.text(), "effective_principals = ['verna']")
 
     def test_phash(self):
         inst = self._makeOne(('verna', 'fred'), None)
-        self.assertEqual(inst.phash(),
-                         "effective_principals = ['fred', 'verna']")
+        self.assertEqual(
+            inst.phash(), "effective_principals = ['fred', 'verna']"
+        )
 
     def test_it_call_no_authentication_policy(self):
         request = testing.DummyRequest()
@@ -501,6 +533,7 @@ class Test_EffectivePrincipalsPredicate(unittest.TestCase):
 
     def test_it_call_authentication_policy_provides_superset_implicit(self):
         from pyramid.security import Authenticated
+
         request = testing.DummyRequest()
         self.config.testing_securitypolicy('fred', groupids=('verna', 'bambi'))
         inst = self._makeOne(Authenticated, None)
@@ -518,6 +551,7 @@ class Test_EffectivePrincipalsPredicate(unittest.TestCase):
 class TestNotted(unittest.TestCase):
     def _makeOne(self, predicate):
         from pyramid.predicates import Notted
+
         return Notted(predicate)
 
     def test_it_with_phash_val(self):
@@ -534,15 +568,19 @@ class TestNotted(unittest.TestCase):
         self.assertEqual(inst.phash(), '')
         self.assertEqual(inst(None, None), True)
 
+
 class predicate(object):
     def __repr__(self):
         return 'predicate'
+
     def __hash__(self):
         return 1
 
+
 class Dummy(object):
     pass
 
+
 class DummyPredicate(object):
     def __init__(self, result):
         self.result = result
diff --git a/tests/test_registry.py b/tests/test_registry.py
index a07c7660d..f35a54dba 100644
--- a/tests/test_registry.py
+++ b/tests/test_registry.py
@@ -1,10 +1,12 @@
 import unittest
 
+
 class TestRegistry(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.registry import Registry
+
         return Registry
-    
+
     def _makeOne(self, *args, **kw):
         return self._getTargetClass()(*args, **kw)
 
@@ -35,8 +37,10 @@ class TestRegistry(unittest.TestCase):
         registry = self._makeOne()
         self.assertEqual(registry.has_listeners, False)
         L = []
+
         def f(event):
             L.append(event)
+
         registry.registerHandler(f, [IDummyEvent])
         self.assertEqual(registry.has_listeners, True)
         event = DummyEvent()
@@ -47,8 +51,10 @@ class TestRegistry(unittest.TestCase):
         registry = self._makeOne()
         self.assertEqual(registry.has_listeners, False)
         from zope.interface import Interface
-        registry.registerSubscriptionAdapter(DummyEvent,
-                                             [IDummyEvent], Interface)
+
+        registry.registerSubscriptionAdapter(
+            DummyEvent, [IDummyEvent], Interface
+        )
         self.assertEqual(registry.has_listeners, True)
 
     def test__get_settings(self):
@@ -64,6 +70,7 @@ class TestRegistry(unittest.TestCase):
     def test_init_forwards_args(self):
         from zope.interface import Interface
         from zope.interface.registry import Components
+
         dummy = object()
         c = Components()
         c.registerUtility(dummy, Interface)
@@ -74,17 +81,20 @@ class TestRegistry(unittest.TestCase):
     def test_init_forwards_kw(self):
         from zope.interface import Interface
         from zope.interface.registry import Components
+
         dummy = object()
         c = Components()
         c.registerUtility(dummy, Interface)
         registry = self._makeOne(bases=(c,))
         self.assertEqual(registry.getUtility(Interface), dummy)
 
+
 class TestIntrospector(unittest.TestCase):
     def _getTargetClass(slf):
         from pyramid.registry import Introspector
+
         return Introspector
-        
+
     def _makeOne(self):
         return self._getTargetClass()()
 
@@ -92,6 +102,7 @@ class TestIntrospector(unittest.TestCase):
         from zope.interface.verify import verifyClass
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IIntrospector
+
         verifyClass(IIntrospector, self._getTargetClass())
         verifyObject(IIntrospector, self._makeOne())
 
@@ -100,8 +111,8 @@ class TestIntrospector(unittest.TestCase):
         intr = DummyIntrospectable()
         inst.add(intr)
         self.assertEqual(intr.order, 0)
-        category = {'discriminator':intr, 'discriminator_hash':intr}
-        self.assertEqual(inst._categories, {'category':category})
+        category = {'discriminator': intr, 'discriminator_hash': intr}
+        self.assertEqual(inst._categories, {'category': category})
 
     def test_get_success(self):
         inst = self._makeOne()
@@ -130,9 +141,9 @@ class TestIntrospector(unittest.TestCase):
         inst.add(intr2)
         inst.add(intr)
         expected = [
-            {'introspectable':intr2, 'related':[]},
-            {'introspectable':intr,  'related':[]},
-            ]
+            {'introspectable': intr2, 'related': []},
+            {'introspectable': intr, 'related': []},
+        ]
         self.assertEqual(inst.get_category('category'), expected)
 
     def test_get_category_returns_default_on_miss(self):
@@ -141,6 +152,7 @@ class TestIntrospector(unittest.TestCase):
 
     def test_get_category_with_sortkey(self):
         import operator
+
         inst = self._makeOne()
         intr = DummyIntrospectable()
         intr.foo = 2
@@ -151,15 +163,17 @@ class TestIntrospector(unittest.TestCase):
         inst.add(intr)
         inst.add(intr2)
         expected = [
-            {'introspectable':intr2, 'related':[]},
-            {'introspectable':intr,  'related':[]},
-            ]
+            {'introspectable': intr2, 'related': []},
+            {'introspectable': intr, 'related': []},
+        ]
         self.assertEqual(
             inst.get_category('category', sort_key=operator.attrgetter('foo')),
-                              expected)
+            expected,
+        )
 
     def test_categorized(self):
         import operator
+
         inst = self._makeOne()
         intr = DummyIntrospectable()
         intr.foo = 2
@@ -169,12 +183,18 @@ class TestIntrospector(unittest.TestCase):
         intr2.foo = 1
         inst.add(intr)
         inst.add(intr2)
-        expected = [('category', [
-            {'introspectable':intr2, 'related':[]},
-            {'introspectable':intr,  'related':[]},
-            ])]
+        expected = [
+            (
+                'category',
+                [
+                    {'introspectable': intr2, 'related': []},
+                    {'introspectable': intr, 'related': []},
+                ],
+            )
+        ]
         self.assertEqual(
-            inst.categorized(sort_key=operator.attrgetter('foo')), expected)
+            inst.categorized(sort_key=operator.attrgetter('foo')), expected
+        )
 
     def test_categories(self):
         inst = self._makeOne()
@@ -191,16 +211,20 @@ class TestIntrospector(unittest.TestCase):
         intr2.discriminator_hash = 'discriminator2_hash'
         inst.add(intr)
         inst.add(intr2)
-        inst.relate(('category', 'discriminator'),
-                    ('category2', 'discriminator2'))
+        inst.relate(
+            ('category', 'discriminator'), ('category2', 'discriminator2')
+        )
         inst.remove('category', 'discriminator')
-        self.assertEqual(inst._categories,
-                         {'category':
-                              {},
-                          'category2':
-                              {'discriminator2': intr2,
-                               'discriminator2_hash': intr2}
-                         })
+        self.assertEqual(
+            inst._categories,
+            {
+                'category': {},
+                'category2': {
+                    'discriminator2': intr2,
+                    'discriminator2_hash': intr2,
+                },
+            },
+        )
         self.assertEqual(inst._refs.get(intr), None)
         self.assertEqual(inst._refs[intr2], [])
 
@@ -217,16 +241,22 @@ class TestIntrospector(unittest.TestCase):
         intr2.discriminator_hash = 'discriminator2_hash'
         inst.add(intr)
         inst.add(intr2)
-        inst.relate(('category', 'discriminator'),
-                    ('category2', 'discriminator2'))
-        self.assertEqual(inst._categories,
-                         {'category':
-                              {'discriminator':intr,
-                               'discriminator_hash':intr},
-                          'category2':
-                              {'discriminator2': intr2,
-                               'discriminator2_hash': intr2}
-                         })
+        inst.relate(
+            ('category', 'discriminator'), ('category2', 'discriminator2')
+        )
+        self.assertEqual(
+            inst._categories,
+            {
+                'category': {
+                    'discriminator': intr,
+                    'discriminator_hash': intr,
+                },
+                'category2': {
+                    'discriminator2': intr2,
+                    'discriminator2_hash': intr2,
+                },
+            },
+        )
         self.assertEqual(inst._refs[intr], [intr2])
         self.assertEqual(inst._refs[intr2], [intr])
 
@@ -238,8 +268,8 @@ class TestIntrospector(unittest.TestCase):
             KeyError,
             inst.relate,
             ('category', 'discriminator'),
-            ('category2', 'discriminator2')
-            )
+            ('category2', 'discriminator2'),
+        )
 
     def test_unrelate(self):
         inst = self._makeOne()
@@ -250,18 +280,25 @@ class TestIntrospector(unittest.TestCase):
         intr2.discriminator_hash = 'discriminator2_hash'
         inst.add(intr)
         inst.add(intr2)
-        inst.relate(('category', 'discriminator'),
-                    ('category2', 'discriminator2'))
-        inst.unrelate(('category', 'discriminator'),
-                    ('category2', 'discriminator2'))
-        self.assertEqual(inst._categories,
-                         {'category':
-                              {'discriminator':intr,
-                               'discriminator_hash':intr},
-                          'category2':
-                              {'discriminator2': intr2,
-                               'discriminator2_hash': intr2}
-                         })
+        inst.relate(
+            ('category', 'discriminator'), ('category2', 'discriminator2')
+        )
+        inst.unrelate(
+            ('category', 'discriminator'), ('category2', 'discriminator2')
+        )
+        self.assertEqual(
+            inst._categories,
+            {
+                'category': {
+                    'discriminator': intr,
+                    'discriminator_hash': intr,
+                },
+                'category2': {
+                    'discriminator2': intr2,
+                    'discriminator2_hash': intr2,
+                },
+            },
+        )
         self.assertEqual(inst._refs[intr], [])
         self.assertEqual(inst._refs[intr2], [])
 
@@ -274,8 +311,9 @@ class TestIntrospector(unittest.TestCase):
         intr2.discriminator_hash = 'discriminator2_hash'
         inst.add(intr)
         inst.add(intr2)
-        inst.relate(('category', 'discriminator'),
-                    ('category2', 'discriminator2'))
+        inst.relate(
+            ('category', 'discriminator'), ('category2', 'discriminator2')
+        )
         self.assertEqual(inst.related(intr), [intr2])
 
     def test_related_fail(self):
@@ -287,16 +325,19 @@ class TestIntrospector(unittest.TestCase):
         intr2.discriminator_hash = 'discriminator2_hash'
         inst.add(intr)
         inst.add(intr2)
-        inst.relate(('category', 'discriminator'),
-                    ('category2', 'discriminator2'))
+        inst.relate(
+            ('category', 'discriminator'), ('category2', 'discriminator2')
+        )
         del inst._categories['category']
         self.assertRaises(KeyError, inst.related, intr)
 
+
 class TestIntrospectable(unittest.TestCase):
     def _getTargetClass(slf):
         from pyramid.registry import Introspectable
+
         return Introspectable
-        
+
     def _makeOne(self, *arg, **kw):
         return self._getTargetClass()(*arg, **kw)
 
@@ -307,6 +348,7 @@ class TestIntrospectable(unittest.TestCase):
         from zope.interface.verify import verifyClass
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IIntrospectable
+
         verifyClass(IIntrospectable, self._getTargetClass())
         verifyObject(IIntrospectable, self._makeOnePopulated())
 
@@ -326,14 +368,16 @@ class TestIntrospectable(unittest.TestCase):
 
     def test___hash__(self):
         inst = self._makeOnePopulated()
-        self.assertEqual(hash(inst),
-                         hash((inst.category_name,) + (inst.discriminator,)))
+        self.assertEqual(
+            hash(inst), hash((inst.category_name,) + (inst.discriminator,))
+        )
 
     def test___repr__(self):
         inst = self._makeOnePopulated()
         self.assertEqual(
             repr(inst),
-            "<Introspectable category 'category', discriminator 'discrim'>")
+            "<Introspectable category 'category', discriminator 'discrim'>",
+        )
 
     def test___nonzero__(self):
         inst = self._makeOnePopulated()
@@ -352,17 +396,22 @@ class TestIntrospectable(unittest.TestCase):
         inst.register(introspector, action_info)
         self.assertEqual(inst.action_info, action_info)
         self.assertEqual(introspector.intrs, [inst])
-        self.assertEqual(introspector.relations,
-                         [(('category', 'discrim'), ('category1', 'discrim1'))])
-        self.assertEqual(introspector.unrelations,
-                         [(('category', 'discrim'), ('category2', 'discrim2'))])
+        self.assertEqual(
+            introspector.relations,
+            [(('category', 'discrim'), ('category1', 'discrim1'))],
+        )
+        self.assertEqual(
+            introspector.unrelations,
+            [(('category', 'discrim'), ('category2', 'discrim2'))],
+        )
+
 
 class DummyIntrospector(object):
     def __init__(self):
         self.intrs = []
         self.relations = []
         self.unrelations = []
-            
+
     def add(self, intr):
         self.intrs.append(intr)
 
@@ -372,11 +421,13 @@ class DummyIntrospector(object):
     def unrelate(self, *pairs):
         self.unrelations.append(pairs)
 
+
 class DummyModule:
     __path__ = "foo"
     __name__ = "dummy"
     __file__ = ''
 
+
 class DummyIntrospectable(object):
     category_name = 'category'
     discriminator = 'discriminator'
@@ -392,10 +443,12 @@ class DummyIntrospectable(object):
 
 from zope.interface import Interface
 from zope.interface import implementer
+
+
 class IDummyEvent(Interface):
     pass
 
+
 @implementer(IDummyEvent)
 class DummyEvent(object):
     pass
-    
diff --git a/tests/test_renderers.py b/tests/test_renderers.py
index fce902662..0eacfa996 100644
--- a/tests/test_renderers.py
+++ b/tests/test_renderers.py
@@ -4,6 +4,7 @@ from pyramid.testing import cleanUp
 from pyramid import testing
 from pyramid.compat import text_
 
+
 class TestJSON(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -13,47 +14,52 @@ class TestJSON(unittest.TestCase):
 
     def _makeOne(self, **kw):
         from pyramid.renderers import JSON
+
         return JSON(**kw)
 
     def test_it(self):
         renderer = self._makeOne()(None)
-        result = renderer({'a':1}, {})
+        result = renderer({'a': 1}, {})
         self.assertEqual(result, '{"a": 1}')
 
     def test_with_request_content_type_notset(self):
         request = testing.DummyRequest()
         renderer = self._makeOne()(None)
-        renderer({'a':1}, {'request':request})
+        renderer({'a': 1}, {'request': request})
         self.assertEqual(request.response.content_type, 'application/json')
 
     def test_with_request_content_type_set(self):
         request = testing.DummyRequest()
         request.response.content_type = 'text/mishmash'
         renderer = self._makeOne()(None)
-        renderer({'a':1}, {'request':request})
+        renderer({'a': 1}, {'request': request})
         self.assertEqual(request.response.content_type, 'text/mishmash')
 
     def test_with_custom_adapter(self):
         request = testing.DummyRequest()
         from datetime import datetime
+
         def adapter(obj, req):
             self.assertEqual(req, request)
             return obj.isoformat()
+
         now = datetime.utcnow()
         renderer = self._makeOne()
         renderer.add_adapter(datetime, adapter)
-        result = renderer(None)({'a':now}, {'request':request})
+        result = renderer(None)({'a': now}, {'request': request})
         self.assertEqual(result, '{"a": "%s"}' % now.isoformat())
 
     def test_with_custom_adapter2(self):
         request = testing.DummyRequest()
         from datetime import datetime
+
         def adapter(obj, req):
             self.assertEqual(req, request)
             return obj.isoformat()
+
         now = datetime.utcnow()
         renderer = self._makeOne(adapters=((datetime, adapter),))
-        result = renderer(None)({'a':now}, {'request':request})
+        result = renderer(None)({'a': now}, {'request': request})
         self.assertEqual(result, '{"a": "%s"}' % now.isoformat())
 
     def test_with_custom_serializer(self):
@@ -62,9 +68,10 @@ class TestJSON(unittest.TestCase):
                 self.obj = obj
                 self.kw = kw
                 return 'foo'
+
         serializer = Serializer()
         renderer = self._makeOne(serializer=serializer, baz=5)
-        obj = {'a':'b'}
+        obj = {'a': 'b'}
         result = renderer(None)(obj, {})
         self.assertEqual(result, 'foo')
         self.assertEqual(serializer.obj, obj)
@@ -74,29 +81,34 @@ class TestJSON(unittest.TestCase):
     def test_with_object_adapter(self):
         request = testing.DummyRequest()
         outerself = self
+
         class MyObject(object):
             def __init__(self, x):
                 self.x = x
+
             def __json__(self, req):
                 outerself.assertEqual(req, request)
                 return {'x': self.x}
 
         objects = [MyObject(1), MyObject(2)]
         renderer = self._makeOne()(None)
-        result = renderer(objects, {'request':request})
+        result = renderer(objects, {'request': request})
         self.assertEqual(result, '[{"x": 1}, {"x": 2}]')
 
     def test_with_object_adapter_no___json__(self):
         class MyObject(object):
             def __init__(self, x):
                 self.x = x
+
         objects = [MyObject(1), MyObject(2)]
         renderer = self._makeOne()(None)
         self.assertRaises(TypeError, renderer, objects, {})
 
+
 class Test_string_renderer_factory(unittest.TestCase):
     def _callFUT(self, name):
         from pyramid.renderers import string_renderer_factory
+
         return string_renderer_factory(name)
 
     def test_it_unicode(self):
@@ -120,14 +132,14 @@ class Test_string_renderer_factory(unittest.TestCase):
     def test_with_request_content_type_notset(self):
         request = testing.DummyRequest()
         renderer = self._callFUT(None)
-        renderer('', {'request':request})
+        renderer('', {'request': request})
         self.assertEqual(request.response.content_type, 'text/plain')
 
     def test_with_request_content_type_set(self):
         request = testing.DummyRequest()
         request.response.content_type = 'text/mishmash'
         renderer = self._callFUT(None)
-        renderer('', {'request':request})
+        renderer('', {'request': request})
         self.assertEqual(request.response.content_type, 'text/mishmash')
 
 
@@ -140,46 +152,56 @@ class TestRendererHelper(unittest.TestCase):
 
     def _makeOne(self, *arg, **kw):
         from pyramid.renderers import RendererHelper
+
         return RendererHelper(*arg, **kw)
 
     def test_instance_conforms(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IRendererInfo
+
         helper = self._makeOne()
         verifyObject(IRendererInfo, helper)
 
     def test_settings_registry_settings_is_None(self):
         class Dummy(object):
             settings = None
+
         helper = self._makeOne(registry=Dummy)
         self.assertEqual(helper.settings, {})
 
     def test_settings_registry_name_is_None(self):
         class Dummy(object):
             settings = None
+
         helper = self._makeOne(registry=Dummy)
         self.assertEqual(helper.name, None)
         self.assertEqual(helper.type, '')
 
     def test_settings_registry_settings_is_not_None(self):
         class Dummy(object):
-            settings = {'a':1}
+            settings = {'a': 1}
+
         helper = self._makeOne(registry=Dummy)
-        self.assertEqual(helper.settings, {'a':1})
+        self.assertEqual(helper.settings, {'a': 1})
 
     def _registerRendererFactory(self):
         from pyramid.interfaces import IRendererFactory
+
         def renderer(*arg):
             def respond(*arg):
                 return arg
+
             renderer.respond = respond
             return respond
-        self.config.registry.registerUtility(renderer, IRendererFactory,
-                                             name='.foo')
+
+        self.config.registry.registerUtility(
+            renderer, IRendererFactory, name='.foo'
+        )
         return renderer
 
     def _registerResponseFactory(self):
         from pyramid.interfaces import IResponseFactory
+
         class ResponseFactory(object):
             pass
 
@@ -192,8 +214,7 @@ class TestRendererHelper(unittest.TestCase):
         self._registerResponseFactory()
         request = Dummy()
         helper = self._makeOne('loo.foo')
-        response = helper.render_to_response('values', {},
-                                             request=request)
+        response = helper.render_to_response('values', {}, request=request)
         self.assertEqual(response.app_iter[0], 'values')
         self.assertEqual(response.app_iter[1], {})
 
@@ -204,6 +225,7 @@ class TestRendererHelper(unittest.TestCase):
 
     def test_render_view(self):
         import pyramid.csrf
+
         self._registerRendererFactory()
         self._registerResponseFactory()
         request = Dummy()
@@ -214,28 +236,35 @@ class TestRendererHelper(unittest.TestCase):
         response = 'response'
         response = helper.render_view(request, response, view, context)
         get_csrf = response.app_iter[1].pop('get_csrf_token')
-        self.assertEqual(get_csrf.args, (request, ))
+        self.assertEqual(get_csrf.args, (request,))
         self.assertEqual(get_csrf.func, pyramid.csrf.get_csrf_token)
         self.assertEqual(response.app_iter[0], 'response')
-        self.assertEqual(response.app_iter[1],
-                          {'renderer_info': helper,
-                           'renderer_name': 'loo.foo',
-                           'request': request,
-                           'context': 'context',
-                           'view': 'view',
-                           'req': request,}
-                         )
+        self.assertEqual(
+            response.app_iter[1],
+            {
+                'renderer_info': helper,
+                'renderer_name': 'loo.foo',
+                'request': request,
+                'context': 'context',
+                'view': 'view',
+                'req': request,
+            },
+        )
 
     def test_render_explicit_registry(self):
         factory = self._registerRendererFactory()
+
         class DummyRegistry(object):
             def __init__(self):
                 self.responses = [factory, lambda *arg: {}, None]
+
             def queryUtility(self, iface, name=None):
                 self.queried = True
                 return self.responses.pop(0)
+
             def notify(self, event):
                 self.event = event
+
         reg = DummyRegistry()
         helper = self._makeOne('loo.foo', registry=reg)
         result = helper.render('value', {})
@@ -247,6 +276,7 @@ class TestRendererHelper(unittest.TestCase):
 
     def test_render_system_values_is_None(self):
         import pyramid.csrf
+
         self._registerRendererFactory()
         request = Dummy()
         context = Dummy()
@@ -254,15 +284,16 @@ class TestRendererHelper(unittest.TestCase):
         helper = self._makeOne('loo.foo')
         result = helper.render('values', None, request=request)
         get_csrf = result[1].pop('get_csrf_token')
-        self.assertEqual(get_csrf.args, (request, ))
+        self.assertEqual(get_csrf.args, (request,))
         self.assertEqual(get_csrf.func, pyramid.csrf.get_csrf_token)
-        system = {'request':request,
-                  'context':context,
-                  'renderer_name':'loo.foo',
-                  'view':None,
-                  'renderer_info':helper,
-                  'req':request,
-                  }
+        system = {
+            'request': request,
+            'context': context,
+            'renderer_name': 'loo.foo',
+            'view': None,
+            'renderer_info': helper,
+            'req': request,
+        }
         self.assertEqual(result[0], 'values')
         self.assertEqual(result[1], system)
 
@@ -282,6 +313,7 @@ class TestRendererHelper(unittest.TestCase):
 
     def test__make_response_result_is_unicode(self):
         from pyramid.response import Response
+
         request = testing.DummyRequest()
         request.response = Response()
         helper = self._makeOne('loo.foo')
@@ -291,6 +323,7 @@ class TestRendererHelper(unittest.TestCase):
 
     def test__make_response_result_is_str(self):
         from pyramid.response import Response
+
         request = testing.DummyRequest()
         request.response = Response()
         helper = self._makeOne('loo.foo')
@@ -300,6 +333,7 @@ class TestRendererHelper(unittest.TestCase):
 
     def test__make_response_result_is_iterable(self):
         from pyramid.response import Response
+
         request = testing.DummyRequest()
         request.response = Response()
         helper = self._makeOne('loo.foo')
@@ -317,6 +351,7 @@ class TestRendererHelper(unittest.TestCase):
 
     def test__make_response_result_is_None_no_body(self):
         from pyramid.response import Response
+
         request = testing.DummyRequest()
         request.response = Response()
         helper = self._makeOne('loo.foo')
@@ -325,6 +360,7 @@ class TestRendererHelper(unittest.TestCase):
 
     def test__make_response_result_is_None_existing_body_not_molested(self):
         from pyramid.response import Response
+
         request = testing.DummyRequest()
         response = Response()
         response.body = b'abc'
@@ -335,9 +371,11 @@ class TestRendererHelper(unittest.TestCase):
 
     def test_with_alternate_response_factory(self):
         from pyramid.interfaces import IResponseFactory
+
         class ResponseFactory(object):
             def __init__(self):
                 pass
+
         self.config.registry.registerUtility(
             lambda r: ResponseFactory(), IResponseFactory
         )
@@ -350,6 +388,7 @@ class TestRendererHelper(unittest.TestCase):
     def test__make_response_with_real_request(self):
         # functional
         from pyramid.request import Request
+
         request = Request({})
         request.registry = self.config.registry
         request.response.status = '406 You Lose'
@@ -368,8 +407,9 @@ class TestRendererHelper(unittest.TestCase):
 
     def test_clone_allargs(self):
         helper = self._makeOne('name', 'package', 'registry')
-        cloned_helper = helper.clone(name='name2', package='package2',
-                                     registry='registry2')
+        cloned_helper = helper.clone(
+            name='name2', package='package2', registry='registry2'
+        )
         self.assertEqual(cloned_helper.name, 'name2')
         self.assertEqual(cloned_helper.package, 'package2')
         self.assertEqual(cloned_helper.registry, 'registry2')
@@ -381,12 +421,16 @@ class TestRendererHelper(unittest.TestCase):
         registry.settings = settings
         from pyramid.interfaces import IRendererFactory
         import os
+
         here = os.path.dirname(os.path.abspath(__file__))
         fixture = os.path.join(here, 'fixtures/minimal.pt')
+
         def factory(info, **kw):
             return info
+
         self.config.registry.registerUtility(
-            factory, IRendererFactory, name='.pt')
+            factory, IRendererFactory, name='.pt'
+        )
         result = self._makeOne(fixture).renderer
         self.assertEqual(result.registry, registry)
         self.assertEqual(result.type, '.pt')
@@ -396,17 +440,22 @@ class TestRendererHelper(unittest.TestCase):
 
     def test_renderer_with_package(self):
         import pyramid
+
         registry = self.config.registry
         settings = {}
         registry.settings = settings
         from pyramid.interfaces import IRendererFactory
         import os
+
         here = os.path.dirname(os.path.abspath(__file__))
         fixture = os.path.join(here, 'fixtures/minimal.pt')
+
         def factory(info, **kw):
             return info
+
         self.config.registry.registerUtility(
-            factory, IRendererFactory, name='.pt')
+            factory, IRendererFactory, name='.pt'
+        )
         result = self._makeOne(fixture, pyramid).renderer
         self.assertEqual(result.registry, registry)
         self.assertEqual(result.type, '.pt')
@@ -418,6 +467,7 @@ class TestRendererHelper(unittest.TestCase):
         inst = self._makeOne('foo')
         self.assertRaises(ValueError, getattr, inst, 'renderer')
 
+
 class TestNullRendererHelper(unittest.TestCase):
     def setUp(self):
         self.config = cleanUp()
@@ -427,11 +477,13 @@ class TestNullRendererHelper(unittest.TestCase):
 
     def _makeOne(self, *arg, **kw):
         from pyramid.renderers import NullRendererHelper
+
         return NullRendererHelper(*arg, **kw)
 
     def test_instance_conforms(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IRendererInfo
+
         helper = self._makeOne()
         verifyObject(IRendererInfo, helper)
 
@@ -451,6 +503,7 @@ class TestNullRendererHelper(unittest.TestCase):
         helper = self._makeOne()
         self.assertTrue(helper.clone() is helper)
 
+
 class Test_render(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -460,11 +513,11 @@ class Test_render(unittest.TestCase):
 
     def _callFUT(self, renderer_name, value, request=None, package=None):
         from pyramid.renderers import render
+
         return render(renderer_name, value, request=request, package=package)
 
     def _registerRenderer(self):
-        renderer = self.config.testing_add_renderer(
-            'tests:abc/def.pt')
+        renderer = self.config.testing_add_renderer('tests:abc/def.pt')
         renderer.string_response = 'abc'
         return renderer
 
@@ -478,25 +531,26 @@ class Test_render(unittest.TestCase):
     def test_it_with_request(self):
         renderer = self._registerRenderer()
         request = testing.DummyRequest()
-        result = self._callFUT('abc/def.pt',
-                               dict(a=1), request=request)
+        result = self._callFUT('abc/def.pt', dict(a=1), request=request)
         self.assertEqual(result, 'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=request)
 
     def test_it_with_package(self):
         import tests
+
         renderer = self._registerRenderer()
         request = testing.DummyRequest()
-        result = self._callFUT('abc/def.pt', dict(a=1), request=request,
-                               package=tests)
+        result = self._callFUT(
+            'abc/def.pt', dict(a=1), request=request, package=tests
+        )
         self.assertEqual(result, 'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=request)
 
     def test_response_preserved(self):
         request = testing.DummyRequest()
-        response = object() # should error if mutated
+        response = object()  # should error if mutated
         request.response = response
         # use a json renderer, which will mutate the response
         result = self._callFUT('json', dict(a=1), request=request)
@@ -505,19 +559,23 @@ class Test_render(unittest.TestCase):
 
     def test_no_response_to_preserve(self):
         from pyramid.decorator import reify
+
         class DummyRequestWithClassResponse(object):
             _response = DummyResponse()
             _response.content_type = None
             _response.default_content_type = None
+
             @reify
             def response(self):
                 return self._response
+
         request = DummyRequestWithClassResponse()
         # use a json renderer, which will mutate the response
         result = self._callFUT('json', dict(a=1), request=request)
         self.assertEqual(result, '{"a": 1}')
         self.assertFalse('response' in request.__dict__)
 
+
 class Test_render_to_response(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -525,15 +583,21 @@ class Test_render_to_response(unittest.TestCase):
     def tearDown(self):
         testing.tearDown()
 
-    def _callFUT(self, renderer_name, value, request=None, package=None,
-                 response=None):
+    def _callFUT(
+        self, renderer_name, value, request=None, package=None, response=None
+    ):
         from pyramid.renderers import render_to_response
-        return render_to_response(renderer_name, value, request=request,
-                                  package=package, response=response)
+
+        return render_to_response(
+            renderer_name,
+            value,
+            request=request,
+            package=package,
+            response=response,
+        )
 
     def test_it_no_request(self):
-        renderer = self.config.testing_add_renderer(
-            'tests:abc/def.pt')
+        renderer = self.config.testing_add_renderer('tests:abc/def.pt')
         renderer.string_response = 'abc'
         response = self._callFUT('abc/def.pt', dict(a=1))
         self.assertEqual(response.body, b'abc')
@@ -541,31 +605,30 @@ class Test_render_to_response(unittest.TestCase):
         renderer.assert_(request=None)
 
     def test_it_with_request(self):
-        renderer = self.config.testing_add_renderer(
-            'tests:abc/def.pt')
+        renderer = self.config.testing_add_renderer('tests:abc/def.pt')
         renderer.string_response = 'abc'
         request = testing.DummyRequest()
-        response = self._callFUT('abc/def.pt',
-                                 dict(a=1), request=request)
+        response = self._callFUT('abc/def.pt', dict(a=1), request=request)
         self.assertEqual(response.body, b'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=request)
 
     def test_it_with_package(self):
         import tests
-        renderer = self.config.testing_add_renderer(
-            'tests:abc/def.pt')
+
+        renderer = self.config.testing_add_renderer('tests:abc/def.pt')
         renderer.string_response = 'abc'
         request = testing.DummyRequest()
-        response = self._callFUT('abc/def.pt', dict(a=1), request=request,
-                                 package=tests)
+        response = self._callFUT(
+            'abc/def.pt', dict(a=1), request=request, package=tests
+        )
         self.assertEqual(response.body, b'abc')
         renderer.assert_(a=1)
         renderer.assert_(request=request)
 
     def test_response_preserved(self):
         request = testing.DummyRequest()
-        response = object() # should error if mutated
+        response = object()  # should error if mutated
         request.response = response
         # use a json renderer, which will mutate the response
         result = self._callFUT('json', dict(a=1), request=request)
@@ -575,13 +638,16 @@ class Test_render_to_response(unittest.TestCase):
 
     def test_no_response_to_preserve(self):
         from pyramid.decorator import reify
+
         class DummyRequestWithClassResponse(object):
             _response = DummyResponse()
             _response.content_type = None
             _response.default_content_type = None
+
             @reify
             def response(self):
                 return self._response
+
         request = DummyRequestWithClassResponse()
         # use a json renderer, which will mutate the response
         result = self._callFUT('json', dict(a=1), request=request)
@@ -591,15 +657,18 @@ class Test_render_to_response(unittest.TestCase):
     def test_custom_response_object(self):
         class DummyRequestWithClassResponse(object):
             pass
+
         request = DummyRequestWithClassResponse()
         response = DummyResponse()
         # use a json renderer, which will mutate the response
-        result = self._callFUT('json', dict(a=1), request=request,
-                               response=response)
+        result = self._callFUT(
+            'json', dict(a=1), request=request, response=response
+        )
         self.assertTrue(result is response)
         self.assertEqual(result.body, b'{"a": 1}')
         self.assertFalse('response' in request.__dict__)
 
+
 class Test_get_renderer(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -609,38 +678,39 @@ class Test_get_renderer(unittest.TestCase):
 
     def _callFUT(self, renderer_name, **kw):
         from pyramid.renderers import get_renderer
+
         return get_renderer(renderer_name, **kw)
 
     def test_it_no_package(self):
-        renderer = self.config.testing_add_renderer(
-            'tests:abc/def.pt')
+        renderer = self.config.testing_add_renderer('tests:abc/def.pt')
         result = self._callFUT('abc/def.pt')
         self.assertEqual(result, renderer)
 
     def test_it_with_package(self):
         import tests
-        renderer = self.config.testing_add_renderer(
-            'tests:abc/def.pt')
+
+        renderer = self.config.testing_add_renderer('tests:abc/def.pt')
         result = self._callFUT('abc/def.pt', package=tests)
         self.assertEqual(result, renderer)
 
     def test_it_with_registry(self):
-        renderer = self.config.testing_add_renderer(
-            'tests:abc/def.pt')
+        renderer = self.config.testing_add_renderer('tests:abc/def.pt')
         result = self._callFUT('abc/def.pt', registry=self.config.registry)
         self.assertEqual(result, renderer)
 
     def test_it_with_isolated_registry(self):
         from pyramid.config import Configurator
+
         isolated_config = Configurator()
-        renderer = isolated_config.testing_add_renderer(
-            'tests:abc/def.pt')
+        renderer = isolated_config.testing_add_renderer('tests:abc/def.pt')
         result = self._callFUT('abc/def.pt', registry=isolated_config.registry)
         self.assertEqual(result, renderer)
 
+
 class TestJSONP(unittest.TestCase):
     def _makeOne(self, param_name='callback'):
         from pyramid.renderers import JSONP
+
         return JSONP(param_name)
 
     def test_render_to_jsonp(self):
@@ -648,48 +718,53 @@ class TestJSONP(unittest.TestCase):
         renderer = renderer_factory(None)
         request = testing.DummyRequest()
         request.GET['callback'] = 'callback'
-        result = renderer({'a':'1'}, {'request':request})
+        result = renderer({'a': '1'}, {'request': request})
         self.assertEqual(result, '/**/callback({"a": "1"});')
-        self.assertEqual(request.response.content_type,
-                         'application/javascript')
+        self.assertEqual(
+            request.response.content_type, 'application/javascript'
+        )
 
     def test_render_to_jsonp_with_dot(self):
         renderer_factory = self._makeOne()
         renderer = renderer_factory(None)
         request = testing.DummyRequest()
         request.GET['callback'] = 'angular.callbacks._0'
-        result = renderer({'a':'1'}, {'request':request})
+        result = renderer({'a': '1'}, {'request': request})
         self.assertEqual(result, '/**/angular.callbacks._0({"a": "1"});')
-        self.assertEqual(request.response.content_type,
-                         'application/javascript')
+        self.assertEqual(
+            request.response.content_type, 'application/javascript'
+        )
 
     def test_render_to_json(self):
         renderer_factory = self._makeOne()
         renderer = renderer_factory(None)
         request = testing.DummyRequest()
-        result = renderer({'a':'1'}, {'request':request})
+        result = renderer({'a': '1'}, {'request': request})
         self.assertEqual(result, '{"a": "1"}')
-        self.assertEqual(request.response.content_type,
-                         'application/json')
+        self.assertEqual(request.response.content_type, 'application/json')
 
     def test_render_without_request(self):
         renderer_factory = self._makeOne()
         renderer = renderer_factory(None)
-        result = renderer({'a':'1'}, {})
+        result = renderer({'a': '1'}, {})
         self.assertEqual(result, '{"a": "1"}')
 
     def test_render_to_jsonp_invalid_callback(self):
         from pyramid.httpexceptions import HTTPBadRequest
+
         renderer_factory = self._makeOne()
         renderer = renderer_factory(None)
         request = testing.DummyRequest()
         request.GET['callback'] = '78mycallback'
-        self.assertRaises(HTTPBadRequest, renderer, {'a':'1'}, {'request':request})
+        self.assertRaises(
+            HTTPBadRequest, renderer, {'a': '1'}, {'request': request}
+        )
 
 
 class Dummy:
     pass
 
+
 class DummyResponse:
     status = '200 OK'
     default_content_type = 'text/html'
@@ -699,7 +774,7 @@ class DummyResponse:
     body = b''
 
     # compat for renderer that will set unicode on py3
-    def _set_text(self, val): # pragma: no cover
+    def _set_text(self, val):  # pragma: no cover
         self.body = val.encode('utf8')
-    text = property(fset=_set_text)
 
+    text = property(fset=_set_text)
diff --git a/tests/test_request.py b/tests/test_request.py
index c79c84d63..13e424f79 100644
--- a/tests/test_request.py
+++ b/tests/test_request.py
@@ -2,16 +2,9 @@ from collections import deque
 import unittest
 from pyramid import testing
 
-from pyramid.compat import (
-    PY2,
-    text_,
-    bytes_,
-    native_,
-    )
-from pyramid.security import (
-    AuthenticationAPIMixin,
-    AuthorizationAPIMixin,
-    )
+from pyramid.compat import PY2, text_, bytes_, native_
+from pyramid.security import AuthenticationAPIMixin, AuthorizationAPIMixin
+
 
 class TestRequest(unittest.TestCase):
     def setUp(self):
@@ -22,6 +15,7 @@ class TestRequest(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.request import Request
+
         return Request
 
     def _makeOne(self, environ=None):
@@ -32,26 +26,31 @@ class TestRequest(unittest.TestCase):
     def _registerResourceURL(self):
         from pyramid.interfaces import IResourceURL
         from zope.interface import Interface
+
         class DummyResourceURL(object):
             def __init__(self, context, request):
                 self.physical_path = '/context/'
                 self.virtual_path = '/context/'
+
         self.config.registry.registerAdapter(
-            DummyResourceURL, (Interface, Interface),
-            IResourceURL)
+            DummyResourceURL, (Interface, Interface), IResourceURL
+        )
 
     def test_class_conforms_to_IRequest(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import IRequest
+
         verifyClass(IRequest, self._getTargetClass())
 
     def test_instance_conforms_to_IRequest(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import IRequest
+
         verifyObject(IRequest, self._makeOne())
 
     def test_ResponseClass_is_pyramid_Response(self):
         from pyramid.response import Response
+
         cls = self._getTargetClass()
         self.assertEqual(cls.ResponseClass, Response)
 
@@ -61,41 +60,42 @@ class TestRequest(unittest.TestCase):
         self.assertTrue(isinstance(r, apis))
 
     def test_charset_defaults_to_utf8(self):
-        r = self._makeOne({'PATH_INFO':'/'})
+        r = self._makeOne({'PATH_INFO': '/'})
         self.assertEqual(r.charset, 'UTF-8')
 
     def test_exception_defaults_to_None(self):
-        r = self._makeOne({'PATH_INFO':'/'})
+        r = self._makeOne({'PATH_INFO': '/'})
         self.assertEqual(r.exception, None)
 
     def test_matchdict_defaults_to_None(self):
-        r = self._makeOne({'PATH_INFO':'/'})
+        r = self._makeOne({'PATH_INFO': '/'})
         self.assertEqual(r.matchdict, None)
 
     def test_matched_route_defaults_to_None(self):
-        r = self._makeOne({'PATH_INFO':'/'})
+        r = self._makeOne({'PATH_INFO': '/'})
         self.assertEqual(r.matched_route, None)
 
     def test_params_decoded_from_utf_8_by_default(self):
-        environ = {
-            'PATH_INFO':'/',
-            'QUERY_STRING':'la=La%20Pe%C3%B1a'
-            }
+        environ = {'PATH_INFO': '/', 'QUERY_STRING': 'la=La%20Pe%C3%B1a'}
         request = self._makeOne(environ)
         request.charset = None
         self.assertEqual(request.GET['la'], text_(b'La Pe\xf1a'))
 
     def test_tmpl_context(self):
         from pyramid.request import TemplateContext
+
         inst = self._makeOne()
         result = inst.tmpl_context
         self.assertEqual(result.__class__, TemplateContext)
 
     def test_session_configured(self):
         from pyramid.interfaces import ISessionFactory
+
         inst = self._makeOne()
+
         def factory(request):
             return 'orangejuice'
+
         self.config.registry.registerUtility(factory, ISessionFactory)
         inst.registry = self.config.registry
         self.assertEqual(inst.session, 'orangejuice')
@@ -116,13 +116,15 @@ class TestRequest(unittest.TestCase):
         inst = self._makeOne(environ)
         setattr(inst, 'bar', 1)
         self.assertEqual(getattr(inst, 'bar'), 1)
-        self.assertEqual(environ, {}) # make sure we're not using adhoc attrs
+        self.assertEqual(environ, {})  # make sure we're not using adhoc attrs
 
     def test_add_response_callback(self):
         inst = self._makeOne()
         self.assertEqual(len(inst.response_callbacks), 0)
+
         def callback(request, response):
             """ """
+
         inst.add_response_callback(callback)
         self.assertEqual(list(inst.response_callbacks), [callback])
         inst.add_response_callback(callback)
@@ -130,12 +132,15 @@ class TestRequest(unittest.TestCase):
 
     def test__process_response_callbacks(self):
         inst = self._makeOne()
+
         def callback1(request, response):
             request.called1 = True
             response.called1 = True
+
         def callback2(request, response):
-            request.called2  = True
+            request.called2 = True
             response.called2 = True
+
         inst.add_response_callback(callback1)
         inst.add_response_callback(callback2)
         response = DummyResponse()
@@ -153,13 +158,16 @@ class TestRequest(unittest.TestCase):
         See https://github.com/Pylons/pyramid/pull/1373
         """
         inst = self._makeOne()
+
         def callback1(request, response):
             request.called1 = True
             response.called1 = True
             request.add_response_callback(callback2)
+
         def callback2(request, response):
-            request.called2  = True
+            request.called2 = True
             response.called2 = True
+
         inst.add_response_callback(callback1)
         response = DummyResponse()
         inst._process_response_callbacks(response)
@@ -172,8 +180,10 @@ class TestRequest(unittest.TestCase):
     def test_add_finished_callback(self):
         inst = self._makeOne()
         self.assertEqual(len(inst.finished_callbacks), 0)
+
         def callback(request):
             """ """
+
         inst.add_finished_callback(callback)
         self.assertEqual(list(inst.finished_callbacks), [callback])
         inst.add_finished_callback(callback)
@@ -181,10 +191,13 @@ class TestRequest(unittest.TestCase):
 
     def test__process_finished_callbacks(self):
         inst = self._makeOne()
+
         def callback1(request):
             request.called1 = True
+
         def callback2(request):
-            request.called2  = True
+            request.called2 = True
+
         inst.add_finished_callback(callback1)
         inst.add_finished_callback(callback2)
         inst._process_finished_callbacks()
@@ -195,11 +208,11 @@ class TestRequest(unittest.TestCase):
     def test_resource_url(self):
         self._registerResourceURL()
         environ = {
-            'PATH_INFO':'/',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'80',
-            'wsgi.url_scheme':'http',
-            }
+            'PATH_INFO': '/',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '80',
+            'wsgi.url_scheme': 'http',
+        }
         inst = self._makeOne(environ)
         root = DummyContext()
         result = inst.resource_url(root)
@@ -207,55 +220,74 @@ class TestRequest(unittest.TestCase):
 
     def test_route_url(self):
         environ = {
-            'PATH_INFO':'/',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'5432',
-            'QUERY_STRING':'la=La%20Pe%C3%B1a',
-            'wsgi.url_scheme':'http',
-            }
+            'PATH_INFO': '/',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '5432',
+            'QUERY_STRING': 'la=La%20Pe%C3%B1a',
+            'wsgi.url_scheme': 'http',
+        }
         from pyramid.interfaces import IRoutesMapper
+
         inst = self._makeOne(environ)
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         self.config.registry.registerUtility(mapper, IRoutesMapper)
-        result = inst.route_url('flub', 'extra1', 'extra2',
-                                a=1, b=2, c=3, _query={'a':1},
-                                _anchor=text_("foo"))
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo')
+        result = inst.route_url(
+            'flub',
+            'extra1',
+            'extra2',
+            a=1,
+            b=2,
+            c=3,
+            _query={'a': 1},
+            _anchor=text_("foo"),
+        )
+        self.assertEqual(
+            result, 'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo'
+        )
 
     def test_route_path(self):
         environ = {
-            'PATH_INFO':'/',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'5432',
-            'QUERY_STRING':'la=La%20Pe%C3%B1a',
-            'wsgi.url_scheme':'http',
-            }
+            'PATH_INFO': '/',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '5432',
+            'QUERY_STRING': 'la=La%20Pe%C3%B1a',
+            'wsgi.url_scheme': 'http',
+        }
         from pyramid.interfaces import IRoutesMapper
+
         inst = self._makeOne(environ)
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         self.config.registry.registerUtility(mapper, IRoutesMapper)
-        result = inst.route_path('flub', 'extra1', 'extra2',
-                                a=1, b=2, c=3, _query={'a':1},
-                                _anchor=text_("foo"))
+        result = inst.route_path(
+            'flub',
+            'extra1',
+            'extra2',
+            a=1,
+            b=2,
+            c=3,
+            _query={'a': 1},
+            _anchor=text_("foo"),
+        )
         self.assertEqual(result, '/1/2/3/extra1/extra2?a=1#foo')
 
     def test_static_url(self):
         from pyramid.interfaces import IStaticURLInfo
+
         environ = {
-            'PATH_INFO':'/',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'5432',
-            'QUERY_STRING':'',
-            'wsgi.url_scheme':'http',
-            }
+            'PATH_INFO': '/',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '5432',
+            'QUERY_STRING': '',
+            'wsgi.url_scheme': 'http',
+        }
         request = self._makeOne(environ)
         info = DummyStaticURLInfo('abc')
         self.config.registry.registerUtility(info, IStaticURLInfo)
         result = request.static_url('pyramid.tests:static/foo.css')
         self.assertEqual(result, 'abc')
-        self.assertEqual(info.args,
-                         ('pyramid.tests:static/foo.css', request, {}) )
+        self.assertEqual(
+            info.args, ('pyramid.tests:static/foo.css', request, {})
+        )
 
     def test_is_response_false(self):
         request = self._makeOne()
@@ -264,6 +296,7 @@ class TestRequest(unittest.TestCase):
 
     def test_is_response_true_ob_is_pyramid_response(self):
         from pyramid.response import Response
+
         r = Response('hello')
         request = self._makeOne()
         request.registry = self.config.registry
@@ -271,62 +304,73 @@ class TestRequest(unittest.TestCase):
 
     def test_is_response_false_adapter_is_not_self(self):
         from pyramid.interfaces import IResponse
+
         request = self._makeOne()
         request.registry = self.config.registry
+
         def adapter(ob):
             return object()
+
         class Foo(object):
             pass
+
         foo = Foo()
         request.registry.registerAdapter(adapter, (Foo,), IResponse)
         self.assertEqual(request.is_response(foo), False)
-        
+
     def test_is_response_adapter_true(self):
         from pyramid.interfaces import IResponse
+
         request = self._makeOne()
         request.registry = self.config.registry
+
         class Foo(object):
             pass
+
         foo = Foo()
+
         def adapter(ob):
             return ob
+
         request.registry.registerAdapter(adapter, (Foo,), IResponse)
         self.assertEqual(request.is_response(foo), True)
 
     def test_json_body_invalid_json(self):
-        request = self._makeOne({'REQUEST_METHOD':'POST'})
+        request = self._makeOne({'REQUEST_METHOD': 'POST'})
         request.body = b'{'
         self.assertRaises(ValueError, getattr, request, 'json_body')
-        
+
     def test_json_body_valid_json(self):
-        request = self._makeOne({'REQUEST_METHOD':'POST'})
+        request = self._makeOne({'REQUEST_METHOD': 'POST'})
         request.body = b'{"a":1}'
-        self.assertEqual(request.json_body, {'a':1})
+        self.assertEqual(request.json_body, {'a': 1})
 
     def test_json_body_alternate_charset(self):
         import json
-        request = self._makeOne({'REQUEST_METHOD':'POST'})
+
+        request = self._makeOne({'REQUEST_METHOD': 'POST'})
         inp = text_(
-            b'/\xe6\xb5\x81\xe8\xa1\x8c\xe8\xb6\x8b\xe5\x8a\xbf',
-            'utf-8'
-            )
+            b'/\xe6\xb5\x81\xe8\xa1\x8c\xe8\xb6\x8b\xe5\x8a\xbf', 'utf-8'
+        )
         if PY2:
-            body = json.dumps({'a':inp}).decode('utf-8').encode('utf-16')
+            body = json.dumps({'a': inp}).decode('utf-8').encode('utf-16')
         else:
-            body = bytes(json.dumps({'a':inp}), 'utf-16')
+            body = bytes(json.dumps({'a': inp}), 'utf-16')
         request.body = body
         request.content_type = 'application/json; charset=utf-16'
-        self.assertEqual(request.json_body, {'a':inp})
+        self.assertEqual(request.json_body, {'a': inp})
 
     def test_json_body_GET_request(self):
-        request = self._makeOne({'REQUEST_METHOD':'GET'})
+        request = self._makeOne({'REQUEST_METHOD': 'GET'})
         self.assertRaises(ValueError, getattr, request, 'json_body')
 
     def test_set_property(self):
         request = self._makeOne()
         opts = [2, 1]
+
         def connect(obj):
             return opts.pop()
+
         request.set_property(connect, name='db')
         self.assertEqual(1, request.db)
         self.assertEqual(2, request.db)
@@ -334,35 +378,43 @@ class TestRequest(unittest.TestCase):
     def test_set_property_reify(self):
         request = self._makeOne()
         opts = [2, 1]
+
         def connect(obj):
             return opts.pop()
+
         request.set_property(connect, name='db', reify=True)
         self.assertEqual(1, request.db)
         self.assertEqual(1, request.db)
 
+
 class Test_route_request_iface(unittest.TestCase):
     def _callFUT(self, name):
         from pyramid.request import route_request_iface
+
         return route_request_iface(name)
 
     def test_it(self):
         iface = self._callFUT('routename')
         self.assertEqual(iface.__name__, 'routename_IRequest')
         self.assertTrue(hasattr(iface, 'combined'))
-        self.assertEqual(iface.combined.__name__, 'routename_combined_IRequest')
+        self.assertEqual(
+            iface.combined.__name__, 'routename_combined_IRequest'
+        )
 
     def test_it_routename_with_spaces(self):
         #  see https://github.com/Pylons/pyramid/issues/232
         iface = self._callFUT('routename with spaces')
         self.assertEqual(iface.__name__, 'routename with spaces_IRequest')
         self.assertTrue(hasattr(iface, 'combined'))
-        self.assertEqual(iface.combined.__name__,
-                         'routename with spaces_combined_IRequest')
-        
+        self.assertEqual(
+            iface.combined.__name__, 'routename with spaces_combined_IRequest'
+        )
+
 
 class Test_add_global_response_headers(unittest.TestCase):
     def _callFUT(self, request, headerlist):
         from pyramid.request import add_global_response_headers
+
         return add_global_response_headers(request, headerlist)
 
     def test_it(self):
@@ -371,11 +423,13 @@ class Test_add_global_response_headers(unittest.TestCase):
         self._callFUT(request, [('c', 1)])
         self.assertEqual(len(request.response_callbacks), 1)
         request.response_callbacks[0](None, response)
-        self.assertEqual(response.headerlist,  [('c', 1)] )
+        self.assertEqual(response.headerlist, [('c', 1)])
+
 
 class Test_call_app_with_subpath_as_path_info(unittest.TestCase):
     def _callFUT(self, request, app):
         from pyramid.request import call_app_with_subpath_as_path_info
+
         return call_app_with_subpath_as_path_info(request, app)
 
     def test_it_all_request_and_environment_data_missing(self):
@@ -387,7 +441,7 @@ class Test_call_app_with_subpath_as_path_info(unittest.TestCase):
         self.assertEqual(request.environ['PATH_INFO'], '/')
 
     def test_it_with_subpath_and_path_info(self):
-        request = DummyRequest({'PATH_INFO':'/hello'})
+        request = DummyRequest({'PATH_INFO': '/hello'})
         request.subpath = ('hello',)
         response = self._callFUT(request, 'app')
         self.assertTrue(request.copied)
@@ -396,7 +450,7 @@ class Test_call_app_with_subpath_as_path_info(unittest.TestCase):
         self.assertEqual(request.environ['PATH_INFO'], '/hello')
 
     def test_it_with_subpath_and_path_info_path_info_endswith_slash(self):
-        request = DummyRequest({'PATH_INFO':'/hello/'})
+        request = DummyRequest({'PATH_INFO': '/hello/'})
         request.subpath = ('hello',)
         response = self._callFUT(request, 'app')
         self.assertTrue(request.copied)
@@ -405,7 +459,9 @@ class Test_call_app_with_subpath_as_path_info(unittest.TestCase):
         self.assertEqual(request.environ['PATH_INFO'], '/hello/')
 
     def test_it_with_subpath_and_path_info_extra_script_name(self):
-        request = DummyRequest({'PATH_INFO':'/hello', 'SCRIPT_NAME':'/script'})
+        request = DummyRequest(
+            {'PATH_INFO': '/hello', 'SCRIPT_NAME': '/script'}
+        )
         request.subpath = ('hello',)
         response = self._callFUT(request, 'app')
         self.assertTrue(request.copied)
@@ -414,8 +470,9 @@ class Test_call_app_with_subpath_as_path_info(unittest.TestCase):
         self.assertEqual(request.environ['PATH_INFO'], '/hello')
 
     def test_it_with_extra_slashes_in_path_info(self):
-        request = DummyRequest({'PATH_INFO':'//hello/',
-                                'SCRIPT_NAME':'/script'})
+        request = DummyRequest(
+            {'PATH_INFO': '//hello/', 'SCRIPT_NAME': '/script'}
+        )
         request.subpath = ('hello',)
         response = self._callFUT(request, 'app')
         self.assertTrue(request.copied)
@@ -426,15 +483,17 @@ class Test_call_app_with_subpath_as_path_info(unittest.TestCase):
     def test_subpath_path_info_and_script_name_have_utf8(self):
         encoded = native_(text_(b'La Pe\xc3\xb1a'))
         decoded = text_(bytes_(encoded), 'utf-8')
-        request = DummyRequest({'PATH_INFO':'/' + encoded,
-                                'SCRIPT_NAME':'/' + encoded})
-        request.subpath = (decoded, )
+        request = DummyRequest(
+            {'PATH_INFO': '/' + encoded, 'SCRIPT_NAME': '/' + encoded}
+        )
+        request.subpath = (decoded,)
         response = self._callFUT(request, 'app')
         self.assertTrue(request.copied)
         self.assertEqual(response, 'app')
         self.assertEqual(request.environ['SCRIPT_NAME'], '/' + encoded)
         self.assertEqual(request.environ['PATH_INFO'], '/' + encoded)
 
+
 class Test_apply_request_extensions(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -444,10 +503,12 @@ class Test_apply_request_extensions(unittest.TestCase):
 
     def _callFUT(self, request, extensions=None):
         from pyramid.request import apply_request_extensions
+
         return apply_request_extensions(request, extensions=extensions)
 
     def test_it_with_registry(self):
         from pyramid.interfaces import IRequestExtensions
+
         extensions = Dummy()
         extensions.methods = {'foo': lambda x, y: y}
         extensions.descriptors = {'bar': property(lambda x: 'bar')}
@@ -460,6 +521,7 @@ class Test_apply_request_extensions(unittest.TestCase):
 
     def test_it_override_extensions(self):
         from pyramid.interfaces import IRequestExtensions
+
         ignore = Dummy()
         ignore.methods = {'x': lambda x, y, z: 'asdf'}
         ignore.descriptors = {'bar': property(lambda x: 'asdf')}
@@ -475,9 +537,11 @@ class Test_apply_request_extensions(unittest.TestCase):
         self.assertEqual(request.bar, 'bar')
         self.assertEqual(request.foo('abc'), 'abc')
 
+
 class Dummy(object):
     pass
 
+
 class Test_subclassing_Request(unittest.TestCase):
     def test_subclass(self):
         from pyramid.interfaces import IRequest
@@ -497,7 +561,6 @@ class Test_subclassing_Request(unittest.TestCase):
         # The call to implementedBy will add __provides__ to the class
         self.assertTrue(hasattr(RequestSub, '__provides__'))
 
-
     def test_subclass_with_implementer(self):
         from pyramid.interfaces import IRequest
         from pyramid.request import Request
@@ -554,6 +617,7 @@ class DummyRequest(object):
         self.copied = True
         return self
 
+
 class DummyResponse:
     def __init__(self):
         self.headerlist = []
@@ -562,16 +626,20 @@ class DummyResponse:
 class DummyContext:
     pass
 
+
 class DummyRoutesMapper:
     raise_exc = None
+
     def __init__(self, route=None, raise_exc=False):
         self.route = route
 
     def get_route(self, route_name):
         return self.route
 
+
 class DummyRoute:
     pregenerator = None
+
     def __init__(self, result='/1/2/3'):
         self.result = result
 
@@ -579,6 +647,7 @@ class DummyRoute:
         self.kw = kw
         return self.result
 
+
 class DummyStaticURLInfo:
     def __init__(self, result):
         self.result = result
diff --git a/tests/test_response.py b/tests/test_response.py
index 53e3ce17a..6ea7125b5 100644
--- a/tests/test_response.py
+++ b/tests/test_response.py
@@ -4,24 +4,30 @@ import os
 import unittest
 from pyramid import testing
 
+
 class TestResponse(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.response import Response
+
         return Response
 
     def test_implements_IResponse(self):
         from pyramid.interfaces import IResponse
+
         cls = self._getTargetClass()
         self.assertTrue(IResponse.implementedBy(cls))
 
     def test_provides_IResponse(self):
         from pyramid.interfaces import IResponse
+
         inst = self._getTargetClass()()
         self.assertTrue(IResponse.providedBy(inst))
 
+
 class TestFileResponse(unittest.TestCase):
     def _makeOne(self, file, **kw):
         from pyramid.response import FileResponse
+
         return FileResponse(file, **kw)
 
     def _getPath(self, suffix='txt'):
@@ -40,8 +46,9 @@ class TestFileResponse(unittest.TestCase):
         path = self._getPath('xml')
         r = self._makeOne(path, content_type='application/xml')
         self.assertEqual(r.content_type, 'application/xml')
-        self.assertEqual(r.headers['content-type'],
-                         'application/xml; charset=UTF-8')
+        self.assertEqual(
+            r.headers['content-type'], 'application/xml; charset=UTF-8'
+        )
         r.app_iter.close()
 
     def test_with_pdf_content_type(self):
@@ -55,8 +62,10 @@ class TestFileResponse(unittest.TestCase):
         for suffix in ('txt', 'xml', 'pdf'):
             path = self._getPath(suffix)
             r = self._makeOne(path)
-            self.assertEqual(r.headers['content-type'].split(';')[0],
-                             mimetypes.guess_type(path, strict=False)[0])
+            self.assertEqual(
+                r.headers['content-type'].split(';')[0],
+                mimetypes.guess_type(path, strict=False)[0],
+            )
             r.app_iter.close()
 
     def test_python_277_bug_15207(self):
@@ -67,9 +76,11 @@ class TestFileResponse(unittest.TestCase):
         from pyramid.compat import text_
         import mimetypes as old_mimetypes
         from pyramid import response
+
         class FakeMimetypesModule(object):
-            def guess_type(self,  *arg, **kw):
+            def guess_type(self, *arg, **kw):
                 return text_('foo/bar'), None
+
         fake_mimetypes = FakeMimetypesModule()
         try:
             response.mimetypes = fake_mimetypes
@@ -80,9 +91,11 @@ class TestFileResponse(unittest.TestCase):
         finally:
             response.mimetypes = old_mimetypes
 
+
 class TestFileIter(unittest.TestCase):
     def _makeOne(self, file, block_size):
         from pyramid.response import FileIter
+
         return FileIter(file, block_size)
 
     def test___iter__(self):
@@ -97,7 +110,7 @@ class TestFileIter(unittest.TestCase):
         r = b''
         for x in inst:
             self.assertEqual(len(x), 1)
-            r+=x
+            r += x
         self.assertEqual(r, data)
 
     def test_close(self):
@@ -106,15 +119,18 @@ class TestFileIter(unittest.TestCase):
         inst.close()
         self.assertTrue(f.closed)
 
+
 class Test_patch_mimetypes(unittest.TestCase):
     def _callFUT(self, module):
         from pyramid.response import init_mimetypes
+
         return init_mimetypes(module)
 
     def test_has_init(self):
         class DummyMimetypes(object):
             def init(self):
                 self.initted = True
+
         module = DummyMimetypes()
         result = self._callFUT(module)
         self.assertEqual(result, True)
@@ -123,6 +139,7 @@ class Test_patch_mimetypes(unittest.TestCase):
     def test_missing_init(self):
         class DummyMimetypes(object):
             pass
+
         module = DummyMimetypes()
         result = self._callFUT(module)
         self.assertEqual(result, False)
@@ -138,13 +155,20 @@ class TestResponseAdapter(unittest.TestCase):
 
     def _makeOne(self, *types_or_ifaces, **kw):
         from pyramid.response import response_adapter
+
         return response_adapter(*types_or_ifaces, **kw)
 
     def test_register_single(self):
         from zope.interface import Interface
-        class IFoo(Interface): pass
+
+        class IFoo(Interface):
+            pass
+
         dec = self._makeOne(IFoo)
-        def foo(): pass
+
+        def foo():
+            pass
+
         config = DummyConfigurator()
         scanner = Dummy()
         scanner.config = config
@@ -153,10 +177,18 @@ class TestResponseAdapter(unittest.TestCase):
 
     def test_register_multi(self):
         from zope.interface import Interface
-        class IFoo(Interface): pass
-        class IBar(Interface): pass
+
+        class IFoo(Interface):
+            pass
+
+        class IBar(Interface):
+            pass
+
         dec = self._makeOne(IFoo, IBar)
-        def foo(): pass
+
+        def foo():
+            pass
+
         config = DummyConfigurator()
         scanner = Dummy()
         scanner.config = config
@@ -165,25 +197,39 @@ class TestResponseAdapter(unittest.TestCase):
 
     def test___call__(self):
         from zope.interface import Interface
-        class IFoo(Interface): pass
+
+        class IFoo(Interface):
+            pass
+
         dec = self._makeOne(IFoo)
         dummy_venusian = DummyVenusian()
         dec.venusian = dummy_venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         dec(foo)
-        self.assertEqual(dummy_venusian.attached,
-                         [(foo, dec.register, 'pyramid', 1)])
+        self.assertEqual(
+            dummy_venusian.attached, [(foo, dec.register, 'pyramid', 1)]
+        )
 
     def test___call___with_venusian_args(self):
         from zope.interface import Interface
-        class IFoo(Interface): pass
+
+        class IFoo(Interface):
+            pass
+
         dec = self._makeOne(IFoo, _category='foo', _depth=1)
         dummy_venusian = DummyVenusian()
         dec.venusian = dummy_venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         dec(foo)
-        self.assertEqual(dummy_venusian.attached,
-                         [(foo, dec.register, 'foo', 2)])
+        self.assertEqual(
+            dummy_venusian.attached, [(foo, dec.register, 'foo', 2)]
+        )
 
 
 class TestGetResponseFactory(unittest.TestCase):
@@ -199,6 +245,7 @@ class TestGetResponseFactory(unittest.TestCase):
 class Dummy(object):
     pass
 
+
 class DummyConfigurator(object):
     def __init__(self):
         self.adapters = []
@@ -206,6 +253,7 @@ class DummyConfigurator(object):
     def add_response_adapter(self, wrapped, type_or_iface):
         self.adapters.append((wrapped, type_or_iface))
 
+
 class DummyVenusian(object):
     def __init__(self):
         self.attached = []
diff --git a/tests/test_router.py b/tests/test_router.py
index 6097018f0..f06cfe5bc 100644
--- a/tests/test_router.py
+++ b/tests/test_router.py
@@ -2,6 +2,7 @@ import unittest
 
 from pyramid import testing
 
+
 class TestRouter(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -13,6 +14,7 @@ class TestRouter(unittest.TestCase):
     def _registerRouteRequest(self, name):
         from pyramid.interfaces import IRouteRequest
         from pyramid.request import route_request_iface
+
         iface = route_request_iface(name)
         self.registry.registerUtility(iface, IRouteRequest, name=name)
         return iface
@@ -20,6 +22,7 @@ class TestRouter(unittest.TestCase):
     def _connectRoute(self, name, path, factory=None):
         from pyramid.interfaces import IRoutesMapper
         from pyramid.urldispatch import RoutesMapper
+
         mapper = self.registry.queryUtility(IRoutesMapper)
         if mapper is None:
             mapper = RoutesMapper()
@@ -28,21 +31,31 @@ class TestRouter(unittest.TestCase):
 
     def _registerLogger(self):
         from pyramid.interfaces import IDebugLogger
+
         logger = DummyLogger()
         self.registry.registerUtility(logger, IDebugLogger)
         return logger
 
     def _registerSettings(self, **kw):
-        settings = {'debug_authorization':False,
-                    'debug_notfound':False,
-                    'debug_routematch':False}
+        settings = {
+            'debug_authorization': False,
+            'debug_notfound': False,
+            'debug_routematch': False,
+        }
         settings.update(kw)
         self.registry.settings = settings
 
-    def _registerTraverserFactory(self, context, view_name='', subpath=None,
-                                  traversed=None, virtual_root=None,
-                                  virtual_root_path=None, raise_error=None,
-                                  **kw):
+    def _registerTraverserFactory(
+        self,
+        context,
+        view_name='',
+        subpath=None,
+        traversed=None,
+        virtual_root=None,
+        virtual_root_path=None,
+        raise_error=None,
+        **kw
+    ):
         from pyramid.interfaces import ITraverser
 
         if virtual_root is None:
@@ -61,39 +74,48 @@ class TestRouter(unittest.TestCase):
             def __call__(self, request):
                 if raise_error:
                     raise raise_error
-                values = {'root':self.root,
-                          'context':context,
-                          'view_name':view_name,
-                          'subpath':subpath,
-                          'traversed':traversed,
-                          'virtual_root':virtual_root,
-                          'virtual_root_path':virtual_root_path}
+                values = {
+                    'root': self.root,
+                    'context': context,
+                    'view_name': view_name,
+                    'subpath': subpath,
+                    'traversed': traversed,
+                    'virtual_root': virtual_root,
+                    'virtual_root_path': virtual_root_path,
+                }
                 kw.update(values)
                 return kw
 
-        self.registry.registerAdapter(DummyTraverserFactory, (None,),
-                                      ITraverser, name='')
+        self.registry.registerAdapter(
+            DummyTraverserFactory, (None,), ITraverser, name=''
+        )
 
     def _registerView(self, app, name, classifier, req_iface, ctx_iface):
         from pyramid.interfaces import IView
+
         self.registry.registerAdapter(
-            app, (classifier, req_iface, ctx_iface), IView, name)
+            app, (classifier, req_iface, ctx_iface), IView, name
+        )
 
     def _registerEventListener(self, iface):
         L = []
+
         def listener(event):
             L.append(event)
+
         self.registry.registerHandler(listener, (iface,))
         return L
 
     def _registerRootFactory(self, val):
         rootfactory = DummyRootFactory(val)
         from pyramid.interfaces import IRootFactory
+
         self.registry.registerUtility(rootfactory, IRootFactory)
         return rootfactory
 
     def _getTargetClass(self):
         from pyramid.router import Router
+
         return Router
 
     def _makeOne(self):
@@ -102,12 +124,12 @@ class TestRouter(unittest.TestCase):
 
     def _makeEnviron(self, **extras):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'localhost',
-            'SERVER_PORT':'8080',
-            'REQUEST_METHOD':'GET',
-            'PATH_INFO':'/',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'localhost',
+            'SERVER_PORT': '8080',
+            'REQUEST_METHOD': 'GET',
+            'PATH_INFO': '/',
+        }
         environ.update(extras)
         return environ
 
@@ -128,8 +150,10 @@ class TestRouter(unittest.TestCase):
 
     def test_request_factory(self):
         from pyramid.interfaces import IRequestFactory
+
         class DummyRequestFactory(object):
             pass
+
         self.registry.registerUtility(DummyRequestFactory, IRequestFactory)
         router = self._makeOne()
         self.assertEqual(router.request_factory, DummyRequestFactory)
@@ -140,41 +164,53 @@ class TestRouter(unittest.TestCase):
         from pyramid.response import Response
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IResponse
+
         tweens = Tweens()
         self.registry.registerUtility(tweens, ITweens)
         L = []
+
         def tween_factory1(handler, registry):
             L.append((handler, registry))
+
             def wrapper(request):
                 request.environ['handled'].append('one')
                 return handler(request)
+
             wrapper.name = 'one'
             wrapper.child = handler
             return wrapper
+
         def tween_factory2(handler, registry):
             L.append((handler, registry))
+
             def wrapper(request):
                 request.environ['handled'] = ['two']
                 return handler(request)
+
             wrapper.name = 'two'
             wrapper.child = handler
             return wrapper
+
         tweens.add_implicit('one', tween_factory1)
         tweens.add_implicit('two', tween_factory2)
         router = self._makeOne()
         self.assertEqual(router.handle_request.name, 'two')
         self.assertEqual(router.handle_request.child.name, 'one')
-        self.assertEqual(router.handle_request.child.child.__name__,
-                         'handle_request')
+        self.assertEqual(
+            router.handle_request.child.child.__name__, 'handle_request'
+        )
         context = DummyContext()
         self._registerTraverserFactory(context)
         environ = self._makeEnviron()
         view = DummyView('abc')
-        self._registerView(self.config.derive_view(view), '',
-                           IViewClassifier, None, None)
+        self._registerView(
+            self.config.derive_view(view), '', IViewClassifier, None, None
+        )
         start_response = DummyStartResponse()
+
         def make_response(s):
             return Response(s)
+
         router.registry.registerAdapter(make_response, (str,), IResponse)
         app_iter = router(environ, start_response)
         self.assertEqual(app_iter, [b'abc'])
@@ -183,6 +219,7 @@ class TestRouter(unittest.TestCase):
 
     def test_call_traverser_default(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         environ = self._makeEnviron()
         logger = self._registerLogger()
         router = self._makeOne()
@@ -194,6 +231,7 @@ class TestRouter(unittest.TestCase):
 
     def test_traverser_raises_notfound_class(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context, raise_error=HTTPNotFound)
@@ -203,9 +241,12 @@ class TestRouter(unittest.TestCase):
 
     def test_traverser_raises_notfound_instance(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         environ = self._makeEnviron()
         context = DummyContext()
-        self._registerTraverserFactory(context, raise_error=HTTPNotFound('foo'))
+        self._registerTraverserFactory(
+            context, raise_error=HTTPNotFound('foo')
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         why = exc_raised(HTTPNotFound, router, environ, start_response)
@@ -213,6 +254,7 @@ class TestRouter(unittest.TestCase):
 
     def test_traverser_raises_forbidden_class(self):
         from pyramid.httpexceptions import HTTPForbidden
+
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context, raise_error=HTTPForbidden)
@@ -222,10 +264,12 @@ class TestRouter(unittest.TestCase):
 
     def test_traverser_raises_forbidden_instance(self):
         from pyramid.httpexceptions import HTTPForbidden
+
         environ = self._makeEnviron()
         context = DummyContext()
-        self._registerTraverserFactory(context,
-                                       raise_error=HTTPForbidden('foo'))
+        self._registerTraverserFactory(
+            context, raise_error=HTTPForbidden('foo')
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         why = exc_raised(HTTPForbidden, router, environ, start_response)
@@ -233,6 +277,7 @@ class TestRouter(unittest.TestCase):
 
     def test_call_no_view_registered_no_isettings(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context)
@@ -246,6 +291,7 @@ class TestRouter(unittest.TestCase):
 
     def test_call_no_view_registered_debug_notfound_false(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context)
@@ -260,6 +306,7 @@ class TestRouter(unittest.TestCase):
 
     def test_call_no_view_registered_debug_notfound_true(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context)
@@ -269,7 +316,8 @@ class TestRouter(unittest.TestCase):
         start_response = DummyStartResponse()
         why = exc_raised(HTTPNotFound, router, environ, start_response)
         self.assertTrue(
-            "debug_notfound of url http://localhost:8080/; " in why.args[0])
+            "debug_notfound of url http://localhost:8080/; " in why.args[0]
+        )
         self.assertTrue("view_name: '', subpath: []" in why.args[0])
         self.assertTrue('http://localhost:8080' in why.args[0], why)
 
@@ -283,12 +331,14 @@ class TestRouter(unittest.TestCase):
 
     def test_call_view_returns_non_iresponse(self):
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
         self._registerTraverserFactory(context)
         environ = self._makeEnviron()
         view = DummyView('abc')
-        self._registerView(self.config.derive_view(view), '', IViewClassifier,
-                           None, None)
+        self._registerView(
+            self.config.derive_view(view), '', IViewClassifier, None, None
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         self.assertRaises(ValueError, router, environ, start_response)
@@ -297,16 +347,20 @@ class TestRouter(unittest.TestCase):
         from pyramid.response import Response
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IResponse
+
         context = DummyContext()
         self._registerTraverserFactory(context)
         environ = self._makeEnviron()
         view = DummyView('abc')
-        self._registerView(self.config.derive_view(view), '',
-                           IViewClassifier, None, None)
+        self._registerView(
+            self.config.derive_view(view), '', IViewClassifier, None, None
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
+
         def make_response(s):
             return Response(s)
+
         router.registry.registerAdapter(make_response, (str,), IResponse)
         app_iter = router(environ, start_response)
         self.assertEqual(app_iter, [b'abc'])
@@ -318,12 +372,15 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IRequest
         from pyramid.request import Request
         from pyramid.util import InstancePropertyHelper
+
         context = DummyContext()
         self._registerTraverserFactory(context)
+
         class Extensions(object):
             def __init__(self):
                 self.methods = {}
                 self.descriptors = {}
+
         extensions = Extensions()
         ext_method = lambda r: 'bar'
         name, fn = InstancePropertyHelper.make_property(ext_method, name='foo')
@@ -331,15 +388,18 @@ class TestRouter(unittest.TestCase):
         request = Request.blank('/')
         request.request_iface = IRequest
         request.registry = self.registry
+
         def request_factory(environ):
             return request
+
         self.registry.registerUtility(extensions, IRequestExtensions)
         environ = self._makeEnviron()
         response = DummyResponse()
         response.app_iter = ['Hello world']
         view = DummyView(response)
-        self._registerView(self.config.derive_view(view), '',
-                           IViewClassifier, None, None)
+        self._registerView(
+            self.config.derive_view(view), '', IViewClassifier, None, None
+        )
         router = self._makeOne()
         router.request_factory = request_factory
         start_response = DummyStartResponse()
@@ -348,14 +408,16 @@ class TestRouter(unittest.TestCase):
 
     def test_call_view_registered_nonspecific_default_path(self):
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
         self._registerTraverserFactory(context)
         response = DummyResponse()
         response.app_iter = ['Hello world']
         view = DummyView(response)
         environ = self._makeEnviron()
-        self._registerView(self.config.derive_view(view), '',
-                           IViewClassifier, None, None)
+        self._registerView(
+            self.config.derive_view(view), '', IViewClassifier, None, None
+        )
         self._registerRootFactory(context)
         router = self._makeOne()
         start_response = DummyStartResponse()
@@ -369,12 +431,15 @@ class TestRouter(unittest.TestCase):
         self.assertEqual(request.context, context)
         self.assertEqual(request.root, context)
 
-    def test_call_view_registered_nonspecific_nondefault_path_and_subpath(self):
+    def test_call_view_registered_nonspecific_nondefault_path_and_subpath(
+        self
+    ):
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
-        self._registerTraverserFactory(context, view_name='foo',
-                                       subpath=['bar'],
-                                       traversed=['context'])
+        self._registerTraverserFactory(
+            context, view_name='foo', subpath=['bar'], traversed=['context']
+        )
         self._registerRootFactory(context)
         response = DummyResponse()
         response.app_iter = ['Hello world']
@@ -396,10 +461,13 @@ class TestRouter(unittest.TestCase):
     def test_call_view_registered_specific_success(self):
         from zope.interface import Interface
         from zope.interface import directlyProvides
+
         class IContext(Interface):
             pass
+
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context)
@@ -426,11 +494,15 @@ class TestRouter(unittest.TestCase):
         from zope.interface import directlyProvides
         from pyramid.httpexceptions import HTTPNotFound
         from pyramid.interfaces import IViewClassifier
+
         class IContext(Interface):
             pass
+
         class INotContext(Interface):
             pass
+
         from pyramid.interfaces import IRequest
+
         context = DummyContext()
         directlyProvides(context, INotContext)
         self._registerTraverserFactory(context, subpath=[''])
@@ -446,16 +518,20 @@ class TestRouter(unittest.TestCase):
         from zope.interface import Interface
         from zope.interface import directlyProvides
         from pyramid.httpexceptions import HTTPForbidden
+
         class IContext(Interface):
             pass
+
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context, subpath=[''])
         response = DummyResponse()
-        view = DummyView(response,
-                         raise_exception=HTTPForbidden("unauthorized"))
+        view = DummyView(
+            response, raise_exception=HTTPForbidden("unauthorized")
+        )
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, IContext)
         router = self._makeOne()
@@ -466,11 +542,14 @@ class TestRouter(unittest.TestCase):
     def test_call_view_raises_notfound(self):
         from zope.interface import Interface
         from zope.interface import directlyProvides
+
         class IContext(Interface):
             pass
+
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
         from pyramid.httpexceptions import HTTPNotFound
+
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context, subpath=[''])
@@ -487,24 +566,31 @@ class TestRouter(unittest.TestCase):
         from zope.interface import Interface
         from zope.interface import directlyProvides
         from pyramid.interfaces import IExceptionViewClassifier
+
         class IContext(Interface):
             pass
+
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context, subpath=[''])
+
         def view(context, request):
             request.response.a = 1
             raise KeyError
+
         def exc_view(context, request):
             self.assertFalse(hasattr(request.response, 'a'))
             request.response.body = b'OK'
             return request.response
+
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, IContext)
-        self._registerView(exc_view, '', IExceptionViewClassifier,
-                           IRequest, KeyError)
+        self._registerView(
+            exc_view, '', IExceptionViewClassifier, IRequest, KeyError
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         itera = router(environ, start_response)
@@ -513,19 +599,25 @@ class TestRouter(unittest.TestCase):
     def test_call_request_has_response_callbacks(self):
         from zope.interface import Interface
         from zope.interface import directlyProvides
+
         class IContext(Interface):
             pass
+
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context, subpath=[''])
         response = DummyResponse('200 OK')
+
         def view(context, request):
             def callback(request, response):
                 response.called_back = True
+
             request.add_response_callback(callback)
             return response
+
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, IContext)
         router = self._makeOne()
@@ -536,19 +628,25 @@ class TestRouter(unittest.TestCase):
     def test_call_request_has_finished_callbacks_when_view_succeeds(self):
         from zope.interface import Interface
         from zope.interface import directlyProvides
+
         class IContext(Interface):
             pass
+
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context, subpath=[''])
         response = DummyResponse('200 OK')
+
         def view(context, request):
             def callback(request):
                 request.environ['called_back'] = True
+
             request.add_finished_callback(callback)
             return response
+
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, IContext)
         router = self._makeOne()
@@ -559,18 +657,24 @@ class TestRouter(unittest.TestCase):
     def test_call_request_has_finished_callbacks_when_view_raises(self):
         from zope.interface import Interface
         from zope.interface import directlyProvides
+
         class IContext(Interface):
             pass
+
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context, subpath=[''])
+
         def view(context, request):
             def callback(request):
                 request.environ['called_back'] = True
+
             request.add_finished_callback(callback)
             raise NotImplementedError
+
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, IContext)
         router = self._makeOne()
@@ -582,8 +686,10 @@ class TestRouter(unittest.TestCase):
         # making sure finally doesnt barf when a request cannot be created
         environ = self._makeEnviron()
         router = self._makeOne()
+
         def dummy_request_factory(environ):
             raise NotImplementedError
+
         router.request_factory = dummy_request_factory
         start_response = DummyStartResponse()
         exc_raised(NotImplementedError, router, environ, start_response)
@@ -594,6 +700,7 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IBeforeTraversal
         from pyramid.interfaces import IContextFound
         from pyramid.interfaces import IViewClassifier
+
         context = DummyContext()
         self._registerTraverserFactory(context)
         response = DummyResponse()
@@ -624,18 +731,22 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import INewRequest
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         context = DummyContext()
         self._registerTraverserFactory(context)
         environ = self._makeEnviron()
+
         def listener(event):
             raise KeyError
+
         self.registry.registerHandler(listener, (INewRequest,))
         exception_response = DummyResponse()
         exception_response.app_iter = ["Hello, world"]
         exception_view = DummyView(exception_response)
         environ = self._makeEnviron()
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, KeyError)
+        self._registerView(
+            exception_view, '', IExceptionViewClassifier, IRequest, KeyError
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -643,12 +754,15 @@ class TestRouter(unittest.TestCase):
 
     def test_call_route_matches_and_has_factory(self):
         from pyramid.interfaces import IViewClassifier
+
         logger = self._registerLogger()
         self._registerSettings(debug_routematch=True)
         self._registerRouteRequest('foo')
         root = object()
+
         def factory(request):
             return root
+
         route = self._connectRoute('foo', 'archives/:action/:article', factory)
         route.predicates = [DummyPredicate()]
         context = DummyContext()
@@ -670,23 +784,23 @@ class TestRouter(unittest.TestCase):
         self.assertEqual(request.subpath, [])
         self.assertEqual(request.context, context)
         self.assertEqual(request.root, root)
-        matchdict = {'action':'action1', 'article':'article1'}
+        matchdict = {'action': 'action1', 'article': 'article1'}
         self.assertEqual(request.matchdict, matchdict)
         self.assertEqual(request.matched_route.name, 'foo')
         self.assertEqual(len(logger.messages), 1)
         self.assertTrue(
             logger.messages[0].startswith(
-            "route matched for url http://localhost:8080"
-            "/archives/action1/article1; "
-            "route_name: 'foo', "
-            "path_info: ")
-            )
-        self.assertTrue(
-            "predicates: 'predicate'" in logger.messages[0]
+                "route matched for url http://localhost:8080"
+                "/archives/action1/article1; "
+                "route_name: 'foo', "
+                "path_info: "
             )
+        )
+        self.assertTrue("predicates: 'predicate'" in logger.messages[0])
 
     def test_call_route_match_miss_debug_routematch(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         logger = self._registerLogger()
         self._registerSettings(debug_routematch=True)
         self._registerRouteRequest('foo')
@@ -702,22 +816,29 @@ class TestRouter(unittest.TestCase):
         self.assertEqual(len(logger.messages), 1)
         self.assertEqual(
             logger.messages[0],
-            'no route matched for url http://localhost:8080/wontmatch')
+            'no route matched for url http://localhost:8080/wontmatch',
+        )
 
     def test_call_route_matches_doesnt_overwrite_subscriber_iface(self):
         from pyramid.interfaces import INewRequest
         from pyramid.interfaces import IViewClassifier
         from zope.interface import alsoProvides
         from zope.interface import Interface
+
         self._registerRouteRequest('foo')
+
         class IFoo(Interface):
             pass
+
         def listener(event):
             alsoProvides(event.request, IFoo)
+
         self.registry.registerHandler(listener, (INewRequest,))
         root = object()
+
         def factory(request):
             return root
+
         self._connectRoute('foo', 'archives/:action/:article', factory)
         context = DummyContext()
         self._registerTraverserFactory(context)
@@ -738,7 +859,7 @@ class TestRouter(unittest.TestCase):
         self.assertEqual(request.subpath, [])
         self.assertEqual(request.context, context)
         self.assertEqual(request.root, root)
-        matchdict = {'action':'action1', 'article':'article1'}
+        matchdict = {'action': 'action1', 'article': 'article1'}
         self.assertEqual(request.matchdict, matchdict)
         self.assertEqual(request.matched_route.name, 'foo')
         self.assertTrue(IFoo.providedBy(request))
@@ -748,11 +869,15 @@ class TestRouter(unittest.TestCase):
         from pyramid.httpexceptions import HTTPNotFound
         from zope.interface import Interface
         from zope.interface import directlyProvides
+
         def rootfactory(request):
             raise HTTPNotFound('from root factory')
+
         self.registry.registerUtility(rootfactory, IRootFactory)
+
         class IContext(Interface):
             pass
+
         context = DummyContext()
         directlyProvides(context, IContext)
         environ = self._makeEnviron()
@@ -766,11 +891,15 @@ class TestRouter(unittest.TestCase):
         from pyramid.httpexceptions import HTTPForbidden
         from zope.interface import Interface
         from zope.interface import directlyProvides
+
         def rootfactory(request):
             raise HTTPForbidden('from root factory')
+
         self.registry.registerUtility(rootfactory, IRootFactory)
+
         class IContext(Interface):
             pass
+
         context = DummyContext()
         directlyProvides(context, IContext)
         environ = self._makeEnviron()
@@ -783,11 +912,15 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IRootFactory
         from zope.interface import Interface
         from zope.interface import directlyProvides
+
         def rootfactory(request):
             raise RuntimeError()
+
         self.registry.registerUtility(rootfactory, IRootFactory)
+
         class IContext(Interface):
             pass
+
         context = DummyContext()
         directlyProvides(context, IContext)
         environ = self._makeEnviron()
@@ -806,16 +939,21 @@ class TestRouter(unittest.TestCase):
     def test_call_view_exception_propagating(self):
         from zope.interface import Interface
         from zope.interface import directlyProvides
+
         class IContext(Interface):
             pass
+
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IRequestFactory
         from pyramid.interfaces import IExceptionViewClassifier
+
         def rfactory(environ):
             return request
+
         self.registry.registerUtility(rfactory, IRequestFactory)
         from pyramid.request import Request
+
         request = Request.blank('/')
         context = DummyContext()
         directlyProvides(context, IContext)
@@ -825,12 +963,19 @@ class TestRouter(unittest.TestCase):
         error = RuntimeError()
         view = DummyView(response, raise_exception=error)
         environ = self._makeEnviron()
+
         def exception_view(context, request):
             self.assertEqual(request.exc_info[0], RuntimeError)
             return response
+
         self._registerView(view, '', IViewClassifier, IRequest, IContext)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            RuntimeError,
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -839,23 +984,31 @@ class TestRouter(unittest.TestCase):
         # the excview tween has run (see
         # https://github.com/Pylons/pyramid/issues/1223)
         self.assertEqual(request.exception, error)
-        self.assertEqual(request.exc_info[:2], (RuntimeError, error,))
-        
+        self.assertEqual(request.exc_info[:2], (RuntimeError, error))
+
     def test_call_view_raises_exception_view(self):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         response = DummyResponse()
         exception_response = DummyResponse()
         exception_response.app_iter = ["Hello, world"]
         view = DummyView(response, raise_exception=RuntimeError)
+
         def exception_view(context, request):
             self.assertEqual(request.exception.__class__, RuntimeError)
             return exception_response
+
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, None)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            RuntimeError,
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -865,10 +1018,13 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         class SuperException(Exception):
             pass
+
         class SubException(SuperException):
             pass
+
         response = DummyResponse()
         exception_response = DummyResponse()
         exception_response.app_iter = ["Hello, world"]
@@ -876,8 +1032,13 @@ class TestRouter(unittest.TestCase):
         exception_view = DummyView(exception_response)
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, None)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, SubException)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            SubException,
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         self.assertRaises(SuperException, router, environ, start_response)
@@ -886,10 +1047,13 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         class SuperException(Exception):
             pass
+
         class SubException(SuperException):
             pass
+
         response = DummyResponse()
         exception_response = DummyResponse()
         exception_response.app_iter = ["Hello, world"]
@@ -897,8 +1061,13 @@ class TestRouter(unittest.TestCase):
         exception_view = DummyView(exception_response)
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, None)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, SuperException)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            SuperException,
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -908,10 +1077,13 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         class MyException(Exception):
             pass
+
         class AnotherException(Exception):
             pass
+
         response = DummyResponse()
         exception_response = DummyResponse()
         exception_response.app_iter = ["Hello, world"]
@@ -919,8 +1091,13 @@ class TestRouter(unittest.TestCase):
         exception_view = DummyView(exception_response)
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, None)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, AnotherException)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            AnotherException,
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         self.assertRaises(MyException, router, environ, start_response)
@@ -929,14 +1106,21 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IRootFactory
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IExceptionViewClassifier
+
         def rootfactory(request):
             raise RuntimeError()
+
         self.registry.registerUtility(rootfactory, IRootFactory)
         exception_response = DummyResponse()
         exception_response.app_iter = ["Hello, world"]
         exception_view = DummyView(exception_response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            RuntimeError,
+        )
         environ = self._makeEnviron()
         router = self._makeOne()
         start_response = DummyStartResponse()
@@ -946,14 +1130,20 @@ class TestRouter(unittest.TestCase):
     def test_traverser_raises_exception_view(self):
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IExceptionViewClassifier
+
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context, raise_error=RuntimeError())
         exception_response = DummyResponse()
         exception_response.app_iter = ["Hello, world"]
         exception_view = DummyView(exception_response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            RuntimeError,
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -963,16 +1153,22 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         environ = self._makeEnviron()
         response = DummyResponse()
         view = DummyView(response, raise_exception=RuntimeError)
-        
-        self._registerView(self.config.derive_view(view), '',
-                           IViewClassifier, IRequest, None)
+
+        self._registerView(
+            self.config.derive_view(view), '', IViewClassifier, IRequest, None
+        )
         exception_view = DummyView(None)
-        self._registerView(self.config.derive_view(exception_view), '',
-                           IExceptionViewClassifier,
-                           IRequest, RuntimeError)
+        self._registerView(
+            self.config.derive_view(exception_view),
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            RuntimeError,
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         self.assertRaises(ValueError, router, environ, start_response)
@@ -980,6 +1176,7 @@ class TestRouter(unittest.TestCase):
     def test_call_route_raises_route_exception_view(self):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         req_iface = self._registerRouteRequest('foo')
         self._connectRoute('foo', 'archives/:action/:article', None)
         view = DummyView(DummyResponse(), raise_exception=RuntimeError)
@@ -987,8 +1184,13 @@ class TestRouter(unittest.TestCase):
         response = DummyResponse()
         response.app_iter = ["Hello, world"]
         exception_view = DummyView(response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           req_iface, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            req_iface,
+            RuntimeError,
+        )
         environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
         start_response = DummyStartResponse()
         router = self._makeOne()
@@ -999,6 +1201,7 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         req_iface = self._registerRouteRequest('foo')
         self._connectRoute('foo', 'archives/:action/:article', None)
         view = DummyView(DummyResponse(), raise_exception=RuntimeError)
@@ -1006,8 +1209,13 @@ class TestRouter(unittest.TestCase):
         response = DummyResponse()
         response.app_iter = ["Hello, world"]
         exception_view = DummyView(response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           req_iface, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            req_iface,
+            RuntimeError,
+        )
         environ = self._makeEnviron()
         start_response = DummyStartResponse()
         router = self._makeOne()
@@ -1017,6 +1225,7 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         req_iface = self._registerRouteRequest('foo')
         self._connectRoute('foo', 'archives/:action/:article', None)
         view = DummyView(DummyResponse(), raise_exception=RuntimeError)
@@ -1024,8 +1233,13 @@ class TestRouter(unittest.TestCase):
         response = DummyResponse()
         response.app_iter = ["Hello, world"]
         exception_view = DummyView(response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            RuntimeError,
+        )
         environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
         start_response = DummyStartResponse()
         router = self._makeOne()
@@ -1036,10 +1250,13 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         class SuperException(Exception):
             pass
+
         class SubException(SuperException):
             pass
+
         req_iface = self._registerRouteRequest('foo')
         self._connectRoute('foo', 'archives/:action/:article', None)
         view = DummyView(DummyResponse(), raise_exception=SuperException)
@@ -1047,8 +1264,13 @@ class TestRouter(unittest.TestCase):
         response = DummyResponse()
         response.app_iter = ["Hello, world"]
         exception_view = DummyView(response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, SubException)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            SubException,
+        )
         environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
         start_response = DummyStartResponse()
         router = self._makeOne()
@@ -1058,10 +1280,13 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         class SuperException(Exception):
             pass
+
         class SubException(SuperException):
             pass
+
         req_iface = self._registerRouteRequest('foo')
         self._connectRoute('foo', 'archives/:action/:article', None)
         view = DummyView(DummyResponse(), raise_exception=SubException)
@@ -1069,8 +1294,13 @@ class TestRouter(unittest.TestCase):
         response = DummyResponse()
         response.app_iter = ["Hello, world"]
         exception_view = DummyView(response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, SuperException)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            SuperException,
+        )
         environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
         start_response = DummyStartResponse()
         router = self._makeOne()
@@ -1081,10 +1311,13 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         class MyException(Exception):
             pass
+
         class AnotherException(Exception):
             pass
+
         req_iface = self._registerRouteRequest('foo')
         self._connectRoute('foo', 'archives/:action/:article', None)
         view = DummyView(DummyResponse(), raise_exception=MyException)
@@ -1092,8 +1325,13 @@ class TestRouter(unittest.TestCase):
         response = DummyResponse()
         response.app_iter = ["Hello, world"]
         exception_view = DummyView(response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, AnotherException)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            AnotherException,
+        )
         environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
         start_response = DummyStartResponse()
         router = self._makeOne()
@@ -1103,6 +1341,7 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         req_iface = self._registerRouteRequest('foo')
         self._connectRoute('foo', 'archives/:action/:article', None)
         view = DummyView(DummyResponse(), raise_exception=RuntimeError)
@@ -1110,13 +1349,23 @@ class TestRouter(unittest.TestCase):
         response = DummyResponse()
         response.app_iter = ["Hello, world"]
         exception_view = DummyView(response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           IRequest, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            IRequest,
+            RuntimeError,
+        )
         response_spec = DummyResponse()
         response_spec.app_iter = ["Hello, special world"]
         exception_view_spec = DummyView(response_spec)
-        self._registerView(exception_view_spec, '', IExceptionViewClassifier,
-                           req_iface, RuntimeError)
+        self._registerView(
+            exception_view_spec,
+            '',
+            IExceptionViewClassifier,
+            req_iface,
+            RuntimeError,
+        )
         environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
         start_response = DummyStartResponse()
         router = self._makeOne()
@@ -1126,6 +1375,7 @@ class TestRouter(unittest.TestCase):
     def test_call_route_raises_exception_view_another_route(self):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         req_iface = self._registerRouteRequest('foo')
         another_req_iface = self._registerRouteRequest('bar')
         self._connectRoute('foo', 'archives/:action/:article', None)
@@ -1134,8 +1384,13 @@ class TestRouter(unittest.TestCase):
         response = DummyResponse()
         response.app_iter = ["Hello, world"]
         exception_view = DummyView(response)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           another_req_iface, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            another_req_iface,
+            RuntimeError,
+        )
         environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
         start_response = DummyStartResponse()
         router = self._makeOne()
@@ -1145,6 +1400,7 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
+
         req_iface = self._registerRouteRequest('foo')
         response = DummyResponse()
         exception_response = DummyResponse()
@@ -1153,8 +1409,13 @@ class TestRouter(unittest.TestCase):
         exception_view = DummyView(exception_response)
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, IRequest, None)
-        self._registerView(exception_view, '', IExceptionViewClassifier,
-                           req_iface, RuntimeError)
+        self._registerView(
+            exception_view,
+            '',
+            IExceptionViewClassifier,
+            req_iface,
+            RuntimeError,
+        )
         router = self._makeOne()
         start_response = DummyStartResponse()
         self.assertRaises(RuntimeError, router, environ, start_response)
@@ -1163,6 +1424,7 @@ class TestRouter(unittest.TestCase):
         from pyramid.exceptions import PredicateMismatch
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IRequest
+
         view = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
         self._registerView(view, '', IViewClassifier, IRequest, None)
         environ = self._makeEnviron()
@@ -1175,21 +1437,30 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IRequest, IResponse
         from pyramid.response import Response
+
         class BaseContext:
             pass
+
         class DummyContext(BaseContext):
             pass
+
         context = DummyContext()
         self._registerTraverserFactory(context)
         view = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
-        self._registerView(view, '', IViewClassifier, IRequest,
-                           DummyContext)
+        self._registerView(view, '', IViewClassifier, IRequest, DummyContext)
         good_view = DummyView('abc')
-        self._registerView(self.config.derive_view(good_view),
-                            '', IViewClassifier, IRequest, BaseContext)
+        self._registerView(
+            self.config.derive_view(good_view),
+            '',
+            IViewClassifier,
+            IRequest,
+            BaseContext,
+        )
         router = self._makeOne()
+
         def make_response(s):
             return Response(s)
+
         router.registry.registerAdapter(make_response, (str,), IResponse)
         environ = self._makeEnviron()
         start_response = DummyStartResponse()
@@ -1202,27 +1473,36 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IRequest, IResponse
         from pyramid.response import Response
         from zope.interface import Interface, implementer
+
         class IBaseContext(Interface):
             pass
+
         class IContext(IBaseContext):
             pass
+
         @implementer(IContext)
         class DummyContext:
             pass
+
         context = DummyContext()
         self._registerTraverserFactory(context)
         view1 = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
-        self._registerView(view1, '', IViewClassifier, IRequest,
-                           DummyContext)
+        self._registerView(view1, '', IViewClassifier, IRequest, DummyContext)
         view2 = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
-        self._registerView(view2, '', IViewClassifier, IRequest,
-                           IContext)
+        self._registerView(view2, '', IViewClassifier, IRequest, IContext)
         good_view = DummyView('abc')
-        self._registerView(self.config.derive_view(good_view),
-                            '', IViewClassifier, IRequest, IBaseContext)
+        self._registerView(
+            self.config.derive_view(good_view),
+            '',
+            IViewClassifier,
+            IRequest,
+            IBaseContext,
+        )
         router = self._makeOne()
+
         def make_response(s):
             return Response(s)
+
         router.registry.registerAdapter(make_response, (str,), IResponse)
         environ = self._makeEnviron()
         start_response = DummyStartResponse()
@@ -1234,21 +1514,29 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IRequest
         from zope.interface import Interface, implementer
+
         class IContext(Interface):
             pass
+
         class IOtherContext(Interface):
             pass
+
         @implementer(IContext)
         class DummyContext:
             pass
+
         context = DummyContext()
         self._registerTraverserFactory(context)
         view = DummyView(DummyResponse(), raise_exception=PredicateMismatch)
-        self._registerView(view, '', IViewClassifier, IRequest,
-                           DummyContext)
+        self._registerView(view, '', IViewClassifier, IRequest, DummyContext)
         please_dont_call_me_view = DummyView('abc')
-        self._registerView(self.config.derive_view(please_dont_call_me_view),
-                            '', IViewClassifier, IRequest, IOtherContext)
+        self._registerView(
+            self.config.derive_view(please_dont_call_me_view),
+            '',
+            IViewClassifier,
+            IRequest,
+            IOtherContext,
+        )
         router = self._makeOne()
         environ = self._makeEnviron()
         router = self._makeOne()
@@ -1259,9 +1547,12 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IExecutionPolicy
         from pyramid.request import Request
         from pyramid.response import Response
+
         registry = self.config.registry
+
         def dummy_policy(environ, router):
             return Response(status=200, body=b'foo')
+
         registry.registerUtility(dummy_policy, IExecutionPolicy)
         router = self._makeOne()
         resp = Request.blank('/').get_response(router)
@@ -1272,23 +1563,29 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IExceptionViewClassifier
         from pyramid.interfaces import IRequest
+
         class Exception1(Exception):
             pass
+
         class Exception2(Exception):
             pass
+
         req_iface = self._registerRouteRequest('foo')
         self._connectRoute('foo', 'archives/:action/:article', None)
         view = DummyView(DummyResponse(), raise_exception=Exception1)
         self._registerView(view, '', IViewClassifier, req_iface, None)
-        exception_view1 = DummyView(DummyResponse(),
-                                    raise_exception=Exception2)
-        self._registerView(exception_view1, '', IExceptionViewClassifier,
-                           IRequest, Exception1)
+        exception_view1 = DummyView(
+            DummyResponse(), raise_exception=Exception2
+        )
+        self._registerView(
+            exception_view1, '', IExceptionViewClassifier, IRequest, Exception1
+        )
         response = DummyResponse()
         response.app_iter = ["Hello, world"]
         exception_view2 = DummyView(response)
-        self._registerView(exception_view2, '', IExceptionViewClassifier,
-                           IRequest, Exception2)
+        self._registerView(
+            exception_view2, '', IExceptionViewClassifier, IRequest, Exception2
+        )
         environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
         start_response = DummyStartResponse()
         router = self._makeOne()
@@ -1300,13 +1597,16 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IExecutionPolicy
         from pyramid.request import Request
         from pyramid.response import Response
+
         registry = self.config.registry
         result = []
+
         def dummy_policy(environ, router):
             with router.request_context(environ):
                 result.append(get_current_request())
             result.append(get_current_request())
             return Response(status=200, body=b'foo')
+
         registry.registerUtility(dummy_policy, IExecutionPolicy)
         router = self._makeOne()
         resp = Request.blank('/test_path').get_response(router)
@@ -1320,8 +1620,10 @@ class TestRouter(unittest.TestCase):
         from pyramid.interfaces import IExecutionPolicy
         from pyramid.request import Request
         from pyramid.response import Response
+
         registry = self.config.registry
         result = []
+
         def dummy_policy(environ, router):
             ctx = router.request_context(environ)
             ctx.begin()
@@ -1329,6 +1631,7 @@ class TestRouter(unittest.TestCase):
             ctx.end()
             result.append(get_current_request())
             return Response(status=200, body=b'foo')
+
         registry.registerUtility(dummy_policy, IExecutionPolicy)
         router = self._makeOne()
         resp = Request.blank('/test_path').get_response(router)
@@ -1337,15 +1640,19 @@ class TestRouter(unittest.TestCase):
         self.assertEqual(result[0].path_info, '/test_path')
         self.assertEqual(result[1], None)
 
+
 class DummyPredicate(object):
     def __call__(self, info, request):
         return True
+
     def text(self):
         return 'predicate'
 
+
 class DummyContext:
     pass
 
+
 class DummyView:
     def __init__(self, response, raise_exception=None):
         self.response = response
@@ -1358,6 +1665,7 @@ class DummyView:
             raise self.raise_exception
         return self.response
 
+
 class DummyRootFactory:
     def __init__(self, root):
         self.root = root
@@ -1365,21 +1673,26 @@ class DummyRootFactory:
     def __call__(self, environ):
         return self.root
 
+
 class DummyStartResponse:
     status = ()
     headers = ()
+
     def __call__(self, status, headers):
         self.status = status
         self.headers = headers
 
+
 from pyramid.interfaces import IResponse
 from zope.interface import implementer
 
+
 @implementer(IResponse)
 class DummyResponse(object):
     headerlist = ()
     app_iter = ()
     environ = None
+
     def __init__(self, status='200 OK'):
         self.status = status
 
@@ -1387,24 +1700,27 @@ class DummyResponse(object):
         self.environ = environ
         start_response(self.status, self.headerlist)
         return self.app_iter
-    
+
+
 class DummyAuthenticationPolicy:
     pass
 
+
 class DummyLogger:
     def __init__(self):
         self.messages = []
+
     def info(self, msg):
         self.messages.append(msg)
+
     warn = info
     debug = info
 
+
 def exc_raised(exc, func, *arg, **kw):
     try:
         func(*arg, **kw)
     except exc as e:
         return e
     else:
-        raise AssertionError('%s not raised' % exc) # pragma: no cover
-
-    
+        raise AssertionError('%s not raised' % exc)  # pragma: no cover
diff --git a/tests/test_scaffolds/test_copydir.py b/tests/test_scaffolds/test_copydir.py
index 915cc5033..1f046f9e8 100644
--- a/tests/test_scaffolds/test_copydir.py
+++ b/tests/test_scaffolds/test_copydir.py
@@ -3,39 +3,47 @@ import unittest
 import os
 import pkg_resources
 
+
 class Test_copy_dir(unittest.TestCase):
     def setUp(self):
         import tempfile
         from pyramid.compat import NativeIO
+
         self.dirname = tempfile.mkdtemp()
         self.out = NativeIO()
-        self.fixturetuple = ('tests.test_scaffolds',
-                             'fixture_scaffold')
+        self.fixturetuple = ('tests.test_scaffolds', 'fixture_scaffold')
 
     def tearDown(self):
         import shutil
+
         shutil.rmtree(self.dirname, ignore_errors=True)
         self.out.close()
 
     def _callFUT(self, *arg, **kw):
         kw['out_'] = self.out
         from pyramid.scaffolds.copydir import copy_dir
+
         return copy_dir(*arg, **kw)
 
     def test_copy_source_as_pkg_resource(self):
-        vars = {'package':'mypackage'}
-        self._callFUT(self.fixturetuple,
-                      self.dirname,
-                      vars,
-                      1, False,
-                      template_renderer=dummy_template_renderer)
+        vars = {'package': 'mypackage'}
+        self._callFUT(
+            self.fixturetuple,
+            self.dirname,
+            vars,
+            1,
+            False,
+            template_renderer=dummy_template_renderer,
+        )
         result = self.out.getvalue()
         self.assertTrue('Creating' in result)
         self.assertTrue(
-            'Copying fixture_scaffold/+package+/__init__.py_tmpl to' in result)
+            'Copying fixture_scaffold/+package+/__init__.py_tmpl to' in result
+        )
         source = pkg_resources.resource_filename(
             'tests.test_scaffolds',
-            'fixture_scaffold/+package+/__init__.py_tmpl')
+            'fixture_scaffold/+package+/__init__.py_tmpl',
+        )
         target = os.path.join(self.dirname, 'mypackage', '__init__.py')
         with open(target, 'r') as f:
             tcontent = f.read()
@@ -44,19 +52,23 @@ class Test_copy_dir(unittest.TestCase):
         self.assertEqual(scontent, tcontent)
 
     def test_copy_source_as_dirname(self):
-        vars = {'package':'mypackage'}
+        vars = {'package': 'mypackage'}
         source = pkg_resources.resource_filename(*self.fixturetuple)
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      1, False,
-                      template_renderer=dummy_template_renderer)
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            1,
+            False,
+            template_renderer=dummy_template_renderer,
+        )
         result = self.out.getvalue()
         self.assertTrue('Creating' in result)
         self.assertTrue('Copying __init__.py_tmpl to' in result)
         source = pkg_resources.resource_filename(
             'tests.test_scaffolds',
-            'fixture_scaffold/+package+/__init__.py_tmpl')
+            'fixture_scaffold/+package+/__init__.py_tmpl',
+        )
         target = os.path.join(self.dirname, 'mypackage', '__init__.py')
         with open(target, 'r') as f:
             tcontent = f.read()
@@ -65,58 +77,78 @@ class Test_copy_dir(unittest.TestCase):
         self.assertEqual(scontent, tcontent)
 
     def test_content_is_same_message(self):
-        vars = {'package':'mypackage'}
+        vars = {'package': 'mypackage'}
         source = pkg_resources.resource_filename(*self.fixturetuple)
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      2, False,
-                      template_renderer=dummy_template_renderer)
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      2, False,
-                      template_renderer=dummy_template_renderer)
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            2,
+            False,
+            template_renderer=dummy_template_renderer,
+        )
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            2,
+            False,
+            template_renderer=dummy_template_renderer,
+        )
         result = self.out.getvalue()
-        self.assertTrue('%s already exists (same content)' % \
-            os.path.join(self.dirname, 'mypackage', '__init__.py') in result)
+        self.assertTrue(
+            '%s already exists (same content)'
+            % os.path.join(self.dirname, 'mypackage', '__init__.py')
+            in result
+        )
 
     def test_direxists_message(self):
-        vars = {'package':'mypackage'}
+        vars = {'package': 'mypackage'}
         source = pkg_resources.resource_filename(*self.fixturetuple)
         # if not os.path.exists(self.dirname):
         #     os.mkdir(self.dirname)
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      2, False,
-                      template_renderer=dummy_template_renderer)
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            2,
+            False,
+            template_renderer=dummy_template_renderer,
+        )
         result = self.out.getvalue()
         self.assertTrue('Directory %s exists' % self.dirname in result, result)
 
     def test_overwrite_false(self):
-        vars = {'package':'mypackage'}
+        vars = {'package': 'mypackage'}
         source = pkg_resources.resource_filename(*self.fixturetuple)
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      1, False,
-                      overwrite=False,
-                      template_renderer=dummy_template_renderer)
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            1,
+            False,
+            overwrite=False,
+            template_renderer=dummy_template_renderer,
+        )
         # toplevel file
         toplevel = os.path.join(self.dirname, 'mypackage', '__init__.py')
         with open(toplevel, 'w') as f:
             f.write('These are the words you are looking for.')
         # sub directory file
-        sub = os.path.join(self.dirname, 'mypackage', 'templates', 'mytemplate.pt')
+        sub = os.path.join(
+            self.dirname, 'mypackage', 'templates', 'mytemplate.pt'
+        )
         with open(sub, 'w') as f:
             f.write('These are the words you are looking for.')
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      1, False,
-                      overwrite=False,
-                      template_renderer=dummy_template_renderer)
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            1,
+            False,
+            overwrite=False,
+            template_renderer=dummy_template_renderer,
+        )
         with open(toplevel, 'r') as f:
             tcontent = f.read()
         self.assertEqual('These are the words you are looking for.', tcontent)
@@ -125,57 +157,79 @@ class Test_copy_dir(unittest.TestCase):
         self.assertEqual('These are the words you are looking for.', tcontent)
 
     def test_overwrite_true(self):
-        vars = {'package':'mypackage'}
+        vars = {'package': 'mypackage'}
         source = pkg_resources.resource_filename(*self.fixturetuple)
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      1, False,
-                      overwrite=True,
-                      template_renderer=dummy_template_renderer)
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            1,
+            False,
+            overwrite=True,
+            template_renderer=dummy_template_renderer,
+        )
         # toplevel file
         toplevel = os.path.join(self.dirname, 'mypackage', '__init__.py')
         with open(toplevel, 'w') as f:
             f.write('These are not the words you are looking for.')
         # sub directory file
-        sub = os.path.join(self.dirname, 'mypackage', 'templates', 'mytemplate.pt')
+        sub = os.path.join(
+            self.dirname, 'mypackage', 'templates', 'mytemplate.pt'
+        )
         with open(sub, 'w') as f:
             f.write('These are not the words you are looking for.')
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      1, False,
-                      overwrite=True,
-                      template_renderer=dummy_template_renderer)
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            1,
+            False,
+            overwrite=True,
+            template_renderer=dummy_template_renderer,
+        )
         with open(toplevel, 'r') as f:
             tcontent = f.read()
-        self.assertNotEqual('These are not the words you are looking for.', tcontent)
+        self.assertNotEqual(
+            'These are not the words you are looking for.', tcontent
+        )
         with open(sub, 'r') as f:
             tcontent = f.read()
-        self.assertNotEqual('These are not the words you are looking for.', tcontent)
-    
+        self.assertNotEqual(
+            'These are not the words you are looking for.', tcontent
+        )
+
     def test_detect_SkipTemplate(self):
-        vars = {'package':'mypackage'}
+        vars = {'package': 'mypackage'}
         source = pkg_resources.resource_filename(*self.fixturetuple)
+
         def dummy_template_renderer(*args, **kwargs):
             from pyramid.scaffolds.copydir import SkipTemplate
+
             raise SkipTemplate
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      1, False,
-                      template_renderer=dummy_template_renderer)
+
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            1,
+            False,
+            template_renderer=dummy_template_renderer,
+        )
 
     def test_query_interactive(self):
         from pyramid.scaffolds import copydir
-        vars = {'package':'mypackage'}
+
+        vars = {'package': 'mypackage'}
         source = pkg_resources.resource_filename(*self.fixturetuple)
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      1, False,
-                      overwrite=False,
-                      template_renderer=dummy_template_renderer)
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            1,
+            False,
+            overwrite=False,
+            template_renderer=dummy_template_renderer,
+        )
         target = os.path.join(self.dirname, 'mypackage', '__init__.py')
         with open(target, 'w') as f:
             f.write('These are not the words you are looking for.')
@@ -183,35 +237,41 @@ class Test_copy_dir(unittest.TestCase):
         # execution of a branch
         original_code_object = copydir.query_interactive
         copydir.query_interactive = lambda *args, **kwargs: False
-        self._callFUT(source,
-                      self.dirname,
-                      vars,
-                      1, False,
-                      interactive=True,
-                      overwrite=False,
-                      template_renderer=dummy_template_renderer)
+        self._callFUT(
+            source,
+            self.dirname,
+            vars,
+            1,
+            False,
+            interactive=True,
+            overwrite=False,
+            template_renderer=dummy_template_renderer,
+        )
         copydir.query_interactive = original_code_object
 
-class Test_raise_SkipTemplate(unittest.TestCase):
 
+class Test_raise_SkipTemplate(unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from pyramid.scaffolds.copydir import skip_template
+
         return skip_template(*arg, **kw)
 
     def test_raise_SkipTemplate(self):
         from pyramid.scaffolds.copydir import SkipTemplate
-        self.assertRaises(SkipTemplate, 
-            self._callFUT, True, "exc-message")
 
-class Test_makedirs(unittest.TestCase):
+        self.assertRaises(SkipTemplate, self._callFUT, True, "exc-message")
 
+
+class Test_makedirs(unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from pyramid.scaffolds.copydir import makedirs
+
         return makedirs(*arg, **kw)
 
     def test_makedirs_parent_dir(self):
         import shutil
         import tempfile
+
         tmpdir = tempfile.mkdtemp()
         target = os.path.join(tmpdir, 'nonexistent_subdir')
         self._callFUT(target, 2, None)
@@ -220,100 +280,118 @@ class Test_makedirs(unittest.TestCase):
     def test_makedirs_no_parent_dir(self):
         import shutil
         import tempfile
+
         tmpdir = tempfile.mkdtemp()
         target = os.path.join(tmpdir, 'nonexistent_subdir', 'non2')
         self._callFUT(target, 2, None)
         shutil.rmtree(tmpdir)
 
-class Test_support_functions(unittest.TestCase):
 
+class Test_support_functions(unittest.TestCase):
     def _call_html_quote(self, *arg, **kw):
         from pyramid.scaffolds.copydir import html_quote
+
         return html_quote(*arg, **kw)
 
     def _call_url_quote(self, *arg, **kw):
         from pyramid.scaffolds.copydir import url_quote
+
         return url_quote(*arg, **kw)
 
     def _call_test(self, *arg, **kw):
         from pyramid.scaffolds.copydir import test
+
         return test(*arg, **kw)
 
     def test_html_quote(self):
         import string
+
         s = None
         self.assertEqual(self._call_html_quote(s), '')
         s = string.ascii_letters
         self.assertEqual(self._call_html_quote(s), s)
         s = "Λεμεσός"
-        self.assertEqual(self._call_url_quote(s), 
-            "%CE%9B%CE%B5%CE%BC%CE%B5%CF%83%CF%8C%CF%82")
+        self.assertEqual(
+            self._call_url_quote(s),
+            "%CE%9B%CE%B5%CE%BC%CE%B5%CF%83%CF%8C%CF%82",
+        )
 
     def test_url_quote(self):
         import string
+
         s = None
         self.assertEqual(self._call_url_quote(s), '')
         s = string.ascii_letters
         self.assertEqual(self._call_url_quote(s), s)
         s = "Λεμεσός"
-        self.assertEqual(self._call_url_quote(s), 
-            "%CE%9B%CE%B5%CE%BC%CE%B5%CF%83%CF%8C%CF%82")
+        self.assertEqual(
+            self._call_url_quote(s),
+            "%CE%9B%CE%B5%CE%BC%CE%B5%CF%83%CF%8C%CF%82",
+        )
 
     def test_test(self):
         conf = True
         true_cond = "faked"
-        self.assertEqual(self._call_test(
-                conf, true_cond, false_cond=None), "faked")
+        self.assertEqual(
+            self._call_test(conf, true_cond, false_cond=None), "faked"
+        )
         conf = False
-        self.assertEqual(self._call_test(
-                conf, true_cond, false_cond="alsofaked"), "alsofaked")
+        self.assertEqual(
+            self._call_test(conf, true_cond, false_cond="alsofaked"),
+            "alsofaked",
+        )
 
 
 class Test_should_skip_file(unittest.TestCase):
-
     def _callFUT(self, *arg, **kw):
         from pyramid.scaffolds.copydir import should_skip_file
+
         return should_skip_file(*arg, **kw)
 
     def test_should_skip_dot_hidden_file(self):
         self.assertEqual(
-            self._callFUT('.a_filename'), 
-            'Skipping hidden file %(filename)s')
+            self._callFUT('.a_filename'), 'Skipping hidden file %(filename)s'
+        )
 
     def test_should_skip_backup_file(self):
         for name in ('a_filename~', 'a_filename.bak'):
             self.assertEqual(
-                self._callFUT(name),
-                'Skipping backup file %(filename)s')
+                self._callFUT(name), 'Skipping backup file %(filename)s'
+            )
 
     def test_should_skip_bytecompiled_file(self):
         for name in ('afilename.pyc', 'afilename.pyo'):
             extension = os.path.splitext(name)[1]
             self.assertEqual(
                 self._callFUT(name),
-                'Skipping %s file ' % extension + '%(filename)s')
+                'Skipping %s file ' % extension + '%(filename)s',
+            )
 
     def test_should_skip_jython_class_file(self):
         self.assertEqual(
             self._callFUT('afilename$py.class'),
-            'Skipping $py.class file %(filename)s') 
+            'Skipping $py.class file %(filename)s',
+        )
 
     def test_should_skip_version_control_directory(self):
         for name in ('CVS', '_darcs'):
             self.assertEqual(
                 self._callFUT(name),
-                'Skipping version control directory %(filename)s')         
+                'Skipping version control directory %(filename)s',
+            )
 
     def test_valid_file_is_not_skipped(self):
-        self.assertEqual(
-            self._callFUT('a_filename'), None)
+        self.assertEqual(self._callFUT('a_filename'), None)
+
 
-class RawInputMockObject( object ):
+class RawInputMockObject(object):
     count = 0
-    def __init__( self, fake_input ):
-        self.input= fake_input
+
+    def __init__(self, fake_input):
+        self.input = fake_input
         self.count = 0
-    def __call__( self, prompt ):
+
+    def __call__(self, prompt):
         # Don't cycle endlessly.
         self.count += 1
         if self.count > 1:
@@ -321,11 +399,12 @@ class RawInputMockObject( object ):
         else:
             return self.input
 
-class Test_query_interactive(unittest.TestCase):
 
+class Test_query_interactive(unittest.TestCase):
     def setUp(self):
         import tempfile
         from pyramid.compat import NativeIO
+
         self.dirname = tempfile.mkdtemp()
         self.out = NativeIO()
         self.fixturetuple = ('tests.test_scaffolds', 'fixture_scaffold')
@@ -338,64 +417,90 @@ whom you are looking;
 now you have found them."""
         self.src_fn = os.path.join(self.dirname, 'mypackage', '__init__.py')
         self.dest_fn = os.path.join(self.dirname, 'mypackage', '__init__.py')
-        # query_interactive is only normally executed when the destination 
+        # query_interactive is only normally executed when the destination
         # is discovered to be already occupied by existing files, so ...
         # create the required occupancy.
         from pyramid.scaffolds.copydir import copy_dir
-        copy_dir(self.fixturetuple,
-                      self.dirname,
-                      {'package':'mypackage'},
-                      0, False,
-                      template_renderer=dummy_template_renderer)
+
+        copy_dir(
+            self.fixturetuple,
+            self.dirname,
+            {'package': 'mypackage'},
+            0,
+            False,
+            template_renderer=dummy_template_renderer,
+        )
 
     def tearDown(self):
         import shutil
+
         shutil.rmtree(self.dirname, ignore_errors=True)
         self.out.close()
 
     def _callFUT(self, *arg, **kw):
         from pyramid.scaffolds.copydir import query_interactive
+
         return query_interactive(*arg, **kw)
 
     def test_query_interactive_0y(self):
         from pyramid.scaffolds import copydir
+
         copydir.input_ = RawInputMockObject("y")
-        self._callFUT(self.src_fn, self.dest_fn, 
-                      self.src_content, self.dest_content, 
-                      simulate=False,
-                      out_=self.out)
+        self._callFUT(
+            self.src_fn,
+            self.dest_fn,
+            self.src_content,
+            self.dest_content,
+            simulate=False,
+            out_=self.out,
+        )
         self.assertTrue("Replace" in self.out.getvalue())
 
     def test_query_interactive_1n(self):
         from pyramid.scaffolds import copydir
+
         copydir.input_ = RawInputMockObject("n")
-        self._callFUT(self.src_fn, self.dest_fn, 
-                      self.src_content, 
-                      '\n'.join(self.dest_content.split('\n')[:-1]), 
-                      simulate=False,
-                      out_=self.out)
+        self._callFUT(
+            self.src_fn,
+            self.dest_fn,
+            self.src_content,
+            '\n'.join(self.dest_content.split('\n')[:-1]),
+            simulate=False,
+            out_=self.out,
+        )
         self.assertTrue("Replace" in self.out.getvalue())
 
     def test_query_interactive_2b(self):
         from pyramid.scaffolds import copydir
+
         copydir.input_ = RawInputMockObject("b")
-        with open(os.path.join(
-            self.dirname, 'mypackage', '__init__.py.bak'), 'w') as fp:
+        with open(
+            os.path.join(self.dirname, 'mypackage', '__init__.py.bak'), 'w'
+        ) as fp:
             fp.write("")
             fp.close()
-        self._callFUT(self.src_fn, self.dest_fn, 
-                      self.dest_content, self.src_content, 
-                      simulate=False,
-                      out_=self.out)
+        self._callFUT(
+            self.src_fn,
+            self.dest_fn,
+            self.dest_content,
+            self.src_content,
+            simulate=False,
+            out_=self.out,
+        )
         self.assertTrue("Backing up" in self.out.getvalue())
 
     def test_query_interactive_3d(self):
         from pyramid.scaffolds import copydir
+
         copydir.input_ = RawInputMockObject("d")
-        self._callFUT(self.src_fn, self.dest_fn, 
-                      self.dest_content, self.src_content, 
-                      simulate=False,
-                      out_=self.out)
+        self._callFUT(
+            self.src_fn,
+            self.dest_fn,
+            self.dest_content,
+            self.src_content,
+            simulate=False,
+            out_=self.out,
+        )
         output = self.out.getvalue()
         # The useful text in self.out gets wiped out on the second
         # call to raw_input, otherwise the test could be made
@@ -406,11 +511,16 @@ now you have found them."""
 
     def test_query_interactive_4dc(self):
         from pyramid.scaffolds import copydir
+
         copydir.input_ = RawInputMockObject("dc")
-        self._callFUT(self.src_fn, self.dest_fn, 
-                      self.dest_content, self.src_content, 
-                      simulate=False,
-                      out_=self.out)
+        self._callFUT(
+            self.src_fn,
+            self.dest_fn,
+            self.dest_content,
+            self.src_content,
+            simulate=False,
+            out_=self.out,
+        )
         output = self.out.getvalue()
         # The useful text in self.out gets wiped out on the second
         # call to raw_input, otherwise, the test could be made
@@ -421,11 +531,16 @@ now you have found them."""
 
     def test_query_interactive_5allbad(self):
         from pyramid.scaffolds import copydir
+
         copydir.input_ = RawInputMockObject("all z")
-        self._callFUT(self.src_fn, self.dest_fn, 
-                      self.src_content, self.dest_content, 
-                      simulate=False,
-                      out_=self.out)
+        self._callFUT(
+            self.src_fn,
+            self.dest_fn,
+            self.src_content,
+            self.dest_content,
+            simulate=False,
+            out_=self.out,
+        )
         output = self.out.getvalue()
         # The useful text in self.out gets wiped out on the second
         # call to raw_input, otherwise the test could be made
@@ -436,11 +551,16 @@ now you have found them."""
 
     def test_query_interactive_6all(self):
         from pyramid.scaffolds import copydir
+
         copydir.input_ = RawInputMockObject("all b")
-        self._callFUT(self.src_fn, self.dest_fn, 
-                      self.src_content, self.dest_content, 
-                      simulate=False,
-                      out_=self.out)
+        self._callFUT(
+            self.src_fn,
+            self.dest_fn,
+            self.src_content,
+            self.dest_content,
+            simulate=False,
+            out_=self.out,
+        )
         output = self.out.getvalue()
         # The useful text in self.out gets wiped out on the second
         # call to raw_input, otherwise the test could be made
@@ -449,6 +569,6 @@ now you have found them."""
         # self.assertTrue("Responses" in output, output)
         self.assertTrue("Replace" in output)
 
+
 def dummy_template_renderer(content, v, filename=None):
     return content
-    
diff --git a/tests/test_scaffolds/test_init.py b/tests/test_scaffolds/test_init.py
index f4d1b287a..6238915f6 100644
--- a/tests/test_scaffolds/test_init.py
+++ b/tests/test_scaffolds/test_init.py
@@ -1,21 +1,22 @@
 import unittest
 
+
 class TestPyramidTemplate(unittest.TestCase):
     def _makeOne(self):
         from pyramid.scaffolds import PyramidTemplate
+
         return PyramidTemplate('name')
 
     def test_pre(self):
         inst = self._makeOne()
-        vars = {'package':'one'}
+        vars = {'package': 'one'}
         inst.pre('command', 'output dir', vars)
         self.assertTrue(vars['random_string'])
         self.assertEqual(vars['package_logger'], 'one')
 
     def test_pre_root(self):
         inst = self._makeOne()
-        vars = {'package':'root'}
+        vars = {'package': 'root'}
         inst.pre('command', 'output dir', vars)
         self.assertTrue(vars['random_string'])
         self.assertEqual(vars['package_logger'], 'app')
-
diff --git a/tests/test_scaffolds/test_template.py b/tests/test_scaffolds/test_template.py
index 98f2daf73..d9a2dfadb 100644
--- a/tests/test_scaffolds/test_template.py
+++ b/tests/test_scaffolds/test_template.py
@@ -2,59 +2,72 @@ import unittest
 
 from pyramid.compat import bytes_
 
+
 class TestTemplate(unittest.TestCase):
     def _makeOne(self, name='whatever'):
         from pyramid.scaffolds.template import Template
+
         return Template(name)
 
     def test_render_template_success(self):
         inst = self._makeOne()
-        result = inst.render_template('{{a}} {{b}}', {'a':'1', 'b':'2'})
+        result = inst.render_template('{{a}} {{b}}', {'a': '1', 'b': '2'})
         self.assertEqual(result, bytes_('1 2'))
 
     def test_render_template_expr_failure(self):
         inst = self._makeOne()
-        self.assertRaises(AttributeError, inst.render_template,
-                          '{{a.foo}}', {'a':'1', 'b':'2'})
+        self.assertRaises(
+            AttributeError,
+            inst.render_template,
+            '{{a.foo}}',
+            {'a': '1', 'b': '2'},
+        )
 
     def test_render_template_expr_success(self):
         inst = self._makeOne()
-        result = inst.render_template('{{a.lower()}}', {'a':'A'})
+        result = inst.render_template('{{a.lower()}}', {'a': 'A'})
         self.assertEqual(result, b'a')
 
     def test_render_template_expr_success_via_pipe(self):
         inst = self._makeOne()
-        result = inst.render_template('{{b|c|a.lower()}}', {'a':'A'})
+        result = inst.render_template('{{b|c|a.lower()}}', {'a': 'A'})
         self.assertEqual(result, b'a')
 
     def test_render_template_expr_success_via_pipe2(self):
         inst = self._makeOne()
-        result = inst.render_template('{{b|a.lower()|c}}', {'a':'A'})
+        result = inst.render_template('{{b|a.lower()|c}}', {'a': 'A'})
         self.assertEqual(result, b'a')
 
     def test_render_template_expr_value_is_None(self):
         inst = self._makeOne()
-        result = inst.render_template('{{a}}', {'a':None})
+        result = inst.render_template('{{a}}', {'a': None})
         self.assertEqual(result, b'')
 
     def test_render_template_with_escaped_double_braces(self):
         inst = self._makeOne()
-        result = inst.render_template('{{a}} {{b}} \{\{a\}\} \{\{c\}\}', {'a':'1', 'b':'2'})
+        result = inst.render_template(
+            '{{a}} {{b}} \{\{a\}\} \{\{c\}\}', {'a': '1', 'b': '2'}
+        )
         self.assertEqual(result, bytes_('1 2 {{a}} {{c}}'))
 
     def test_render_template_with_breaking_escaped_braces(self):
         inst = self._makeOne()
-        result = inst.render_template('{{a}} {{b}} \{\{a\} \{b\}\}', {'a':'1', 'b':'2'})
+        result = inst.render_template(
+            '{{a}} {{b}} \{\{a\} \{b\}\}', {'a': '1', 'b': '2'}
+        )
         self.assertEqual(result, bytes_('1 2 \{\{a\} \{b\}\}'))
 
     def test_render_template_with_escaped_single_braces(self):
         inst = self._makeOne()
-        result = inst.render_template('{{a}} {{b}} \{a\} \{b', {'a':'1', 'b':'2'})
+        result = inst.render_template(
+            '{{a}} {{b}} \{a\} \{b', {'a': '1', 'b': '2'}
+        )
         self.assertEqual(result, bytes_('1 2 \{a\} \{b'))
 
     def test_module_dir(self):
         import sys
         import pkg_resources
+
         package = sys.modules['pyramid.scaffolds.template']
         path = pkg_resources.resource_filename(package.__name__, '')
         inst = self._makeOne()
@@ -74,10 +87,11 @@ class TestTemplate(unittest.TestCase):
         import os
         import sys
         import pkg_resources
+
         package = sys.modules['pyramid.scaffolds.template']
         path = pkg_resources.resource_filename(package.__name__, '')
         inst = self._makeOne()
-        inst._template_dir ='foo'
+        inst._template_dir = 'foo'
         result = inst.template_dir()
         self.assertEqual(result, os.path.join(path, 'foo'))
 
@@ -85,6 +99,7 @@ class TestTemplate(unittest.TestCase):
         import os
         import sys
         import pkg_resources
+
         package = sys.modules['pyramid.scaffolds.template']
         path = pkg_resources.resource_filename(package.__name__, '')
         inst = self._makeOne()
@@ -93,18 +108,21 @@ class TestTemplate(unittest.TestCase):
         copydir = DummyCopydir()
         inst.copydir = copydir
         command = DummyCommand()
-        inst.write_files(command, 'output dir', {'a':1})
+        inst.write_files(command, 'output dir', {'a': 1})
         self.assertEqual(copydir.template_dir, os.path.join(path, 'foo'))
         self.assertEqual(copydir.output_dir, 'output dir')
-        self.assertEqual(copydir.vars, {'a':1})
-        self.assertEqual(copydir.kw,
-                         {'template_renderer':inst.render_template,
-                          'indent':1,
-                          'verbosity':1,
-                          'simulate':False,
-                          'overwrite':False,
-                          'interactive':False,
-                          })
+        self.assertEqual(copydir.vars, {'a': 1})
+        self.assertEqual(
+            copydir.kw,
+            {
+                'template_renderer': inst.render_template,
+                'indent': 1,
+                'verbosity': 1,
+                'simulate': False,
+                'overwrite': False,
+                'interactive': False,
+            },
+        )
 
     def test_write_files_path_missing(self):
         L = []
@@ -116,7 +134,7 @@ class TestTemplate(unittest.TestCase):
         copydir = DummyCopydir()
         inst.copydir = copydir
         command = DummyCommand()
-        inst.write_files(command, 'output dir', {'a':1})
+        inst.write_files(command, 'output dir', {'a': 1})
         self.assertEqual(L, ['output dir'])
 
     def test_run(self):
@@ -129,13 +147,14 @@ class TestTemplate(unittest.TestCase):
         copydir = DummyCopydir()
         inst.copydir = copydir
         command = DummyCommand()
-        inst.run(command, 'output dir', {'a':1})
+        inst.run(command, 'output dir', {'a': 1})
         self.assertEqual(L, ['output dir'])
 
     def test_check_vars(self):
         inst = self._makeOne()
         self.assertRaises(RuntimeError, inst.check_vars, 'one', 'two')
 
+
 class DummyCopydir(object):
     def copy_dir(self, template_dir, output_dir, vars, **kw):
         self.template_dir = template_dir
@@ -143,13 +162,13 @@ class DummyCopydir(object):
         self.vars = vars
         self.kw = kw
 
+
 class DummyArgs(object):
     simulate = False
     overwrite = False
     interactive = False
 
+
 class DummyCommand(object):
     args = DummyArgs()
     verbosity = 1
-
-
diff --git a/tests/test_scripting.py b/tests/test_scripting.py
index ed88bb470..6bb293a0d 100644
--- a/tests/test_scripting.py
+++ b/tests/test_scripting.py
@@ -1,8 +1,10 @@
 import unittest
 
+
 class Test_get_root(unittest.TestCase):
     def _callFUT(self, app, request=None):
         from pyramid.scripting import get_root
+
         return get_root(app, request)
 
     def _makeRegistry(self):
@@ -10,6 +12,7 @@ class Test_get_root(unittest.TestCase):
 
     def setUp(self):
         from pyramid.threadlocal import manager
+
         self.manager = manager
         self.default = manager.get()
 
@@ -38,9 +41,11 @@ class Test_get_root(unittest.TestCase):
         closer()
         self.assertEqual(self.default, self.manager.get())
 
+
 class Test_prepare(unittest.TestCase):
     def _callFUT(self, request=None, registry=None):
         from pyramid.scripting import prepare
+
         return prepare(request, registry)
 
     def _makeRegistry(self, L=None):
@@ -50,11 +55,13 @@ class Test_prepare(unittest.TestCase):
 
     def setUp(self):
         from pyramid.threadlocal import manager
+
         self.manager = manager
         self.default = manager.get()
 
     def test_it_no_valid_apps(self):
         from pyramid.exceptions import ConfigurationError
+
         self.assertRaises(ConfigurationError, self._callFUT)
 
     def test_it_norequest(self):
@@ -120,6 +127,7 @@ class Test_prepare(unittest.TestCase):
 
     def test_it_with_extensions(self):
         from pyramid.util import InstancePropertyHelper
+
         exts = DummyExtensions()
         ext_method = lambda r: 'bar'
         name, fn = InstancePropertyHelper.make_property(ext_method, 'foo')
@@ -143,18 +151,22 @@ class Test_prepare(unittest.TestCase):
             self.assertEqual(pushed['request'].registry, registry)
             self.assertEqual(root.a, (request,))
             orig_closer = info['closer']
+
             def closer():
                 orig_closer()
                 closer_called[0] = True
+
             info['closer'] = closer
         self.assertTrue(closer_called[0])
         self.assertEqual(self.default, self.manager.get())
         self.assertEqual(request.context, root)
         self.assertEqual(request.registry, registry)
 
+
 class Test__make_request(unittest.TestCase):
     def _callFUT(self, path='/', registry=None):
         from pyramid.scripting import _make_request
+
         return _make_request(path, registry)
 
     def _makeRegistry(self):
@@ -168,6 +180,7 @@ class Test__make_request(unittest.TestCase):
 
     def test_it_with_no_registry(self):
         from pyramid.config import global_registries
+
         registry = self._makeRegistry()
         global_registries.add(registry)
         try:
@@ -177,11 +190,14 @@ class Test__make_request(unittest.TestCase):
         finally:
             global_registries.empty()
 
+
 class Dummy:
     pass
 
+
 dummy_root = Dummy()
 
+
 class DummyFactory(object):
     @classmethod
     def blank(cls, path):
@@ -192,15 +208,17 @@ class DummyFactory(object):
         self.a = a
         self.kw = kw
 
+
 class DummyRegistry(object):
     def __init__(self, utilities):
         self.utilities = utilities
 
-    def queryUtility(self, iface, default=None): # pragma: no cover
+    def queryUtility(self, iface, default=None):  # pragma: no cover
         if self.utilities:
             return self.utilities.pop(0)
         return default
 
+
 class DummyApp:
     def __init__(self, registry=None):
         if registry:
@@ -209,12 +227,15 @@ class DummyApp:
     def root_factory(self, environ):
         return dummy_root
 
+
 class DummyRequest(object):
     matchdict = None
     matched_route = None
+
     def __init__(self, environ):
         self.environ = environ
 
+
 class DummyExtensions:
     def __init__(self):
         self.descriptors = {}
diff --git a/tests/test_scripts/dummy.py b/tests/test_scripts/dummy.py
index f1ef403f8..69e69a280 100644
--- a/tests/test_scripts/dummy.py
+++ b/tests/test_scripts/dummy.py
@@ -3,21 +3,28 @@ class DummyTweens(object):
         self._implicit = implicit
         self.explicit = explicit
         self.name_to_alias = {}
+
     def implicit(self):
         return self._implicit
 
+
 class Dummy:
     pass
 
+
 dummy_root = Dummy()
 
+
 class DummyRegistry(object):
     settings = {}
+
     def queryUtility(self, iface, default=None, name=''):
         return default
 
+
 dummy_registry = DummyRegistry()
 
+
 class DummyShell(object):
     env = {}
     help = ''
@@ -30,15 +37,18 @@ class DummyShell(object):
         self.called = True
         self.env['request'].dummy_attr = self.dummy_attr
 
+
 class DummyInteractor:
     def __call__(self, banner, local):
         self.banner = banner
         self.local = local
 
+
 class DummyApp:
     def __init__(self):
         self.registry = dummy_registry
 
+
 class DummyMapper(object):
     def __init__(self, *routes):
         self.routes = routes
@@ -46,9 +56,11 @@ class DummyMapper(object):
     def get_routes(self, include_static=False):
         return self.routes
 
+
 class DummyRoute(object):
-    def __init__(self, name, pattern, factory=None,
-                 matchdict=None, predicate=None):
+    def __init__(
+        self, name, pattern, factory=None, matchdict=None, predicate=None
+    ):
         self.name = name
         self.path = pattern
         self.pattern = pattern
@@ -61,35 +73,50 @@ class DummyRoute(object):
     def match(self, route):
         return self.matchdict
 
+
 class DummyRequest:
     application_url = 'http://example.com:5432'
     script_name = ''
+
     def __init__(self, environ):
         self.environ = environ
         self.matchdict = {}
 
+
 class DummyView(object):
     def __init__(self, **attrs):
         self.__request_attrs__ = attrs
 
-    def view(context, request): pass
+    def view(context, request):
+        pass
+
 
 from zope.interface import implementer
 from pyramid.interfaces import IMultiView
+
+
 @implementer(IMultiView)
 class DummyMultiView(object):
-
     def __init__(self, *views, **attrs):
         self.views = [(None, view, None) for view in views]
         self.__request_attrs__ = attrs
 
+
 class DummyCloser(object):
     def __call__(self):
         self.called = True
 
+
 class DummyBootstrap(object):
-    def __init__(self, app=None, registry=None, request=None, root=None,
-                 root_factory=None, closer=None):
+    def __init__(
+        self,
+        app=None,
+        registry=None,
+        request=None,
+        root=None,
+        root_factory=None,
+        closer=None,
+    ):
         self.app = app or DummyApp()
         if registry is None:
             registry = DummyRegistry()
@@ -150,7 +177,9 @@ class dummy_setup_logging(object):
 
 
 class DummyLoader(object):
-    def __init__(self, settings=None, app_settings=None, app=None, server=None):
+    def __init__(
+        self, settings=None, app_settings=None, app=None, server=None
+    ):
         if not settings:
             settings = {}
         if not app_settings:
@@ -163,6 +192,7 @@ class DummyLoader(object):
 
     def __call__(self, uri):
         import plaster
+
         self.uri = plaster.parse_uri(uri)
         return self
 
diff --git a/tests/test_scripts/test_common.py b/tests/test_scripts/test_common.py
index 60741db92..e286d3c3e 100644
--- a/tests/test_scripts/test_common.py
+++ b/tests/test_scripts/test_common.py
@@ -1,13 +1,16 @@
 import unittest
 
+
 class TestParseVars(unittest.TestCase):
     def test_parse_vars_good(self):
         from pyramid.scripts.common import parse_vars
+
         vars = ['a=1', 'b=2']
         result = parse_vars(vars)
         self.assertEqual(result, {'a': '1', 'b': '2'})
 
     def test_parse_vars_bad(self):
         from pyramid.scripts.common import parse_vars
+
         vars = ['a']
         self.assertRaises(ValueError, parse_vars, vars)
diff --git a/tests/test_scripts/test_pcreate.py b/tests/test_scripts/test_pcreate.py
index 0286614ce..6ac082b41 100644
--- a/tests/test_scripts/test_pcreate.py
+++ b/tests/test_scripts/test_pcreate.py
@@ -4,6 +4,7 @@ import unittest
 class TestPCreateCommand(unittest.TestCase):
     def setUp(self):
         from pyramid.compat import NativeIO
+
         self.out_ = NativeIO()
 
     def out(self, msg):
@@ -11,6 +12,7 @@ class TestPCreateCommand(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.scripts.pcreate import PCreateCommand
+
         return PCreateCommand
 
     def _makeOne(self, *args, **kw):
@@ -46,8 +48,9 @@ class TestPCreateCommand(unittest.TestCase):
         result = cmd.run()
         self.assertEqual(result, 2)
         out = self.out_.getvalue()
-        self.assertTrue(out.count(
-            'You must provide at least one scaffold name'))
+        self.assertTrue(
+            out.count('You must provide at least one scaffold name')
+        )
 
     def test_no_project_name(self):
         cmd = self._makeOne('-s', 'dummy')
@@ -65,6 +68,7 @@ class TestPCreateCommand(unittest.TestCase):
 
     def test_known_scaffold_single_rendered(self):
         import os
+
         cmd = self._makeOne('-s', 'dummy', 'Distro')
         scaffold = DummyScaffold('dummy')
         cmd.scaffolds = [scaffold]
@@ -73,17 +77,25 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.output_dir,
-            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
-            )
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro')),
+        )
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': '0.1',
+                'pyramid_docs_branch': '0.1-branch',
+            },
+        )
 
     def test_scaffold_with_package_name(self):
         import os
-        cmd = self._makeOne('-s', 'dummy', '--package-name', 'dummy_package',
-                            'Distro')
+
+        cmd = self._makeOne(
+            '-s', 'dummy', '--package-name', 'dummy_package', 'Distro'
+        )
         scaffold = DummyScaffold('dummy')
         cmd.scaffolds = [scaffold]
         cmd.pyramid_dist = DummyDist("0.1")
@@ -92,17 +104,22 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.output_dir,
-            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
-            )
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro')),
+        )
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro', 'egg': 'dummy_package',
-             'package': 'dummy_package', 'pyramid_version': '0.1',
-             'pyramid_docs_branch':'0.1-branch'})
-
+            {
+                'project': 'Distro',
+                'egg': 'dummy_package',
+                'package': 'dummy_package',
+                'pyramid_version': '0.1',
+                'pyramid_docs_branch': '0.1-branch',
+            },
+        )
 
     def test_scaffold_with_hyphen_in_project_name(self):
         import os
+
         cmd = self._makeOne('-s', 'dummy', 'Distro-')
         scaffold = DummyScaffold('dummy')
         cmd.scaffolds = [scaffold]
@@ -111,15 +128,22 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.output_dir,
-            os.path.normpath(os.path.join(os.getcwd(), 'Distro-'))
-            )
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro-')),
+        )
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro-', 'egg': 'Distro_', 'package': 'distro_',
-             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+            {
+                'project': 'Distro-',
+                'egg': 'Distro_',
+                'package': 'distro_',
+                'pyramid_version': '0.1',
+                'pyramid_docs_branch': '0.1-branch',
+            },
+        )
 
     def test_known_scaffold_absolute_path(self):
         import os
+
         path = os.path.abspath('Distro')
         cmd = self._makeOne('-s', 'dummy', path)
         cmd.pyramid_dist = DummyDist("0.1")
@@ -130,15 +154,22 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.output_dir,
-            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
-            )
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro')),
+        )
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': '0.1',
+                'pyramid_docs_branch': '0.1-branch',
+            },
+        )
 
     def test_known_scaffold_multiple_rendered(self):
         import os
+
         cmd = self._makeOne('-s', 'dummy1', '-s', 'dummy2', 'Distro')
         scaffold1 = DummyScaffold('dummy1')
         scaffold2 = DummyScaffold('dummy2')
@@ -148,23 +179,36 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold1.output_dir,
-            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
-            )
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro')),
+        )
         self.assertEqual(
             scaffold1.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': '0.1',
+                'pyramid_docs_branch': '0.1-branch',
+            },
+        )
         self.assertEqual(
             scaffold2.output_dir,
-            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
-            )
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro')),
+        )
         self.assertEqual(
             scaffold2.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': '0.1',
+                'pyramid_docs_branch': '0.1-branch',
+            },
+        )
 
     def test_known_scaffold_with_path_as_project_target_rendered(self):
         import os
+
         cmd = self._makeOne('-s', 'dummy', '/tmp/foo/Distro/')
         scaffold = DummyScaffold('dummy')
         cmd.scaffolds = [scaffold]
@@ -173,13 +217,18 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.output_dir,
-            os.path.normpath(os.path.join(os.getcwd(), '/tmp/foo/Distro'))
-            )
+            os.path.normpath(os.path.join(os.getcwd(), '/tmp/foo/Distro')),
+        )
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
-
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': '0.1',
+                'pyramid_docs_branch': '0.1-branch',
+            },
+        )
 
     def test_scaffold_with_prod_pyramid_version(self):
         cmd = self._makeOne('-s', 'dummy', 'Distro')
@@ -190,8 +239,14 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': '0.2', 'pyramid_docs_branch':'0.2-branch'})
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': '0.2',
+                'pyramid_docs_branch': '0.2-branch',
+            },
+        )
 
     def test_scaffold_with_prod_pyramid_long_version(self):
         cmd = self._makeOne('-s', 'dummy', 'Distro')
@@ -202,8 +257,14 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': '0.2.1', 'pyramid_docs_branch':'0.2-branch'})
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': '0.2.1',
+                'pyramid_docs_branch': '0.2-branch',
+            },
+        )
 
     def test_scaffold_with_prod_pyramid_unparsable_version(self):
         cmd = self._makeOne('-s', 'dummy', 'Distro')
@@ -214,8 +275,14 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': 'abc', 'pyramid_docs_branch':'latest'})
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': 'abc',
+                'pyramid_docs_branch': 'latest',
+            },
+        )
 
     def test_scaffold_with_dev_pyramid_version(self):
         cmd = self._makeOne('-s', 'dummy', 'Distro')
@@ -226,9 +293,14 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': '0.12dev',
-             'pyramid_docs_branch': 'master'})
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': '0.12dev',
+                'pyramid_docs_branch': 'master',
+            },
+        )
 
     def test_scaffold_with_dev_pyramid_long_version(self):
         cmd = self._makeOne('-s', 'dummy', 'Distro')
@@ -239,16 +311,25 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
-             'pyramid_version': '0.10.1dev',
-             'pyramid_docs_branch': 'master'})
+            {
+                'project': 'Distro',
+                'egg': 'Distro',
+                'package': 'distro',
+                'pyramid_version': '0.10.1dev',
+                'pyramid_docs_branch': 'master',
+            },
+        )
 
     def test_confirm_override_conflicting_name(self):
         from pyramid.scripts.pcreate import PCreateCommand
+
         class YahInputPCreateCommand(PCreateCommand):
             def confirm_bad_name(self, pkg_name):
                 return True
-        cmd = self._makeOne('-s', 'dummy', 'Unittest', target_class=YahInputPCreateCommand)
+
+        cmd = self._makeOne(
+            '-s', 'dummy', 'Unittest', target_class=YahInputPCreateCommand
+        )
         scaffold = DummyScaffold('dummy')
         cmd.scaffolds = [scaffold]
         cmd.pyramid_dist = DummyDist("0.10.1dev")
@@ -256,12 +337,19 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Unittest', 'egg': 'Unittest', 'package': 'unittest',
-             'pyramid_version': '0.10.1dev',
-             'pyramid_docs_branch': 'master'})
+            {
+                'project': 'Unittest',
+                'egg': 'Unittest',
+                'package': 'unittest',
+                'pyramid_version': '0.10.1dev',
+                'pyramid_docs_branch': 'master',
+            },
+        )
 
     def test_force_override_conflicting_name(self):
-        cmd = self._makeOne('-s', 'dummy', 'Unittest', '--ignore-conflicting-name')
+        cmd = self._makeOne(
+            '-s', 'dummy', 'Unittest', '--ignore-conflicting-name'
+        )
         scaffold = DummyScaffold('dummy')
         cmd.scaffolds = [scaffold]
         cmd.pyramid_dist = DummyDist("0.10.1dev")
@@ -269,16 +357,25 @@ class TestPCreateCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(
             scaffold.vars,
-            {'project': 'Unittest', 'egg': 'Unittest', 'package': 'unittest',
-             'pyramid_version': '0.10.1dev',
-             'pyramid_docs_branch': 'master'})
+            {
+                'project': 'Unittest',
+                'egg': 'Unittest',
+                'package': 'unittest',
+                'pyramid_version': '0.10.1dev',
+                'pyramid_docs_branch': 'master',
+            },
+        )
 
     def test_force_override_site_name(self):
         from pyramid.scripts.pcreate import PCreateCommand
+
         class NayInputPCreateCommand(PCreateCommand):
             def confirm_bad_name(self, pkg_name):
                 return False
-        cmd = self._makeOne('-s', 'dummy', 'Site', target_class=NayInputPCreateCommand)
+
+        cmd = self._makeOne(
+            '-s', 'dummy', 'Site', target_class=NayInputPCreateCommand
+        )
         scaffold = DummyScaffold('dummy')
         cmd.scaffolds = [scaffold]
         cmd.pyramid_dist = DummyDist("0.10.1dev")
@@ -289,12 +386,14 @@ class TestPCreateCommand(unittest.TestCase):
 class Test_main(unittest.TestCase):
     def _callFUT(self, argv):
         from pyramid.scripts.pcreate import main
+
         return main(argv, quiet=True)
 
     def test_it(self):
         result = self._callFUT(['pcreate'])
         self.assertEqual(result, 2)
 
+
 class DummyScaffold(object):
     def __init__(self, name):
         self.name = name
@@ -304,6 +403,7 @@ class DummyScaffold(object):
         self.output_dir = output_dir
         self.vars = vars
 
+
 class DummyDist(object):
     def __init__(self, version):
         self.version = version
diff --git a/tests/test_scripts/test_pdistreport.py b/tests/test_scripts/test_pdistreport.py
index e229667c5..031a6ff2b 100644
--- a/tests/test_scripts/test_pdistreport.py
+++ b/tests/test_scripts/test_pdistreport.py
@@ -1,57 +1,68 @@
 import unittest
 
+
 class TestPDistReportCommand(unittest.TestCase):
     def _callFUT(self, **kw):
         argv = []
         from pyramid.scripts.pdistreport import main
+
         return main(argv, **kw)
 
     def test_no_dists(self):
         def platform():
             return 'myplatform'
+
         pkg_resources = DummyPkgResources()
         L = []
+
         def out(*args):
             L.extend(args)
-        result = self._callFUT(pkg_resources=pkg_resources, platform=platform,
-                               out=out)
+
+        result = self._callFUT(
+            pkg_resources=pkg_resources, platform=platform, out=out
+        )
         self.assertEqual(result, None)
         self.assertEqual(
             L,
-            ['Pyramid version:', '1',
-             'Platform:', 'myplatform',
-             'Packages:']
-            )
+            ['Pyramid version:', '1', 'Platform:', 'myplatform', 'Packages:'],
+        )
 
     def test_with_dists(self):
         def platform():
             return 'myplatform'
+
         working_set = (DummyDistribution('abc'), DummyDistribution('def'))
         pkg_resources = DummyPkgResources(working_set)
         L = []
+
         def out(*args):
             L.extend(args)
-        result = self._callFUT(pkg_resources=pkg_resources, platform=platform,
-                               out=out)
+
+        result = self._callFUT(
+            pkg_resources=pkg_resources, platform=platform, out=out
+        )
         self.assertEqual(result, None)
         self.assertEqual(
             L,
-            ['Pyramid version:',
-             '1',
-             'Platform:',
-             'myplatform',
-             'Packages:',
-             ' ',
-             'abc',
-             '1',
-             '   ',
-             '/projects/abc',
-             ' ',
-             'def',
-             '1',
-             '   ',
-             '/projects/def']
-            )
+            [
+                'Pyramid version:',
+                '1',
+                'Platform:',
+                'myplatform',
+                'Packages:',
+                ' ',
+                'abc',
+                '1',
+                '   ',
+                '/projects/abc',
+                ' ',
+                'def',
+                '1',
+                '   ',
+                '/projects/def',
+            ],
+        )
+
 
 class DummyPkgResources(object):
     def __init__(self, working_set=()):
@@ -60,14 +71,14 @@ class DummyPkgResources(object):
     def get_distribution(self, name):
         return Version('1')
 
+
 class Version(object):
     def __init__(self, version):
         self.version = version
 
+
 class DummyDistribution(object):
     def __init__(self, name):
         self.project_name = name
         self.version = '1'
         self.location = '/projects/%s' % name
-        
-        
diff --git a/tests/test_scripts/test_prequest.py b/tests/test_scripts/test_prequest.py
index f7e656995..1521172bc 100644
--- a/tests/test_scripts/test_prequest.py
+++ b/tests/test_scripts/test_prequest.py
@@ -1,9 +1,11 @@
 import unittest
 from . import dummy
 
+
 class TestPRequestCommand(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.scripts.prequest import PRequestCommand
+
         return PRequestCommand
 
     def _makeOne(self, argv, headers=None):
@@ -14,6 +16,7 @@ class TestPRequestCommand(unittest.TestCase):
             self._path_info = environ['PATH_INFO']
             start_request('200 OK', headers or [])
             return [b'abc']
+
         self.loader = dummy.DummyLoader(app=helloworld)
         self._out = []
         cmd._get_config_loader = self.loader
@@ -26,11 +29,15 @@ class TestPRequestCommand(unittest.TestCase):
     def test_command_not_enough_args(self):
         command = self._makeOne([])
         command.run()
-        self.assertEqual(self._out, ['You must provide at least two arguments'])
+        self.assertEqual(
+            self._out, ['You must provide at least two arguments']
+        )
 
     def test_command_two_args(self):
-        command = self._makeOne(['', 'development.ini', '/'],
-                [('Content-Type', 'text/html; charset=UTF-8')])
+        command = self._makeOne(
+            ['', 'development.ini', '/'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         command.run()
         self.assertEqual(self._path_info, '/')
         self.assertEqual(self.loader.uri.path, 'development.ini')
@@ -40,26 +47,31 @@ class TestPRequestCommand(unittest.TestCase):
         self.assertEqual(self._out, ['abc'])
 
     def test_command_path_doesnt_start_with_slash(self):
-        command = self._makeOne(['', 'development.ini', 'abc'],
-                [('Content-Type', 'text/html; charset=UTF-8')])
+        command = self._makeOne(
+            ['', 'development.ini', 'abc'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         command.run()
         self.assertEqual(self._path_info, '/abc')
         self.assertEqual(self.loader.uri.path, 'development.ini')
         self.assertEqual(self._out, ['abc'])
 
     def test_command_has_bad_config_header(self):
-        command = self._makeOne(
-            ['', '--header=name','development.ini', '/'])
+        command = self._makeOne(['', '--header=name', 'development.ini', '/'])
         command.run()
         self.assertEqual(
             self._out[0],
-            ("Bad --header=name option, value must be in the form "
-             "'name:value'"))
+            (
+                "Bad --header=name option, value must be in the form "
+                "'name:value'"
+            ),
+        )
 
     def test_command_has_good_header_var(self):
         command = self._makeOne(
-            ['', '--header=name:value','development.ini', '/'],
-            [('Content-Type', 'text/html; charset=UTF-8')])
+            ['', '--header=name:value', 'development.ini', '/'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         command.run()
         self.assertEqual(self._environ['HTTP_NAME'], 'value')
         self.assertEqual(self._path_info, '/')
@@ -67,20 +79,28 @@ class TestPRequestCommand(unittest.TestCase):
 
     def test_command_w_basic_auth(self):
         command = self._makeOne(
-            ['', '--login=user:password',
-                 '--header=name:value','development.ini', '/'],
-            [('Content-Type', 'text/html; charset=UTF-8')])
+            [
+                '',
+                '--login=user:password',
+                '--header=name:value',
+                'development.ini',
+                '/',
+            ],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         command.run()
         self.assertEqual(self._environ['HTTP_NAME'], 'value')
-        self.assertEqual(self._environ['HTTP_AUTHORIZATION'],
-                        'Basic dXNlcjpwYXNzd29yZA==')
+        self.assertEqual(
+            self._environ['HTTP_AUTHORIZATION'], 'Basic dXNlcjpwYXNzd29yZA=='
+        )
         self.assertEqual(self._path_info, '/')
         self.assertEqual(self._out, ['abc'])
 
     def test_command_has_content_type_header_var(self):
         command = self._makeOne(
-            ['', '--header=content-type:app/foo','development.ini', '/'],
-            [('Content-Type', 'text/html; charset=UTF-8')])
+            ['', '--header=content-type:app/foo', 'development.ini', '/'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         command.run()
         self.assertEqual(self._environ['CONTENT_TYPE'], 'app/foo')
         self.assertEqual(self._path_info, '/')
@@ -88,13 +108,15 @@ class TestPRequestCommand(unittest.TestCase):
 
     def test_command_has_multiple_header_vars(self):
         command = self._makeOne(
-            ['',
-             '--header=name:value',
-             '--header=name2:value2',
-             'development.ini',
-             '/'],
-            [('Content-Type', 'text/html; charset=UTF-8')]
-            )
+            [
+                '',
+                '--header=name:value',
+                '--header=name2:value2',
+                'development.ini',
+                '/',
+            ],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         command.run()
         self.assertEqual(self._environ['HTTP_NAME'], 'value')
         self.assertEqual(self._environ['HTTP_NAME2'], 'value2')
@@ -102,8 +124,10 @@ class TestPRequestCommand(unittest.TestCase):
         self.assertEqual(self._out, ['abc'])
 
     def test_command_method_get(self):
-        command = self._makeOne(['', '--method=GET', 'development.ini', '/'],
-                [('Content-Type', 'text/html; charset=UTF-8')])
+        command = self._makeOne(
+            ['', '--method=GET', 'development.ini', '/'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         command.run()
         self.assertEqual(self._environ['REQUEST_METHOD'], 'GET')
         self.assertEqual(self._path_info, '/')
@@ -111,8 +135,11 @@ class TestPRequestCommand(unittest.TestCase):
 
     def test_command_method_post(self):
         from pyramid.compat import NativeIO
-        command = self._makeOne(['', '--method=POST', 'development.ini', '/'],
-                [('Content-Type', 'text/html; charset=UTF-8')])
+
+        command = self._makeOne(
+            ['', '--method=POST', 'development.ini', '/'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         stdin = NativeIO()
         command.stdin = stdin
         command.run()
@@ -124,8 +151,11 @@ class TestPRequestCommand(unittest.TestCase):
 
     def test_command_method_put(self):
         from pyramid.compat import NativeIO
-        command = self._makeOne(['', '--method=PUT', 'development.ini', '/'],
-                [('Content-Type', 'text/html; charset=UTF-8')])
+
+        command = self._makeOne(
+            ['', '--method=PUT', 'development.ini', '/'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         stdin = NativeIO()
         command.stdin = stdin
         command.run()
@@ -137,8 +167,11 @@ class TestPRequestCommand(unittest.TestCase):
 
     def test_command_method_patch(self):
         from pyramid.compat import NativeIO
-        command = self._makeOne(['', '--method=PATCH', 'development.ini', '/'],
-                [('Content-Type', 'text/html; charset=UTF-8')])
+
+        command = self._makeOne(
+            ['', '--method=PATCH', 'development.ini', '/'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         stdin = NativeIO()
         command.stdin = stdin
         command.run()
@@ -150,9 +183,11 @@ class TestPRequestCommand(unittest.TestCase):
 
     def test_command_method_propfind(self):
         from pyramid.compat import NativeIO
-        command = self._makeOne(['', '--method=PROPFIND', 'development.ini',
-                                '/'],
-                                [('Content-Type', 'text/html; charset=UTF-8')])
+
+        command = self._makeOne(
+            ['', '--method=PROPFIND', 'development.ini', '/'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         stdin = NativeIO()
         command.stdin = stdin
         command.run()
@@ -162,9 +197,11 @@ class TestPRequestCommand(unittest.TestCase):
 
     def test_command_method_options(self):
         from pyramid.compat import NativeIO
-        command = self._makeOne(['', '--method=OPTIONS', 'development.ini',
-                                '/'],
-                                [('Content-Type', 'text/html; charset=UTF-8')])
+
+        command = self._makeOne(
+            ['', '--method=OPTIONS', 'development.ini', '/'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         stdin = NativeIO()
         command.stdin = stdin
         command.run()
@@ -173,8 +210,10 @@ class TestPRequestCommand(unittest.TestCase):
         self.assertEqual(self._out, ['abc'])
 
     def test_command_with_query_string(self):
-        command = self._makeOne(['', 'development.ini', '/abc?a=1&b=2&c'],
-                [('Content-Type', 'text/html; charset=UTF-8')])
+        command = self._makeOne(
+            ['', 'development.ini', '/abc?a=1&b=2&c'],
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         command.run()
         self.assertEqual(self._environ['QUERY_STRING'], 'a=1&b=2&c')
         self.assertEqual(self._path_info, '/abc')
@@ -183,16 +222,20 @@ class TestPRequestCommand(unittest.TestCase):
     def test_command_display_headers(self):
         command = self._makeOne(
             ['', '--display-headers', 'development.ini', '/'],
-            [('Content-Type', 'text/html; charset=UTF-8')])
+            [('Content-Type', 'text/html; charset=UTF-8')],
+        )
         command.run()
         self.assertEqual(self._path_info, '/')
         self.assertEqual(
             self._out,
-            ['200 OK', 'Content-Type: text/html; charset=UTF-8', 'abc'])
+            ['200 OK', 'Content-Type: text/html; charset=UTF-8', 'abc'],
+        )
 
     def test_command_response_has_no_charset(self):
-        command = self._makeOne(['', '--method=GET', 'development.ini', '/'],
-                                headers=[('Content-Type', 'image/jpeg')])
+        command = self._makeOne(
+            ['', '--method=GET', 'development.ini', '/'],
+            headers=[('Content-Type', 'image/jpeg')],
+        )
         command.run()
         self.assertEqual(self._path_info, '/')
 
@@ -207,6 +250,7 @@ class TestPRequestCommand(unittest.TestCase):
 class Test_main(unittest.TestCase):
     def _callFUT(self, argv):
         from pyramid.scripts.prequest import main
+
         return main(argv, True)
 
     def test_it(self):
diff --git a/tests/test_scripts/test_proutes.py b/tests/test_scripts/test_proutes.py
index 0de331c94..5bbfa9f25 100644
--- a/tests/test_scripts/test_proutes.py
+++ b/tests/test_scripts/test_proutes.py
@@ -15,6 +15,7 @@ class DummyIntrospector(object):
 class TestPRoutesCommand(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.scripts.proutes import PRoutesCommand
+
         return PRoutesCommand
 
     def _makeOne(self):
@@ -27,12 +28,14 @@ class TestPRoutesCommand(unittest.TestCase):
 
     def _makeRegistry(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         registry.introspector = DummyIntrospector()
         return registry
 
     def _makeConfig(self, *arg, **kw):
         from pyramid.config import Configurator
+
         config = Configurator(*arg, **kw)
         return config
 
@@ -76,7 +79,7 @@ class TestPRoutesCommand(unittest.TestCase):
 
     def test_no_mapper(self):
         command = self._makeOne()
-        command._get_mapper = lambda *arg:None
+        command._get_mapper = lambda *arg: None
         L = []
         command.out = L.append
         result = command.run()
@@ -115,11 +118,15 @@ class TestPRoutesCommand(unittest.TestCase):
     def test_single_route_no_views_registered(self):
         from zope.interface import Interface
         from pyramid.interfaces import IRouteRequest
+
         registry = self._makeRegistry()
 
-        def view():pass
+        def view():
+            pass
+
         class IMyRoute(Interface):
             pass
+
         registry.registerUtility(IMyRoute, IRouteRequest, name='a')
         command = self._makeOne()
         route = dummy.DummyRoute('a', '/a')
@@ -138,14 +145,18 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.interfaces import IRouteRequest
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IView
+
         registry = self._makeRegistry()
 
-        def view():pass
+        def view():
+            pass
+
         class IMyRoute(Interface):
             pass
-        registry.registerAdapter(view,
-                                 (IViewClassifier, IMyRoute, Interface),
-                                 IView, '')
+
+        registry.registerAdapter(
+            view, (IViewClassifier, IMyRoute, Interface), IView, ''
+        )
         registry.registerUtility(IMyRoute, IRouteRequest, name='a')
         command = self._makeOne()
         route = dummy.DummyRoute('a', '/a')
@@ -159,8 +170,7 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()[:3]
         self.assertEqual(
-            compare_to,
-            ['a', '/a', 'tests.test_scripts.test_proutes.view']
+            compare_to, ['a', '/a', 'tests.test_scripts.test_proutes.view']
         )
 
     def test_one_route_with_long_name_one_view_registered(self):
@@ -168,26 +178,26 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.interfaces import IRouteRequest
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IView
+
         registry = self._makeRegistry()
 
-        def view():pass
+        def view():
+            pass
 
         class IMyRoute(Interface):
             pass
 
         registry.registerAdapter(
-            view,
-            (IViewClassifier, IMyRoute, Interface),
-            IView, ''
+            view, (IViewClassifier, IMyRoute, Interface), IView, ''
         )
 
-        registry.registerUtility(IMyRoute, IRouteRequest,
-                                 name='very_long_name_123')
+        registry.registerUtility(
+            IMyRoute, IRouteRequest, name='very_long_name_123'
+        )
 
         command = self._makeOne()
         route = dummy.DummyRoute(
-            'very_long_name_123',
-            '/and_very_long_pattern_as_well'
+            'very_long_name_123', '/and_very_long_pattern_as_well'
         )
         mapper = dummy.DummyMapper(route)
         command._get_mapper = lambda *arg: mapper
@@ -200,9 +210,11 @@ class TestPRoutesCommand(unittest.TestCase):
         compare_to = L[-1].split()[:3]
         self.assertEqual(
             compare_to,
-            ['very_long_name_123',
-             '/and_very_long_pattern_as_well',
-             'tests.test_scripts.test_proutes.view']
+            [
+                'very_long_name_123',
+                '/and_very_long_pattern_as_well',
+                'tests.test_scripts.test_proutes.view',
+            ],
         )
 
     def test_class_view(self):
@@ -215,7 +227,7 @@ class TestPRoutesCommand(unittest.TestCase):
             view=dummy.DummyView,
             attr='view',
             renderer=nr,
-            request_method='POST'
+            request_method='POST',
         )
 
         command = self._makeOne()
@@ -227,8 +239,10 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
         expected = [
-            'foo', '/a/b',
-            'tests.test_scripts.dummy.DummyView.view', 'POST'
+            'foo',
+            '/a/b',
+            'tests.test_scripts.dummy.DummyView.view',
+            'POST',
         ]
         self.assertEqual(compare_to, expected)
 
@@ -237,19 +251,27 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.interfaces import IRouteRequest
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IView
+
         registry = self._makeRegistry()
 
-        def view():pass
+        def view():
+            pass
+
         class IMyRoot(Interface):
             pass
+
         class IMyRoute(Interface):
             pass
-        registry.registerAdapter(view,
-                                 (IViewClassifier, IMyRoute, IMyRoot),
-                                 IView, '')
+
+        registry.registerAdapter(
+            view, (IViewClassifier, IMyRoute, IMyRoot), IView, ''
+        )
         registry.registerUtility(IMyRoute, IRouteRequest, name='a')
         command = self._makeOne()
-        def factory(request): pass
+
+        def factory(request):
+            pass
+
         route = dummy.DummyRoute('a', '/a', factory=factory)
         mapper = dummy.DummyMapper(route)
         command._get_mapper = lambda *arg: mapper
@@ -269,20 +291,18 @@ class TestPRoutesCommand(unittest.TestCase):
 
         registry = self._makeRegistry()
 
-        def view(): pass
+        def view():
+            pass
 
         class IMyRoute(Interface):
             pass
 
         multiview1 = dummy.DummyMultiView(
-            view, context='context',
-            view_name='a1'
+            view, context='context', view_name='a1'
         )
 
         registry.registerAdapter(
-            multiview1,
-            (IViewClassifier, IMyRoute, Interface),
-            IMultiView, ''
+            multiview1, (IViewClassifier, IMyRoute, Interface), IMultiView, ''
         )
         registry.registerUtility(IMyRoute, IRouteRequest, name='a')
         command = self._makeOne()
@@ -300,13 +320,11 @@ class TestPRoutesCommand(unittest.TestCase):
         view_str = '<tests.test_scripts.dummy.DummyMultiView'
         final = '%s.%s' % (view_module, view_str)
 
-        self.assertEqual(
-            compare_to,
-            ['a', '/a', final]
-        )
+        self.assertEqual(compare_to, ['a', '/a', final])
 
     def test__get_mapper(self):
         from pyramid.urldispatch import RoutesMapper
+
         command = self._makeOne()
         registry = self._makeRegistry()
 
@@ -316,15 +334,13 @@ class TestPRoutesCommand(unittest.TestCase):
     def test_one_route_all_methods_view_only_post(self):
         from pyramid.renderers import null_renderer as nr
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b')
         config.add_view(
-            route_name='foo',
-            view=view1,
-            renderer=nr,
-            request_method='POST'
+            route_name='foo', view=view1, renderer=nr, request_method='POST'
         )
 
         command = self._makeOne()
@@ -336,23 +352,22 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
         expected = [
-            'foo', '/a/b',
-            'tests.test_scripts.test_proutes.view1', 'POST'
+            'foo',
+            '/a/b',
+            'tests.test_scripts.test_proutes.view1',
+            'POST',
         ]
         self.assertEqual(compare_to, expected)
 
     def test_one_route_only_post_view_all_methods(self):
         from pyramid.renderers import null_renderer as nr
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b', request_method='POST')
-        config.add_view(
-            route_name='foo',
-            view=view1,
-            renderer=nr,
-        )
+        config.add_view(route_name='foo', view=view1, renderer=nr)
 
         command = self._makeOne()
         L = []
@@ -363,15 +378,18 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
         expected = [
-            'foo', '/a/b',
-            'tests.test_scripts.test_proutes.view1', 'POST'
+            'foo',
+            '/a/b',
+            'tests.test_scripts.test_proutes.view1',
+            'POST',
         ]
         self.assertEqual(compare_to, expected)
 
     def test_one_route_only_post_view_post_and_get(self):
         from pyramid.renderers import null_renderer as nr
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b', request_method='POST')
@@ -379,7 +397,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='foo',
             view=view1,
             renderer=nr,
-            request_method=('POST', 'GET')
+            request_method=('POST', 'GET'),
         )
 
         command = self._makeOne()
@@ -391,23 +409,23 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
         expected = [
-            'foo', '/a/b',
-            'tests.test_scripts.test_proutes.view1', 'POST'
+            'foo',
+            '/a/b',
+            'tests.test_scripts.test_proutes.view1',
+            'POST',
         ]
         self.assertEqual(compare_to, expected)
 
     def test_route_request_method_mismatch(self):
         from pyramid.renderers import null_renderer as nr
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b', request_method='POST')
         config.add_view(
-            route_name='foo',
-            view=view1,
-            renderer=nr,
-            request_method='GET'
+            route_name='foo', view=view1, renderer=nr, request_method='GET'
         )
 
         command = self._makeOne()
@@ -419,21 +437,24 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
         expected = [
-            'foo', '/a/b',
+            'foo',
+            '/a/b',
             'tests.test_scripts.test_proutes.view1',
-            '<route', 'mismatch>'
+            '<route',
+            'mismatch>',
         ]
         self.assertEqual(compare_to, expected)
 
     def test_route_static_views(self):
         from pyramid.renderers import null_renderer as nr
+
         config = self._makeConfig(autocommit=True)
         config.add_static_view('static', 'static', cache_max_age=3600)
         path2 = os.path.normpath('/var/www/static')
         config.add_static_view(name='static2', path=path2)
         config.add_static_view(
             name='pyramid_scaffold',
-            path='pyramid:scaffolds/starter/+package+/static'
+            path='pyramid:scaffolds/starter/+package+/static',
         )
 
         command = self._makeOne()
@@ -445,11 +466,19 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 5)
 
         expected = [
-            ['__static/', '/static/*subpath',
-             'tests.test_scripts:static/', '*'],
+            [
+                '__static/',
+                '/static/*subpath',
+                'tests.test_scripts:static/',
+                '*',
+            ],
             ['__static2/', '/static2/*subpath', path2 + os.sep, '*'],
-            ['__pyramid_scaffold/', '/pyramid_scaffold/*subpath',
-             'pyramid:scaffolds/starter/+package+/static/',  '*'],
+            [
+                '__pyramid_scaffold/',
+                '/pyramid_scaffold/*subpath',
+                'pyramid:scaffolds/starter/+package+/static/',
+                '*',
+            ],
         ]
 
         for index, line in enumerate(L[2:]):
@@ -458,6 +487,7 @@ class TestPRoutesCommand(unittest.TestCase):
 
     def test_route_no_view(self):
         from pyramid.renderers import null_renderer as nr
+
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b', request_method='POST')
 
@@ -469,27 +499,23 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
-        expected = [
-            'foo', '/a/b',
-            '<unknown>',
-            'POST',
-        ]
+        expected = ['foo', '/a/b', '<unknown>', 'POST']
         self.assertEqual(compare_to, expected)
 
     def test_route_as_wsgiapp(self):
         from pyramid.wsgi import wsgiapp2
 
         config1 = self._makeConfig(autocommit=True)
-        def view1(context, request): return 'view1'
+
+        def view1(context, request):
+            return 'view1'
+
         config1.add_route('foo', '/a/b', request_method='POST')
         config1.add_view(view=view1, route_name='foo')
 
         config2 = self._makeConfig(autocommit=True)
         config2.add_route('foo', '/a/b', request_method='POST')
-        config2.add_view(
-            wsgiapp2(config1.make_wsgi_app()),
-            route_name='foo',
-        )
+        config2.add_view(wsgiapp2(config1.make_wsgi_app()), route_name='foo')
 
         command = self._makeOne()
         L = []
@@ -499,18 +525,15 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
-        expected = [
-            'foo', '/a/b',
-            '<wsgiapp>',
-            'POST',
-        ]
+        expected = ['foo', '/a/b', '<wsgiapp>', 'POST']
         self.assertEqual(compare_to, expected)
 
     def test_route_is_get_view_request_method_not_post(self):
         from pyramid.renderers import null_renderer as nr
         from pyramid.config import not_
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b', request_method='GET')
@@ -518,7 +541,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='foo',
             view=view1,
             renderer=nr,
-            request_method=not_('POST')
+            request_method=not_('POST'),
         )
 
         command = self._makeOne()
@@ -530,9 +553,10 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
         expected = [
-            'foo', '/a/b',
+            'foo',
+            '/a/b',
             'tests.test_scripts.test_proutes.view1',
-            'GET'
+            'GET',
         ]
         self.assertEqual(compare_to, expected)
 
@@ -540,7 +564,8 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.renderers import null_renderer as nr
         from pyramid.config import not_
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b')
@@ -548,7 +573,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='foo',
             view=view1,
             renderer=nr,
-            request_method=not_('POST')
+            request_method=not_('POST'),
         )
 
         command = self._makeOne()
@@ -560,9 +585,10 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
         expected = [
-            'foo', '/a/b',
+            'foo',
+            '/a/b',
             'tests.test_scripts.test_proutes.view1',
-            '!POST,*'
+            '!POST,*',
         ]
         self.assertEqual(compare_to, expected)
 
@@ -570,8 +596,11 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.renderers import null_renderer as nr
         from pyramid.config import not_
 
-        def view1(context, request): return 'view1'
-        def view2(context, request): return 'view2'
+        def view1(context, request):
+            return 'view1'
+
+        def view2(context, request):
+            return 'view2'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b')
@@ -579,7 +608,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='foo',
             view=view1,
             renderer=nr,
-            request_method=not_('POST')
+            request_method=not_('POST'),
         )
 
         config.add_route('bar', '/b/a')
@@ -587,7 +616,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='bar',
             view=view2,
             renderer=nr,
-            request_method=not_('POST')
+            request_method=not_('POST'),
         )
 
         command = self._makeOne()
@@ -601,9 +630,10 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
         expected = [
-            'foo', '/a/b',
+            'foo',
+            '/a/b',
             'tests.test_scripts.test_proutes.view1',
-            '!POST,*'
+            '!POST,*',
         ]
         self.assertEqual(compare_to, expected)
 
@@ -611,7 +641,8 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.renderers import null_renderer as nr
         from pyramid.config import not_
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b')
@@ -619,7 +650,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='foo',
             view=view1,
             renderer=nr,
-            request_method=not_('POST')
+            request_method=not_('POST'),
         )
 
         command = self._makeOne()
@@ -641,7 +672,8 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.renderers import null_renderer as nr
         from pyramid.config import not_
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b')
@@ -649,7 +681,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='foo',
             view=view1,
             renderer=nr,
-            request_method=not_('POST')
+            request_method=not_('POST'),
         )
 
         command = self._makeOne()
@@ -670,7 +702,8 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.renderers import null_renderer as nr
         from pyramid.config import not_
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b')
@@ -678,7 +711,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='foo',
             view=view1,
             renderer=nr,
-            request_method=not_('POST')
+            request_method=not_('POST'),
         )
 
         command = self._makeOne()
@@ -687,7 +720,8 @@ class TestPRoutesCommand(unittest.TestCase):
         command.out = L.append
         command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
         command.get_config_loader = dummy.DummyLoader(
-            {'proutes': {'format': 'method\nname'}})
+            {'proutes': {'format': 'method\nname'}}
+        )
 
         result = command.run()
         self.assertEqual(result, 0)
@@ -702,7 +736,8 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.renderers import null_renderer as nr
         from pyramid.config import not_
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b')
@@ -710,7 +745,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='foo',
             view=view1,
             renderer=nr,
-            request_method=not_('POST')
+            request_method=not_('POST'),
         )
 
         command = self._makeOne()
@@ -719,7 +754,8 @@ class TestPRoutesCommand(unittest.TestCase):
         command.out = L.append
         command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
         command.get_config_loader = dummy.DummyLoader(
-            {'proutes': {'format': 'method name'}})
+            {'proutes': {'format': 'method name'}}
+        )
 
         result = command.run()
         self.assertEqual(result, 0)
@@ -734,7 +770,8 @@ class TestPRoutesCommand(unittest.TestCase):
         from pyramid.renderers import null_renderer as nr
         from pyramid.config import not_
 
-        def view1(context, request): return 'view1'
+        def view1(context, request):
+            return 'view1'
 
         config = self._makeConfig(autocommit=True)
         config.add_route('foo', '/a/b')
@@ -742,7 +779,7 @@ class TestPRoutesCommand(unittest.TestCase):
             route_name='foo',
             view=view1,
             renderer=nr,
-            request_method=not_('POST')
+            request_method=not_('POST'),
         )
 
         command = self._makeOne()
@@ -751,7 +788,8 @@ class TestPRoutesCommand(unittest.TestCase):
         command.out = L.append
         command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
         command.get_config_loader = dummy.DummyLoader(
-            {'proutes': {'format': 'method,name'}})
+            {'proutes': {'format': 'method,name'}}
+        )
 
         result = command.run()
         self.assertEqual(result, 0)
@@ -776,15 +814,14 @@ class TestPRoutesCommand(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(len(L), 3)
         compare_to = L[-1].split()
-        expected = [
-            'foo', 'http://example.com/bar.aspx',
-            '<unknown>', '*',
-        ]
+        expected = ['foo', 'http://example.com/bar.aspx', '<unknown>', '*']
         self.assertEqual(compare_to, expected)
 
+
 class Test_main(unittest.TestCase):
     def _callFUT(self, argv):
         from pyramid.scripts.proutes import main
+
         return main(argv, quiet=True)
 
     def test_it(self):
diff --git a/tests/test_scripts/test_pserve.py b/tests/test_scripts/test_pserve.py
index 0c46b5348..b85f4ddb7 100644
--- a/tests/test_scripts/test_pserve.py
+++ b/tests/test_scripts/test_pserve.py
@@ -9,6 +9,7 @@ here = os.path.abspath(os.path.dirname(__file__))
 class TestPServeCommand(unittest.TestCase):
     def setUp(self):
         from pyramid.compat import NativeIO
+
         self.out_ = NativeIO()
 
     def out(self, msg):
@@ -16,6 +17,7 @@ class TestPServeCommand(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.scripts.pserve import PServeCommand
+
         return PServeCommand
 
     def _makeOne(self, *args):
@@ -41,6 +43,7 @@ class TestPServeCommand(unittest.TestCase):
             app.name = name
             app.global_conf = global_conf
             return app
+
         self.loader.get_wsgi_app = get_app
         self.loader.server = lambda x: x
 
@@ -54,41 +57,36 @@ class TestPServeCommand(unittest.TestCase):
     def test_config_file_finds_watch_files(self):
         inst = self._makeOne('development.ini')
         loader = self.loader('/base/path.ini')
-        loader.settings = {'pserve': {
-            'watch_files': 'foo\n/baz\ntests.test_scripts:*.py',
-        }}
+        loader.settings = {
+            'pserve': {'watch_files': 'foo\n/baz\ntests.test_scripts:*.py'}
+        }
         inst.pserve_file_config(loader, global_conf={'a': '1'})
-        self.assertEqual(loader.calls[0]['defaults'], {
-            'a': '1',
-        })
-        self.assertEqual(inst.watch_files, set([
-            os.path.abspath('/base/foo'),
-            os.path.abspath('/baz'),
-            os.path.abspath(os.path.join(here, '*.py')),
-        ]))
+        self.assertEqual(loader.calls[0]['defaults'], {'a': '1'})
+        self.assertEqual(
+            inst.watch_files,
+            set(
+                [
+                    os.path.abspath('/base/foo'),
+                    os.path.abspath('/baz'),
+                    os.path.abspath(os.path.join(here, '*.py')),
+                ]
+            ),
+        )
 
     def test_config_file_finds_open_url(self):
         inst = self._makeOne('development.ini')
         loader = self.loader('/base/path.ini')
-        loader.settings = {'pserve': {
-            'open_url': 'http://127.0.0.1:8080/',
-        }}
+        loader.settings = {'pserve': {'open_url': 'http://127.0.0.1:8080/'}}
         inst.pserve_file_config(loader, global_conf={'a': '1'})
-        self.assertEqual(loader.calls[0]['defaults'], {
-            'a': '1',
-        })
+        self.assertEqual(loader.calls[0]['defaults'], {'a': '1'})
         self.assertEqual(inst.open_url, 'http://127.0.0.1:8080/')
 
     def test_guess_server_url(self):
         inst = self._makeOne('development.ini')
         loader = self.loader('/base/path.ini')
-        loader.settings = {'server:foo': {
-            'port': '8080',
-        }}
+        loader.settings = {'server:foo': {'port': '8080'}}
         url = inst.guess_server_url(loader, 'foo', global_conf={'a': '1'})
-        self.assertEqual(loader.calls[0]['defaults'], {
-            'a': '1',
-        })
+        self.assertEqual(loader.calls[0]['defaults'], {'a': '1'})
         self.assertEqual(url, 'http://127.0.0.1:8080')
 
     def test_reload_call_hupper_with_correct_args(self):
@@ -105,25 +103,35 @@ class TestPServeCommand(unittest.TestCase):
 
         orig_hupper = pserve.hupper
         try:
-            pserve.hupper = AttrDict(is_active=lambda: False,
-                                     start_reloader=dummy_start_reloader)
+            pserve.hupper = AttrDict(
+                is_active=lambda: False, start_reloader=dummy_start_reloader
+            )
 
             inst = self._makeOne('--reload', 'development.ini')
             inst.run()
         finally:
             pserve.hupper = orig_hupper
 
-        self.assertEquals(dummy_start_reloader.args, ('pyramid.scripts.pserve.main',))
-        self.assertEquals(dummy_start_reloader.kwargs, {
-            'reload_interval': 1,
-            'verbose': 1,
-            'worker_kwargs': {'argv': ['pserve', '--reload', 'development.ini'],
-                              'quiet': False}})
+        self.assertEquals(
+            dummy_start_reloader.args, ('pyramid.scripts.pserve.main',)
+        )
+        self.assertEquals(
+            dummy_start_reloader.kwargs,
+            {
+                'reload_interval': 1,
+                'verbose': 1,
+                'worker_kwargs': {
+                    'argv': ['pserve', '--reload', 'development.ini'],
+                    'quiet': False,
+                },
+            },
+        )
 
 
 class Test_main(unittest.TestCase):
     def _callFUT(self, argv):
         from pyramid.scripts.pserve import main
+
         return main(argv, quiet=True)
 
     def test_it(self):
diff --git a/tests/test_scripts/test_pshell.py b/tests/test_scripts/test_pshell.py
index 291714340..6beaacda6 100644
--- a/tests/test_scripts/test_pshell.py
+++ b/tests/test_scripts/test_pshell.py
@@ -6,10 +6,16 @@ from . import dummy
 class TestPShellCommand(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.scripts.pshell import PShellCommand
+
         return PShellCommand
 
-    def _makeOne(self, patch_bootstrap=True, patch_loader=True,
-                 patch_args=True, patch_options=True):
+    def _makeOne(
+        self,
+        patch_bootstrap=True,
+        patch_loader=True,
+        patch_args=True,
+        patch_options=True,
+    ):
         cmd = self._getTargetClass()([])
 
         if patch_bootstrap:
@@ -19,12 +25,18 @@ class TestPShellCommand(unittest.TestCase):
             self.loader = dummy.DummyLoader()
             cmd.get_config_loader = self.loader
         if patch_args:
-            class Args(object): pass
+
+            class Args(object):
+                pass
+
             self.args = Args()
             self.args.config_uri = '/foo/bar/myapp.ini#myapp'
             cmd.args.config_uri = self.args.config_uri
         if patch_options:
-            class Options(object): pass
+
+            class Options(object):
+                pass
+
             self.options = Options()
             self.options.python_shell = ''
             self.options.setup = None
@@ -47,12 +59,16 @@ class TestPShellCommand(unittest.TestCase):
         command.default_runner = shell
         command.run()
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
-        self.assertEqual(shell.env, {
-            'app':self.bootstrap.app, 'root':self.bootstrap.root,
-            'registry':self.bootstrap.registry,
-            'request':self.bootstrap.request,
-            'root_factory':self.bootstrap.root_factory,
-        })
+        self.assertEqual(
+            shell.env,
+            {
+                'app': self.bootstrap.app,
+                'root': self.bootstrap.root,
+                'registry': self.bootstrap.registry,
+                'request': self.bootstrap.request,
+                'root_factory': self.bootstrap.root_factory,
+            },
+        )
         self.assertTrue(self.bootstrap.closer.called)
         self.assertTrue(shell.help)
 
@@ -84,23 +100,23 @@ class TestPShellCommand(unittest.TestCase):
         shell = dummy.DummyShell()
         bad_shell = dummy.DummyShell()
         self._makeEntryPoints(
-            command,
-            {
-                'ipython': shell,
-                'bpython': bad_shell,
-            }
+            command, {'ipython': shell, 'bpython': bad_shell}
         )
 
         command.args.python_shell = 'ipython'
 
         command.run()
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
-        self.assertEqual(shell.env, {
-            'app':self.bootstrap.app, 'root':self.bootstrap.root,
-            'registry':self.bootstrap.registry,
-            'request':self.bootstrap.request,
-            'root_factory':self.bootstrap.root_factory,
-        })
+        self.assertEqual(
+            shell.env,
+            {
+                'app': self.bootstrap.app,
+                'root': self.bootstrap.root,
+                'registry': self.bootstrap.registry,
+                'request': self.bootstrap.request,
+                'root_factory': self.bootstrap.root_factory,
+            },
+        )
         self.assertTrue(self.bootstrap.closer.called)
         self.assertTrue(shell.help)
 
@@ -108,13 +124,7 @@ class TestPShellCommand(unittest.TestCase):
         command = self._makeOne()
         dshell = dummy.DummyShell()
 
-        self._makeEntryPoints(
-            command,
-            {
-                'ipython': dshell,
-                'bpython': dshell,
-            }
-        )
+        self._makeEntryPoints(command, {'ipython': dshell, 'bpython': dshell})
 
         command.default_runner = None
         shell = command.make_shell()
@@ -137,12 +147,7 @@ class TestPShellCommand(unittest.TestCase):
         self.assertRaises(ValueError, command.make_shell)
 
         self._makeEntryPoints(
-            command,
-            {
-                'ipython': ipshell,
-                'bpython': bpshell,
-                'python': dshell,
-            }
+            command, {'ipython': ipshell, 'bpython': bpshell, 'python': dshell}
         )
 
         command.args.python_shell = 'ipython'
@@ -164,12 +169,7 @@ class TestPShellCommand(unittest.TestCase):
         dshell = dummy.DummyShell()
 
         self._makeEntryPoints(
-            command,
-            {
-                'ipython': ipshell,
-                'bpython': bpshell,
-                'python': dshell,
-            }
+            command, {'ipython': ipshell, 'bpython': bpshell, 'python': dshell}
         )
 
         command.default_runner = dshell
@@ -194,41 +194,52 @@ class TestPShellCommand(unittest.TestCase):
         shell = dummy.DummyShell()
         command.run(shell)
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
-        self.assertEqual(shell.env, {
-            'app':self.bootstrap.app, 'root':self.bootstrap.root,
-            'registry':self.bootstrap.registry,
-            'request':self.bootstrap.request,
-            'root_factory':self.bootstrap.root_factory,
-            'm':model,
-            'User': user,
-        })
+        self.assertEqual(
+            shell.env,
+            {
+                'app': self.bootstrap.app,
+                'root': self.bootstrap.root,
+                'registry': self.bootstrap.registry,
+                'request': self.bootstrap.request,
+                'root_factory': self.bootstrap.root_factory,
+                'm': model,
+                'User': user,
+            },
+        )
         self.assertTrue(self.bootstrap.closer.called)
         self.assertTrue(shell.help)
 
     def test_command_setup(self):
         command = self._makeOne()
+
         def setup(env):
             env['a'] = 1
             env['root'] = 'root override'
             env['none'] = None
+
         self.loader.settings = {'pshell': {'setup': setup}}
         shell = dummy.DummyShell()
         command.run(shell)
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
-        self.assertEqual(shell.env, {
-            'app':self.bootstrap.app, 'root':'root override',
-            'registry':self.bootstrap.registry,
-            'request':self.bootstrap.request,
-            'root_factory':self.bootstrap.root_factory,
-            'a':1,
-            'none': None,
-        })
+        self.assertEqual(
+            shell.env,
+            {
+                'app': self.bootstrap.app,
+                'root': 'root override',
+                'registry': self.bootstrap.registry,
+                'request': self.bootstrap.request,
+                'root_factory': self.bootstrap.root_factory,
+                'a': 1,
+                'none': None,
+            },
+        )
         self.assertTrue(self.bootstrap.closer.called)
         self.assertTrue(shell.help)
 
     def test_command_setup_generator(self):
         command = self._makeOne()
         did_resume_after_yield = {}
+
         def setup(env):
             env['a'] = 1
             env['root'] = 'root override'
@@ -237,18 +248,23 @@ class TestPShellCommand(unittest.TestCase):
             yield
             did_resume_after_yield['result'] = True
             self.assertEqual(request.dummy_attr, 1)
+
         self.loader.settings = {'pshell': {'setup': setup}}
         shell = dummy.DummyShell()
         command.run(shell)
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
-        self.assertEqual(shell.env, {
-            'app':self.bootstrap.app, 'root':'root override',
-            'registry':self.bootstrap.registry,
-            'request':self.bootstrap.request,
-            'root_factory':self.bootstrap.root_factory,
-            'a':1,
-            'none': None,
-        })
+        self.assertEqual(
+            shell.env,
+            {
+                'app': self.bootstrap.app,
+                'root': 'root override',
+                'registry': self.bootstrap.registry,
+                'request': self.bootstrap.request,
+                'root_factory': self.bootstrap.root_factory,
+                'a': 1,
+                'none': None,
+            },
+        )
         self.assertTrue(did_resume_after_yield['result'])
         self.assertTrue(self.bootstrap.closer.called)
         self.assertTrue(shell.help)
@@ -257,15 +273,10 @@ class TestPShellCommand(unittest.TestCase):
         command = self._makeOne()
         ipshell = dummy.DummyShell()
         dshell = dummy.DummyShell()
-        self._makeEntryPoints(
-            command,
-            {
-                'ipython': ipshell,
-                'python': dshell,
-            }
-        )
-        self.loader.settings = {'pshell': {
-            'default_shell': 'bpython python\nipython'}}
+        self._makeEntryPoints(command, {'ipython': ipshell, 'python': dshell})
+        self.loader.settings = {
+            'pshell': {'default_shell': 'bpython python\nipython'}
+        }
         command.run()
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
         self.assertTrue(dshell.called)
@@ -273,78 +284,105 @@ class TestPShellCommand(unittest.TestCase):
     def test_command_loads_check_variable_override_order(self):
         command = self._makeOne()
         model = dummy.Dummy()
+
         def setup(env):
             env['a'] = 1
             env['m'] = 'model override'
             env['root'] = 'root override'
+
         self.loader.settings = {'pshell': {'setup': setup, 'm': model}}
         shell = dummy.DummyShell()
         command.run(shell)
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
-        self.assertEqual(shell.env, {
-            'app':self.bootstrap.app, 'root':'root override',
-            'registry':self.bootstrap.registry,
-            'request':self.bootstrap.request,
-            'root_factory':self.bootstrap.root_factory,
-            'a':1, 'm':'model override',
-        })
+        self.assertEqual(
+            shell.env,
+            {
+                'app': self.bootstrap.app,
+                'root': 'root override',
+                'registry': self.bootstrap.registry,
+                'request': self.bootstrap.request,
+                'root_factory': self.bootstrap.root_factory,
+                'a': 1,
+                'm': 'model override',
+            },
+        )
         self.assertTrue(self.bootstrap.closer.called)
         self.assertTrue(shell.help)
 
     def test_command_loads_setup_from_options(self):
         command = self._makeOne()
+
         def setup(env):
             env['a'] = 1
             env['root'] = 'root override'
+
         model = dummy.Dummy()
         self.loader.settings = {'pshell': {'setup': 'abc', 'm': model}}
         command.args.setup = setup
         shell = dummy.DummyShell()
         command.run(shell)
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
-        self.assertEqual(shell.env, {
-            'app':self.bootstrap.app, 'root':'root override',
-            'registry':self.bootstrap.registry,
-            'request':self.bootstrap.request,
-            'root_factory':self.bootstrap.root_factory,
-            'a':1, 'm':model,
-        })
+        self.assertEqual(
+            shell.env,
+            {
+                'app': self.bootstrap.app,
+                'root': 'root override',
+                'registry': self.bootstrap.registry,
+                'request': self.bootstrap.request,
+                'root_factory': self.bootstrap.root_factory,
+                'a': 1,
+                'm': model,
+            },
+        )
         self.assertTrue(self.bootstrap.closer.called)
         self.assertTrue(shell.help)
 
     def test_command_custom_section_override(self):
         command = self._makeOne()
         dummy_ = dummy.Dummy()
-        self.loader.settings = {'pshell': {
-            'app': dummy_, 'root': dummy_, 'registry': dummy_,
-            'request': dummy_}}
+        self.loader.settings = {
+            'pshell': {
+                'app': dummy_,
+                'root': dummy_,
+                'registry': dummy_,
+                'request': dummy_,
+            }
+        }
         shell = dummy.DummyShell()
         command.run(shell)
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
-        self.assertEqual(shell.env, {
-            'app':dummy_, 'root':dummy_, 'registry':dummy_, 'request':dummy_,
-            'root_factory':self.bootstrap.root_factory,
-        })
+        self.assertEqual(
+            shell.env,
+            {
+                'app': dummy_,
+                'root': dummy_,
+                'registry': dummy_,
+                'request': dummy_,
+                'root_factory': self.bootstrap.root_factory,
+            },
+        )
         self.assertTrue(self.bootstrap.closer.called)
         self.assertTrue(shell.help)
 
     def test_command_loads_pythonstartup(self):
         command = self._makeOne()
-        command.pystartup = (
-            os.path.abspath(
-                os.path.join(
-                    os.path.dirname(__file__),
-                    'pystartup.txt')))
+        command.pystartup = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), 'pystartup.txt')
+        )
         shell = dummy.DummyShell()
         command.run(shell)
         self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
-        self.assertEqual(shell.env, {
-            'app':self.bootstrap.app, 'root':self.bootstrap.root,
-            'registry':self.bootstrap.registry,
-            'request':self.bootstrap.request,
-            'root_factory':self.bootstrap.root_factory,
-            'foo':1,
-        })
+        self.assertEqual(
+            shell.env,
+            {
+                'app': self.bootstrap.app,
+                'root': self.bootstrap.root,
+                'registry': self.bootstrap.registry,
+                'request': self.bootstrap.request,
+                'root_factory': self.bootstrap.root_factory,
+                'foo': 1,
+            },
+        )
         self.assertTrue(self.bootstrap.closer.called)
         self.assertTrue(shell.help)
 
@@ -359,27 +397,20 @@ class TestPShellCommand(unittest.TestCase):
 
         command.out = out
 
-        self._makeEntryPoints(
-            command,
-            {
-                'ipython': dshell,
-                'python': dshell,
-            }
-        )
+        self._makeEntryPoints(command, {'ipython': dshell, 'python': dshell})
 
         command.args.list = True
         result = command.run()
         self.assertEqual(result, 0)
-        self.assertEqual(out_calls, [
-            'Available shells:',
-            '  ipython',
-            '  python',
-        ])
+        self.assertEqual(
+            out_calls, ['Available shells:', '  ipython', '  python']
+        )
 
 
 class Test_python_shell_runner(unittest.TestCase):
     def _callFUT(self, env, help, interact):
         from pyramid.scripts.pshell import python_shell_runner
+
         return python_shell_runner(env, help, interact=interact)
 
     def test_it(self):
@@ -388,9 +419,11 @@ class Test_python_shell_runner(unittest.TestCase):
         self.assertEqual(interact.local, {'foo': 'bar'})
         self.assertTrue('a help message' in interact.banner)
 
+
 class Test_main(unittest.TestCase):
     def _callFUT(self, argv):
         from pyramid.scripts.pshell import main
+
         return main(argv, quiet=True)
 
     def test_it(self):
diff --git a/tests/test_scripts/test_ptweens.py b/tests/test_scripts/test_ptweens.py
index 4ad015249..a7fe6f651 100644
--- a/tests/test_scripts/test_ptweens.py
+++ b/tests/test_scripts/test_ptweens.py
@@ -1,9 +1,11 @@
 import unittest
 from . import dummy
 
+
 class TestPTweensCommand(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.scripts.ptweens import PTweensCommand
+
         return PTweensCommand
 
     def _makeOne(self):
@@ -31,9 +33,10 @@ class TestPTweensCommand(unittest.TestCase):
         result = command.run()
         self.assertEqual(result, 0)
         self.assertEqual(
-           L[0],
-           '"pyramid.tweens" config value NOT set (implicitly ordered tweens '
-            'used)')
+            L[0],
+            '"pyramid.tweens" config value NOT set (implicitly ordered tweens '
+            'used)',
+        )
 
     def test_command_implicit_and_explicit_tweens(self):
         command = self._makeOne()
@@ -44,17 +47,20 @@ class TestPTweensCommand(unittest.TestCase):
         result = command.run()
         self.assertEqual(result, 0)
         self.assertEqual(
-           L[0],
-           '"pyramid.tweens" config value set (explicitly ordered tweens used)')
+            L[0],
+            '"pyramid.tweens" config value set (explicitly ordered tweens used)',
+        )
 
     def test__get_tweens(self):
         command = self._makeOne()
         registry = dummy.DummyRegistry()
         self.assertEqual(command._get_tweens(registry), None)
 
+
 class Test_main(unittest.TestCase):
     def _callFUT(self, argv):
         from pyramid.scripts.ptweens import main
+
         return main(argv, quiet=True)
 
     def test_it(self):
diff --git a/tests/test_scripts/test_pviews.py b/tests/test_scripts/test_pviews.py
index 999028f28..cdb3c1c33 100644
--- a/tests/test_scripts/test_pviews.py
+++ b/tests/test_scripts/test_pviews.py
@@ -1,9 +1,11 @@
 import unittest
 from . import dummy
 
+
 class TestPViewsCommand(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.scripts.pviews import PViewsCommand
+
         return PViewsCommand
 
     def _makeOne(self, registry=None):
@@ -15,17 +17,20 @@ class TestPViewsCommand(unittest.TestCase):
 
     def _makeRequest(self, url, registry):
         from pyramid.request import Request
+
         request = Request.blank('/a')
         request.registry = registry
         return request
 
     def _register_mapper(self, registry, routes):
         from pyramid.interfaces import IRoutesMapper
+
         mapper = dummy.DummyMapper(*routes)
         registry.registerUtility(mapper, IRoutesMapper)
 
     def test__find_view_no_match(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         self._register_mapper(registry, [])
         command = self._makeOne(registry)
@@ -41,16 +46,19 @@ class TestPViewsCommand(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.traversal import DefaultRootFactory
         from pyramid.registry import Registry
+
         registry = Registry()
+
         @implementer(IMultiView)
         class View1(object):
             pass
-        request = dummy.DummyRequest({'PATH_INFO':'/a'})
+
+        request = dummy.DummyRequest({'PATH_INFO': '/a'})
         root = DefaultRootFactory(request)
         root_iface = providedBy(root)
-        registry.registerAdapter(View1(),
-                                 (IViewClassifier, IRequest, root_iface),
-                                 IMultiView)
+        registry.registerAdapter(
+            View1(), (IViewClassifier, IRequest, root_iface), IMultiView
+        )
         self._register_mapper(registry, [])
         command = self._makeOne(registry=registry)
         request = self._makeRequest('/x', registry)
@@ -64,14 +72,18 @@ class TestPViewsCommand(unittest.TestCase):
         from pyramid.interfaces import IView
         from pyramid.traversal import DefaultRootFactory
         from pyramid.registry import Registry
+
         registry = Registry()
-        def view1(): pass
-        request = dummy.DummyRequest({'PATH_INFO':'/a'})
+
+        def view1():
+            pass
+
+        request = dummy.DummyRequest({'PATH_INFO': '/a'})
         root = DefaultRootFactory(request)
         root_iface = providedBy(root)
-        registry.registerAdapter(view1,
-                                 (IViewClassifier, IRequest, root_iface),
-                                 IView, name='a')
+        registry.registerAdapter(
+            view1, (IViewClassifier, IRequest, root_iface), IView, name='a'
+        )
         self._register_mapper(registry, [])
         command = self._makeOne(registry=registry)
         request = self._makeRequest('/a', registry)
@@ -86,17 +98,20 @@ class TestPViewsCommand(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.traversal import DefaultRootFactory
         from pyramid.registry import Registry
+
         registry = Registry()
+
         @implementer(IMultiView)
         class View1(object):
             pass
-        request = dummy.DummyRequest({'PATH_INFO':'/a'})
+
+        request = dummy.DummyRequest({'PATH_INFO': '/a'})
         root = DefaultRootFactory(request)
         root_iface = providedBy(root)
         view = View1()
-        registry.registerAdapter(view,
-                                 (IViewClassifier, IRequest, root_iface),
-                                 IMultiView, name='a')
+        registry.registerAdapter(
+            view, (IViewClassifier, IRequest, root_iface), IMultiView, name='a'
+        )
         self._register_mapper(registry, [])
         command = self._makeOne(registry=registry)
         request = self._makeRequest('/a', registry)
@@ -110,22 +125,32 @@ class TestPViewsCommand(unittest.TestCase):
         from pyramid.interfaces import IViewClassifier
         from pyramid.interfaces import IView
         from pyramid.registry import Registry
+
         registry = Registry()
-        def view():pass
+
+        def view():
+            pass
+
         class IMyRoot(Interface):
             pass
+
         class IMyRoute(Interface):
             pass
-        registry.registerAdapter(view,
-                                 (IViewClassifier, IMyRoute, IMyRoot),
-                                 IView, '')
+
+        registry.registerAdapter(
+            view, (IViewClassifier, IMyRoute, IMyRoot), IView, ''
+        )
         registry.registerUtility(IMyRoute, IRouteRequest, name='a')
+
         @implementer(IMyRoot)
         class Factory(object):
             def __init__(self, request):
                 pass
-        routes = [dummy.DummyRoute('a', '/a', factory=Factory, matchdict={}),
-                  dummy.DummyRoute('b', '/b', factory=Factory)]
+
+        routes = [
+            dummy.DummyRoute('a', '/a', factory=Factory, matchdict={}),
+            dummy.DummyRoute('b', '/b', factory=Factory),
+        ]
         self._register_mapper(registry, routes)
         command = self._makeOne(registry=registry)
         request = self._makeRequest('/a', registry)
@@ -139,24 +164,37 @@ class TestPViewsCommand(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IRootFactory
         from pyramid.registry import Registry
+
         registry = Registry()
-        def view1():pass
-        def view2():pass
+
+        def view1():
+            pass
+
+        def view2():
+            pass
+
         class IMyRoot(Interface):
             pass
+
         class IMyRoute1(Interface):
             pass
+
         class IMyRoute2(Interface):
             pass
+
         registry.registerUtility(IMyRoute1, IRouteRequest, name='a')
         registry.registerUtility(IMyRoute2, IRouteRequest, name='b')
+
         @implementer(IMyRoot)
         class Factory(object):
             def __init__(self, request):
                 pass
+
         registry.registerUtility(Factory, IRootFactory)
-        routes = [dummy.DummyRoute('a', '/a', matchdict={}),
-                  dummy.DummyRoute('b', '/a', matchdict={})]
+        routes = [
+            dummy.DummyRoute('a', '/a', matchdict={}),
+            dummy.DummyRoute('b', '/a', matchdict={}),
+        ]
         self._register_mapper(registry, routes)
         command = self._makeOne(registry=registry)
         request = self._makeRequest('/a', registry)
@@ -172,30 +210,43 @@ class TestPViewsCommand(unittest.TestCase):
         from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IRootFactory
         from pyramid.registry import Registry
+
         registry = Registry()
-        def view1():pass
-        def view2():pass
+
+        def view1():
+            pass
+
+        def view2():
+            pass
+
         class IMyRoot(Interface):
             pass
+
         class IMyRoute1(Interface):
             pass
+
         class IMyRoute2(Interface):
             pass
-        registry.registerAdapter(view1,
-                                 (IViewClassifier, IMyRoute1, IMyRoot),
-                                 IView, '')
-        registry.registerAdapter(view2,
-                                 (IViewClassifier, IMyRoute2, IMyRoot),
-                                 IView, '')
+
+        registry.registerAdapter(
+            view1, (IViewClassifier, IMyRoute1, IMyRoot), IView, ''
+        )
+        registry.registerAdapter(
+            view2, (IViewClassifier, IMyRoute2, IMyRoot), IView, ''
+        )
         registry.registerUtility(IMyRoute1, IRouteRequest, name='a')
         registry.registerUtility(IMyRoute2, IRouteRequest, name='b')
+
         @implementer(IMyRoot)
         class Factory(object):
             def __init__(self, request):
                 pass
+
         registry.registerUtility(Factory, IRootFactory)
-        routes = [dummy.DummyRoute('a', '/a', matchdict={}),
-                  dummy.DummyRoute('b', '/a', matchdict={})]
+        routes = [
+            dummy.DummyRoute('a', '/a', matchdict={}),
+            dummy.DummyRoute('b', '/a', matchdict={}),
+        ]
         self._register_mapper(registry, routes)
         command = self._makeOne(registry=registry)
         request = self._makeRequest('/a', registry)
@@ -207,37 +258,58 @@ class TestPViewsCommand(unittest.TestCase):
 
     def test__find_multi_routes_all_match(self):
         command = self._makeOne()
-        def factory(request): pass
-        routes = [dummy.DummyRoute('a', '/a', factory=factory, matchdict={}),
-                  dummy.DummyRoute('b', '/a', factory=factory, matchdict={})]
+
+        def factory(request):
+            pass
+
+        routes = [
+            dummy.DummyRoute('a', '/a', factory=factory, matchdict={}),
+            dummy.DummyRoute('b', '/a', factory=factory, matchdict={}),
+        ]
         mapper = dummy.DummyMapper(*routes)
-        request = dummy.DummyRequest({'PATH_INFO':'/a'})
+        request = dummy.DummyRequest({'PATH_INFO': '/a'})
         result = command._find_multi_routes(mapper, request)
-        self.assertEqual(result, [{'match':{}, 'route':routes[0]},
-                                  {'match':{}, 'route':routes[1]}])
-        
+        self.assertEqual(
+            result,
+            [
+                {'match': {}, 'route': routes[0]},
+                {'match': {}, 'route': routes[1]},
+            ],
+        )
+
     def test__find_multi_routes_some_match(self):
         command = self._makeOne()
-        def factory(request): pass
-        routes = [dummy.DummyRoute('a', '/a', factory=factory),
-                  dummy.DummyRoute('b', '/a', factory=factory, matchdict={})]
+
+        def factory(request):
+            pass
+
+        routes = [
+            dummy.DummyRoute('a', '/a', factory=factory),
+            dummy.DummyRoute('b', '/a', factory=factory, matchdict={}),
+        ]
         mapper = dummy.DummyMapper(*routes)
-        request = dummy.DummyRequest({'PATH_INFO':'/a'})
+        request = dummy.DummyRequest({'PATH_INFO': '/a'})
         result = command._find_multi_routes(mapper, request)
-        self.assertEqual(result, [{'match':{}, 'route':routes[1]}])
-        
+        self.assertEqual(result, [{'match': {}, 'route': routes[1]}])
+
     def test__find_multi_routes_none_match(self):
         command = self._makeOne()
-        def factory(request): pass
-        routes = [dummy.DummyRoute('a', '/a', factory=factory),
-                  dummy.DummyRoute('b', '/a', factory=factory)]
+
+        def factory(request):
+            pass
+
+        routes = [
+            dummy.DummyRoute('a', '/a', factory=factory),
+            dummy.DummyRoute('b', '/a', factory=factory),
+        ]
         mapper = dummy.DummyMapper(*routes)
-        request = dummy.DummyRequest({'PATH_INFO':'/a'})
+        request = dummy.DummyRequest({'PATH_INFO': '/a'})
         result = command._find_multi_routes(mapper, request)
         self.assertEqual(result, [])
-        
+
     def test_views_command_not_found(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
@@ -252,6 +324,7 @@ class TestPViewsCommand(unittest.TestCase):
 
     def test_views_command_not_found_url_starts_without_slash(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
@@ -266,6 +339,7 @@ class TestPViewsCommand(unittest.TestCase):
 
     def test_views_command_single_view_traversal(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
@@ -279,16 +353,19 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[1], 'URL = /a')
         self.assertEqual(L[3], '    context: context')
         self.assertEqual(L[4], '    view name: a')
-        self.assertEqual(L[8],
-                         '    tests.test_scripts.dummy.DummyView')
+        self.assertEqual(L[8], '    tests.test_scripts.dummy.DummyView')
 
     def test_views_command_single_view_function_traversal(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
         command.out = L.append
-        def view(): pass
+
+        def view():
+            pass
+
         view.__request_attrs__ = {'context': 'context', 'view_name': 'a'}
         command._find_view = lambda arg1: view
         command.args.config_uri = '/foo/bar/myapp.ini#myapp'
@@ -298,11 +375,11 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[1], 'URL = /a')
         self.assertEqual(L[3], '    context: context')
         self.assertEqual(L[4], '    view name: a')
-        self.assertEqual(L[8],
-                         '    tests.test_scripts.test_pviews.view')
+        self.assertEqual(L[8], '    tests.test_scripts.test_pviews.view')
 
     def test_views_command_single_view_traversal_with_permission(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
@@ -317,17 +394,20 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[1], 'URL = /a')
         self.assertEqual(L[3], '    context: context')
         self.assertEqual(L[4], '    view name: a')
-        self.assertEqual(L[8],
-                         '    tests.test_scripts.dummy.DummyView')
+        self.assertEqual(L[8], '    tests.test_scripts.dummy.DummyView')
         self.assertEqual(L[9], '    required permission = test')
 
     def test_views_command_single_view_traversal_with_predicates(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
         command.out = L.append
-        def predicate(): pass
+
+        def predicate():
+            pass
+
         predicate.text = lambda *arg: "predicate = x"
         view = dummy.DummyView(context='context', view_name='a')
         view.__predicates__ = [predicate]
@@ -339,19 +419,20 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[1], 'URL = /a')
         self.assertEqual(L[3], '    context: context')
         self.assertEqual(L[4], '    view name: a')
-        self.assertEqual(L[8],
-                         '    tests.test_scripts.dummy.DummyView')
+        self.assertEqual(L[8], '    tests.test_scripts.dummy.DummyView')
         self.assertEqual(L[9], '    view predicates (predicate = x)')
 
     def test_views_command_single_view_route(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
         command.out = L.append
         route = dummy.DummyRoute('a', '/a', matchdict={})
-        view = dummy.DummyView(context='context', view_name='a',
-                         matched_route=route, subpath='')
+        view = dummy.DummyView(
+            context='context', view_name='a', matched_route=route, subpath=''
+        )
         command._find_view = lambda arg1: view
         command.args.config_uri = '/foo/bar/myapp.ini#myapp'
         command.args.url = '/a'
@@ -365,11 +446,11 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[9], '    route pattern: /a')
         self.assertEqual(L[10], '    route path: /a')
         self.assertEqual(L[11], '    subpath: ')
-        self.assertEqual(L[15],
-                   '        tests.test_scripts.dummy.DummyView')
+        self.assertEqual(L[15], '        tests.test_scripts.dummy.DummyView')
 
     def test_views_command_multi_view_nested(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
@@ -377,10 +458,12 @@ class TestPViewsCommand(unittest.TestCase):
         view1 = dummy.DummyView(context='context', view_name='a1')
         view1.__name__ = 'view1'
         view1.__view_attr__ = 'call'
-        multiview1 = dummy.DummyMultiView(view1, context='context',
-                                          view_name='a1')
-        multiview2 = dummy.DummyMultiView(multiview1, context='context',
-                                    view_name='a')
+        multiview1 = dummy.DummyMultiView(
+            view1, context='context', view_name='a1'
+        )
+        multiview2 = dummy.DummyMultiView(
+            multiview1, context='context', view_name='a'
+        )
         command._find_view = lambda arg1: multiview2
         command.args.config_uri = '/foo/bar/myapp.ini#myapp'
         command.args.url = '/a'
@@ -389,22 +472,25 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[1], 'URL = /a')
         self.assertEqual(L[3], '    context: context')
         self.assertEqual(L[4], '    view name: a')
-        self.assertEqual(L[8],
-                  '    tests.test_scripts.dummy.DummyMultiView')
-        self.assertEqual(L[12],
-                  '        tests.test_scripts.dummy.view1.call')
+        self.assertEqual(L[8], '    tests.test_scripts.dummy.DummyMultiView')
+        self.assertEqual(L[12], '        tests.test_scripts.dummy.view1.call')
 
     def test_views_command_single_view_route_with_route_predicates(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
         command.out = L.append
-        def predicate(): pass
+
+        def predicate():
+            pass
+
         predicate.text = lambda *arg: "predicate = x"
         route = dummy.DummyRoute('a', '/a', matchdict={}, predicate=predicate)
-        view = dummy.DummyView(context='context', view_name='a',
-                         matched_route=route, subpath='')
+        view = dummy.DummyView(
+            context='context', view_name='a', matched_route=route, subpath=''
+        )
         command._find_view = lambda arg1: view
         command.args.config_uri = '/foo/bar/myapp.ini#myapp'
         command.args.url = '/a'
@@ -419,11 +505,11 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[10], '    route path: /a')
         self.assertEqual(L[11], '    subpath: ')
         self.assertEqual(L[12], '    route predicates (predicate = x)')
-        self.assertEqual(L[16],
-               '        tests.test_scripts.dummy.DummyView')
+        self.assertEqual(L[16], '        tests.test_scripts.dummy.DummyView')
 
     def test_views_command_multiview(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
@@ -431,7 +517,9 @@ class TestPViewsCommand(unittest.TestCase):
         view = dummy.DummyView(context='context')
         view.__name__ = 'view'
         view.__view_attr__ = 'call'
-        multiview = dummy.DummyMultiView(view, context='context', view_name='a')
+        multiview = dummy.DummyMultiView(
+            view, context='context', view_name='a'
+        )
         command._find_view = lambda arg1: multiview
         command.args.config_uri = '/foo/bar/myapp.ini#myapp'
         command.args.url = '/a'
@@ -440,11 +528,11 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[1], 'URL = /a')
         self.assertEqual(L[3], '    context: context')
         self.assertEqual(L[4], '    view name: a')
-        self.assertEqual(L[8],
-                     '    tests.test_scripts.dummy.view.call')
+        self.assertEqual(L[8], '    tests.test_scripts.dummy.view.call')
 
     def test_views_command_multiview_with_permission(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
@@ -453,7 +541,9 @@ class TestPViewsCommand(unittest.TestCase):
         view.__name__ = 'view'
         view.__view_attr__ = 'call'
         view.__permission__ = 'test'
-        multiview = dummy.DummyMultiView(view, context='context', view_name='a')
+        multiview = dummy.DummyMultiView(
+            view, context='context', view_name='a'
+        )
         command._find_view = lambda arg1: multiview
         command.args.config_uri = '/foo/bar/myapp.ini#myapp'
         command.args.url = '/a'
@@ -462,23 +552,28 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[1], 'URL = /a')
         self.assertEqual(L[3], '    context: context')
         self.assertEqual(L[4], '    view name: a')
-        self.assertEqual(L[8],
-                       '    tests.test_scripts.dummy.view.call')
+        self.assertEqual(L[8], '    tests.test_scripts.dummy.view.call')
         self.assertEqual(L[9], '    required permission = test')
 
     def test_views_command_multiview_with_predicates(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         command = self._makeOne(registry=registry)
         L = []
         command.out = L.append
-        def predicate(): pass
+
+        def predicate():
+            pass
+
         predicate.text = lambda *arg: "predicate = x"
         view = dummy.DummyView(context='context')
         view.__name__ = 'view'
         view.__view_attr__ = 'call'
         view.__predicates__ = [predicate]
-        multiview = dummy.DummyMultiView(view, context='context', view_name='a')
+        multiview = dummy.DummyMultiView(
+            view, context='context', view_name='a'
+        )
         command._find_view = lambda arg1: multiview
         command.args.config_uri = '/foo/bar/myapp.ini#myapp'
         command.args.url = '/a'
@@ -487,13 +582,14 @@ class TestPViewsCommand(unittest.TestCase):
         self.assertEqual(L[1], 'URL = /a')
         self.assertEqual(L[3], '    context: context')
         self.assertEqual(L[4], '    view name: a')
-        self.assertEqual(L[8],
-                         '    tests.test_scripts.dummy.view.call')
+        self.assertEqual(L[8], '    tests.test_scripts.dummy.view.call')
         self.assertEqual(L[9], '    view predicates (predicate = x)')
 
+
 class Test_main(unittest.TestCase):
     def _callFUT(self, argv):
         from pyramid.scripts.pviews import main
+
         return main(argv, quiet=True)
 
     def test_it(self):
diff --git a/tests/test_security.py b/tests/test_security.py
index e5399ecdf..a11035d85 100644
--- a/tests/test_security.py
+++ b/tests/test_security.py
@@ -2,6 +2,7 @@ import unittest
 
 from pyramid import testing
 
+
 class TestAllPermissionsList(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -11,6 +12,7 @@ class TestAllPermissionsList(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.security import AllPermissionsList
+
         return AllPermissionsList
 
     def _makeOne(self):
@@ -44,13 +46,16 @@ class TestAllPermissionsList(unittest.TestCase):
 
     def test_singleton(self):
         from pyramid.security import ALL_PERMISSIONS
+
         self.assertEqual(ALL_PERMISSIONS.__class__, self._getTargetClass())
 
+
 class TestAllowed(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.security import Allowed
+
         return Allowed
-    
+
     def _makeOne(self, *arg, **kw):
         klass = self._getTargetClass()
         return klass(*arg, **kw)
@@ -64,11 +69,13 @@ class TestAllowed(unittest.TestCase):
         self.assertTrue('<Allowed instance at ' in repr(allowed))
         self.assertTrue("with msg 'hello'>" in repr(allowed))
 
+
 class TestDenied(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.security import Denied
+
         return Denied
-    
+
     def _makeOne(self, *arg, **kw):
         klass = self._getTargetClass()
         return klass(*arg, **kw)
@@ -82,20 +89,27 @@ class TestDenied(unittest.TestCase):
         self.assertTrue('<Denied instance at ' in repr(denied))
         self.assertTrue("with msg 'hello'>" in repr(denied))
 
+
 class TestACLAllowed(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.security import ACLAllowed
+
         return ACLAllowed
-    
+
     def _makeOne(self, *arg, **kw):
         klass = self._getTargetClass()
         return klass(*arg, **kw)
 
     def test_it(self):
         from pyramid.security import Allowed
-        msg = ("ACLAllowed permission 'permission' via ACE 'ace' in ACL 'acl' "
-               "on context 'ctx' for principals 'principals'")
-        allowed = self._makeOne('ace', 'acl', 'permission', 'principals', 'ctx')
+
+        msg = (
+            "ACLAllowed permission 'permission' via ACE 'ace' in ACL 'acl' "
+            "on context 'ctx' for principals 'principals'"
+        )
+        allowed = self._makeOne(
+            'ace', 'acl', 'permission', 'principals', 'ctx'
+        )
         self.assertIsInstance(allowed, Allowed)
         self.assertTrue(msg in allowed.msg)
         self.assertEqual(allowed, True)
@@ -104,19 +118,24 @@ class TestACLAllowed(unittest.TestCase):
         self.assertTrue('<ACLAllowed instance at ' in repr(allowed))
         self.assertTrue("with msg %r>" % msg in repr(allowed))
 
+
 class TestACLDenied(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.security import ACLDenied
+
         return ACLDenied
-    
+
     def _makeOne(self, *arg, **kw):
         klass = self._getTargetClass()
         return klass(*arg, **kw)
 
     def test_it(self):
         from pyramid.security import Denied
-        msg = ("ACLDenied permission 'permission' via ACE 'ace' in ACL 'acl' "
-               "on context 'ctx' for principals 'principals'")
+
+        msg = (
+            "ACLDenied permission 'permission' via ACE 'ace' in ACL 'acl' "
+            "on context 'ctx' for principals 'principals'"
+        )
         denied = self._makeOne('ace', 'acl', 'permission', 'principals', 'ctx')
         self.assertIsInstance(denied, Denied)
         self.assertTrue(msg in denied.msg)
@@ -126,6 +145,7 @@ class TestACLDenied(unittest.TestCase):
         self.assertTrue('<ACLDenied instance at ' in repr(denied))
         self.assertTrue("with msg %r>" % msg in repr(denied))
 
+
 class TestPrincipalsAllowedByPermission(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -135,31 +155,36 @@ class TestPrincipalsAllowedByPermission(unittest.TestCase):
 
     def _callFUT(self, *arg):
         from pyramid.security import principals_allowed_by_permission
+
         return principals_allowed_by_permission(*arg)
 
     def test_no_authorization_policy(self):
         from pyramid.security import Everyone
+
         context = DummyContext()
         result = self._callFUT(context, 'view')
         self.assertEqual(result, [Everyone])
 
     def test_with_authorization_policy(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         _registerAuthorizationPolicy(registry, 'yo')
         context = DummyContext()
         result = self._callFUT(context, 'view')
         self.assertEqual(result, 'yo')
 
+
 class TestRemember(unittest.TestCase):
     def setUp(self):
         testing.setUp()
-        
+
     def tearDown(self):
         testing.tearDown()
 
     def _callFUT(self, *arg, **kwarg):
         from pyramid.security import remember
+
         return remember(*arg, **kwarg)
 
     def test_no_authentication_policy(self):
@@ -176,6 +201,7 @@ class TestRemember(unittest.TestCase):
 
     def test_with_authentication_policy_no_reg_on_request(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         request = _makeRequest()
         del request.registry
@@ -189,15 +215,17 @@ class TestRemember(unittest.TestCase):
         _registerAuthenticationPolicy(registry, 'yo')
         self.assertRaises(TypeError, lambda: self._callFUT(request))
 
+
 class TestForget(unittest.TestCase):
     def setUp(self):
         testing.setUp()
-        
+
     def tearDown(self):
         testing.tearDown()
 
     def _callFUT(self, *arg):
         from pyramid.security import forget
+
         return forget(*arg)
 
     def test_no_authentication_policy(self):
@@ -213,22 +241,25 @@ class TestForget(unittest.TestCase):
 
     def test_with_authentication_policy_no_reg_on_request(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         request = _makeRequest()
         del request.registry
         _registerAuthenticationPolicy(registry, 'yo')
         result = self._callFUT(request)
         self.assertEqual(result, [('X-Pyramid-Test', 'logout')])
-        
+
+
 class TestViewExecutionPermitted(unittest.TestCase):
     def setUp(self):
         testing.setUp()
 
     def tearDown(self):
         testing.tearDown()
-    
+
     def _callFUT(self, *arg, **kw):
         from pyramid.security import view_execution_permitted
+
         return view_execution_permitted(*arg, **kw)
 
     def _registerSecuredView(self, view_name, allow=True):
@@ -236,15 +267,21 @@ class TestViewExecutionPermitted(unittest.TestCase):
         from zope.interface import Interface
         from pyramid.interfaces import ISecuredView
         from pyramid.interfaces import IViewClassifier
+
         class Checker(object):
             def __permitted__(self, context, request):
                 self.context = context
                 self.request = request
                 return allow
+
         checker = Checker()
         reg = get_current_registry()
-        reg.registerAdapter(checker, (IViewClassifier, Interface, Interface),
-                            ISecuredView, view_name)
+        reg.registerAdapter(
+            checker,
+            (IViewClassifier, Interface, Interface),
+            ISecuredView,
+            view_name,
+        )
         return checker
 
     def test_no_permission(self):
@@ -253,16 +290,20 @@ class TestViewExecutionPermitted(unittest.TestCase):
         from pyramid.interfaces import ISettings
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
+
         settings = dict(debug_authorization=True)
         reg = get_current_registry()
         reg.registerUtility(settings, ISettings)
         context = DummyContext()
         request = testing.DummyRequest({})
+
         class DummyView(object):
             pass
+
         view = DummyView()
-        reg.registerAdapter(view, (IViewClassifier, Interface, Interface),
-                            IView, '')
+        reg.registerAdapter(
+            view, (IViewClassifier, Interface, Interface), IView, ''
+        )
         result = self._callFUT(context, request, '')
         msg = result.msg
         self.assertTrue("Allowed: view name '' in context" in msg)
@@ -272,6 +313,7 @@ class TestViewExecutionPermitted(unittest.TestCase):
     def test_no_view_registered(self):
         from pyramid.threadlocal import get_current_registry
         from pyramid.interfaces import ISettings
+
         settings = dict(debug_authorization=True)
         reg = get_current_registry()
         reg.registerUtility(settings, ISettings)
@@ -283,8 +325,10 @@ class TestViewExecutionPermitted(unittest.TestCase):
         from zope.interface import Interface
         from zope.interface import directlyProvides
         from pyramid.interfaces import IRequest
+
         class IContext(Interface):
             pass
+
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerSecuredView('', True)
@@ -293,23 +337,25 @@ class TestViewExecutionPermitted(unittest.TestCase):
         result = self._callFUT(context, request, '')
         self.assertTrue(result)
 
+
 class TestAuthenticatedUserId(unittest.TestCase):
     def setUp(self):
         testing.setUp()
 
     def tearDown(self):
         testing.tearDown()
-        
+
     def test_backward_compat_delegates_to_mixin(self):
         from zope.deprecation import __show__
+
         try:
             __show__.off()
             request = _makeFakeRequest()
             from pyramid.security import authenticated_userid
+
             self.assertEqual(
-                authenticated_userid(request),
-                'authenticated_userid'
-                )
+                authenticated_userid(request), 'authenticated_userid'
+            )
         finally:
             __show__.on()
 
@@ -324,29 +370,32 @@ class TestAuthenticatedUserId(unittest.TestCase):
 
     def test_with_authentication_policy_no_reg_on_request(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         request = _makeRequest()
         del request.registry
         _registerAuthenticationPolicy(registry, 'yo')
         self.assertEqual(request.authenticated_userid, 'yo')
 
+
 class TestUnAuthenticatedUserId(unittest.TestCase):
     def setUp(self):
         testing.setUp()
 
     def tearDown(self):
         testing.tearDown()
-        
+
     def test_backward_compat_delegates_to_mixin(self):
         from zope.deprecation import __show__
+
         try:
             __show__.off()
             request = _makeFakeRequest()
             from pyramid.security import unauthenticated_userid
+
             self.assertEqual(
-                unauthenticated_userid(request),
-                'unauthenticated_userid',
-                )
+                unauthenticated_userid(request), 'unauthenticated_userid'
+            )
         finally:
             __show__.on()
 
@@ -361,34 +410,38 @@ class TestUnAuthenticatedUserId(unittest.TestCase):
 
     def test_with_authentication_policy_no_reg_on_request(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         request = _makeRequest()
         del request.registry
         _registerAuthenticationPolicy(registry, 'yo')
         self.assertEqual(request.unauthenticated_userid, 'yo')
 
+
 class TestEffectivePrincipals(unittest.TestCase):
     def setUp(self):
         testing.setUp()
 
     def tearDown(self):
         testing.tearDown()
-        
+
     def test_backward_compat_delegates_to_mixin(self):
         request = _makeFakeRequest()
         from zope.deprecation import __show__
+
         try:
             __show__.off()
             from pyramid.security import effective_principals
+
             self.assertEqual(
-                effective_principals(request),
-                'effective_principals'
-                )
+                effective_principals(request), 'effective_principals'
+            )
         finally:
             __show__.on()
 
     def test_no_authentication_policy(self):
         from pyramid.security import Everyone
+
         request = _makeRequest()
         self.assertEqual(request.effective_principals, [Everyone])
 
@@ -399,22 +452,25 @@ class TestEffectivePrincipals(unittest.TestCase):
 
     def test_with_authentication_policy_no_reg_on_request(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         request = _makeRequest()
         del request.registry
         _registerAuthenticationPolicy(registry, 'yo')
         self.assertEqual(request.effective_principals, 'yo')
 
+
 class TestHasPermission(unittest.TestCase):
     def setUp(self):
         testing.setUp()
-        
+
     def tearDown(self):
         testing.tearDown()
 
     def _makeOne(self):
         from pyramid.security import AuthorizationAPIMixin
         from pyramid.registry import Registry
+
         mixin = AuthorizationAPIMixin()
         mixin.registry = Registry()
         mixin.context = object()
@@ -422,10 +478,12 @@ class TestHasPermission(unittest.TestCase):
 
     def test_delegates_to_mixin(self):
         from zope.deprecation import __show__
+
         try:
             __show__.off()
             mixin = self._makeOne()
             from pyramid.security import has_permission
+
             self.called_has_permission = False
 
             def mocked_has_permission(*args, **kw):
@@ -446,8 +504,9 @@ class TestHasPermission(unittest.TestCase):
     def test_with_no_authorization_policy(self):
         request = self._makeOne()
         _registerAuthenticationPolicy(request.registry, None)
-        self.assertRaises(ValueError,
-                          request.has_permission, 'view', context=None)
+        self.assertRaises(
+            ValueError, request.has_permission, 'view', context=None
+        )
 
     def test_with_authn_and_authz_policies_registered(self):
         request = self._makeOne()
@@ -457,6 +516,7 @@ class TestHasPermission(unittest.TestCase):
 
     def test_with_no_reg_on_request(self):
         from pyramid.threadlocal import get_current_registry
+
         registry = get_current_registry()
         request = self._makeOne()
         del request.registry
@@ -473,12 +533,15 @@ class TestHasPermission(unittest.TestCase):
         del request.context
         self.assertRaises(AttributeError, request.has_permission, 'view')
 
+
 _TEST_HEADER = 'X-Pyramid-Test'
 
+
 class DummyContext:
     def __init__(self, *arg, **kw):
         self.__dict__.update(kw)
 
+
 class DummyAuthenticationPolicy:
     def __init__(self, result):
         self.result = result
@@ -502,6 +565,7 @@ class DummyAuthenticationPolicy:
         self._header_forgotten = headers[0]
         return headers
 
+
 class DummyAuthorizationPolicy:
     def __init__(self, result):
         self.result = result
@@ -512,25 +576,32 @@ class DummyAuthorizationPolicy:
     def principals_allowed_by_permission(self, context, permission):
         return self.result
 
+
 def _registerAuthenticationPolicy(reg, result):
     from pyramid.interfaces import IAuthenticationPolicy
+
     policy = DummyAuthenticationPolicy(result)
     reg.registerUtility(policy, IAuthenticationPolicy)
     return policy
 
+
 def _registerAuthorizationPolicy(reg, result):
     from pyramid.interfaces import IAuthorizationPolicy
+
     policy = DummyAuthorizationPolicy(result)
     reg.registerUtility(policy, IAuthorizationPolicy)
     return policy
 
+
 def _makeRequest():
     from pyramid.registry import Registry
+
     request = testing.DummyRequest(environ={})
     request.registry = Registry()
     request.context = object()
     return request
 
+
 def _makeFakeRequest():
     class FakeRequest(testing.DummyRequest):
         @property
@@ -546,4 +617,3 @@ def _makeFakeRequest():
             return 'effective_principals'
 
     return FakeRequest({})
-
diff --git a/tests/test_session.py b/tests/test_session.py
index 6cd058bfb..05c257e73 100644
--- a/tests/test_session.py
+++ b/tests/test_session.py
@@ -4,8 +4,8 @@ import unittest
 from pyramid import testing
 from pyramid.compat import pickle
 
-class SharedCookieSessionTests(object):
 
+class SharedCookieSessionTests(object):
     def test_ctor_no_cookie(self):
         request = testing.DummyRequest()
         session = self._makeOne(request)
@@ -14,17 +14,19 @@ class SharedCookieSessionTests(object):
     def test_instance_conforms(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import ISession
+
         request = testing.DummyRequest()
         session = self._makeOne(request)
         verifyObject(ISession, session)
 
     def test_ctor_with_cookie_still_valid(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time(), 0, {'state': 1}))
         request.cookies['session'] = cookieval
         session = self._makeOne(request)
-        self.assertEqual(dict(session), {'state':1})
+        self.assertEqual(dict(session), {'state': 1})
 
     def test_ctor_with_cookie_expired(self):
         request = testing.DummyRequest()
@@ -48,6 +50,7 @@ class SharedCookieSessionTests(object):
 
     def test_timeout(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time() - 5, 0, {'state': 1}))
         request.cookies['session'] = cookieval
@@ -56,6 +59,7 @@ class SharedCookieSessionTests(object):
 
     def test_timeout_never(self):
         import time
+
         request = testing.DummyRequest()
         LONG_TIME = 31536000
         cookieval = self._serialize((time.time() + LONG_TIME, 0, {'state': 1}))
@@ -65,6 +69,7 @@ class SharedCookieSessionTests(object):
 
     def test_timeout_str(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time() - 5, 0, {'state': 1}))
         request.cookies['session'] = cookieval
@@ -73,7 +78,9 @@ class SharedCookieSessionTests(object):
 
     def test_timeout_invalid(self):
         request = testing.DummyRequest()
-        self.assertRaises(ValueError, self._makeOne, request, timeout='Invalid value')
+        self.assertRaises(
+            ValueError, self._makeOne, request, timeout='Invalid value'
+        )
 
     def test_changed(self):
         request = testing.DummyRequest()
@@ -90,6 +97,7 @@ class SharedCookieSessionTests(object):
 
     def test_reissue_triggered(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time() - 2, 0, {'state': 1}))
         request.cookies['session'] = cookieval
@@ -107,6 +115,7 @@ class SharedCookieSessionTests(object):
 
     def test__set_cookie_on_exception_no_request_exception(self):
         import webob
+
         request = testing.DummyRequest()
         request.exception = None
         session = self._makeOne(request)
@@ -118,12 +127,13 @@ class SharedCookieSessionTests(object):
     def test__set_cookie_cookieval_too_long(self):
         request = testing.DummyRequest()
         session = self._makeOne(request)
-        session['abc'] = 'x'*100000
+        session['abc'] = 'x' * 100000
         response = DummyResponse()
         self.assertRaises(ValueError, session._set_cookie, response)
 
     def test__set_cookie_real_webob_response(self):
         import webob
+
         request = testing.DummyRequest()
         session = self._makeOne(request)
         session['abc'] = 'x'
@@ -133,21 +143,24 @@ class SharedCookieSessionTests(object):
 
     def test__set_cookie_options(self):
         from pyramid.response import Response
+
         request = testing.DummyRequest()
         request.exception = None
-        session = self._makeOne(request,
-                                cookie_name='abc',
-                                path='/foo',
-                                domain='localhost',
-                                secure=True,
-                                httponly=True,
-                                )
+        session = self._makeOne(
+            request,
+            cookie_name='abc',
+            path='/foo',
+            domain='localhost',
+            secure=True,
+            httponly=True,
+        )
         session['abc'] = 'x'
         response = Response()
         self.assertEqual(session._set_cookie(response), True)
         cookieval = response.headerlist[-1][1]
-        val, domain, path, secure, httponly, samesite = [x.strip() for x in
-                                                         cookieval.split(';')]
+        val, domain, path, secure, httponly, samesite = [
+            x.strip() for x in cookieval.split(';')
+        ]
         self.assertTrue(val.startswith('abc='))
         self.assertEqual(domain, 'Domain=localhost')
         self.assertEqual(path, 'Path=/foo')
@@ -249,6 +262,7 @@ class SharedCookieSessionTests(object):
 
     def test_no_set_cookie_with_exception(self):
         import webob
+
         request = testing.DummyRequest()
         request.exception = True
         session = self._makeOne(request, set_on_exception=False)
@@ -262,6 +276,7 @@ class SharedCookieSessionTests(object):
 
     def test_set_cookie_with_exception(self):
         import webob
+
         request = testing.DummyRequest()
         request.exception = True
         session = self._makeOne(request)
@@ -275,6 +290,7 @@ class SharedCookieSessionTests(object):
 
     def test_cookie_is_set(self):
         import webob
+
         request = testing.DummyRequest()
         session = self._makeOne(request)
         session['a'] = 1
@@ -285,9 +301,11 @@ class SharedCookieSessionTests(object):
         self.assertEqual(result, None)
         self.assertTrue('Set-Cookie' in dict(response.headerlist))
 
+
 class TestBaseCookieSession(SharedCookieSessionTests, unittest.TestCase):
     def _makeOne(self, request, **kw):
         from pyramid.session import BaseCookieSessionFactory
+
         serializer = DummySerializer()
         return BaseCookieSessionFactory(serializer, **kw)(request)
 
@@ -296,6 +314,7 @@ class TestBaseCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
     def test_reissue_not_triggered(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time(), 0, {'state': 1}))
         request.cookies['session'] = cookieval
@@ -313,6 +332,7 @@ class TestBaseCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
     def test_reissue_str_triggered(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time() - 2, 0, {'state': 1}))
         request.cookies['session'] = cookieval
@@ -322,15 +342,21 @@ class TestBaseCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
     def test_reissue_invalid(self):
         request = testing.DummyRequest()
-        self.assertRaises(ValueError, self._makeOne, request, reissue_time='invalid value')
+        self.assertRaises(
+            ValueError, self._makeOne, request, reissue_time='invalid value'
+        )
 
     def test_cookie_max_age_invalid(self):
         request = testing.DummyRequest()
-        self.assertRaises(ValueError, self._makeOne, request, max_age='invalid value')
+        self.assertRaises(
+            ValueError, self._makeOne, request, max_age='invalid value'
+        )
+
 
 class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
     def _makeOne(self, request, **kw):
         from pyramid.session import SignedCookieSessionFactory
+
         kw.setdefault('secret', 'secret')
         return SignedCookieSessionFactory(**kw)(request)
 
@@ -347,6 +373,7 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
     def test_reissue_not_triggered(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time(), 0, {'state': 1}))
         request.cookies['session'] = cookieval
@@ -364,6 +391,7 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
     def test_reissue_str_triggered(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time() - 2, 0, {'state': 1}))
         request.cookies['session'] = cookieval
@@ -373,14 +401,19 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
     def test_reissue_invalid(self):
         request = testing.DummyRequest()
-        self.assertRaises(ValueError, self._makeOne, request, reissue_time='invalid value')
+        self.assertRaises(
+            ValueError, self._makeOne, request, reissue_time='invalid value'
+        )
 
     def test_cookie_max_age_invalid(self):
         request = testing.DummyRequest()
-        self.assertRaises(ValueError, self._makeOne, request, max_age='invalid value')
+        self.assertRaises(
+            ValueError, self._makeOne, request, max_age='invalid value'
+        )
 
     def test_custom_salt(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time(), 0, {'state': 1}), salt=b'f.')
         request.cookies['session'] = cookieval
@@ -389,6 +422,7 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
     def test_salt_mismatch(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time(), 0, {'state': 1}), salt=b'f.')
         request.cookies['session'] = cookieval
@@ -397,24 +431,29 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
     def test_custom_hashalg(self):
         import time
+
         request = testing.DummyRequest()
-        cookieval = self._serialize((time.time(), 0, {'state': 1}),
-                                    hashalg='sha1')
+        cookieval = self._serialize(
+            (time.time(), 0, {'state': 1}), hashalg='sha1'
+        )
         request.cookies['session'] = cookieval
         session = self._makeOne(request, hashalg='sha1')
         self.assertEqual(session['state'], 1)
 
     def test_hashalg_mismatch(self):
         import time
+
         request = testing.DummyRequest()
-        cookieval = self._serialize((time.time(), 0, {'state': 1}),
-                                    hashalg='sha1')
+        cookieval = self._serialize(
+            (time.time(), 0, {'state': 1}), hashalg='sha1'
+        )
         request.cookies['session'] = cookieval
         session = self._makeOne(request, hashalg='sha256')
         self.assertEqual(session, {})
 
     def test_secret_mismatch(self):
         import time
+
         request = testing.DummyRequest()
         cookieval = self._serialize((time.time(), 0, {'state': 1}))
         request.cookies['session'] = cookieval
@@ -426,6 +465,7 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
         from hashlib import sha512
         import hmac
         import time
+
         request = testing.DummyRequest()
         serializer = DummySerializer()
         cstruct = serializer.dumps((time.time(), 0, {'state': 1}))
@@ -438,6 +478,7 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
     def test_invalid_data_size(self):
         from hashlib import sha512
         import base64
+
         request = testing.DummyRequest()
         num_bytes = sha512().digest_size - 1
         cookieval = base64.b64encode(b' ' * num_bytes)
@@ -448,6 +489,7 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
     def test_very_long_key(self):
         verylongkey = b'a' * 1024
         import webob
+
         request = testing.DummyRequest()
         session = self._makeOne(request, secret=verylongkey)
         session['a'] = 1
@@ -457,7 +499,7 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
         try:
             result = callbacks[0](request, response)
-        except TypeError: # pragma: no cover
+        except TypeError:  # pragma: no cover
             self.fail('HMAC failed to initialize due to key length.')
 
         self.assertEqual(result, None)
@@ -481,19 +523,25 @@ class TestSignedCookieSession(SharedCookieSessionTests, unittest.TestCase):
         session = self._makeOne(request, secret='secret')
         self.assertEqual(session, {})
 
-class TestUnencryptedCookieSession(SharedCookieSessionTests, unittest.TestCase):
+
+class TestUnencryptedCookieSession(
+    SharedCookieSessionTests, unittest.TestCase
+):
     def setUp(self):
         super(TestUnencryptedCookieSession, self).setUp()
         from zope.deprecation import __show__
+
         __show__.off()
 
     def tearDown(self):
         super(TestUnencryptedCookieSession, self).tearDown()
         from zope.deprecation import __show__
+
         __show__.on()
-        
+
     def _makeOne(self, request, **kw):
         from pyramid.session import UnencryptedCookieSessionFactoryConfig
+
         self._rename_cookie_var(kw, 'path', 'cookie_path')
         self._rename_cookie_var(kw, 'domain', 'cookie_domain')
         self._rename_cookie_var(kw, 'secure', 'cookie_secure')
@@ -508,20 +556,24 @@ class TestUnencryptedCookieSession(SharedCookieSessionTests, unittest.TestCase):
     def _serialize(self, value):
         from pyramid.compat import bytes_
         from pyramid.session import signed_serialize
+
         return bytes_(signed_serialize(value, 'secret'))
 
     def test_serialize_option(self):
         from pyramid.response import Response
+
         secret = 'secret'
         request = testing.DummyRequest()
-        session = self._makeOne(request,
-            signed_serialize=dummy_signed_serialize)
+        session = self._makeOne(
+            request, signed_serialize=dummy_signed_serialize
+        )
         session['key'] = 'value'
         response = Response()
         self.assertEqual(session._set_cookie(response), True)
         cookie = response.headerlist[-1][1]
         expected_cookieval = dummy_signed_serialize(
-            (session.accessed, session.created, {'key': 'value'}), secret)
+            (session.accessed, session.created, {'key': 'value'}), secret
+        )
         response = Response()
         response.set_cookie('session', expected_cookieval, samesite='Lax')
         expected_cookie = response.headerlist[-1][1]
@@ -529,32 +581,41 @@ class TestUnencryptedCookieSession(SharedCookieSessionTests, unittest.TestCase):
 
     def test_deserialize_option(self):
         import time
+
         secret = 'secret'
         request = testing.DummyRequest()
         accessed = time.time()
         state = {'key': 'value'}
         cookieval = dummy_signed_serialize((accessed, accessed, state), secret)
         request.cookies['session'] = cookieval
-        session = self._makeOne(request,
-            signed_deserialize=dummy_signed_deserialize)
+        session = self._makeOne(
+            request, signed_deserialize=dummy_signed_deserialize
+        )
         self.assertEqual(dict(session), state)
 
+
 def dummy_signed_serialize(data, secret):
     import base64
     from pyramid.compat import pickle, bytes_
+
     pickled = pickle.dumps(data)
     return base64.b64encode(bytes_(secret)) + base64.b64encode(pickled)
 
+
 def dummy_signed_deserialize(serialized, secret):
     import base64
     from pyramid.compat import pickle, bytes_
+
     serialized_data = base64.b64decode(
-        serialized[len(base64.b64encode(bytes_(secret))):])
+        serialized[len(base64.b64encode(bytes_(secret))) :]
+    )
     return pickle.loads(serialized_data)
 
+
 class Test_manage_accessed(unittest.TestCase):
     def _makeOne(self, wrapped):
         from pyramid.session import manage_accessed
+
         return manage_accessed(wrapped)
 
     def test_accessed_set(self):
@@ -568,6 +629,7 @@ class Test_manage_accessed(unittest.TestCase):
 
     def test_accessed_without_renew(self):
         import time
+
         request = testing.DummyRequest()
         session = DummySessionFactory(request)
         session._reissue_time = 5
@@ -588,11 +650,14 @@ class Test_manage_accessed(unittest.TestCase):
         result = wrapper(session, 'a')
         self.assertEqual(result, 1)
         callbacks = request.response_callbacks
-        if callbacks is not None: self.assertEqual(len(callbacks), 0)
+        if callbacks is not None:
+            self.assertEqual(len(callbacks), 0)
+
 
 class Test_manage_changed(unittest.TestCase):
     def _makeOne(self, wrapped):
         from pyramid.session import manage_changed
+
         return manage_changed(wrapped)
 
     def test_it(self):
@@ -603,6 +668,7 @@ class Test_manage_changed(unittest.TestCase):
         self.assertNotEqual(session.accessed, None)
         self.assertTrue(session._dirty)
 
+
 def serialize(data, secret):
     import hmac
     import base64
@@ -610,13 +676,16 @@ def serialize(data, secret):
     from pyramid.compat import bytes_
     from pyramid.compat import native_
     from pyramid.compat import pickle
+
     pickled = pickle.dumps(data, pickle.HIGHEST_PROTOCOL)
     sig = hmac.new(bytes_(secret, 'utf-8'), pickled, sha1).hexdigest()
     return sig + native_(base64.b64encode(pickled))
 
+
 class Test_signed_serialize(unittest.TestCase):
     def _callFUT(self, data, secret):
         from pyramid.session import signed_serialize
+
         return signed_serialize(data, secret)
 
     def test_it(self):
@@ -635,12 +704,14 @@ class Test_signed_serialize(unittest.TestCase):
         expected = serialize('123', secret)
         result = self._callFUT('123', secret.decode('latin-1'))
         self.assertEqual(result, expected)
-        
+
+
 class Test_signed_deserialize(unittest.TestCase):
     def _callFUT(self, serialized, secret, hmac=None):
         if hmac is None:
             import hmac
         from pyramid.session import signed_deserialize
+
         return signed_deserialize(serialized, secret, hmac=hmac)
 
     def test_it(self):
@@ -656,12 +727,15 @@ class Test_signed_deserialize(unittest.TestCase):
         class hmac(object):
             def new(self, *arg):
                 return self
+
             def hexdigest(self):
                 return '1234'
+
         serialized = serialize('123', 'secret123')
-        self.assertRaises(ValueError, self._callFUT, serialized, 'secret',
-                          hmac=hmac())
-        
+        self.assertRaises(
+            ValueError, self._callFUT, serialized, 'secret', hmac=hmac()
+        )
+
     def test_it_bad_encoding(self):
         serialized = 'bad' + serialize('123', 'secret')
         self.assertRaises(ValueError, self._callFUT, serialized, 'secret')
@@ -683,6 +757,7 @@ class Test_signed_deserialize(unittest.TestCase):
 class TestPickleSerializer(unittest.TestCase):
     def _makeOne(self):
         from pyramid.session import PickleSerializer
+
         return PickleSerializer()
 
     def test_loads(self):
@@ -731,6 +806,7 @@ class DummySerializer(object):
         except TypeError:
             raise ValueError
 
+
 class DummySessionFactory(dict):
     _dirty = False
     _cookie_name = 'session'
@@ -749,6 +825,7 @@ class DummySessionFactory(dict):
     def changed(self):
         self._dirty = True
 
+
 class DummyResponse(object):
     def __init__(self):
         self.headerlist = []
diff --git a/tests/test_settings.py b/tests/test_settings.py
index a586cb6fd..e8be490ee 100644
--- a/tests/test_settings.py
+++ b/tests/test_settings.py
@@ -1,18 +1,20 @@
 import unittest
 
+
 class Test_asbool(unittest.TestCase):
     def _callFUT(self, s):
         from pyramid.settings import asbool
+
         return asbool(s)
 
     def test_s_is_None(self):
         result = self._callFUT(None)
         self.assertEqual(result, False)
-        
+
     def test_s_is_True(self):
         result = self._callFUT(True)
         self.assertEqual(result, True)
-        
+
     def test_s_is_False(self):
         result = self._callFUT(False)
         self.assertEqual(result, False)
@@ -37,15 +39,17 @@ class Test_asbool(unittest.TestCase):
         result = self._callFUT(1)
         self.assertEqual(result, True)
 
+
 class Test_aslist_cronly(unittest.TestCase):
     def _callFUT(self, val):
         from pyramid.settings import aslist_cronly
+
         return aslist_cronly(val)
 
     def test_with_list(self):
         result = self._callFUT(['abc', 'def'])
         self.assertEqual(result, ['abc', 'def'])
-        
+
     def test_with_string(self):
         result = self._callFUT('abc def')
         self.assertEqual(result, ['abc def'])
@@ -54,15 +58,17 @@ class Test_aslist_cronly(unittest.TestCase):
         result = self._callFUT(' abc\n def')
         self.assertEqual(result, ['abc', 'def'])
 
+
 class Test_aslist(unittest.TestCase):
     def _callFUT(self, val, **kw):
         from pyramid.settings import aslist
+
         return aslist(val, **kw)
 
     def test_with_list(self):
         result = self._callFUT(['abc', 'def'])
         self.assertEqual(list(result), ['abc', 'def'])
-        
+
     def test_with_string(self):
         result = self._callFUT('abc def')
         self.assertEqual(result, ['abc', 'def'])
diff --git a/tests/test_static.py b/tests/test_static.py
index f34f8f943..a323b1d89 100644
--- a/tests/test_static.py
+++ b/tests/test_static.py
@@ -5,11 +5,13 @@ import unittest
 here = os.path.dirname(__file__)
 
 # 5 years from now (more or less)
-fiveyrsfuture = datetime.datetime.utcnow() + datetime.timedelta(5*365)
+fiveyrsfuture = datetime.datetime.utcnow() + datetime.timedelta(5 * 365)
+
 
 class Test_static_view_use_subpath_False(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.static import static_view
+
         return static_view
 
     def _makeOne(self, *arg, **kw):
@@ -17,15 +19,16 @@ class Test_static_view_use_subpath_False(unittest.TestCase):
 
     def _makeRequest(self, kw=None):
         from pyramid.request import Request
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'wsgi.version':(1,0),
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'6543',
-            'PATH_INFO':'/',
-            'SCRIPT_NAME':'',
-            'REQUEST_METHOD':'GET',
-            }
+            'wsgi.url_scheme': 'http',
+            'wsgi.version': (1, 0),
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '6543',
+            'PATH_INFO': '/',
+            'SCRIPT_NAME': '',
+            'REQUEST_METHOD': 'GET',
+        }
         if kw is not None:
             environ.update(kw)
         return Request(environ=environ)
@@ -39,9 +42,10 @@ class Test_static_view_use_subpath_False(unittest.TestCase):
 
     def test_call_adds_slash_path_info_empty(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':''})
+        request = self._makeRequest({'PATH_INFO': ''})
         context = DummyContext()
         from pyramid.httpexceptions import HTTPMovedPermanently
+
         self.assertRaises(HTTPMovedPermanently, inst, context, request)
 
     def test_path_info_slash_means_index_html(self):
@@ -53,7 +57,7 @@ class Test_static_view_use_subpath_False(unittest.TestCase):
 
     def test_oob_singledot(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/./index.html'})
+        request = self._makeRequest({'PATH_INFO': '/./index.html'})
         context = DummyContext()
         response = inst(context, request)
         self.assertEqual(response.status, '200 OK')
@@ -61,7 +65,7 @@ class Test_static_view_use_subpath_False(unittest.TestCase):
 
     def test_oob_emptyelement(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'//index.html'})
+        request = self._makeRequest({'PATH_INFO': '//index.html'})
         context = DummyContext()
         response = inst(context, request)
         self.assertEqual(response.status, '200 OK')
@@ -69,58 +73,68 @@ class Test_static_view_use_subpath_False(unittest.TestCase):
 
     def test_oob_dotdotslash(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/subdir/../../minimal.pt'})
+        request = self._makeRequest({'PATH_INFO': '/subdir/../../minimal.pt'})
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_oob_dotdotslash_encoded(self):
         inst = self._makeOne('tests:fixtures/static')
         request = self._makeRequest(
-            {'PATH_INFO':'/subdir/%2E%2E%2F%2E%2E/minimal.pt'})
+            {'PATH_INFO': '/subdir/%2E%2E%2F%2E%2E/minimal.pt'}
+        )
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_oob_os_sep(self):
         import os
+
         inst = self._makeOne('tests:fixtures/static')
         dds = '..' + os.sep
-        request = self._makeRequest({'PATH_INFO':'/subdir/%s%sminimal.pt' %
-                                     (dds, dds)})
+        request = self._makeRequest(
+            {'PATH_INFO': '/subdir/%s%sminimal.pt' % (dds, dds)}
+        )
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_resource_doesnt_exist(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/notthere'})
+        request = self._makeRequest({'PATH_INFO': '/notthere'})
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_resource_isdir(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/subdir/'})
+        request = self._makeRequest({'PATH_INFO': '/subdir/'})
         context = DummyContext()
         response = inst(context, request)
         self.assertTrue(b'<html>subdir</html>' in response.body)
 
     def test_resource_is_file(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/index.html'})
+        request = self._makeRequest({'PATH_INFO': '/index.html'})
         context = DummyContext()
         response = inst(context, request)
         self.assertTrue(b'<html>static</html>' in response.body)
 
     def test_resource_is_file_with_wsgi_file_wrapper(self):
         from pyramid.response import _BLOCK_SIZE
+
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/index.html'})
+        request = self._makeRequest({'PATH_INFO': '/index.html'})
+
         class _Wrapper(object):
             def __init__(self, file, block_size=None):
                 self.file = file
                 self.block_size = block_size
+
         request.environ['wsgi.file_wrapper'] = _Wrapper
         context = DummyContext()
         response = inst(context, request)
@@ -132,34 +146,40 @@ class Test_static_view_use_subpath_False(unittest.TestCase):
 
     def test_resource_is_file_with_cache_max_age(self):
         inst = self._makeOne('tests:fixtures/static', cache_max_age=600)
-        request = self._makeRequest({'PATH_INFO':'/index.html'})
+        request = self._makeRequest({'PATH_INFO': '/index.html'})
         context = DummyContext()
         response = inst(context, request)
         self.assertTrue(b'<html>static</html>' in response.body)
         self.assertEqual(len(response.headerlist), 5)
-        header_names = [ x[0] for x in response.headerlist ]
+        header_names = [x[0] for x in response.headerlist]
         header_names.sort()
-        self.assertEqual(header_names,
-                         ['Cache-Control', 'Content-Length', 'Content-Type',
-                          'Expires', 'Last-Modified'])
+        self.assertEqual(
+            header_names,
+            [
+                'Cache-Control',
+                'Content-Length',
+                'Content-Type',
+                'Expires',
+                'Last-Modified',
+            ],
+        )
 
     def test_resource_is_file_with_no_cache_max_age(self):
-        inst = self._makeOne('tests:fixtures/static',
-                             cache_max_age=None)
-        request = self._makeRequest({'PATH_INFO':'/index.html'})
+        inst = self._makeOne('tests:fixtures/static', cache_max_age=None)
+        request = self._makeRequest({'PATH_INFO': '/index.html'})
         context = DummyContext()
         response = inst(context, request)
         self.assertTrue(b'<html>static</html>' in response.body)
         self.assertEqual(len(response.headerlist), 3)
-        header_names = [ x[0] for x in response.headerlist ]
+        header_names = [x[0] for x in response.headerlist]
         header_names.sort()
         self.assertEqual(
-            header_names,
-            ['Content-Length', 'Content-Type', 'Last-Modified'])
+            header_names, ['Content-Length', 'Content-Type', 'Last-Modified']
+        )
 
     def test_resource_notmodified(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/index.html'})
+        request = self._makeRequest({'PATH_INFO': '/index.html'})
         request.if_modified_since = fiveyrsfuture
         context = DummyContext()
         response = inst(context, request)
@@ -173,14 +193,15 @@ class Test_static_view_use_subpath_False(unittest.TestCase):
 
     def test_not_found(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/notthere.html'})
+        request = self._makeRequest({'PATH_INFO': '/notthere.html'})
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_gz_resource_no_content_encoding(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/arcs.svg.tgz'})
+        request = self._makeRequest({'PATH_INFO': '/arcs.svg.tgz'})
         context = DummyContext()
         response = inst(context, request)
         self.assertEqual(response.status, '200 OK')
@@ -190,7 +211,7 @@ class Test_static_view_use_subpath_False(unittest.TestCase):
 
     def test_resource_no_content_encoding(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':'/index.html'})
+        request = self._makeRequest({'PATH_INFO': '/index.html'})
         context = DummyContext()
         response = inst(context, request)
         self.assertEqual(response.status, '200 OK')
@@ -198,9 +219,11 @@ class Test_static_view_use_subpath_False(unittest.TestCase):
         self.assertEqual(response.content_encoding, None)
         response.app_iter.close()
 
+
 class Test_static_view_use_subpath_True(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.static import static_view
+
         return static_view
 
     def _makeOne(self, *arg, **kw):
@@ -209,15 +232,16 @@ class Test_static_view_use_subpath_True(unittest.TestCase):
 
     def _makeRequest(self, kw=None):
         from pyramid.request import Request
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'wsgi.version':(1,0),
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'6543',
-            'PATH_INFO':'/',
-            'SCRIPT_NAME':'',
-            'REQUEST_METHOD':'GET',
-            }
+            'wsgi.url_scheme': 'http',
+            'wsgi.version': (1, 0),
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '6543',
+            'PATH_INFO': '/',
+            'SCRIPT_NAME': '',
+            'REQUEST_METHOD': 'GET',
+        }
         if kw is not None:
             environ.update(kw)
         return Request(environ=environ)
@@ -231,10 +255,11 @@ class Test_static_view_use_subpath_True(unittest.TestCase):
 
     def test_call_adds_slash_path_info_empty(self):
         inst = self._makeOne('tests:fixtures/static')
-        request = self._makeRequest({'PATH_INFO':''})
+        request = self._makeRequest({'PATH_INFO': ''})
         request.subpath = ()
         context = DummyContext()
         from pyramid.httpexceptions import HTTPMovedPermanently
+
         self.assertRaises(HTTPMovedPermanently, inst, context, request)
 
     def test_path_info_slash_means_index_html(self):
@@ -251,6 +276,7 @@ class Test_static_view_use_subpath_True(unittest.TestCase):
         request.subpath = ('.', 'index.html')
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_oob_emptyelement(self):
@@ -259,6 +285,7 @@ class Test_static_view_use_subpath_True(unittest.TestCase):
         request.subpath = ('', 'index.html')
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_oob_dotdotslash(self):
@@ -267,6 +294,7 @@ class Test_static_view_use_subpath_True(unittest.TestCase):
         request.subpath = ('subdir', '..', '..', 'minimal.pt')
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_oob_dotdotslash_encoded(self):
@@ -275,24 +303,28 @@ class Test_static_view_use_subpath_True(unittest.TestCase):
         request.subpath = ('subdir', '%2E%2E', '%2E%2E', 'minimal.pt')
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_oob_os_sep(self):
         import os
+
         inst = self._makeOne('tests:fixtures/static')
         dds = '..' + os.sep
         request = self._makeRequest()
         request.subpath = ('subdir', dds, dds, 'minimal.pt')
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_resource_doesnt_exist(self):
         inst = self._makeOne('tests:fixtures/static')
         request = self._makeRequest()
-        request.subpath = ('notthere,')
+        request.subpath = 'notthere,'
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
     def test_resource_isdir(self):
@@ -319,26 +351,32 @@ class Test_static_view_use_subpath_True(unittest.TestCase):
         response = inst(context, request)
         self.assertTrue(b'<html>static</html>' in response.body)
         self.assertEqual(len(response.headerlist), 5)
-        header_names = [ x[0] for x in response.headerlist ]
+        header_names = [x[0] for x in response.headerlist]
         header_names.sort()
-        self.assertEqual(header_names,
-                         ['Cache-Control', 'Content-Length', 'Content-Type',
-                          'Expires', 'Last-Modified'])
+        self.assertEqual(
+            header_names,
+            [
+                'Cache-Control',
+                'Content-Length',
+                'Content-Type',
+                'Expires',
+                'Last-Modified',
+            ],
+        )
 
     def test_resource_is_file_with_no_cache_max_age(self):
-        inst = self._makeOne('tests:fixtures/static',
-                             cache_max_age=None)
+        inst = self._makeOne('tests:fixtures/static', cache_max_age=None)
         request = self._makeRequest()
         request.subpath = ('index.html',)
         context = DummyContext()
         response = inst(context, request)
         self.assertTrue(b'<html>static</html>' in response.body)
         self.assertEqual(len(response.headerlist), 3)
-        header_names = [ x[0] for x in response.headerlist ]
+        header_names = [x[0] for x in response.headerlist]
         header_names.sort()
         self.assertEqual(
-            header_names,
-            ['Content-Length', 'Content-Type', 'Last-Modified'])
+            header_names, ['Content-Length', 'Content-Type', 'Last-Modified']
+        )
 
     def test_resource_notmodified(self):
         inst = self._makeOne('tests:fixtures/static')
@@ -361,12 +399,14 @@ class Test_static_view_use_subpath_True(unittest.TestCase):
         request.subpath = ('notthere.html',)
         context = DummyContext()
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertRaises(HTTPNotFound, inst, context, request)
 
-class TestQueryStringConstantCacheBuster(unittest.TestCase):
 
+class TestQueryStringConstantCacheBuster(unittest.TestCase):
     def _makeOne(self, param=None):
         from pyramid.static import QueryStringConstantCacheBuster as cls
+
         if param:
             inst = cls('foo', param)
         else:
@@ -380,31 +420,34 @@ class TestQueryStringConstantCacheBuster(unittest.TestCase):
     def test_it(self):
         fut = self._makeOne()
         self.assertEqual(
-            fut('foo', 'bar', {}),
-            ('bar', {'_query': {'x': 'foo'}}))
+            fut('foo', 'bar', {}), ('bar', {'_query': {'x': 'foo'}})
+        )
 
     def test_change_param(self):
         fut = self._makeOne('y')
         self.assertEqual(
-            fut('foo', 'bar', {}),
-            ('bar', {'_query': {'y': 'foo'}}))
+            fut('foo', 'bar', {}), ('bar', {'_query': {'y': 'foo'}})
+        )
 
     def test_query_is_already_tuples(self):
         fut = self._makeOne()
         self.assertEqual(
             fut('foo', 'bar', {'_query': [('a', 'b')]}),
-            ('bar', {'_query': (('a', 'b'), ('x', 'foo'))}))
+            ('bar', {'_query': (('a', 'b'), ('x', 'foo'))}),
+        )
 
     def test_query_is_tuple_of_tuples(self):
         fut = self._makeOne()
         self.assertEqual(
             fut('foo', 'bar', {'_query': (('a', 'b'),)}),
-            ('bar', {'_query': (('a', 'b'), ('x', 'foo'))}))
+            ('bar', {'_query': (('a', 'b'), ('x', 'foo'))}),
+        )
 
-class TestManifestCacheBuster(unittest.TestCase):
 
+class TestManifestCacheBuster(unittest.TestCase):
     def _makeOne(self, path, **kw):
         from pyramid.static import ManifestCacheBuster as cls
+
         return cls(path, **kw)
 
     def test_it(self):
@@ -412,22 +455,22 @@ class TestManifestCacheBuster(unittest.TestCase):
         fut = self._makeOne(manifest_path)
         self.assertEqual(fut('foo', 'bar', {}), ('bar', {}))
         self.assertEqual(
-            fut('foo', 'css/main.css', {}),
-            ('css/main-test.css', {}))
+            fut('foo', 'css/main.css', {}), ('css/main-test.css', {})
+        )
 
     def test_it_with_relspec(self):
         fut = self._makeOne('fixtures/manifest.json')
         self.assertEqual(fut('foo', 'bar', {}), ('bar', {}))
         self.assertEqual(
-            fut('foo', 'css/main.css', {}),
-            ('css/main-test.css', {}))
+            fut('foo', 'css/main.css', {}), ('css/main-test.css', {})
+        )
 
     def test_it_with_absspec(self):
         fut = self._makeOne('tests:fixtures/manifest.json')
         self.assertEqual(fut('foo', 'bar', {}), ('bar', {}))
         self.assertEqual(
-            fut('foo', 'css/main.css', {}),
-            ('css/main-test.css', {}))
+            fut('foo', 'css/main.css', {}), ('css/main-test.css', {})
+        )
 
     def test_reload(self):
         manifest_path = os.path.join(here, 'fixtures', 'manifest.json')
@@ -437,27 +480,25 @@ class TestManifestCacheBuster(unittest.TestCase):
         fut = inst
 
         # test without a valid manifest
-        self.assertEqual(
-            fut('foo', 'css/main.css', {}),
-            ('css/main.css', {}))
+        self.assertEqual(fut('foo', 'css/main.css', {}), ('css/main.css', {}))
 
         # swap to a real manifest, setting mtime to 0
         inst.manifest_path = manifest_path
         self.assertEqual(
-            fut('foo', 'css/main.css', {}),
-            ('css/main-test.css', {}))
+            fut('foo', 'css/main.css', {}), ('css/main-test.css', {})
+        )
 
         # ensure switching the path doesn't change the result
         inst.manifest_path = new_manifest_path
         self.assertEqual(
-            fut('foo', 'css/main.css', {}),
-            ('css/main-test.css', {}))
+            fut('foo', 'css/main.css', {}), ('css/main-test.css', {})
+        )
 
         # update mtime, should cause a reload
         inst.getmtime = lambda *args, **kwargs: 1
         self.assertEqual(
-            fut('foo', 'css/main.css', {}),
-            ('css/main-678b7c80.css', {}))
+            fut('foo', 'css/main.css', {}), ('css/main-678b7c80.css', {})
+        )
 
     def test_invalid_manifest(self):
         self.assertRaises(IOError, lambda: self._makeOne('foo'))
@@ -466,12 +507,15 @@ class TestManifestCacheBuster(unittest.TestCase):
         inst = self._makeOne('foo', reload=True)
         self.assertEqual(inst.manifest, {})
 
+
 class DummyContext:
     pass
 
+
 class DummyStartResponse:
     status = ()
     headers = ()
+
     def __call__(self, status, headers):
         self.status = status
         self.headers = headers
diff --git a/tests/test_testing.py b/tests/test_testing.py
index 51ffb9822..b5c689794 100644
--- a/tests/test_testing.py
+++ b/tests/test_testing.py
@@ -2,19 +2,23 @@ import unittest
 from zope.component import getSiteManager
 from pyramid import testing
 
+
 class TestDummyRootFactory(unittest.TestCase):
     def _makeOne(self, environ):
         from pyramid.testing import DummyRootFactory
+
         return DummyRootFactory(environ)
 
     def test_it(self):
-        environ = {'bfg.routes.matchdict':{'a':1}}
+        environ = {'bfg.routes.matchdict': {'a': 1}}
         factory = self._makeOne(environ)
         self.assertEqual(factory.a, 1)
 
+
 class TestDummySecurityPolicy(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.testing import DummySecurityPolicy
+
         return DummySecurityPolicy
 
     def _makeOne(self, userid=None, groupids=(), permissive=True):
@@ -33,47 +37,55 @@ class TestDummySecurityPolicy(unittest.TestCase):
         policy = self._makeOne('user', ('group1',))
         from pyramid.security import Everyone
         from pyramid.security import Authenticated
-        self.assertEqual(policy.effective_principals(None),
-                         [Everyone, Authenticated, 'user', 'group1'])
+
+        self.assertEqual(
+            policy.effective_principals(None),
+            [Everyone, Authenticated, 'user', 'group1'],
+        )
 
     def test_effective_principals_nouserid(self):
         policy = self._makeOne()
         from pyramid.security import Everyone
+
         self.assertEqual(policy.effective_principals(None), [Everyone])
 
     def test_permits(self):
         policy = self._makeOne()
         self.assertEqual(policy.permits(None, None, None), True)
-        
+
     def test_principals_allowed_by_permission(self):
         policy = self._makeOne('user', ('group1',))
         from pyramid.security import Everyone
         from pyramid.security import Authenticated
+
         result = policy.principals_allowed_by_permission(None, None)
         self.assertEqual(result, [Everyone, Authenticated, 'user', 'group1'])
 
     def test_forget(self):
         policy = self._makeOne()
         self.assertEqual(policy.forget(None), [])
-        
+
     def test_remember(self):
         policy = self._makeOne()
         self.assertEqual(policy.remember(None, None), [])
-        
-        
+
 
 class TestDummyResource(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.testing import DummyResource
+
         return DummyResource
 
     def _makeOne(self, name=None, parent=None, **kw):
         klass = self._getTargetClass()
         return klass(name, parent, **kw)
 
-    def test__setitem__and__getitem__and__delitem__and__contains__and_get(self):
+    def test__setitem__and__getitem__and__delitem__and__contains__and_get(
+        self
+    ):
         class Dummy:
             pass
+
         dummy = Dummy()
         resource = self._makeOne()
         resource['abc'] = dummy
@@ -91,7 +103,7 @@ class TestDummyResource(unittest.TestCase):
     def test_extra_params(self):
         resource = self._makeOne(foo=1)
         self.assertEqual(resource.foo, 1)
-        
+
     def test_clone(self):
         resource = self._makeOne('name', 'parent', foo=1, bar=2)
         clone = resource.clone('name2', 'parent2', bar=1)
@@ -103,6 +115,7 @@ class TestDummyResource(unittest.TestCase):
     def test_keys_items_values_len(self):
         class Dummy:
             pass
+
         resource = self._makeOne()
         resource['abc'] = Dummy()
         resource['def'] = Dummy()
@@ -119,24 +132,27 @@ class TestDummyResource(unittest.TestCase):
     def test_bool(self):
         resource = self._makeOne()
         self.assertEqual(resource.__bool__(), True)
-        
+
     def test_ctor_with__provides__(self):
         resource = self._makeOne(__provides__=IDummy)
         self.assertTrue(IDummy.providedBy(resource))
 
+
 class TestDummyRequest(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.testing import DummyRequest
+
         return DummyRequest
 
     def _makeOne(self, *arg, **kw):
         return self._getTargetClass()(*arg, **kw)
 
     def test_params(self):
-        request = self._makeOne(params = {'say':'Hello'},
-                                environ = {'PATH_INFO':'/foo'},
-                                headers = {'X-Foo':'YUP'},
-                               )
+        request = self._makeOne(
+            params={'say': 'Hello'},
+            environ={'PATH_INFO': '/foo'},
+            headers={'X-Foo': 'YUP'},
+        )
         self.assertEqual(request.params['say'], 'Hello')
         self.assertEqual(request.GET['say'], 'Hello')
         self.assertEqual(request.POST['say'], 'Hello')
@@ -146,6 +162,7 @@ class TestDummyRequest(unittest.TestCase):
     def test_defaults(self):
         from pyramid.threadlocal import get_current_registry
         from pyramid.testing import DummySession
+
         request = self._makeOne()
         self.assertEqual(request.method, 'GET')
         self.assertEqual(request.application_url, 'http://example.com')
@@ -174,25 +191,25 @@ class TestDummyRequest(unittest.TestCase):
         self.assertEqual(request.session.__class__, DummySession)
 
     def test_params_explicit(self):
-        request = self._makeOne(params = {'foo':'bar'})
+        request = self._makeOne(params={'foo': 'bar'})
         self.assertEqual(request.params['foo'], 'bar')
         self.assertEqual(request.GET['foo'], 'bar')
         self.assertEqual(request.POST['foo'], 'bar')
 
     def test_environ_explicit(self):
-        request = self._makeOne(environ = {'PATH_INFO':'/foo'})
+        request = self._makeOne(environ={'PATH_INFO': '/foo'})
         self.assertEqual(request.environ['PATH_INFO'], '/foo')
 
     def test_headers_explicit(self):
-        request = self._makeOne(headers = {'X-Foo':'YUP'})
+        request = self._makeOne(headers={'X-Foo': 'YUP'})
         self.assertEqual(request.headers['X-Foo'], 'YUP')
 
     def test_path_explicit(self):
-        request = self._makeOne(path = '/abc')
+        request = self._makeOne(path='/abc')
         self.assertEqual(request.path, '/abc')
 
     def test_cookies_explicit(self):
-        request = self._makeOne(cookies = {'type': 'gingersnap'})
+        request = self._makeOne(cookies={'type': 'gingersnap'})
         self.assertEqual(request.cookies['type'], 'gingersnap')
 
     def test_post_explicit(self):
@@ -213,7 +230,7 @@ class TestDummyRequest(unittest.TestCase):
         self.assertEqual(request.POST.get('foo'), None)
 
     def test_kwargs(self):
-        request = self._makeOne(water = 1)
+        request = self._makeOne(water=1)
         self.assertEqual(request.water, 1)
 
     def test_add_response_callback(self):
@@ -225,6 +242,7 @@ class TestDummyRequest(unittest.TestCase):
         # see https://github.com/Pylons/pyramid/issues/165
         from pyramid.registry import Registry
         from pyramid.config import Configurator
+
         request = self._makeOne()
         try:
             registry = Registry('this_test')
@@ -243,6 +261,7 @@ class TestDummyRequest(unittest.TestCase):
         # see https://github.com/Pylons/pyramid/issues/165
         from pyramid.registry import Registry
         from pyramid.config import Configurator
+
         request = self._makeOne()
         request.registry = 'abc'
         self.assertEqual(request.registry, 'abc')
@@ -258,32 +277,35 @@ class TestDummyRequest(unittest.TestCase):
     def test_response_with_responsefactory(self):
         from pyramid.registry import Registry
         from pyramid.interfaces import IResponseFactory
+
         registry = Registry('this_test')
+
         class ResponseFactory(object):
             pass
-        registry.registerUtility(
-            lambda r: ResponseFactory(), IResponseFactory
-        )
+
+        registry.registerUtility(lambda r: ResponseFactory(), IResponseFactory)
         request = self._makeOne()
         request.registry = registry
         resp = request.response
         self.assertEqual(resp.__class__, ResponseFactory)
-        self.assertTrue(request.response is resp) # reified
+        self.assertTrue(request.response is resp)  # reified
 
     def test_response_without_responsefactory(self):
         from pyramid.registry import Registry
         from pyramid.response import Response
+
         registry = Registry('this_test')
         request = self._makeOne()
         request.registry = registry
         resp = request.response
         self.assertEqual(resp.__class__, Response)
-        self.assertTrue(request.response is resp) # reified
-        
+        self.assertTrue(request.response is resp)  # reified
+
 
 class TestDummyTemplateRenderer(unittest.TestCase):
-    def _getTargetClass(self, ):
+    def _getTargetClass(self,):
         from pyramid.testing import DummyTemplateRenderer
+
         return DummyTemplateRenderer
 
     def _makeOne(self, string_response=''):
@@ -298,29 +320,32 @@ class TestDummyTemplateRenderer(unittest.TestCase):
 
     def test_getattr(self):
         renderer = self._makeOne()
-        renderer({'a':1})
+        renderer({'a': 1})
         self.assertEqual(renderer.a, 1)
         self.assertRaises(AttributeError, renderer.__getattr__, 'b')
 
     def test_assert_(self):
         renderer = self._makeOne()
-        renderer({'a':1, 'b':2})
+        renderer({'a': 1, 'b': 2})
         self.assertRaises(AssertionError, renderer.assert_, c=1)
         self.assertRaises(AssertionError, renderer.assert_, b=3)
         self.assertTrue(renderer.assert_(a=1, b=2))
-        
+
     def test_nondefault_string_response(self):
         renderer = self._makeOne('abc')
-        result = renderer({'a':1, 'b':2})
+        result = renderer({'a': 1, 'b': 2})
         self.assertEqual(result, 'abc')
 
+
 class Test_setUp(unittest.TestCase):
     def _callFUT(self, **kw):
         from pyramid.testing import setUp
+
         return setUp(**kw)
 
     def tearDown(self):
         from pyramid.threadlocal import manager
+
         manager.clear()
         getSiteManager.reset()
 
@@ -332,6 +357,7 @@ class Test_setUp(unittest.TestCase):
         from pyramid.threadlocal import manager
         from pyramid.threadlocal import get_current_registry
         from pyramid.registry import Registry
+
         old = True
         manager.push(old)
         config = self._callFUT()
@@ -346,13 +372,15 @@ class Test_setUp(unittest.TestCase):
     def test_it_with_registry(self):
         from pyramid.registry import Registry
         from pyramid.threadlocal import manager
+
         registry = Registry()
         self._callFUT(registry=registry)
         current = manager.get()
         self.assertEqual(current['registry'], registry)
-            
+
     def test_it_with_request(self):
         from pyramid.threadlocal import manager
+
         request = object()
         self._callFUT(request=request)
         current = manager.get()
@@ -364,6 +392,7 @@ class Test_setUp(unittest.TestCase):
 
     def test_it_with_hook_zca_false(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         self._callFUT(registry=registry, hook_zca=False)
         sm = getSiteManager()
@@ -371,26 +400,32 @@ class Test_setUp(unittest.TestCase):
 
     def test_it_with_settings_passed_explicit_registry(self):
         from pyramid.registry import Registry
+
         registry = Registry()
         self._callFUT(registry=registry, hook_zca=False, settings=dict(a=1))
         self.assertEqual(registry.settings['a'], 1)
-        
+
     def test_it_with_settings_passed_implicit_registry(self):
         config = self._callFUT(hook_zca=False, settings=dict(a=1))
         self.assertEqual(config.registry.settings['a'], 1)
 
+
 class Test_cleanUp(Test_setUp):
     def _callFUT(self, *arg, **kw):
         from pyramid.testing import cleanUp
+
         return cleanUp(*arg, **kw)
-        
+
+
 class Test_tearDown(unittest.TestCase):
     def _callFUT(self, **kw):
         from pyramid.testing import tearDown
+
         return tearDown(**kw)
 
     def tearDown(self):
         from pyramid.threadlocal import manager
+
         manager.clear()
         getSiteManager.reset()
 
@@ -403,8 +438,9 @@ class Test_tearDown(unittest.TestCase):
 
     def test_defaults(self):
         from pyramid.threadlocal import manager
+
         registry = DummyRegistry()
-        old = {'registry':registry}
+        old = {'registry': registry}
         hook = lambda *arg: None
         try:
             self._setSMHook(hook)
@@ -419,14 +455,17 @@ class Test_tearDown(unittest.TestCase):
 
     def test_registry_cannot_be_inited(self):
         from pyramid.threadlocal import manager
+
         registry = DummyRegistry()
+
         def raiseit(name):
             raise TypeError
+
         registry.__init__ = raiseit
-        old = {'registry':registry}
+        old = {'registry': registry}
         try:
             manager.push(old)
-            self._callFUT() # doesn't blow up
+            self._callFUT()  # doesn't blow up
             current = manager.get()
             self.assertNotEqual(current, old)
             self.assertEqual(registry.inited, 1)
@@ -441,9 +480,11 @@ class Test_tearDown(unittest.TestCase):
         finally:
             self._assertSMHook(hook)
 
+
 class TestDummyRendererFactory(unittest.TestCase):
     def _makeOne(self, name, factory):
         from pyramid.testing import DummyRendererFactory
+
         return DummyRendererFactory(name, factory)
 
     def test_add_no_colon(self):
@@ -460,30 +501,33 @@ class TestDummyRendererFactory(unittest.TestCase):
     def test_call(self):
         f = self._makeOne('name', None)
         f.renderers['spec'] = 'renderer'
-        info = DummyRendererInfo({'name':'spec'})
+        info = DummyRendererInfo({'name': 'spec'})
         self.assertEqual(f(info), 'renderer')
-        
+
     def test_call2(self):
         f = self._makeOne('name', None)
         f.renderers['spec'] = 'renderer'
-        info = DummyRendererInfo({'name':'spec:spec'})
+        info = DummyRendererInfo({'name': 'spec:spec'})
         self.assertEqual(f(info), 'renderer')
 
     def test_call3(self):
         def factory(spec):
             return 'renderer'
+
         f = self._makeOne('name', factory)
-        info = DummyRendererInfo({'name':'spec'})
+        info = DummyRendererInfo({'name': 'spec'})
         self.assertEqual(f(info), 'renderer')
 
     def test_call_miss(self):
         f = self._makeOne('name', None)
-        info = DummyRendererInfo({'name':'spec'})
+        info = DummyRendererInfo({'name': 'spec'})
         self.assertRaises(KeyError, f, info)
 
+
 class TestMockTemplate(unittest.TestCase):
     def _makeOne(self, response):
         from pyramid.testing import MockTemplate
+
         return MockTemplate(response)
 
     def test_getattr(self):
@@ -498,39 +542,52 @@ class TestMockTemplate(unittest.TestCase):
         template = self._makeOne('123')
         self.assertEqual(template(), '123')
 
+
 class Test_skip_on(unittest.TestCase):
     def setUp(self):
         from pyramid.testing import skip_on
+
         self.os_name = skip_on.os_name
         skip_on.os_name = 'wrong'
 
     def tearDown(self):
         from pyramid.testing import skip_on
+
         skip_on.os_name = self.os_name
-        
+
     def _callFUT(self, *platforms):
         from pyramid.testing import skip_on
+
         return skip_on(*platforms)
 
     def test_wrong_platform(self):
-        def foo(): return True
+        def foo():
+            return True
+
         decorated = self._callFUT('wrong')(foo)
         self.assertEqual(decorated(), None)
-        
+
     def test_ok_platform(self):
-        def foo(): return True
+        def foo():
+            return True
+
         decorated = self._callFUT('ok')(foo)
         self.assertEqual(decorated(), True)
 
+
 class TestDummySession(unittest.TestCase):
     def _makeOne(self):
         from pyramid.testing import DummySession
+
         return DummySession()
 
-    @testing.skip_on('pypy') # see https://github.com/Pylons/pyramid/issues/3237
+    @testing.skip_on(
+        'pypy'
+    )  # see https://github.com/Pylons/pyramid/issues/3237
     def test_instance_conforms(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import ISession
+
         session = self._makeOne()
         verifyObject(ISession, session)
 
@@ -549,7 +606,7 @@ class TestDummySession(unittest.TestCase):
         session.flash('msg1')
         session.flash('msg2')
         self.assertEqual(session['_f_'], ['msg1', 'msg2'])
-        
+
     def test_flash_mixed(self):
         session = self._makeOne()
         session.flash('warn1', 'warn')
@@ -608,32 +665,39 @@ class TestDummySession(unittest.TestCase):
         self.assertNotEqual(token, None)
         self.assertTrue(len(token) >= 1)
 
+
 from zope.interface import Interface
 from zope.interface import implementer
-        
+
+
 class IDummy(Interface):
     pass
 
+
 @implementer(IDummy)
 class DummyEvent:
     pass
-    
+
+
 class DummyFactory:
     def __init__(self, environ):
         """ """
 
+
 class DummyRegistry(object):
     inited = 0
     __name__ = 'name'
+
     def __init__(self, name=''):
         self.inited = self.inited + 1
-        
+
+
 class DummyRendererInfo(object):
     def __init__(self, kw):
         self.__dict__.update(kw)
-        
-class Test_testConfig(unittest.TestCase):
 
+
+class Test_testConfig(unittest.TestCase):
     def _setUp(self, **kw):
         self._log.append(('setUp', kw))
         return 'fake config'
@@ -643,6 +707,7 @@ class Test_testConfig(unittest.TestCase):
 
     def setUp(self):
         from pyramid import testing
+
         self._log = []
         self._orig_setUp = testing.setUp
         testing.setUp = self._setUp
@@ -651,39 +716,53 @@ class Test_testConfig(unittest.TestCase):
 
     def tearDown(self):
         from pyramid import testing
+
         testing.setUp = self._orig_setUp
         testing.tearDown = self._orig_tearDown
 
     def _callFUT(self, inner, **kw):
         from pyramid.testing import testConfig
+
         with testConfig(**kw) as config:
             inner(config)
 
     def test_ok_calls(self):
         self.assertEqual(self._log, [])
+
         def inner(config):
-            self.assertEqual(self._log,
-                    [('setUp',
-                        {'autocommit': True,
+            self.assertEqual(
+                self._log,
+                [
+                    (
+                        'setUp',
+                        {
+                            'autocommit': True,
                             'hook_zca': True,
                             'registry': None,
                             'request': None,
-                            'settings': None})])
+                            'settings': None,
+                        },
+                    )
+                ],
+            )
             self._log.pop()
+
         self._callFUT(inner)
-        self.assertEqual(self._log,
-                [('tearDown', {'unhook_zca': True})])
+        self.assertEqual(self._log, [('tearDown', {'unhook_zca': True})])
 
     def test_teardown_called_on_exception(self):
         class TestException(Exception):
             pass
+
         def inner(config):
             self._log = []
             raise TestException('oops')
+
         self.assertRaises(TestException, self._callFUT, inner)
         self.assertEqual(self._log[0][0], 'tearDown')
 
     def test_ok_get_config(self):
         def inner(config):
             self.assertEqual(config, 'fake config')
+
         self._callFUT(inner)
diff --git a/tests/test_threadlocal.py b/tests/test_threadlocal.py
index 088156507..487c7f4f2 100644
--- a/tests/test_threadlocal.py
+++ b/tests/test_threadlocal.py
@@ -1,6 +1,7 @@
 from pyramid import testing
 import unittest
 
+
 class TestThreadLocalManager(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -10,6 +11,7 @@ class TestThreadLocalManager(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.threadlocal import ThreadLocalManager
+
         return ThreadLocalManager
 
     def _makeOne(self, default=lambda *x: 1):
@@ -23,6 +25,7 @@ class TestThreadLocalManager(unittest.TestCase):
     def test_default(self):
         def thedefault():
             return '123'
+
         local = self._makeOne(thedefault)
         self.assertEqual(local.stack, [])
         self.assertEqual(local.get(), '123')
@@ -49,6 +52,7 @@ class TestThreadLocalManager(unittest.TestCase):
 class TestGetCurrentRequest(unittest.TestCase):
     def _callFUT(self):
         from pyramid.threadlocal import get_current_request
+
         return get_current_request()
 
     def test_it_None(self):
@@ -57,39 +61,45 @@ class TestGetCurrentRequest(unittest.TestCase):
 
     def test_it(self):
         from pyramid.threadlocal import manager
+
         request = object()
         try:
-            manager.push({'request':request})
+            manager.push({'request': request})
             self.assertEqual(self._callFUT(), request)
         finally:
             manager.pop()
         self.assertEqual(self._callFUT(), None)
 
+
 class GetCurrentRegistryTests(unittest.TestCase):
     def setUp(self):
         testing.setUp()
 
     def tearDown(self):
         testing.tearDown()
-        
+
     def _callFUT(self):
         from pyramid.threadlocal import get_current_registry
+
         return get_current_registry()
 
     def test_it(self):
         from pyramid.threadlocal import manager
+
         try:
-            manager.push({'registry':123})
+            manager.push({'registry': 123})
             self.assertEqual(self._callFUT(), 123)
         finally:
             manager.pop()
 
+
 class GetCurrentRegistryWithoutTestingRegistry(unittest.TestCase):
     def _callFUT(self):
         from pyramid.threadlocal import get_current_registry
+
         return get_current_registry()
 
     def test_it(self):
         from pyramid.registry import global_registry
+
         self.assertEqual(self._callFUT(), global_registry)
-    
diff --git a/tests/test_traversal.py b/tests/test_traversal.py
index 437fe46df..8521844b0 100644
--- a/tests/test_traversal.py
+++ b/tests/test_traversal.py
@@ -3,17 +3,13 @@ import unittest
 
 from pyramid.testing import cleanUp
 
-from pyramid.compat import (
-    text_,
-    native_,
-    text_type,
-    url_quote,
-    PY2,
-    )
+from pyramid.compat import text_, native_, text_type, url_quote, PY2
+
 
 class TraversalPathTests(unittest.TestCase):
     def _callFUT(self, path):
         from pyramid.traversal import traversal_path
+
         return traversal_path(path)
 
     def test_utf8(self):
@@ -26,6 +22,7 @@ class TraversalPathTests(unittest.TestCase):
 
     def test_utf16(self):
         from pyramid.exceptions import URLDecodeError
+
         la = text_(b'La Pe\xc3\xb1a', 'utf-8').encode('utf-16')
         encoded = url_quote(la)
         path = '/'.join([encoded, encoded])
@@ -33,20 +30,26 @@ class TraversalPathTests(unittest.TestCase):
 
     def test_unicode_highorder_chars(self):
         path = text_('/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF')
-        self.assertEqual(self._callFUT(path),
-                         (text_('\u6d41\u884c\u8d8b\u52bf', 'unicode_escape'),))
+        self.assertEqual(
+            self._callFUT(path),
+            (text_('\u6d41\u884c\u8d8b\u52bf', 'unicode_escape'),),
+        )
 
     def test_element_urllquoted(self):
-        self.assertEqual(self._callFUT('/foo/space%20thing/bar'),
-                         (text_('foo'), text_('space thing'), text_('bar')))
+        self.assertEqual(
+            self._callFUT('/foo/space%20thing/bar'),
+            (text_('foo'), text_('space thing'), text_('bar')),
+        )
 
     def test_unicode_undecodeable_to_ascii(self):
         path = text_(b'/La Pe\xc3\xb1a', 'utf-8')
         self.assertRaises(UnicodeEncodeError, self._callFUT, path)
 
+
 class TraversalPathInfoTests(unittest.TestCase):
     def _callFUT(self, path):
         from pyramid.traversal import traversal_path_info
+
         return traversal_path_info(path)
 
     def test_path_startswith_endswith(self):
@@ -56,8 +59,9 @@ class TraversalPathInfoTests(unittest.TestCase):
         self.assertEqual(self._callFUT('foo///'), (text_('foo'),))
 
     def test_onedot(self):
-        self.assertEqual(self._callFUT('foo/./bar'),
-                         (text_('foo'), text_('bar')))
+        self.assertEqual(
+            self._callFUT('foo/./bar'), (text_('foo'), text_('bar'))
+        )
 
     def test_twodots(self):
         self.assertEqual(self._callFUT('foo/../bar'), (text_('bar'),))
@@ -88,10 +92,12 @@ class TraversalPathInfoTests(unittest.TestCase):
 
     def test_highorder_undecodeable(self):
         from pyramid.exceptions import URLDecodeError
+
         la = text_(b'La Pe\xc3\xb1a', 'utf-8')
         notlatin1 = native_(la)
         self.assertRaises(URLDecodeError, self._callFUT, notlatin1)
 
+
 class ResourceTreeTraverserTests(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -101,6 +107,7 @@ class ResourceTreeTraverserTests(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.traversal import ResourceTreeTraverser
+
         return ResourceTreeTraverser
 
     def _makeOne(self, *arg, **kw):
@@ -115,11 +122,13 @@ class ResourceTreeTraverserTests(unittest.TestCase):
     def test_class_conforms_to_ITraverser(self):
         from zope.interface.verify import verifyClass
         from pyramid.interfaces import ITraverser
+
         verifyClass(ITraverser, self._getTargetClass())
 
     def test_instance_conforms_to_ITraverser(self):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import ITraverser
+
         context = DummyContext()
         verifyObject(ITraverser, self._makeOne(context))
 
@@ -249,12 +258,14 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         self.assertEqual(result['context'], baz)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
-        self.assertEqual(result['traversed'],
-                         (text_('foo'), text_('bar'), text_('baz')))
+        self.assertEqual(
+            result['traversed'], (text_('foo'), text_('bar'), text_('baz'))
+        )
         self.assertEqual(result['root'], root)
         self.assertEqual(result['virtual_root'], bar)
-        self.assertEqual(result['virtual_root_path'],
-                         (text_('foo'), text_('bar')))
+        self.assertEqual(
+            result['virtual_root_path'], (text_('foo'), text_('bar'))
+        )
 
     def test_call_with_vh_root2(self):
         environ = self._getEnviron(HTTP_X_VHM_ROOT='/foo')
@@ -268,8 +279,9 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         self.assertEqual(result['context'], baz)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
-        self.assertEqual(result['traversed'],
-                         (text_('foo'), text_('bar'), text_('baz')))
+        self.assertEqual(
+            result['traversed'], (text_('foo'), text_('bar'), text_('baz'))
+        )
         self.assertEqual(result['root'], root)
         self.assertEqual(result['virtual_root'], foo)
         self.assertEqual(result['virtual_root_path'], (text_('foo'),))
@@ -286,8 +298,9 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         self.assertEqual(result['context'], baz)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
-        self.assertEqual(result['traversed'],
-                         (text_('foo'), text_('bar'), text_('baz')))
+        self.assertEqual(
+            result['traversed'], (text_('foo'), text_('bar'), text_('baz'))
+        )
         self.assertEqual(result['root'], root)
         self.assertEqual(result['virtual_root'], root)
         self.assertEqual(result['virtual_root_path'], ())
@@ -304,12 +317,15 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         self.assertEqual(result['context'], baz)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
-        self.assertEqual(result['traversed'],
-                         (text_('foo'), text_('bar'), text_('baz')))
+        self.assertEqual(
+            result['traversed'], (text_('foo'), text_('bar'), text_('baz'))
+        )
         self.assertEqual(result['root'], root)
         self.assertEqual(result['virtual_root'], baz)
-        self.assertEqual(result['virtual_root_path'],
-                         (text_('foo'), text_('bar'), text_('baz')))
+        self.assertEqual(
+            result['virtual_root_path'],
+            (text_('foo'), text_('bar'), text_('baz')),
+        )
 
     def test_call_with_vh_root_path_root(self):
         policy = self._makeOne(None)
@@ -340,19 +356,14 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         self.assertEqual(result['context'], bar)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
-        self.assertEqual(
-            result['traversed'],
-            (path, text_('bar'))
-            )
+        self.assertEqual(result['traversed'], (path, text_('bar')))
         self.assertEqual(result['root'], policy.root)
         self.assertEqual(result['virtual_root'], foo)
-        self.assertEqual(
-            result['virtual_root_path'],
-            (path,)
-            )
+        self.assertEqual(result['virtual_root_path'], (path,))
 
     def test_path_info_raises_unicodedecodeerror(self):
         from pyramid.exceptions import URLDecodeError
+
         foo = DummyContext()
         root = DummyContext(foo)
         policy = self._makeOne(root)
@@ -379,13 +390,13 @@ class ResourceTreeTraverserTests(unittest.TestCase):
     def test_withroute_with_subpath_string(self):
         resource = DummyContext()
         traverser = self._makeOne(resource)
-        matchdict = {'subpath':'/a/b/c'}
+        matchdict = {'subpath': '/a/b/c'}
         request = DummyRequest({})
         request.matchdict = matchdict
         result = traverser(request)
         self.assertEqual(result['context'], resource)
         self.assertEqual(result['view_name'], '')
-        self.assertEqual(result['subpath'], ('a', 'b','c'))
+        self.assertEqual(result['subpath'], ('a', 'b', 'c'))
         self.assertEqual(result['traversed'], ())
         self.assertEqual(result['root'], resource)
         self.assertEqual(result['virtual_root'], resource)
@@ -394,13 +405,13 @@ class ResourceTreeTraverserTests(unittest.TestCase):
     def test_withroute_with_subpath_tuple(self):
         resource = DummyContext()
         traverser = self._makeOne(resource)
-        matchdict = {'subpath':('a', 'b', 'c')}
+        matchdict = {'subpath': ('a', 'b', 'c')}
         request = DummyRequest({})
         request.matchdict = matchdict
         result = traverser(request)
         self.assertEqual(result['context'], resource)
         self.assertEqual(result['view_name'], '')
-        self.assertEqual(result['subpath'], ('a', 'b','c'))
+        self.assertEqual(result['subpath'], ('a', 'b', 'c'))
         self.assertEqual(result['traversed'], ())
         self.assertEqual(result['root'], resource)
         self.assertEqual(result['virtual_root'], resource)
@@ -409,7 +420,7 @@ class ResourceTreeTraverserTests(unittest.TestCase):
     def test_withroute_and_traverse_string(self):
         resource = DummyContext()
         traverser = self._makeOne(resource)
-        matchdict =  {'traverse':text_('foo/bar')}
+        matchdict = {'traverse': text_('foo/bar')}
         request = DummyRequest({})
         request.matchdict = matchdict
         result = traverser(request)
@@ -424,7 +435,7 @@ class ResourceTreeTraverserTests(unittest.TestCase):
     def test_withroute_and_traverse_tuple(self):
         resource = DummyContext()
         traverser = self._makeOne(resource)
-        matchdict = {'traverse':('foo', 'bar')}
+        matchdict = {'traverse': ('foo', 'bar')}
         request = DummyRequest({})
         request.matchdict = matchdict
         result = traverser(request)
@@ -439,7 +450,7 @@ class ResourceTreeTraverserTests(unittest.TestCase):
     def test_withroute_and_traverse_empty(self):
         resource = DummyContext()
         traverser = self._makeOne(resource)
-        matchdict = {'traverse':''}
+        matchdict = {'traverse': ''}
         request = DummyRequest({})
         request.matchdict = matchdict
         result = traverser(request)
@@ -457,7 +468,7 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         environ = self._getEnviron(HTTP_X_VHM_ROOT='/abc')
         request = DummyRequest(environ)
         traverser = self._makeOne(resource)
-        matchdict =  {'traverse':text_('/foo/bar')}
+        matchdict = {'traverse': text_('/foo/bar')}
         request.matchdict = matchdict
         result = traverser(request)
         self.assertEqual(result['context'], abc)
@@ -467,10 +478,12 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         self.assertEqual(result['root'], resource)
         self.assertEqual(result['virtual_root'], abc)
         self.assertEqual(result['virtual_root_path'], ('abc',))
-        
+
+
 class FindInterfaceTests(unittest.TestCase):
     def _callFUT(self, context, iface):
         from pyramid.traversal import find_interface
+
         return find_interface(context, iface)
 
     def test_it_interface(self):
@@ -488,8 +501,10 @@ class FindInterfaceTests(unittest.TestCase):
         baz.__name__ = 'baz'
         from zope.interface import directlyProvides
         from zope.interface import Interface
+
         class IFoo(Interface):
             pass
+
         directlyProvides(root, IFoo)
         result = self._callFUT(baz, IFoo)
         self.assertEqual(result.__name__, 'root')
@@ -498,6 +513,7 @@ class FindInterfaceTests(unittest.TestCase):
         class DummyRoot(object):
             def __init__(self, child):
                 self.child = child
+
         baz = DummyContext()
         bar = DummyContext(baz)
         foo = DummyContext(bar)
@@ -513,9 +529,11 @@ class FindInterfaceTests(unittest.TestCase):
         result = self._callFUT(baz, DummyRoot)
         self.assertEqual(result.__name__, 'root')
 
+
 class FindRootTests(unittest.TestCase):
     def _callFUT(self, context):
         from pyramid.traversal import find_root
+
         return find_root(context)
 
     def test_it(self):
@@ -528,21 +546,25 @@ class FindRootTests(unittest.TestCase):
         result = self._callFUT(baz)
         self.assertEqual(result, dummy)
 
+
 class FindResourceTests(unittest.TestCase):
     def _callFUT(self, context, name):
         from pyramid.traversal import find_resource
+
         return find_resource(context, name)
 
     def _registerTraverser(self, traverser):
         from pyramid.threadlocal import get_current_registry
+
         reg = get_current_registry()
         from pyramid.interfaces import ITraverser
         from zope.interface import Interface
+
         reg.registerAdapter(traverser, (Interface,), ITraverser)
 
     def test_list(self):
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
         result = self._callFUT(resource, [''])
         self.assertEqual(result, resource)
@@ -550,17 +572,19 @@ class FindResourceTests(unittest.TestCase):
 
     def test_generator(self):
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
+
         def foo():
             yield ''
+
         result = self._callFUT(resource, foo())
         self.assertEqual(result, resource)
         self.assertEqual(resource.request.environ['PATH_INFO'], '/')
 
     def test_self_string_found(self):
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
         result = self._callFUT(resource, '')
         self.assertEqual(result, resource)
@@ -568,7 +592,7 @@ class FindResourceTests(unittest.TestCase):
 
     def test_self_tuple_found(self):
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
         result = self._callFUT(resource, ())
         self.assertEqual(result, resource)
@@ -577,7 +601,7 @@ class FindResourceTests(unittest.TestCase):
     def test_relative_string_found(self):
         resource = DummyContext()
         baz = DummyContext()
-        traverser = make_traverser({'context':baz, 'view_name':''})
+        traverser = make_traverser({'context': baz, 'view_name': ''})
         self._registerTraverser(traverser)
         result = self._callFUT(resource, 'baz')
         self.assertEqual(result, baz)
@@ -586,7 +610,7 @@ class FindResourceTests(unittest.TestCase):
     def test_relative_tuple_found(self):
         resource = DummyContext()
         baz = DummyContext()
-        traverser = make_traverser({'context':baz, 'view_name':''})
+        traverser = make_traverser({'context': baz, 'view_name': ''})
         self._registerTraverser(traverser)
         result = self._callFUT(resource, ('baz',))
         self.assertEqual(result, baz)
@@ -595,7 +619,7 @@ class FindResourceTests(unittest.TestCase):
     def test_relative_string_notfound(self):
         resource = DummyContext()
         baz = DummyContext()
-        traverser = make_traverser({'context':baz, 'view_name':'bar'})
+        traverser = make_traverser({'context': baz, 'view_name': 'bar'})
         self._registerTraverser(traverser)
         self.assertRaises(KeyError, self._callFUT, resource, 'baz')
         self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
@@ -603,7 +627,7 @@ class FindResourceTests(unittest.TestCase):
     def test_relative_tuple_notfound(self):
         resource = DummyContext()
         baz = DummyContext()
-        traverser = make_traverser({'context':baz, 'view_name':'bar'})
+        traverser = make_traverser({'context': baz, 'view_name': 'bar'})
         self._registerTraverser(traverser)
         self.assertRaises(KeyError, self._callFUT, resource, ('baz',))
         self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
@@ -613,7 +637,7 @@ class FindResourceTests(unittest.TestCase):
         resource = DummyContext()
         resource.__parent__ = root
         resource.__name__ = 'baz'
-        traverser = make_traverser({'context':root, 'view_name':''})
+        traverser = make_traverser({'context': root, 'view_name': ''})
         self._registerTraverser(traverser)
         result = self._callFUT(resource, '/')
         self.assertEqual(result, root)
@@ -625,7 +649,7 @@ class FindResourceTests(unittest.TestCase):
         resource = DummyContext()
         resource.__parent__ = root
         resource.__name__ = 'baz'
-        traverser = make_traverser({'context':root, 'view_name':''})
+        traverser = make_traverser({'context': root, 'view_name': ''})
         self._registerTraverser(traverser)
         result = self._callFUT(resource, ('',))
         self.assertEqual(result, root)
@@ -637,7 +661,7 @@ class FindResourceTests(unittest.TestCase):
         resource = DummyContext()
         resource.__parent__ = root
         resource.__name__ = 'baz'
-        traverser = make_traverser({'context':root, 'view_name':'fuz'})
+        traverser = make_traverser({'context': root, 'view_name': 'fuz'})
         self._registerTraverser(traverser)
         self.assertRaises(KeyError, self._callFUT, resource, '/')
         self.assertEqual(root.wascontext, True)
@@ -648,7 +672,7 @@ class FindResourceTests(unittest.TestCase):
         resource = DummyContext()
         resource.__parent__ = root
         resource.__name__ = 'baz'
-        traverser = make_traverser({'context':root, 'view_name':'fuz'})
+        traverser = make_traverser({'context': root, 'view_name': 'fuz'})
         self._registerTraverser(traverser)
         self.assertRaises(KeyError, self._callFUT, resource, ('',))
         self.assertEqual(root.wascontext, True)
@@ -669,24 +693,27 @@ class FindResourceTests(unittest.TestCase):
         # solution: encode string to ascii in pyramid.traversal.traverse
         # before passing it along to webob as path_info
         from pyramid.traversal import ResourceTreeTraverser
+
         unprintable = DummyContext()
         root = DummyContext(unprintable)
         unprintable.__parent__ = root
         unprintable.__name__ = text_(
-            b'/\xe6\xb5\x81\xe8\xa1\x8c\xe8\xb6\x8b\xe5\x8a\xbf', 'utf-8')
+            b'/\xe6\xb5\x81\xe8\xa1\x8c\xe8\xb6\x8b\xe5\x8a\xbf', 'utf-8'
+        )
         root.__parent__ = None
         root.__name__ = None
         traverser = ResourceTreeTraverser
         self._registerTraverser(traverser)
         result = self._callFUT(
-            root,
-            text_(b'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF')
-            )
+            root, text_(b'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF')
+        )
         self.assertEqual(result, unprintable)
 
+
 class ResourcePathTests(unittest.TestCase):
     def _callFUT(self, resource, *elements):
         from pyramid.traversal import resource_path
+
         return resource_path(resource, *elements)
 
     def test_it(self):
@@ -724,7 +751,7 @@ class ResourcePathTests(unittest.TestCase):
         root.__parent__ = None
         root.__name__ = 'flubadub'
         result = self._callFUT(root)
-        self.assertEqual(result, 'flubadub') # insane case
+        self.assertEqual(result, 'flubadub')  # insane case
 
     def test_root_object_nonnull_name_indirect(self):
         root = DummyContext()
@@ -734,7 +761,7 @@ class ResourcePathTests(unittest.TestCase):
         other.__parent__ = root
         other.__name__ = 'barker'
         result = self._callFUT(other)
-        self.assertEqual(result, 'flubadub/barker') # insane case
+        self.assertEqual(result, 'flubadub/barker')  # insane case
 
     def test_nonroot_default(self):
         root = DummyContext()
@@ -759,9 +786,11 @@ class ResourcePathTests(unittest.TestCase):
         result = self._callFUT(other2)
         self.assertEqual(result, '//other2')
 
+
 class ResourcePathTupleTests(unittest.TestCase):
     def _callFUT(self, resource, *elements):
         from pyramid.traversal import resource_path_tuple
+
         return resource_path_tuple(resource, *elements)
 
     def test_it(self):
@@ -778,8 +807,9 @@ class ResourcePathTupleTests(unittest.TestCase):
         baz.__parent__ = bar
         baz.__name__ = 'baz'
         result = self._callFUT(baz, 'this/theotherthing', 'that')
-        self.assertEqual(result, ('','foo ', 'bar', 'baz', 'this/theotherthing',
-                                  'that'))
+        self.assertEqual(
+            result, ('', 'foo ', 'bar', 'baz', 'this/theotherthing', 'that')
+        )
 
     def test_root_default(self):
         root = DummyContext()
@@ -796,7 +826,7 @@ class ResourcePathTupleTests(unittest.TestCase):
         other.__parent__ = root
         other.__name__ = 'other'
         result = self._callFUT(other)
-        self.assertEqual(result, ('', 'other',))
+        self.assertEqual(result, ('', 'other'))
 
     def test_nonroot_default(self):
         root = DummyContext()
@@ -821,9 +851,11 @@ class ResourcePathTupleTests(unittest.TestCase):
         result = self._callFUT(other2)
         self.assertEqual(result, ('', '', 'other2'))
 
+
 class QuotePathSegmentTests(unittest.TestCase):
     def _callFUT(self, s):
         from pyramid.traversal import quote_path_segment
+
         return quote_path_segment(s)
 
     def test_unicode(self):
@@ -840,10 +872,11 @@ class QuotePathSegmentTests(unittest.TestCase):
         s = 12345
         result = self._callFUT(s)
         self.assertEqual(result, '12345')
-        
+
     def test_long(self):
         from pyramid.compat import long
         import sys
+
         s = long(sys.maxsize + 1)
         result = self._callFUT(s)
         expected = str(s)
@@ -853,27 +886,32 @@ class QuotePathSegmentTests(unittest.TestCase):
         class Foo(object):
             def __str__(self):
                 return 'abc'
+
         s = Foo()
         result = self._callFUT(s)
         self.assertEqual(result, 'abc')
 
+
 class ResourceURLTests(unittest.TestCase):
     def _makeOne(self, context, url):
         return self._getTargetClass()(context, url)
 
     def _getTargetClass(self):
         from pyramid.traversal import ResourceURL
+
         return ResourceURL
 
     def test_instance_conforms_to_IResourceURL(self):
         from pyramid.interfaces import IResourceURL
         from zope.interface.verify import verifyObject
+
         context = DummyContext()
         request = DummyRequest()
         verifyObject(IResourceURL, self._makeOne(context, request))
 
     def test_IResourceURL_attributes_with_vroot(self):
         from pyramid.interfaces import VH_ROOT_KEY
+
         root = DummyContext()
         root.__parent__ = None
         root.__name__ = None
@@ -883,16 +921,19 @@ class ResourceURLTests(unittest.TestCase):
         two = DummyContext()
         two.__parent__ = one
         two.__name__ = 'two'
-        environ = {VH_ROOT_KEY:'/one'}
+        environ = {VH_ROOT_KEY: '/one'}
         request = DummyRequest(environ)
         context_url = self._makeOne(two, request)
         self.assertEqual(context_url.physical_path, '/one/two/')
         self.assertEqual(context_url.virtual_path, '/two/')
-        self.assertEqual(context_url.physical_path_tuple, ('', 'one', 'two',''))
+        self.assertEqual(
+            context_url.physical_path_tuple, ('', 'one', 'two', '')
+        )
         self.assertEqual(context_url.virtual_path_tuple, ('', 'two', ''))
-        
+
     def test_IResourceURL_attributes_vroot_ends_with_slash(self):
         from pyramid.interfaces import VH_ROOT_KEY
+
         root = DummyContext()
         root.__parent__ = None
         root.__name__ = None
@@ -902,14 +943,16 @@ class ResourceURLTests(unittest.TestCase):
         two = DummyContext()
         two.__parent__ = one
         two.__name__ = 'two'
-        environ = {VH_ROOT_KEY:'/one/'}
+        environ = {VH_ROOT_KEY: '/one/'}
         request = DummyRequest(environ)
         context_url = self._makeOne(two, request)
         self.assertEqual(context_url.physical_path, '/one/two/')
         self.assertEqual(context_url.virtual_path, '/two/')
-        self.assertEqual(context_url.physical_path_tuple, ('', 'one', 'two',''))
+        self.assertEqual(
+            context_url.physical_path_tuple, ('', 'one', 'two', '')
+        )
         self.assertEqual(context_url.virtual_path_tuple, ('', 'two', ''))
-        
+
     def test_IResourceURL_attributes_no_vroot(self):
         root = DummyContext()
         root.__parent__ = None
@@ -925,8 +968,13 @@ class ResourceURLTests(unittest.TestCase):
         context_url = self._makeOne(two, request)
         self.assertEqual(context_url.physical_path, '/one/two/')
         self.assertEqual(context_url.virtual_path, '/one/two/')
-        self.assertEqual(context_url.physical_path_tuple, ('', 'one', 'two',''))
-        self.assertEqual(context_url.virtual_path_tuple, ('', 'one', 'two', ''))
+        self.assertEqual(
+            context_url.physical_path_tuple, ('', 'one', 'two', '')
+        )
+        self.assertEqual(
+            context_url.virtual_path_tuple, ('', 'one', 'two', '')
+        )
+
 
 class TestVirtualRoot(unittest.TestCase):
     def setUp(self):
@@ -937,13 +985,16 @@ class TestVirtualRoot(unittest.TestCase):
 
     def _callFUT(self, resource, request):
         from pyramid.traversal import virtual_root
+
         return virtual_root(resource, request)
 
     def _registerTraverser(self, traverser):
         from pyramid.threadlocal import get_current_registry
+
         reg = get_current_registry()
         from pyramid.interfaces import ITraverser
         from zope.interface import Interface
+
         reg.registerAdapter(traverser, (Interface,), ITraverser)
 
     def test_virtual_root_no_virtual_root_path(self):
@@ -967,15 +1018,16 @@ class TestVirtualRoot(unittest.TestCase):
 
     def test_virtual_root_with_virtual_root_path(self):
         from pyramid.interfaces import VH_ROOT_KEY
+
         root = DummyContext()
         root.__parent__ = None
         context = DummyContext()
         context.__name__ = 'one'
         context.__parent__ = root
         traversed_to = DummyContext()
-        environ = {VH_ROOT_KEY:'/one'}
+        environ = {VH_ROOT_KEY: '/one'}
         request = DummyRequest(environ)
-        traverser = make_traverser({'context':traversed_to, 'view_name':''})
+        traverser = make_traverser({'context': traversed_to, 'view_name': ''})
         self._registerTraverser(traverser)
         result = self._callFUT(context, request)
         self.assertEqual(result, traversed_to)
@@ -996,6 +1048,7 @@ class TestVirtualRoot(unittest.TestCase):
         result = self._callFUT(context, request)
         self.assertEqual(result, context)
 
+
 class TraverseTests(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -1005,56 +1058,62 @@ class TraverseTests(unittest.TestCase):
 
     def _callFUT(self, context, name):
         from pyramid.traversal import traverse
+
         return traverse(context, name)
 
     def _registerTraverser(self, traverser):
         from pyramid.threadlocal import get_current_registry
+
         reg = get_current_registry()
         from pyramid.interfaces import ITraverser
         from zope.interface import Interface
+
         reg.registerAdapter(traverser, (Interface,), ITraverser)
 
     def test_request_has_registry(self):
         from pyramid.threadlocal import get_current_registry
+
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, [''])
         self.assertEqual(resource.request.registry, get_current_registry())
 
     def test_list(self):
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, [''])
         self.assertEqual(resource.request.environ['PATH_INFO'], '/')
 
     def test_generator(self):
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
+
         def foo():
             yield ''
+
         self._callFUT(resource, foo())
         self.assertEqual(resource.request.environ['PATH_INFO'], '/')
 
     def test_self_string_found(self):
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, '')
         self.assertEqual(resource.request.environ['PATH_INFO'], '')
 
     def test_self_unicode_found(self):
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, text_(''))
         self.assertEqual(resource.request.environ['PATH_INFO'], '')
 
     def test_self_tuple_found(self):
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, ())
         self.assertEqual(resource.request.environ['PATH_INFO'], '')
@@ -1062,7 +1121,7 @@ class TraverseTests(unittest.TestCase):
     def test_relative_string_found(self):
         resource = DummyContext()
         baz = DummyContext()
-        traverser = make_traverser({'context':baz, 'view_name':''})
+        traverser = make_traverser({'context': baz, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, 'baz')
         self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
@@ -1070,7 +1129,7 @@ class TraverseTests(unittest.TestCase):
     def test_relative_tuple_found(self):
         resource = DummyContext()
         baz = DummyContext()
-        traverser = make_traverser({'context':baz, 'view_name':''})
+        traverser = make_traverser({'context': baz, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, ('baz',))
         self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
@@ -1080,7 +1139,7 @@ class TraverseTests(unittest.TestCase):
         resource = DummyContext()
         resource.__parent__ = root
         resource.__name__ = 'baz'
-        traverser = make_traverser({'context':root, 'view_name':''})
+        traverser = make_traverser({'context': root, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, '/')
         self.assertEqual(root.wascontext, True)
@@ -1091,7 +1150,7 @@ class TraverseTests(unittest.TestCase):
         resource = DummyContext()
         resource.__parent__ = root
         resource.__name__ = 'baz'
-        traverser = make_traverser({'context':root, 'view_name':''})
+        traverser = make_traverser({'context': root, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, ('',))
         self.assertEqual(root.wascontext, True)
@@ -1102,7 +1161,7 @@ class TraverseTests(unittest.TestCase):
         resource = DummyContext()
         resource.__parent__ = root
         resource.__name__ = 'baz'
-        traverser = make_traverser({'context':root, 'view_name':''})
+        traverser = make_traverser({'context': root, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, [])
         self.assertEqual(resource.wascontext, True)
@@ -1118,19 +1177,24 @@ class TraverseTests(unittest.TestCase):
         from pyramid.interfaces import IRequestFactory
         from pyramid.request import Request
         from pyramid.threadlocal import get_current_registry
+
         reg = get_current_registry()
+
         class MyRequest(Request):
             pass
+
         reg.registerUtility(MyRequest, IRequestFactory)
         resource = DummyContext()
-        traverser = make_traverser({'context':resource, 'view_name':''})
+        traverser = make_traverser({'context': resource, 'view_name': ''})
         self._registerTraverser(traverser)
         self._callFUT(resource, [''])
         self.assertEqual(resource.request.__class__, MyRequest)
 
+
 class TestDefaultRootFactory(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.traversal import DefaultRootFactory
+
         return DefaultRootFactory
 
     def _makeOne(self, environ):
@@ -1139,13 +1203,16 @@ class TestDefaultRootFactory(unittest.TestCase):
     def test_it(self):
         class DummyRequest(object):
             pass
+
         root = self._makeOne(DummyRequest())
         self.assertEqual(root.__parent__, None)
         self.assertEqual(root.__name__, None)
 
+
 class Test__join_path_tuple(unittest.TestCase):
     def _callFUT(self, tup):
         from pyramid.traversal import _join_path_tuple
+
         return _join_path_tuple(tup)
 
     def test_empty_tuple(self):
@@ -1158,12 +1225,25 @@ class Test__join_path_tuple(unittest.TestCase):
         self.assertEqual(result, 'x')
 
     def test_segments_with_unsafes(self):
-        safe_segments = tuple(u"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=:@")
+        safe_segments = tuple(
+            u"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=:@"
+        )
         result = self._callFUT(safe_segments)
         self.assertEqual(result, u'/'.join(safe_segments))
-        unsafe_segments = tuple(chr(i) for i in range(0x20, 0x80) if not chr(i) in safe_segments) + (u'あ',)
+        unsafe_segments = tuple(
+            chr(i) for i in range(0x20, 0x80) if not chr(i) in safe_segments
+        ) + (u'あ',)
         result = self._callFUT(unsafe_segments)
-        self.assertEqual(result, u'/'.join(''.join('%%%02X' % (ord(c) if isinstance(c, str) else c) for c in unsafe_segment.encode('utf-8')) for unsafe_segment in unsafe_segments))
+        self.assertEqual(
+            result,
+            u'/'.join(
+                ''.join(
+                    '%%%02X' % (ord(c) if isinstance(c, str) else c)
+                    for c in unsafe_segment.encode('utf-8')
+                )
+                for unsafe_segment in unsafe_segments
+            ),
+        )
 
 
 def make_traverser(result):
@@ -1171,13 +1251,17 @@ def make_traverser(result):
         def __init__(self, context):
             self.context = context
             context.wascontext = True
+
         def __call__(self, request):
             self.context.request = request
             return result
+
     return DummyTraverser
 
+
 class DummyContext(object):
     __parent__ = None
+
     def __init__(self, next=None, name=None):
         self.next = next
         self.__name__ = name
@@ -1188,11 +1272,17 @@ class DummyContext(object):
         return self.next
 
     def __repr__(self):
-        return '<DummyContext with name %s at id %s>'%(self.__name__, id(self))
+        return '<DummyContext with name %s at id %s>' % (
+            self.__name__,
+            id(self),
+        )
+
 
 class DummyRequest:
 
-    application_url = 'http://example.com:5432' # app_url never ends with slash
+    application_url = (
+        'http://example.com:5432'
+    )  # app_url never ends with slash
     matchdict = None
     matched_route = None
 
@@ -1212,10 +1302,11 @@ class DummyRequest:
         self._path_info = v
 
     path_info = property(_get_path_info, _set_path_info)
-        
+
 
 def _makeRequest(environ=None):
     from pyramid.registry import Registry
+
     request = DummyRequest()
     request.registry = Registry()
     return request
diff --git a/tests/test_tweens.py b/tests/test_tweens.py
index 2e74ad7cf..ab9b8b0cd 100644
--- a/tests/test_tweens.py
+++ b/tests/test_tweens.py
@@ -1,6 +1,7 @@
 import unittest
 from pyramid import testing
 
+
 class Test_excview_tween_factory(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -10,14 +11,17 @@ class Test_excview_tween_factory(unittest.TestCase):
 
     def _makeOne(self, handler, registry=None):
         from pyramid.tweens import excview_tween_factory
+
         if registry is None:
             registry = self.config.registry
         return excview_tween_factory(handler, registry)
 
     def test_it_passthrough_no_exception(self):
         dummy_response = DummyResponse()
+
         def handler(request):
             return dummy_response
+
         tween = self._makeOne(handler)
         request = DummyRequest()
         result = tween(request)
@@ -28,9 +32,12 @@ class Test_excview_tween_factory(unittest.TestCase):
     def test_it_catches_notfound(self):
         from pyramid.request import Request
         from pyramid.httpexceptions import HTTPNotFound
+
         self.config.add_notfound_view(lambda exc, request: exc)
+
         def handler(request):
             raise HTTPNotFound
+
         tween = self._makeOne(handler)
         request = Request.blank('/')
         request.registry = self.config.registry
@@ -42,11 +49,15 @@ class Test_excview_tween_factory(unittest.TestCase):
     def test_it_catches_with_predicate(self):
         from pyramid.request import Request
         from pyramid.response import Response
+
         def excview(request):
             return Response('foo')
+
         self.config.add_view(excview, context=ValueError, request_method='GET')
+
         def handler(request):
             raise ValueError
+
         tween = self._makeOne(handler)
         request = Request.blank('/')
         request.registry = self.config.registry
@@ -57,10 +68,15 @@ class Test_excview_tween_factory(unittest.TestCase):
 
     def test_it_reraises_on_mismatch(self):
         from pyramid.request import Request
-        def excview(request): pass
+
+        def excview(request):
+            pass
+
         self.config.add_view(excview, context=ValueError, request_method='GET')
+
         def handler(request):
             raise ValueError
+
         tween = self._makeOne(handler)
         request = Request.blank('/')
         request.registry = self.config.registry
@@ -71,8 +87,10 @@ class Test_excview_tween_factory(unittest.TestCase):
 
     def test_it_reraises_on_no_match(self):
         from pyramid.request import Request
+
         def handler(request):
             raise ValueError
+
         tween = self._makeOne(handler)
         request = Request.blank('/')
         request.registry = self.config.registry
@@ -80,9 +98,11 @@ class Test_excview_tween_factory(unittest.TestCase):
         self.assertIsNone(request.exception)
         self.assertIsNone(request.exc_info)
 
+
 class DummyRequest:
     exception = None
     exc_info = None
 
+
 class DummyResponse:
     pass
diff --git a/tests/test_url.py b/tests/test_url.py
index 3d161da21..3acfbc876 100644
--- a/tests/test_url.py
+++ b/tests/test_url.py
@@ -4,10 +4,8 @@ import warnings
 
 from pyramid import testing
 
-from pyramid.compat import (
-    text_,
-    WIN,
-    )
+from pyramid.compat import text_, WIN
+
 
 class TestURLMethodsMixin(unittest.TestCase):
     def setUp(self):
@@ -15,16 +13,20 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def tearDown(self):
         testing.tearDown()
-        
+
     def _makeOne(self, environ=None):
         from pyramid.url import URLMethodsMixin
+
         if environ is None:
             environ = {}
+
         class Request(URLMethodsMixin):
             application_url = 'http://example.com:5432'
             script_name = ''
+
             def __init__(self, environ):
                 self.environ = environ
+
         request = Request(environ)
         request.registry = self.config.registry
         return request
@@ -32,12 +34,17 @@ class TestURLMethodsMixin(unittest.TestCase):
     def _registerResourceURL(self, reg):
         from pyramid.interfaces import IResourceURL
         from zope.interface import Interface
+
         class DummyResourceURL(object):
             physical_path = '/context/'
             virtual_path = '/context/'
-            def __init__(self, context, request): pass
-        reg.registerAdapter(DummyResourceURL, (Interface, Interface),
-                            IResourceURL)
+
+            def __init__(self, context, request):
+                pass
+
+        reg.registerAdapter(
+            DummyResourceURL, (Interface, Interface), IResourceURL
+        )
         return DummyResourceURL
 
     def test_resource_url_root_default(self):
@@ -53,8 +60,8 @@ class TestURLMethodsMixin(unittest.TestCase):
         context = DummyContext()
         result = request.resource_url(context, 'this/theotherthing', 'that')
         self.assertEqual(
-            result,
-            'http://example.com:5432/context/this%2Ftheotherthing/that')
+            result, 'http://example.com:5432/context/this%2Ftheotherthing/that'
+        )
 
     def test_resource_url_unicode_in_element_names(self):
         request = self._makeOne()
@@ -62,16 +69,16 @@ class TestURLMethodsMixin(unittest.TestCase):
         uc = text_(b'La Pe\xc3\xb1a', 'utf-8')
         context = DummyContext()
         result = request.resource_url(context, uc)
-        self.assertEqual(result,
-                     'http://example.com:5432/context/La%20Pe%C3%B1a')
+        self.assertEqual(
+            result, 'http://example.com:5432/context/La%20Pe%C3%B1a'
+        )
 
     def test_resource_url_at_sign_in_element_names(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
         context = DummyContext()
         result = request.resource_url(context, '@@myview')
-        self.assertEqual(result,
-                     'http://example.com:5432/context/@@myview')
+        self.assertEqual(result, 'http://example.com:5432/context/@@myview')
 
     def test_resource_url_element_names_url_quoted(self):
         request = self._makeOne()
@@ -85,68 +92,69 @@ class TestURLMethodsMixin(unittest.TestCase):
         self._registerResourceURL(request.registry)
         context = DummyContext()
         result = request.resource_url(context, 'a', query='(openlayers)')
-        self.assertEqual(result,
-            'http://example.com:5432/context/a?(openlayers)')
+        self.assertEqual(
+            result, 'http://example.com:5432/context/a?(openlayers)'
+        )
 
     def test_resource_url_with_query_dict(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
         context = DummyContext()
         uc = text_(b'La Pe\xc3\xb1a', 'utf-8')
-        result = request.resource_url(context, 'a', query={'a':uc})
-        self.assertEqual(result,
-                         'http://example.com:5432/context/a?a=La+Pe%C3%B1a')
+        result = request.resource_url(context, 'a', query={'a': uc})
+        self.assertEqual(
+            result, 'http://example.com:5432/context/a?a=La+Pe%C3%B1a'
+        )
 
     def test_resource_url_with_query_seq(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
         context = DummyContext()
         uc = text_(b'La Pe\xc3\xb1a', 'utf-8')
-        result = request.resource_url(context, 'a', query=[('a', 'hi there'),
-                                                           ('b', uc)])
-        self.assertEqual(result,
-            'http://example.com:5432/context/a?a=hi+there&b=La+Pe%C3%B1a')
+        result = request.resource_url(
+            context, 'a', query=[('a', 'hi there'), ('b', uc)]
+        )
+        self.assertEqual(
+            result,
+            'http://example.com:5432/context/a?a=hi+there&b=La+Pe%C3%B1a',
+        )
 
     def test_resource_url_with_query_empty(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
         context = DummyContext()
         result = request.resource_url(context, 'a', query=[])
-        self.assertEqual(result,
-            'http://example.com:5432/context/a')
+        self.assertEqual(result, 'http://example.com:5432/context/a')
 
     def test_resource_url_with_query_None(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
         context = DummyContext()
         result = request.resource_url(context, 'a', query=None)
-        self.assertEqual(result,
-            'http://example.com:5432/context/a')
+        self.assertEqual(result, 'http://example.com:5432/context/a')
 
     def test_resource_url_anchor_is_after_root_when_no_elements(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
         context = DummyContext()
         result = request.resource_url(context, anchor='a')
-        self.assertEqual(result,
-                         'http://example.com:5432/context/#a')
+        self.assertEqual(result, 'http://example.com:5432/context/#a')
 
     def test_resource_url_anchor_is_after_elements_when_no_qs(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
         context = DummyContext()
         result = request.resource_url(context, 'a', anchor='b')
-        self.assertEqual(result,
-                         'http://example.com:5432/context/a#b')
+        self.assertEqual(result, 'http://example.com:5432/context/a#b')
 
     def test_resource_url_anchor_is_after_qs_when_qs_is_present(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
         context = DummyContext()
-        result = request.resource_url(context, 'a', 
-                                      query={'b':'c'}, anchor='d')
-        self.assertEqual(result,
-                         'http://example.com:5432/context/a?b=c#d')
+        result = request.resource_url(
+            context, 'a', query={'b': 'c'}, anchor='d'
+        )
+        self.assertEqual(result, 'http://example.com:5432/context/a?b=c#d')
 
     def test_resource_url_anchor_is_encoded_utf8_if_unicode(self):
         request = self._makeOne()
@@ -154,16 +162,16 @@ class TestURLMethodsMixin(unittest.TestCase):
         context = DummyContext()
         uc = text_(b'La Pe\xc3\xb1a', 'utf-8')
         result = request.resource_url(context, anchor=uc)
-        self.assertEqual(result,
-                         'http://example.com:5432/context/#La%20Pe%C3%B1a')
+        self.assertEqual(
+            result, 'http://example.com:5432/context/#La%20Pe%C3%B1a'
+        )
 
     def test_resource_url_anchor_is_urlencoded_safe(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
         context = DummyContext()
         result = request.resource_url(context, anchor=' /#?&+')
-        self.assertEqual(result,
-                         'http://example.com:5432/context/#%20/%23?&+')
+        self.assertEqual(result, 'http://example.com:5432/context/#%20/%23?&+')
 
     def test_resource_url_anchor_is_None(self):
         request = self._makeOne()
@@ -189,7 +197,7 @@ class TestURLMethodsMixin(unittest.TestCase):
         root = DummyContext()
         result = request.resource_url(root)
         self.assertEqual(result, 'http://example.com:5432/context/')
-        
+
     def test_resource_url_with_app_url(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
@@ -199,10 +207,10 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_resource_url_with_scheme(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         self._registerResourceURL(request.registry)
         root = DummyContext()
@@ -211,10 +219,10 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_resource_url_with_host(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         self._registerResourceURL(request.registry)
         root = DummyContext()
@@ -223,10 +231,10 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_resource_url_with_port(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         self._registerResourceURL(request.registry)
         root = DummyContext()
@@ -235,30 +243,33 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_resource_url_with_local_url(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         self._registerResourceURL(request.registry)
         root = DummyContext()
+
         def resource_url(req, info):
             self.assertEqual(req, request)
             self.assertEqual(info['virtual_path'], '/context/')
             self.assertEqual(info['physical_path'], '/context/')
             self.assertEqual(info['app_url'], 'http://example.com:5432')
             return 'http://example.com/contextabc/'
+
         root.__resource_url__ = resource_url
         result = request.resource_url(root)
         self.assertEqual(result, 'http://example.com/contextabc/')
 
     def test_resource_url_with_route_name_no_remainder_on_adapter(self):
         from pyramid.interfaces import IRoutesMapper
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         adapter = self._registerResourceURL(request.registry)
         # no virtual_path_tuple on adapter
@@ -273,11 +284,12 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_resource_url_with_route_name_remainder_on_adapter(self):
         from pyramid.interfaces import IRoutesMapper
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         adapter = self._registerResourceURL(request.registry)
         # virtual_path_tuple on adapter
@@ -292,11 +304,12 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_resource_url_with_route_name_and_app_url(self):
         from pyramid.interfaces import IRoutesMapper
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         adapter = self._registerResourceURL(request.registry)
         # virtual_path_tuple on adapter
@@ -305,17 +318,20 @@ class TestURLMethodsMixin(unittest.TestCase):
         mapper = DummyRoutesMapper(route)
         request.registry.registerUtility(mapper, IRoutesMapper)
         root = DummyContext()
-        result = request.resource_url(root, route_name='foo', app_url='app_url')
+        result = request.resource_url(
+            root, route_name='foo', app_url='app_url'
+        )
         self.assertEqual(result, 'app_url/1/2/3')
         self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')})
 
     def test_resource_url_with_route_name_and_scheme_host_port_etc(self):
         from pyramid.interfaces import IRoutesMapper
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         adapter = self._registerResourceURL(request.registry)
         # virtual_path_tuple on adapter
@@ -324,19 +340,26 @@ class TestURLMethodsMixin(unittest.TestCase):
         mapper = DummyRoutesMapper(route)
         request.registry.registerUtility(mapper, IRoutesMapper)
         root = DummyContext()
-        result = request.resource_url(root, route_name='foo', scheme='scheme',
-                                      host='host', port='port', query={'a':'1'},
-                                      anchor='anchor')
+        result = request.resource_url(
+            root,
+            route_name='foo',
+            scheme='scheme',
+            host='host',
+            port='port',
+            query={'a': '1'},
+            anchor='anchor',
+        )
         self.assertEqual(result, 'scheme://host:port/1/2/3?a=1#anchor')
         self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')})
 
     def test_resource_url_with_route_name_and_route_kwargs(self):
         from pyramid.interfaces import IRoutesMapper
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         adapter = self._registerResourceURL(request.registry)
         # virtual_path_tuple on adapter
@@ -346,22 +369,21 @@ class TestURLMethodsMixin(unittest.TestCase):
         request.registry.registerUtility(mapper, IRoutesMapper)
         root = DummyContext()
         result = request.resource_url(
-            root, route_name='foo', route_kw={'a':'1', 'b':'2'})
+            root, route_name='foo', route_kw={'a': '1', 'b': '2'}
+        )
         self.assertEqual(result, 'http://example.com:5432/1/2/3')
         self.assertEqual(
-            route.kw,
-            {'traverse': ('', 'a', 'b', 'c', ''),
-             'a':'1',
-             'b':'2'}
-            )
+            route.kw, {'traverse': ('', 'a', 'b', 'c', ''), 'a': '1', 'b': '2'}
+        )
 
     def test_resource_url_with_route_name_and_elements(self):
         from pyramid.interfaces import IRoutesMapper
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         adapter = self._registerResourceURL(request.registry)
         # virtual_path_tuple on adapter
@@ -371,16 +393,17 @@ class TestURLMethodsMixin(unittest.TestCase):
         request.registry.registerUtility(mapper, IRoutesMapper)
         root = DummyContext()
         result = request.resource_url(root, 'e1', 'e2', route_name='foo')
-        self.assertEqual(result,  'http://example.com:5432/1/2/3/e1/e2')
+        self.assertEqual(result, 'http://example.com:5432/1/2/3/e1/e2')
         self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')})
-        
+
     def test_resource_url_with_route_name_and_remainder_name(self):
         from pyramid.interfaces import IRoutesMapper
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'8080',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '8080',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         adapter = self._registerResourceURL(request.registry)
         # virtual_path_tuple on adapter
@@ -389,11 +412,12 @@ class TestURLMethodsMixin(unittest.TestCase):
         mapper = DummyRoutesMapper(route)
         request.registry.registerUtility(mapper, IRoutesMapper)
         root = DummyContext()
-        result = request.resource_url(root, route_name='foo',
-                                      route_remainder_name='fred')
+        result = request.resource_url(
+            root, route_name='foo', route_remainder_name='fred'
+        )
         self.assertEqual(result, 'http://example.com:5432/1/2/3')
         self.assertEqual(route.kw, {'fred': ('', 'a', 'b', 'c', '')})
-        
+
     def test_resource_path(self):
         request = self._makeOne()
         self._registerResourceURL(request.registry)
@@ -407,37 +431,39 @@ class TestURLMethodsMixin(unittest.TestCase):
         root = DummyContext()
         result = request.resource_path(root, anchor='abc')
         self.assertEqual(result, '/context/#abc')
-        
+
     def test_route_url_with_elements(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', 'extra1', 'extra2')
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3/extra1/extra2')
+        self.assertEqual(result, 'http://example.com:5432/1/2/3/extra1/extra2')
 
     def test_route_url_with_elements_path_endswith_slash(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3/'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', 'extra1', 'extra2')
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3/extra1/extra2')
+        self.assertEqual(result, 'http://example.com:5432/1/2/3/extra1/extra2')
 
     def test_route_url_no_elements(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
-        result = request.route_url('flub', a=1, b=2, c=3, _query={'a':1},
-                                   _anchor=text_(b"foo"))
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3?a=1#foo')
+        result = request.route_url(
+            'flub', a=1, b=2, c=3, _query={'a': 1}, _anchor=text_(b"foo")
+        )
+        self.assertEqual(result, 'http://example.com:5432/1/2/3?a=1#foo')
 
     def test_route_url_with_query_None(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
@@ -446,27 +472,32 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_route_url_with_anchor_binary(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', _anchor=b"La Pe\xc3\xb1a")
 
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3#La%20Pe%C3%B1a')
+        self.assertEqual(
+            result, 'http://example.com:5432/1/2/3#La%20Pe%C3%B1a'
+        )
 
     def test_route_url_with_anchor_unicode(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         anchor = text_(b'La Pe\xc3\xb1a', 'utf-8')
         result = request.route_url('flub', _anchor=anchor)
 
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3#La%20Pe%C3%B1a')
+        self.assertEqual(
+            result, 'http://example.com:5432/1/2/3#La%20Pe%C3%B1a'
+        )
 
     def test_route_url_with_anchor_None(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
@@ -476,83 +507,81 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_route_url_with_query(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
-        result = request.route_url('flub', _query={'q':'1'})
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3?q=1')
+        result = request.route_url('flub', _query={'q': '1'})
+        self.assertEqual(result, 'http://example.com:5432/1/2/3?q=1')
 
     def test_route_url_with_query_str(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', _query='(openlayers)')
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3?(openlayers)')
+        self.assertEqual(result, 'http://example.com:5432/1/2/3?(openlayers)')
 
     def test_route_url_with_empty_query(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', _query={})
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3')
+        self.assertEqual(result, 'http://example.com:5432/1/2/3')
 
     def test_route_url_with_app_url(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', _app_url='http://example2.com')
-        self.assertEqual(result,
-                         'http://example2.com/1/2/3')
+        self.assertEqual(result, 'http://example2.com/1/2/3')
 
     def test_route_url_with_host(self):
         from pyramid.interfaces import IRoutesMapper
-        environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'5432',
-            }
+
+        environ = {'wsgi.url_scheme': 'http', 'SERVER_PORT': '5432'}
         request = self._makeOne(environ)
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', _host='someotherhost.com')
-        self.assertEqual(result,
-                         'http://someotherhost.com:5432/1/2/3')
+        self.assertEqual(result, 'http://someotherhost.com:5432/1/2/3')
 
     def test_route_url_with_port(self):
         from pyramid.interfaces import IRoutesMapper
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'5432',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '5432',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', _port='8080')
-        self.assertEqual(result,
-                         'http://example.com:8080/1/2/3')
+        self.assertEqual(result, 'http://example.com:8080/1/2/3')
 
     def test_route_url_with_scheme(self):
         from pyramid.interfaces import IRoutesMapper
+
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_PORT':'5432',
-            'SERVER_NAME':'example.com',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_PORT': '5432',
+            'SERVER_NAME': 'example.com',
+        }
         request = self._makeOne(environ)
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', _scheme='https')
-        self.assertEqual(result,
-                         'https://example.com/1/2/3')
-        
+        self.assertEqual(result, 'https://example.com/1/2/3')
+
     def test_route_url_generation_error(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(raise_exc=KeyError)
         request.registry.registerUtility(mapper, IRoutesMapper)
@@ -561,50 +590,59 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_route_url_generate_doesnt_receive_query_or_anchor(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         route = DummyRoute(result='')
         mapper = DummyRoutesMapper(route=route)
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', _query=dict(name='some_name'))
-        self.assertEqual(route.kw, {}) # shouldnt have anchor/query
+        self.assertEqual(route.kw, {})  # shouldnt have anchor/query
         self.assertEqual(result, 'http://example.com:5432?name=some_name')
 
     def test_route_url_with_pregenerator(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         route = DummyRoute(result='/1/2/3')
+
         def pregenerator(request, elements, kw):
-            return ('a',), {'_app_url':'http://example2.com'}
+            return ('a',), {'_app_url': 'http://example2.com'}
+
         route.pregenerator = pregenerator
         mapper = DummyRoutesMapper(route=route)
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub')
-        self.assertEqual(result,  'http://example2.com/1/2/3/a')
-        self.assertEqual(route.kw, {}) # shouldnt have anchor/query
+        self.assertEqual(result, 'http://example2.com/1/2/3/a')
+        self.assertEqual(route.kw, {})  # shouldnt have anchor/query
 
     def test_route_url_with_anchor_app_url_elements_and_query(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute(result='/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
-        result = request.route_url('flub', 'element1',
-                                   _app_url='http://example2.com',
-                                   _anchor='anchor', _query={'q':'1'})
-        self.assertEqual(result,
-                         'http://example2.com/1/2/3/element1?q=1#anchor')
+        result = request.route_url(
+            'flub',
+            'element1',
+            _app_url='http://example2.com',
+            _anchor='anchor',
+            _query={'q': '1'},
+        )
+        self.assertEqual(
+            result, 'http://example2.com/1/2/3/element1?q=1#anchor'
+        )
 
     def test_route_url_integration_with_real_request(self):
         # to try to replicate https://github.com/Pylons/pyramid/issues/213
         from pyramid.interfaces import IRoutesMapper
         from pyramid.request import Request
+
         request = Request.blank('/')
         request.registry = self.config.registry
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.route_url('flub', 'extra1', 'extra2')
-        self.assertEqual(result,
-                         'http://localhost/1/2/3/extra1/extra2')
-        
+        self.assertEqual(result, 'http://localhost/1/2/3/extra1/extra2')
 
     def test_current_route_url_current_request_has_no_route(self):
         request = self._makeOne()
@@ -612,34 +650,44 @@ class TestURLMethodsMixin(unittest.TestCase):
 
     def test_current_route_url_with_elements_query_and_anchor(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         route = DummyRoute('/1/2/3')
         mapper = DummyRoutesMapper(route=route)
         request.matched_route = route
         request.matchdict = {}
         request.registry.registerUtility(mapper, IRoutesMapper)
-        result = request.current_route_url('extra1', 'extra2', _query={'a':1},
-                                           _anchor=text_(b"foo"))
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo')
+        result = request.current_route_url(
+            'extra1', 'extra2', _query={'a': 1}, _anchor=text_(b"foo")
+        )
+        self.assertEqual(
+            result, 'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo'
+        )
 
     def test_current_route_url_with_route_name(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         route = DummyRoute('/1/2/3')
         mapper = DummyRoutesMapper(route=route)
         request.matched_route = route
         request.matchdict = {}
         request.registry.registerUtility(mapper, IRoutesMapper)
-        result = request.current_route_url('extra1', 'extra2', _query={'a':1},
-                                           _anchor=text_(b"foo"),
-                                           _route_name='bar')
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo')
+        result = request.current_route_url(
+            'extra1',
+            'extra2',
+            _query={'a': 1},
+            _anchor=text_(b"foo"),
+            _route_name='bar',
+        )
+        self.assertEqual(
+            result, 'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo'
+        )
 
     def test_current_route_url_with_request_query(self):
         from pyramid.interfaces import IRoutesMapper
         from webob.multidict import GetDict
+
         request = self._makeOne()
         request.GET = GetDict([('q', '123')], {})
         route = DummyRoute('/1/2/3')
@@ -648,27 +696,30 @@ class TestURLMethodsMixin(unittest.TestCase):
         request.matchdict = {}
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.current_route_url()
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3?q=123')
+        self.assertEqual(result, 'http://example.com:5432/1/2/3?q=123')
 
     def test_current_route_url_with_request_query_duplicate_entries(self):
         from pyramid.interfaces import IRoutesMapper
         from webob.multidict import GetDict
+
         request = self._makeOne()
         request.GET = GetDict(
-            [('q', '123'), ('b', '2'), ('b', '2'), ('q', '456')], {})
+            [('q', '123'), ('b', '2'), ('b', '2'), ('q', '456')], {}
+        )
         route = DummyRoute('/1/2/3')
         mapper = DummyRoutesMapper(route=route)
         request.matched_route = route
         request.matchdict = {}
         request.registry.registerUtility(mapper, IRoutesMapper)
         result = request.current_route_url()
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3?q=123&b=2&b=2&q=456')
+        self.assertEqual(
+            result, 'http://example.com:5432/1/2/3?q=123&b=2&b=2&q=456'
+        )
 
     def test_current_route_url_with_query_override(self):
         from pyramid.interfaces import IRoutesMapper
         from webob.multidict import GetDict
+
         request = self._makeOne()
         request.GET = GetDict([('q', '123')], {})
         route = DummyRoute('/1/2/3')
@@ -676,12 +727,12 @@ class TestURLMethodsMixin(unittest.TestCase):
         request.matched_route = route
         request.matchdict = {}
         request.registry.registerUtility(mapper, IRoutesMapper)
-        result = request.current_route_url(_query={'a':1})
-        self.assertEqual(result,
-                         'http://example.com:5432/1/2/3?a=1')
+        result = request.current_route_url(_query={'a': 1})
+        self.assertEqual(result, 'http://example.com:5432/1/2/3?a=1')
 
     def test_current_route_path(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         route = DummyRoute('/1/2/3')
         mapper = DummyRoutesMapper(route=route)
@@ -689,38 +740,56 @@ class TestURLMethodsMixin(unittest.TestCase):
         request.matchdict = {}
         request.script_name = '/script_name'
         request.registry.registerUtility(mapper, IRoutesMapper)
-        result = request.current_route_path('extra1', 'extra2', _query={'a':1},
-                                            _anchor=text_(b"foo"))
+        result = request.current_route_path(
+            'extra1', 'extra2', _query={'a': 1}, _anchor=text_(b"foo")
+        )
         self.assertEqual(result, '/script_name/1/2/3/extra1/extra2?a=1#foo')
 
     def test_route_path_with_elements(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
         request.script_name = ''
-        result = request.route_path('flub', 'extra1', 'extra2',
-                                    a=1, b=2, c=3, _query={'a':1},
-                                    _anchor=text_(b"foo"))
+        result = request.route_path(
+            'flub',
+            'extra1',
+            'extra2',
+            a=1,
+            b=2,
+            c=3,
+            _query={'a': 1},
+            _anchor=text_(b"foo"),
+        )
         self.assertEqual(result, '/1/2/3/extra1/extra2?a=1#foo')
 
     def test_route_path_with_script_name(self):
         from pyramid.interfaces import IRoutesMapper
+
         request = self._makeOne()
         request.script_name = '/foo'
         mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
         request.registry.registerUtility(mapper, IRoutesMapper)
-        result = request.route_path('flub', 'extra1', 'extra2',
-                                    a=1, b=2, c=3, _query={'a':1},
-                                    _anchor=text_(b"foo"))
+        result = request.route_path(
+            'flub',
+            'extra1',
+            'extra2',
+            a=1,
+            b=2,
+            c=3,
+            _query={'a': 1},
+            _anchor=text_(b"foo"),
+        )
         self.assertEqual(result, '/foo/1/2/3/extra1/extra2?a=1#foo')
-        
+
     def test_static_url_staticurlinfo_notfound(self):
         request = self._makeOne()
         self.assertRaises(ValueError, request.static_url, 'static/foo.css')
 
     def test_static_url_abspath(self):
         from pyramid.interfaces import IStaticURLInfo
+
         request = self._makeOne()
         info = DummyStaticURLInfo('abc')
         registry = request.registry
@@ -728,31 +797,34 @@ class TestURLMethodsMixin(unittest.TestCase):
         abspath = makeabs('static', 'foo.css')
         result = request.static_url(abspath)
         self.assertEqual(result, 'abc')
-        self.assertEqual(info.args, (makeabs('static', 'foo.css'), request, {}))
+        self.assertEqual(
+            info.args, (makeabs('static', 'foo.css'), request, {})
+        )
         request = self._makeOne()
 
     def test_static_url_found_rel(self):
         from pyramid.interfaces import IStaticURLInfo
+
         request = self._makeOne()
         info = DummyStaticURLInfo('abc')
         request.registry.registerUtility(info, IStaticURLInfo)
         result = request.static_url('static/foo.css')
         self.assertEqual(result, 'abc')
-        self.assertEqual(info.args,
-                         ('tests:static/foo.css', request, {}) )
+        self.assertEqual(info.args, ('tests:static/foo.css', request, {}))
 
     def test_static_url_abs(self):
         from pyramid.interfaces import IStaticURLInfo
+
         request = self._makeOne()
         info = DummyStaticURLInfo('abc')
         request.registry.registerUtility(info, IStaticURLInfo)
         result = request.static_url('tests:static/foo.css')
         self.assertEqual(result, 'abc')
-        self.assertEqual(info.args,
-                         ('tests:static/foo.css', request, {}) )
+        self.assertEqual(info.args, ('tests:static/foo.css', request, {}))
 
     def test_static_url_found_abs_no_registry_on_request(self):
         from pyramid.interfaces import IStaticURLInfo
+
         request = self._makeOne()
         registry = request.registry
         info = DummyStaticURLInfo('abc')
@@ -760,12 +832,12 @@ class TestURLMethodsMixin(unittest.TestCase):
         del request.registry
         result = request.static_url('tests:static/foo.css')
         self.assertEqual(result, 'abc')
-        self.assertEqual(info.args,
-                         ('tests:static/foo.css', request, {}) )
+        self.assertEqual(info.args, ('tests:static/foo.css', request, {}))
 
     def test_static_url_abspath_integration_with_staticurlinfo(self):
         from pyramid.interfaces import IStaticURLInfo
         from pyramid.config.views import StaticURLInfo
+
         info = StaticURLInfo()
         here = os.path.abspath(os.path.dirname(__file__))
         info.add(self.config, 'absstatic', here)
@@ -774,12 +846,14 @@ class TestURLMethodsMixin(unittest.TestCase):
         registry.registerUtility(info, IStaticURLInfo)
         abspath = os.path.join(here, 'test_url.py')
         result = request.static_url(abspath)
-        self.assertEqual(result,
-                         'http://example.com:5432/absstatic/test_url.py')
+        self.assertEqual(
+            result, 'http://example.com:5432/absstatic/test_url.py'
+        )
 
     def test_static_url_noscheme_uses_scheme_from_request(self):
         from pyramid.interfaces import IStaticURLInfo
         from pyramid.config.views import StaticURLInfo
+
         info = StaticURLInfo()
         here = os.path.abspath(os.path.dirname(__file__))
         info.add(self.config, '//subdomain.example.com/static', here)
@@ -788,11 +862,13 @@ class TestURLMethodsMixin(unittest.TestCase):
         registry.registerUtility(info, IStaticURLInfo)
         abspath = os.path.join(here, 'test_url.py')
         result = request.static_url(abspath)
-        self.assertEqual(result,
-                         'https://subdomain.example.com/static/test_url.py')
+        self.assertEqual(
+            result, 'https://subdomain.example.com/static/test_url.py'
+        )
 
     def test_static_path_abspath(self):
         from pyramid.interfaces import IStaticURLInfo
+
         request = self._makeOne()
         request.script_name = '/foo'
         info = DummyStaticURLInfo('abc')
@@ -801,214 +877,208 @@ class TestURLMethodsMixin(unittest.TestCase):
         abspath = makeabs('static', 'foo.css')
         result = request.static_path(abspath)
         self.assertEqual(result, 'abc')
-        self.assertEqual(info.args, (makeabs('static', 'foo.css'), request,
-                                     {'_app_url':'/foo'})
-                         )
+        self.assertEqual(
+            info.args,
+            (makeabs('static', 'foo.css'), request, {'_app_url': '/foo'}),
+        )
 
     def test_static_path_found_rel(self):
         from pyramid.interfaces import IStaticURLInfo
+
         request = self._makeOne()
         request.script_name = '/foo'
         info = DummyStaticURLInfo('abc')
         request.registry.registerUtility(info, IStaticURLInfo)
         result = request.static_path('static/foo.css')
         self.assertEqual(result, 'abc')
-        self.assertEqual(info.args,
-                         ('tests:static/foo.css', request,
-                          {'_app_url':'/foo'})
-                         )
+        self.assertEqual(
+            info.args, ('tests:static/foo.css', request, {'_app_url': '/foo'})
+        )
 
     def test_static_path_abs(self):
         from pyramid.interfaces import IStaticURLInfo
+
         request = self._makeOne()
         request.script_name = '/foo'
         info = DummyStaticURLInfo('abc')
         request.registry.registerUtility(info, IStaticURLInfo)
         result = request.static_path('tests:static/foo.css')
         self.assertEqual(result, 'abc')
-        self.assertEqual(info.args,
-                         ('tests:static/foo.css', request,
-                          {'_app_url':'/foo'})
-                         )
+        self.assertEqual(
+            info.args, ('tests:static/foo.css', request, {'_app_url': '/foo'})
+        )
 
     def test_static_path(self):
         from pyramid.interfaces import IStaticURLInfo
+
         request = self._makeOne()
         request.script_name = '/foo'
         info = DummyStaticURLInfo('abc')
         request.registry.registerUtility(info, IStaticURLInfo)
         result = request.static_path('static/foo.css')
         self.assertEqual(result, 'abc')
-        self.assertEqual(info.args,
-                         ('tests:static/foo.css', request,
-                          {'_app_url':'/foo'})
-                         )
+        self.assertEqual(
+            info.args, ('tests:static/foo.css', request, {'_app_url': '/foo'})
+        )
 
     def test_partial_application_url_with_http_host_default_port_http(self):
-        environ = {
-            'wsgi.url_scheme':'http',
-            'HTTP_HOST':'example.com:80',
-            }
+        environ = {'wsgi.url_scheme': 'http', 'HTTP_HOST': 'example.com:80'}
         request = self._makeOne(environ)
         result = request._partial_application_url()
         self.assertEqual(result, 'http://example.com')
 
     def test_partial_application_url_with_http_host_default_port_https(self):
-        environ = {
-            'wsgi.url_scheme':'https',
-            'HTTP_HOST':'example.com:443',
-            }
+        environ = {'wsgi.url_scheme': 'https', 'HTTP_HOST': 'example.com:443'}
         request = self._makeOne(environ)
         result = request._partial_application_url()
         self.assertEqual(result, 'https://example.com')
 
     def test_partial_application_url_with_http_host_nondefault_port_http(self):
-        environ = {
-            'wsgi.url_scheme':'http',
-            'HTTP_HOST':'example.com:8080',
-            }
+        environ = {'wsgi.url_scheme': 'http', 'HTTP_HOST': 'example.com:8080'}
         request = self._makeOne(environ)
         result = request._partial_application_url()
         self.assertEqual(result, 'http://example.com:8080')
 
-    def test_partial_application_url_with_http_host_nondefault_port_https(self):
-        environ = {
-            'wsgi.url_scheme':'https',
-            'HTTP_HOST':'example.com:4443',
-            }
+    def test_partial_application_url_with_http_host_nondefault_port_https(
+        self
+    ):
+        environ = {'wsgi.url_scheme': 'https', 'HTTP_HOST': 'example.com:4443'}
         request = self._makeOne(environ)
         result = request._partial_application_url()
         self.assertEqual(result, 'https://example.com:4443')
 
     def test_partial_application_url_with_http_host_no_colon(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'HTTP_HOST':'example.com',
-            'SERVER_PORT':'80',
-            }
+            'wsgi.url_scheme': 'http',
+            'HTTP_HOST': 'example.com',
+            'SERVER_PORT': '80',
+        }
         request = self._makeOne(environ)
         result = request._partial_application_url()
         self.assertEqual(result, 'http://example.com')
 
     def test_partial_application_url_no_http_host(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'80',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '80',
+        }
         request = self._makeOne(environ)
         result = request._partial_application_url()
         self.assertEqual(result, 'http://example.com')
-        
+
     def test_partial_application_replace_port(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'80',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '80',
+        }
         request = self._makeOne(environ)
         result = request._partial_application_url(port=8080)
         self.assertEqual(result, 'http://example.com:8080')
 
     def test_partial_application_replace_scheme_https_special_case(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'80',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '80',
+        }
         request = self._makeOne(environ)
         result = request._partial_application_url(scheme='https')
         self.assertEqual(result, 'https://example.com')
 
     def test_partial_application_replace_scheme_https_special_case_avoid(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'80',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '80',
+        }
         request = self._makeOne(environ)
         result = request._partial_application_url(scheme='https', port='8080')
         self.assertEqual(result, 'https://example.com:8080')
 
     def test_partial_application_replace_scheme_http_special_case(self):
         environ = {
-            'wsgi.url_scheme':'https',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'8080',
-            }
+            'wsgi.url_scheme': 'https',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '8080',
+        }
         request = self._makeOne(environ)
         result = request._partial_application_url(scheme='http')
         self.assertEqual(result, 'http://example.com')
 
     def test_partial_application_replace_scheme_http_special_case_avoid(self):
         environ = {
-            'wsgi.url_scheme':'https',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'8000',
-            }
+            'wsgi.url_scheme': 'https',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '8000',
+        }
         request = self._makeOne(environ)
         result = request._partial_application_url(scheme='http', port='8080')
         self.assertEqual(result, 'http://example.com:8080')
-        
+
     def test_partial_application_replace_host_no_port(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'80',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '80',
+        }
         request = self._makeOne(environ)
         result = request._partial_application_url(host='someotherhost.com')
         self.assertEqual(result, 'http://someotherhost.com')
 
     def test_partial_application_replace_host_with_port(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'8000',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '8000',
+        }
         request = self._makeOne(environ)
-        result = request._partial_application_url(host='someotherhost.com:8080')
+        result = request._partial_application_url(
+            host='someotherhost.com:8080'
+        )
         self.assertEqual(result, 'http://someotherhost.com:8080')
 
     def test_partial_application_replace_host_and_port(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'80',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '80',
+        }
         request = self._makeOne(environ)
-        result = request._partial_application_url(host='someotherhost.com:8080',
-                                                  port='8000')
+        result = request._partial_application_url(
+            host='someotherhost.com:8080', port='8000'
+        )
         self.assertEqual(result, 'http://someotherhost.com:8000')
 
     def test_partial_application_replace_host_port_and_scheme(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'80',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '80',
+        }
         request = self._makeOne(environ)
         result = request._partial_application_url(
-            host='someotherhost.com:8080',
-            port='8000',
-            scheme='https',
-            )
+            host='someotherhost.com:8080', port='8000', scheme='https'
+        )
         self.assertEqual(result, 'https://someotherhost.com:8000')
-        
+
     def test_partial_application_url_with_custom_script_name(self):
         environ = {
-            'wsgi.url_scheme':'http',
-            'SERVER_NAME':'example.com',
-            'SERVER_PORT':'8000',
-            }
+            'wsgi.url_scheme': 'http',
+            'SERVER_NAME': 'example.com',
+            'SERVER_PORT': '8000',
+        }
         request = self._makeOne(environ)
         request.script_name = '/abc'
         result = request._partial_application_url()
-        self.assertEqual(result, 'http://example.com:8000/abc') 
-        
+        self.assertEqual(result, 'http://example.com:8000/abc')
+
+
 class Test_route_url(unittest.TestCase):
     def _callFUT(self, route_name, request, *elements, **kw):
         from pyramid.url import route_url
+
         return route_url(route_name, request, *elements, **kw)
 
     def _makeRequest(self):
@@ -1018,6 +1088,7 @@ class Test_route_url(unittest.TestCase):
                 self.elements = elements
                 self.kw = kw
                 return 'route url'
+
         return Request()
 
     def test_it(self):
@@ -1026,11 +1097,13 @@ class Test_route_url(unittest.TestCase):
         self.assertEqual(result, 'route url')
         self.assertEqual(request.route_name, 'abc')
         self.assertEqual(request.elements, ('a',))
-        self.assertEqual(request.kw, {'_app_url':''})
+        self.assertEqual(request.kw, {'_app_url': ''})
+
 
 class Test_route_path(unittest.TestCase):
     def _callFUT(self, route_name, request, *elements, **kw):
         from pyramid.url import route_path
+
         return route_path(route_name, request, *elements, **kw)
 
     def _makeRequest(self):
@@ -1040,6 +1113,7 @@ class Test_route_path(unittest.TestCase):
                 self.elements = elements
                 self.kw = kw
                 return 'route path'
+
         return Request()
 
     def test_it(self):
@@ -1048,11 +1122,13 @@ class Test_route_path(unittest.TestCase):
         self.assertEqual(result, 'route path')
         self.assertEqual(request.route_name, 'abc')
         self.assertEqual(request.elements, ('a',))
-        self.assertEqual(request.kw, {'_app_url':''})
+        self.assertEqual(request.kw, {'_app_url': ''})
+
 
 class Test_resource_url(unittest.TestCase):
     def _callFUT(self, resource, request, *elements, **kw):
         from pyramid.url import resource_url
+
         return resource_url(resource, request, *elements, **kw)
 
     def _makeRequest(self):
@@ -1062,6 +1138,7 @@ class Test_resource_url(unittest.TestCase):
                 self.elements = elements
                 self.kw = kw
                 return 'resource url'
+
         return Request()
 
     def test_it(self):
@@ -1070,11 +1147,13 @@ class Test_resource_url(unittest.TestCase):
         self.assertEqual(result, 'resource url')
         self.assertEqual(request.resource, 'abc')
         self.assertEqual(request.elements, ('a',))
-        self.assertEqual(request.kw, {'_app_url':''})
+        self.assertEqual(request.kw, {'_app_url': ''})
+
 
 class Test_static_url(unittest.TestCase):
     def _callFUT(self, path, request, **kw):
         from pyramid.url import static_url
+
         return static_url(path, request, **kw)
 
     def _makeRequest(self):
@@ -1083,6 +1162,7 @@ class Test_static_url(unittest.TestCase):
                 self.path = path
                 self.kw = kw
                 return 'static url'
+
         return Request()
 
     def test_it_abs(self):
@@ -1090,25 +1170,27 @@ class Test_static_url(unittest.TestCase):
         result = self._callFUT('/foo/bar/abc', request, _app_url='')
         self.assertEqual(result, 'static url')
         self.assertEqual(request.path, '/foo/bar/abc')
-        self.assertEqual(request.kw, {'_app_url':''})
+        self.assertEqual(request.kw, {'_app_url': ''})
 
     def test_it_absspec(self):
         request = self._makeRequest()
         result = self._callFUT('foo:abc', request, _anchor='anchor')
         self.assertEqual(result, 'static url')
         self.assertEqual(request.path, 'foo:abc')
-        self.assertEqual(request.kw, {'_anchor':'anchor'})
+        self.assertEqual(request.kw, {'_anchor': 'anchor'})
 
     def test_it_rel(self):
         request = self._makeRequest()
         result = self._callFUT('abc', request, _app_url='')
         self.assertEqual(result, 'static url')
         self.assertEqual(request.path, 'tests:abc')
-        self.assertEqual(request.kw, {'_app_url':''})
+        self.assertEqual(request.kw, {'_app_url': ''})
+
 
 class Test_static_path(unittest.TestCase):
     def _callFUT(self, path, request, **kw):
         from pyramid.url import static_path
+
         return static_path(path, request, **kw)
 
     def _makeRequest(self):
@@ -1117,6 +1199,7 @@ class Test_static_path(unittest.TestCase):
                 self.path = path
                 self.kw = kw
                 return 'static path'
+
         return Request()
 
     def test_it_abs(self):
@@ -1124,25 +1207,27 @@ class Test_static_path(unittest.TestCase):
         result = self._callFUT('/foo/bar/abc', request, _anchor='anchor')
         self.assertEqual(result, 'static path')
         self.assertEqual(request.path, '/foo/bar/abc')
-        self.assertEqual(request.kw, {'_anchor':'anchor'})
+        self.assertEqual(request.kw, {'_anchor': 'anchor'})
 
     def test_it_absspec(self):
         request = self._makeRequest()
         result = self._callFUT('foo:abc', request, _anchor='anchor')
         self.assertEqual(result, 'static path')
         self.assertEqual(request.path, 'foo:abc')
-        self.assertEqual(request.kw, {'_anchor':'anchor'})
+        self.assertEqual(request.kw, {'_anchor': 'anchor'})
 
     def test_it_rel(self):
         request = self._makeRequest()
         result = self._callFUT('abc', request, _app_url='')
         self.assertEqual(result, 'static path')
         self.assertEqual(request.path, 'tests:abc')
-        self.assertEqual(request.kw, {'_app_url':''})
+        self.assertEqual(request.kw, {'_app_url': ''})
+
 
 class Test_current_route_url(unittest.TestCase):
     def _callFUT(self, request, *elements, **kw):
         from pyramid.url import current_route_url
+
         return current_route_url(request, *elements, **kw)
 
     def _makeRequest(self):
@@ -1151,6 +1236,7 @@ class Test_current_route_url(unittest.TestCase):
                 self.elements = elements
                 self.kw = kw
                 return 'current route url'
+
         return Request()
 
     def test_it(self):
@@ -1158,11 +1244,13 @@ class Test_current_route_url(unittest.TestCase):
         result = self._callFUT(request, 'abc', _app_url='')
         self.assertEqual(result, 'current route url')
         self.assertEqual(request.elements, ('abc',))
-        self.assertEqual(request.kw, {'_app_url':''})
+        self.assertEqual(request.kw, {'_app_url': ''})
+
 
 class Test_current_route_path(unittest.TestCase):
     def _callFUT(self, request, *elements, **kw):
         from pyramid.url import current_route_path
+
         return current_route_path(request, *elements, **kw)
 
     def _makeRequest(self):
@@ -1171,6 +1259,7 @@ class Test_current_route_path(unittest.TestCase):
                 self.elements = elements
                 self.kw = kw
                 return 'current route path'
+
         return Request()
 
     def test_it(self):
@@ -1178,10 +1267,10 @@ class Test_current_route_path(unittest.TestCase):
         result = self._callFUT(request, 'abc', _anchor='abc')
         self.assertEqual(result, 'current route path')
         self.assertEqual(request.elements, ('abc',))
-        self.assertEqual(request.kw, {'_anchor':'abc'})
+        self.assertEqual(request.kw, {'_anchor': 'abc'})
 
-class Test_external_static_url_integration(unittest.TestCase):
 
+class Test_external_static_url_integration(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
 
@@ -1190,6 +1279,7 @@ class Test_external_static_url_integration(unittest.TestCase):
 
     def _makeRequest(self):
         from pyramid.request import Request
+
         return Request.blank('/')
 
     def test_generate_external_url(self):
@@ -1197,16 +1287,16 @@ class Test_external_static_url_integration(unittest.TestCase):
         request = self._makeRequest()
         request.registry = self.config.registry
         self.assertEqual(
-            request.route_url('acme', foo='bar'),
-            'https://acme.org/path/bar')
+            request.route_url('acme', foo='bar'), 'https://acme.org/path/bar'
+        )
 
     def test_generate_external_url_without_scheme(self):
         self.config.add_route('acme', '//acme.org/path/{foo}')
         request = self._makeRequest()
         request.registry = self.config.registry
         self.assertEqual(
-            request.route_url('acme', foo='bar'),
-            'http://acme.org/path/bar')
+            request.route_url('acme', foo='bar'), 'http://acme.org/path/bar'
+        )
 
     def test_generate_external_url_with_explicit_scheme(self):
         self.config.add_route('acme', '//acme.org/path/{foo}')
@@ -1214,14 +1304,20 @@ class Test_external_static_url_integration(unittest.TestCase):
         request.registry = self.config.registry
         self.assertEqual(
             request.route_url('acme', foo='bar', _scheme='https'),
-            'https://acme.org/path/bar')
+            'https://acme.org/path/bar',
+        )
 
     def test_generate_external_url_with_explicit_app_url(self):
         self.config.add_route('acme', 'http://acme.org/path/{foo}')
         request = self._makeRequest()
         request.registry = self.config.registry
-        self.assertRaises(ValueError,
-            request.route_url, 'acme', foo='bar', _app_url='http://fakeme.com')
+        self.assertRaises(
+            ValueError,
+            request.route_url,
+            'acme',
+            foo='bar',
+            _app_url='http://fakeme.com',
+        )
 
     def test_generate_external_url_route_path(self):
         self.config.add_route('acme', 'https://acme.org/path/{foo}')
@@ -1233,26 +1329,30 @@ class Test_external_static_url_integration(unittest.TestCase):
         def pregenerator(request, elements, kw):
             kw['_query'] = {'q': 'foo'}
             return elements, kw
-        self.config.add_route('acme', 'https://acme.org/path/{foo}',
-                              pregenerator=pregenerator)
+
+        self.config.add_route(
+            'acme', 'https://acme.org/path/{foo}', pregenerator=pregenerator
+        )
         request = self._makeRequest()
         request.registry = self.config.registry
         self.assertEqual(
             request.route_url('acme', foo='bar'),
-            'https://acme.org/path/bar?q=foo')
+            'https://acme.org/path/bar?q=foo',
+        )
 
     def test_external_url_with_route_prefix(self):
         def includeme(config):
             config.add_route('acme', '//acme.org/{foo}')
+
         self.config.include(includeme, route_prefix='some_prefix')
         request = self._makeRequest()
         request.registry = self.config.registry
         self.assertEqual(
-            request.route_url('acme', foo='bar'),
-            'http://acme.org/bar')
+            request.route_url('acme', foo='bar'), 'http://acme.org/bar'
+        )
 
-class Test_with_route_prefix(unittest.TestCase):
 
+class Test_with_route_prefix(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
 
@@ -1261,6 +1361,7 @@ class Test_with_route_prefix(unittest.TestCase):
 
     def _makeRequest(self, route):
         from pyramid.request import Request
+
         return Request.blank(route)
 
     def test_old_route_is_preserved(self):
@@ -1288,10 +1389,7 @@ class Test_with_route_prefix(unittest.TestCase):
         with self.config.route_prefix_context('bar'):
             self.config.add_route('acme', '/foo')
         request = self._makeRequest('/')
-        self.assertEqual(
-            request.route_url('acme'),
-            'http://localhost/bar/foo',
-        )
+        self.assertEqual(request.route_url('acme'), 'http://localhost/bar/foo')
 
     def test_route_does_not_have_prefix(self):
         with self.config.route_prefix_context('bar'):
@@ -1299,10 +1397,7 @@ class Test_with_route_prefix(unittest.TestCase):
 
         self.config.add_route('acme', '/foo')
         request = self._makeRequest('/')
-        self.assertEqual(
-            request.route_url('acme'),
-            'http://localhost/foo',
-        )
+        self.assertEqual(request.route_url('acme'), 'http://localhost/foo')
 
     def test_error_reset_prefix(self):
         self.config.route_prefix = 'old_prefix'
@@ -1315,28 +1410,34 @@ class Test_with_route_prefix(unittest.TestCase):
 
         assert self.config.route_prefix == 'old_prefix'
 
+
 class DummyContext(object):
     def __init__(self, next=None):
         self.next = next
-        
+
+
 class DummyRoutesMapper:
     raise_exc = None
+
     def __init__(self, route=None, raise_exc=False):
         self.route = route
 
     def get_route(self, route_name):
         return self.route
 
+
 class DummyRoute:
     pregenerator = None
     name = 'route'
+
     def __init__(self, result='/1/2/3'):
         self.result = result
 
     def generate(self, kw):
         self.kw = kw
         return self.result
-    
+
+
 class DummyStaticURLInfo:
     def __init__(self, result):
         self.result = result
@@ -1344,9 +1445,10 @@ class DummyStaticURLInfo:
     def generate(self, path, request, **kw):
         self.args = path, request, kw
         return self.result
-    
+
+
 def makeabs(*elements):
-    if WIN: # pragma: no cover
+    if WIN:  # pragma: no cover
         return r'c:\\' + os.path.sep.join(elements)
     else:
         return os.path.sep + os.path.sep.join(elements)
diff --git a/tests/test_urldispatch.py b/tests/test_urldispatch.py
index 06f4ad793..e90fbfa0b 100644
--- a/tests/test_urldispatch.py
+++ b/tests/test_urldispatch.py
@@ -1,13 +1,12 @@
 import unittest
 from pyramid import testing
-from pyramid.compat import (
-    text_,
-    PY2,
-    )
+from pyramid.compat import text_, PY2
+
 
 class TestRoute(unittest.TestCase):
     def _getTargetClass(self):
         from pyramid.urldispatch import Route
+
         return Route
 
     def _makeOne(self, *arg):
@@ -16,10 +15,12 @@ class TestRoute(unittest.TestCase):
     def test_provides_IRoute(self):
         from pyramid.interfaces import IRoute
         from zope.interface.verify import verifyObject
+
         verifyObject(IRoute, self._makeOne('name', 'pattern'))
 
     def test_ctor(self):
         import types
+
         route = self._makeOne('name', ':path', 'factory')
         self.assertEqual(route.pattern, ':path')
         self.assertEqual(route.path, ':path')
@@ -30,6 +31,7 @@ class TestRoute(unittest.TestCase):
 
     def test_ctor_defaults(self):
         import types
+
         route = self._makeOne('name', ':path')
         self.assertEqual(route.pattern, ':path')
         self.assertEqual(route.path, ':path')
@@ -40,11 +42,12 @@ class TestRoute(unittest.TestCase):
 
     def test_match(self):
         route = self._makeOne('name', ':path')
-        self.assertEqual(route.match('/whatever'), {'path':'whatever'})
+        self.assertEqual(route.match('/whatever'), {'path': 'whatever'})
 
     def test_generate(self):
         route = self._makeOne('name', ':path')
-        self.assertEqual(route.generate({'path':'abc'}), '/abc')
+        self.assertEqual(route.generate({'path': 'abc'}), '/abc')
+
 
 class RoutesMapperTests(unittest.TestCase):
     def setUp(self):
@@ -52,11 +55,11 @@ class RoutesMapperTests(unittest.TestCase):
 
     def tearDown(self):
         testing.tearDown()
-        
+
     def _getRequest(self, **kw):
         from pyramid.threadlocal import get_current_registry
-        environ = {'SERVER_NAME':'localhost',
-                   'wsgi.url_scheme':'http'}
+
+        environ = {'SERVER_NAME': 'localhost', 'wsgi.url_scheme': 'http'}
         environ.update(kw)
         request = DummyRequest(environ)
         reg = get_current_registry()
@@ -65,6 +68,7 @@ class RoutesMapperTests(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.urldispatch import RoutesMapper
+
         return RoutesMapper
 
     def _makeOne(self):
@@ -74,6 +78,7 @@ class RoutesMapperTests(unittest.TestCase):
     def test_provides_IRoutesMapper(self):
         from pyramid.interfaces import IRoutesMapper
         from zope.interface.verify import verifyObject
+
         verifyObject(IRoutesMapper, self._makeOne())
 
     def test_no_route_matches(self):
@@ -89,36 +94,43 @@ class RoutesMapperTests(unittest.TestCase):
         mapper.connect('foo', 'archives/:action/:article2')
         self.assertEqual(len(mapper.routelist), 1)
         self.assertEqual(len(mapper.routes), 1)
-        self.assertEqual(mapper.routes['foo'].pattern,
-                         'archives/:action/:article2')
-        self.assertEqual(mapper.routelist[0].pattern,
-                         'archives/:action/:article2')
+        self.assertEqual(
+            mapper.routes['foo'].pattern, 'archives/:action/:article2'
+        )
+        self.assertEqual(
+            mapper.routelist[0].pattern, 'archives/:action/:article2'
+        )
 
     def test_connect_static(self):
         mapper = self._makeOne()
         mapper.connect('foo', 'archives/:action/:article', static=True)
         self.assertEqual(len(mapper.routelist), 0)
         self.assertEqual(len(mapper.routes), 1)
-        self.assertEqual(mapper.routes['foo'].pattern,
-                         'archives/:action/:article')
+        self.assertEqual(
+            mapper.routes['foo'].pattern, 'archives/:action/:article'
+        )
 
     def test_connect_static_overridden(self):
         mapper = self._makeOne()
         mapper.connect('foo', 'archives/:action/:article', static=True)
         self.assertEqual(len(mapper.routelist), 0)
         self.assertEqual(len(mapper.routes), 1)
-        self.assertEqual(mapper.routes['foo'].pattern,
-                         'archives/:action/:article')
+        self.assertEqual(
+            mapper.routes['foo'].pattern, 'archives/:action/:article'
+        )
         mapper.connect('foo', 'archives/:action/:article2')
         self.assertEqual(len(mapper.routelist), 1)
         self.assertEqual(len(mapper.routes), 1)
-        self.assertEqual(mapper.routes['foo'].pattern,
-                         'archives/:action/:article2')
-        self.assertEqual(mapper.routelist[0].pattern,
-                         'archives/:action/:article2')
+        self.assertEqual(
+            mapper.routes['foo'].pattern, 'archives/:action/:article2'
+        )
+        self.assertEqual(
+            mapper.routelist[0].pattern, 'archives/:action/:article2'
+        )
 
     def test___call__pathinfo_cant_be_decoded(self):
         from pyramid.exceptions import URLDecodeError
+
         mapper = self._makeOne()
         if PY2:
             path_info = b'\xff\xfe\xe6\x00'
@@ -138,8 +150,9 @@ class RoutesMapperTests(unittest.TestCase):
 
     def test___call__route_matches_with_predicates(self):
         mapper = self._makeOne()
-        mapper.connect('foo', 'archives/:action/:article',
-                       predicates=[lambda *arg: True])
+        mapper.connect(
+            'foo', 'archives/:action/:article', predicates=[lambda *arg: True]
+        )
         request = self._getRequest(PATH_INFO='/archives/action1/article1')
         result = mapper(request)
         self.assertEqual(result['route'], mapper.routes['foo'])
@@ -148,8 +161,11 @@ class RoutesMapperTests(unittest.TestCase):
 
     def test___call__route_fails_to_match_with_predicates(self):
         mapper = self._makeOne()
-        mapper.connect('foo', 'archives/:action/article1',
-                       predicates=[lambda *arg: True, lambda *arg: False])
+        mapper.connect(
+            'foo',
+            'archives/:action/article1',
+            predicates=[lambda *arg: True, lambda *arg: False],
+        )
         mapper.connect('bar', 'archives/:action/:article')
         request = self._getRequest(PATH_INFO='/archives/action1/article1')
         result = mapper(request)
@@ -159,10 +175,12 @@ class RoutesMapperTests(unittest.TestCase):
 
     def test___call__custom_predicate_gets_info(self):
         mapper = self._makeOne()
+
         def pred(info, request):
-            self.assertEqual(info['match'], {'action':'action1'})
+            self.assertEqual(info['match'], {'action': 'action1'})
             self.assertEqual(info['route'], mapper.routes['foo'])
             return True
+
         mapper.connect('foo', 'archives/:action/article1', predicates=[pred])
         request = self._getRequest(PATH_INFO='/archives/action1/article1')
         mapper(request)
@@ -172,8 +190,9 @@ class RoutesMapperTests(unittest.TestCase):
         # http://labs.creativecommons.org/2010/01/13/cc-engine-and-web-non-frameworks/
         mapper = self._makeOne()
         mapper.connect('rdf', 'licenses/:license_code/:license_version/rdf')
-        mapper.connect('juri',
-                       'licenses/:license_code/:license_version/:jurisdiction')
+        mapper.connect(
+            'juri', 'licenses/:license_code/:license_version/:jurisdiction'
+        )
 
         request = self._getRequest(PATH_INFO='/licenses/1/v2/rdf')
         result = mapper(request)
@@ -236,6 +255,7 @@ class RoutesMapperTests(unittest.TestCase):
 
     def test_get_routes(self):
         from pyramid.urldispatch import Route
+
         mapper = self._makeOne()
         self.assertEqual(mapper.get_routes(), [])
         mapper.connect('whatever', 'archives/:action/:article')
@@ -256,131 +276,167 @@ class RoutesMapperTests(unittest.TestCase):
 
     def test_generate(self):
         mapper = self._makeOne()
+
         def generator(kw):
             return 123
+
         route = DummyRoute(generator)
-        mapper.routes['abc'] =  route
+        mapper.routes['abc'] = route
         self.assertEqual(mapper.generate('abc', {}), 123)
 
+
 class TestCompileRoute(unittest.TestCase):
     def _callFUT(self, pattern):
         from pyramid.urldispatch import _compile_route
+
         return _compile_route(pattern)
 
     def test_no_star(self):
         matcher, generator = self._callFUT('/foo/:baz/biz/:buz/bar')
-        self.assertEqual(matcher('/foo/baz/biz/buz/bar'),
-                         {'baz':'baz', 'buz':'buz'})
+        self.assertEqual(
+            matcher('/foo/baz/biz/buz/bar'), {'baz': 'baz', 'buz': 'buz'}
+        )
         self.assertEqual(matcher('foo/baz/biz/buz/bar'), None)
-        self.assertEqual(generator({'baz':1, 'buz':2}), '/foo/1/biz/2/bar')
+        self.assertEqual(generator({'baz': 1, 'buz': 2}), '/foo/1/biz/2/bar')
 
     def test_with_star(self):
         matcher, generator = self._callFUT('/foo/:baz/biz/:buz/bar*traverse')
-        self.assertEqual(matcher('/foo/baz/biz/buz/bar'),
-                         {'baz':'baz', 'buz':'buz', 'traverse':()})
-        self.assertEqual(matcher('/foo/baz/biz/buz/bar/everything/else/here'),
-                         {'baz':'baz', 'buz':'buz',
-                          'traverse':('everything', 'else', 'here')})
+        self.assertEqual(
+            matcher('/foo/baz/biz/buz/bar'),
+            {'baz': 'baz', 'buz': 'buz', 'traverse': ()},
+        )
+        self.assertEqual(
+            matcher('/foo/baz/biz/buz/bar/everything/else/here'),
+            {
+                'baz': 'baz',
+                'buz': 'buz',
+                'traverse': ('everything', 'else', 'here'),
+            },
+        )
         self.assertEqual(matcher('foo/baz/biz/buz/bar'), None)
-        self.assertEqual(generator(
-            {'baz':1, 'buz':2, 'traverse':'/a/b'}), '/foo/1/biz/2/bar/a/b')
-    
+        self.assertEqual(
+            generator({'baz': 1, 'buz': 2, 'traverse': '/a/b'}),
+            '/foo/1/biz/2/bar/a/b',
+        )
+
     def test_with_bracket_star(self):
         matcher, generator = self._callFUT(
-            '/foo/{baz}/biz/{buz}/bar{remainder:.*}')
-        self.assertEqual(matcher('/foo/baz/biz/buz/bar'),
-                         {'baz':'baz', 'buz':'buz', 'remainder':''})
-        self.assertEqual(matcher('/foo/baz/biz/buz/bar/everything/else/here'),
-                         {'baz':'baz', 'buz':'buz',
-                          'remainder':'/everything/else/here'})
+            '/foo/{baz}/biz/{buz}/bar{remainder:.*}'
+        )
+        self.assertEqual(
+            matcher('/foo/baz/biz/buz/bar'),
+            {'baz': 'baz', 'buz': 'buz', 'remainder': ''},
+        )
+        self.assertEqual(
+            matcher('/foo/baz/biz/buz/bar/everything/else/here'),
+            {'baz': 'baz', 'buz': 'buz', 'remainder': '/everything/else/here'},
+        )
         self.assertEqual(matcher('foo/baz/biz/buz/bar'), None)
-        self.assertEqual(generator(
-            {'baz':1, 'buz':2, 'remainder':'/a/b'}), '/foo/1/biz/2/bar/a/b')
+        self.assertEqual(
+            generator({'baz': 1, 'buz': 2, 'remainder': '/a/b'}),
+            '/foo/1/biz/2/bar/a/b',
+        )
 
     def test_no_beginning_slash(self):
         matcher, generator = self._callFUT('foo/:baz/biz/:buz/bar')
-        self.assertEqual(matcher('/foo/baz/biz/buz/bar'),
-                         {'baz':'baz', 'buz':'buz'})
+        self.assertEqual(
+            matcher('/foo/baz/biz/buz/bar'), {'baz': 'baz', 'buz': 'buz'}
+        )
         self.assertEqual(matcher('foo/baz/biz/buz/bar'), None)
-        self.assertEqual(generator({'baz':1, 'buz':2}), '/foo/1/biz/2/bar')
+        self.assertEqual(generator({'baz': 1, 'buz': 2}), '/foo/1/biz/2/bar')
 
     def test_custom_regex(self):
         matcher, generator = self._callFUT('foo/{baz}/biz/{buz:[^/\.]+}.{bar}')
-        self.assertEqual(matcher('/foo/baz/biz/buz.bar'),
-                         {'baz':'baz', 'buz':'buz', 'bar':'bar'})
+        self.assertEqual(
+            matcher('/foo/baz/biz/buz.bar'),
+            {'baz': 'baz', 'buz': 'buz', 'bar': 'bar'},
+        )
         self.assertEqual(matcher('foo/baz/biz/buz/bar'), None)
-        self.assertEqual(generator({'baz':1, 'buz':2, 'bar': 'html'}),
-                         '/foo/1/biz/2.html')
-    
+        self.assertEqual(
+            generator({'baz': 1, 'buz': 2, 'bar': 'html'}), '/foo/1/biz/2.html'
+        )
+
     def test_custom_regex_with_colons(self):
-        matcher, generator = self._callFUT('foo/{baz}/biz/{buz:(?:[^/\.]+)}.{bar}')
-        self.assertEqual(matcher('/foo/baz/biz/buz.bar'),
-                         {'baz':'baz', 'buz':'buz', 'bar':'bar'})
+        matcher, generator = self._callFUT(
+            'foo/{baz}/biz/{buz:(?:[^/\.]+)}.{bar}'
+        )
+        self.assertEqual(
+            matcher('/foo/baz/biz/buz.bar'),
+            {'baz': 'baz', 'buz': 'buz', 'bar': 'bar'},
+        )
         self.assertEqual(matcher('foo/baz/biz/buz/bar'), None)
-        self.assertEqual(generator({'baz':1, 'buz':2, 'bar': 'html'}),
-                         '/foo/1/biz/2.html')
+        self.assertEqual(
+            generator({'baz': 1, 'buz': 2, 'bar': 'html'}), '/foo/1/biz/2.html'
+        )
 
     def test_mixed_newstyle_oldstyle_pattern_defaults_to_newstyle(self):
         # pattern: '\\/foo\\/(?P<baz>abc)\\/biz\\/(?P<buz>[^/]+)\\/bar$'
         # note presence of :abc in pattern (oldstyle match)
         matcher, generator = self._callFUT('foo/{baz:abc}/biz/{buz}/bar')
-        self.assertEqual(matcher('/foo/abc/biz/buz/bar'),
-                         {'baz':'abc', 'buz':'buz'})
-        self.assertEqual(generator({'baz':1, 'buz':2}), '/foo/1/biz/2/bar')
+        self.assertEqual(
+            matcher('/foo/abc/biz/buz/bar'), {'baz': 'abc', 'buz': 'buz'}
+        )
+        self.assertEqual(generator({'baz': 1, 'buz': 2}), '/foo/1/biz/2/bar')
 
     def test_custom_regex_with_embedded_squigglies(self):
         matcher, generator = self._callFUT('/{buz:\d{4}}')
-        self.assertEqual(matcher('/2001'), {'buz':'2001'})
+        self.assertEqual(matcher('/2001'), {'buz': '2001'})
         self.assertEqual(matcher('/200'), None)
-        self.assertEqual(generator({'buz':2001}), '/2001')
+        self.assertEqual(generator({'buz': 2001}), '/2001')
 
     def test_custom_regex_with_embedded_squigglies2(self):
         matcher, generator = self._callFUT('/{buz:\d{3,4}}')
-        self.assertEqual(matcher('/2001'), {'buz':'2001'})
-        self.assertEqual(matcher('/200'), {'buz':'200'})
+        self.assertEqual(matcher('/2001'), {'buz': '2001'})
+        self.assertEqual(matcher('/200'), {'buz': '200'})
         self.assertEqual(matcher('/20'), None)
-        self.assertEqual(generator({'buz':2001}), '/2001')
+        self.assertEqual(generator({'buz': 2001}), '/2001')
 
     def test_custom_regex_with_embedded_squigglies3(self):
         matcher, generator = self._callFUT(
-            '/{buz:(\d{2}|\d{4})-[a-zA-Z]{3,4}-\d{2}}')
-        self.assertEqual(matcher('/2001-Nov-15'), {'buz':'2001-Nov-15'})
-        self.assertEqual(matcher('/99-June-10'), {'buz':'99-June-10'})
+            '/{buz:(\d{2}|\d{4})-[a-zA-Z]{3,4}-\d{2}}'
+        )
+        self.assertEqual(matcher('/2001-Nov-15'), {'buz': '2001-Nov-15'})
+        self.assertEqual(matcher('/99-June-10'), {'buz': '99-June-10'})
         self.assertEqual(matcher('/2-Nov-15'), None)
         self.assertEqual(matcher('/200-Nov-15'), None)
         self.assertEqual(matcher('/2001-No-15'), None)
-        self.assertEqual(generator({'buz':'2001-Nov-15'}), '/2001-Nov-15')
-        self.assertEqual(generator({'buz':'99-June-10'}), '/99-June-10')
+        self.assertEqual(generator({'buz': '2001-Nov-15'}), '/2001-Nov-15')
+        self.assertEqual(generator({'buz': '99-June-10'}), '/99-June-10')
 
     def test_pattern_with_high_order_literal(self):
         pattern = text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8')
         matcher, generator = self._callFUT(pattern)
-        self.assertEqual(matcher(text_(b'/La Pe\xc3\xb1a/x', 'utf-8')),
-                         {'x':'x'})
-        self.assertEqual(generator({'x':'1'}), '/La%20Pe%C3%B1a/1')
+        self.assertEqual(
+            matcher(text_(b'/La Pe\xc3\xb1a/x', 'utf-8')), {'x': 'x'}
+        )
+        self.assertEqual(generator({'x': '1'}), '/La%20Pe%C3%B1a/1')
 
     def test_pattern_generate_with_high_order_dynamic(self):
         pattern = '/{x}'
         _, generator = self._callFUT(pattern)
         self.assertEqual(
-            generator({'x':text_(b'La Pe\xc3\xb1a', 'utf-8')}),
-            '/La%20Pe%C3%B1a')
+            generator({'x': text_(b'La Pe\xc3\xb1a', 'utf-8')}),
+            '/La%20Pe%C3%B1a',
+        )
 
     def test_docs_sample_generate(self):
         # sample from urldispatch.rst
         pattern = text_(b'/La Pe\xc3\xb1a/{city}', 'utf-8')
         _, generator = self._callFUT(pattern)
         self.assertEqual(
-            generator({'city':text_(b'Qu\xc3\xa9bec', 'utf-8')}),
-            '/La%20Pe%C3%B1a/Qu%C3%A9bec')
+            generator({'city': text_(b'Qu\xc3\xa9bec', 'utf-8')}),
+            '/La%20Pe%C3%B1a/Qu%C3%A9bec',
+        )
 
     def test_generate_with_mixedtype_values(self):
         pattern = '/{city}/{state}'
         _, generator = self._callFUT(pattern)
         result = generator(
-            {'city': text_(b'Qu\xc3\xa9bec', 'utf-8'),
-             'state': b'La Pe\xc3\xb1a'}
-            )
+            {
+                'city': text_(b'Qu\xc3\xa9bec', 'utf-8'),
+                'state': b'La Pe\xc3\xb1a',
+            }
+        )
         self.assertEqual(result, '/Qu%C3%A9bec/La%20Pe%C3%B1a')
         # should be a native string
         self.assertEqual(type(result), str)
@@ -394,7 +450,7 @@ class TestCompileRoute(unittest.TestCase):
         _, generator = self._callFUT(pattern)
         result = generator(
             {'remainder': text_(b'/Qu\xc3\xa9bec/La Pe\xc3\xb1a', 'utf-8')}
-            )
+        )
         self.assertEqual(result, '/abc/Qu%C3%A9bec/La%20Pe%C3%B1a')
         # should be a native string
         self.assertEqual(type(result), str)
@@ -402,22 +458,23 @@ class TestCompileRoute(unittest.TestCase):
     def test_generate_with_string_remainder_and_nonstring_replacement(self):
         pattern = text_(b'/abc/*remainder', 'utf-8')
         _, generator = self._callFUT(pattern)
-        result = generator(
-            {'remainder': None}
-            )
+        result = generator({'remainder': None})
         self.assertEqual(result, '/abc/None')
         # should be a native string
         self.assertEqual(type(result), str)
 
+
 class TestCompileRouteFunctional(unittest.TestCase):
     def matches(self, pattern, path, expected):
         from pyramid.urldispatch import _compile_route
+
         matcher = _compile_route(pattern)[0]
         result = matcher(path)
         self.assertEqual(result, expected)
 
     def generates(self, pattern, dict, result):
         from pyramid.urldispatch import _compile_route
+
         self.assertEqual(_compile_route(pattern)[1](dict), result)
 
     def test_matcher_functional_notdynamic(self):
@@ -432,108 +489,165 @@ class TestCompileRouteFunctional(unittest.TestCase):
         self.matches('/{x}', '', None)
         self.matches('/{x}', '/', None)
         self.matches('/abc/{def}', '/abc/', None)
-        self.matches('/{x}', '/a', {'x':'a'})
-        self.matches('zzz/{x}', '/zzz/abc', {'x':'abc'})
-        self.matches('zzz/{x}*traverse', '/zzz/abc', {'x':'abc', 'traverse':()})
-        self.matches('zzz/{x}*traverse', '/zzz/abc/def/g',
-                     {'x':'abc', 'traverse':('def', 'g')})
-        self.matches('*traverse', '/zzz/abc', {'traverse':('zzz', 'abc')})
-        self.matches('*traverse', '/zzz/ abc', {'traverse':('zzz', ' abc')})
+        self.matches('/{x}', '/a', {'x': 'a'})
+        self.matches('zzz/{x}', '/zzz/abc', {'x': 'abc'})
+        self.matches(
+            'zzz/{x}*traverse', '/zzz/abc', {'x': 'abc', 'traverse': ()}
+        )
+        self.matches(
+            'zzz/{x}*traverse',
+            '/zzz/abc/def/g',
+            {'x': 'abc', 'traverse': ('def', 'g')},
+        )
+        self.matches('*traverse', '/zzz/abc', {'traverse': ('zzz', 'abc')})
+        self.matches('*traverse', '/zzz/ abc', {'traverse': ('zzz', ' abc')})
         #'/La%20Pe%C3%B1a'
-        self.matches('{x}', text_(b'/La Pe\xc3\xb1a', 'utf-8'),
-                     {'x':text_(b'La Pe\xc3\xb1a', 'utf-8')})
+        self.matches(
+            '{x}',
+            text_(b'/La Pe\xc3\xb1a', 'utf-8'),
+            {'x': text_(b'La Pe\xc3\xb1a', 'utf-8')},
+        )
         # '/La%20Pe%C3%B1a/x'
-        self.matches('*traverse', text_(b'/La Pe\xc3\xb1a/x'),
-                     {'traverse':(text_(b'La Pe\xc3\xb1a'), 'x')})
-        self.matches('/foo/{id}.html', '/foo/bar.html', {'id':'bar'})
-        self.matches('/{num:[0-9]+}/*traverse', '/555/abc/def',
-                     {'num':'555', 'traverse':('abc', 'def')})
-        self.matches('/{num:[0-9]*}/*traverse', '/555/abc/def',
-                     {'num':'555', 'traverse':('abc', 'def')})
-        self.matches('zzz/{_}', '/zzz/abc', {'_':'abc'})
-        self.matches('zzz/{_abc}', '/zzz/abc', {'_abc':'abc'})
-        self.matches('zzz/{abc_def}', '/zzz/abc', {'abc_def':'abc'})
+        self.matches(
+            '*traverse',
+            text_(b'/La Pe\xc3\xb1a/x'),
+            {'traverse': (text_(b'La Pe\xc3\xb1a'), 'x')},
+        )
+        self.matches('/foo/{id}.html', '/foo/bar.html', {'id': 'bar'})
+        self.matches(
+            '/{num:[0-9]+}/*traverse',
+            '/555/abc/def',
+            {'num': '555', 'traverse': ('abc', 'def')},
+        )
+        self.matches(
+            '/{num:[0-9]*}/*traverse',
+            '/555/abc/def',
+            {'num': '555', 'traverse': ('abc', 'def')},
+        )
+        self.matches('zzz/{_}', '/zzz/abc', {'_': 'abc'})
+        self.matches('zzz/{_abc}', '/zzz/abc', {'_abc': 'abc'})
+        self.matches('zzz/{abc_def}', '/zzz/abc', {'abc_def': 'abc'})
 
     def test_matcher_functional_oldstyle(self):
         self.matches('/:x', '', None)
         self.matches('/:x', '/', None)
         self.matches('/abc/:def', '/abc/', None)
-        self.matches('/:x', '/a', {'x':'a'})
-        self.matches('zzz/:x', '/zzz/abc', {'x':'abc'})
-        self.matches('zzz/:x*traverse', '/zzz/abc', {'x':'abc', 'traverse':()})
-        self.matches('zzz/:x*traverse', '/zzz/abc/def/g',
-                     {'x':'abc', 'traverse':('def', 'g')})
-        self.matches('*traverse', '/zzz/abc', {'traverse':('zzz', 'abc')})
-        self.matches('*traverse', '/zzz/ abc', {'traverse':('zzz', ' abc')})
+        self.matches('/:x', '/a', {'x': 'a'})
+        self.matches('zzz/:x', '/zzz/abc', {'x': 'abc'})
+        self.matches(
+            'zzz/:x*traverse', '/zzz/abc', {'x': 'abc', 'traverse': ()}
+        )
+        self.matches(
+            'zzz/:x*traverse',
+            '/zzz/abc/def/g',
+            {'x': 'abc', 'traverse': ('def', 'g')},
+        )
+        self.matches('*traverse', '/zzz/abc', {'traverse': ('zzz', 'abc')})
+        self.matches('*traverse', '/zzz/ abc', {'traverse': ('zzz', ' abc')})
         #'/La%20Pe%C3%B1a'
         # pattern, path, expected
-        self.matches(':x', text_(b'/La Pe\xc3\xb1a', 'utf-8'),
-                     {'x':text_(b'La Pe\xc3\xb1a', 'utf-8')})
+        self.matches(
+            ':x',
+            text_(b'/La Pe\xc3\xb1a', 'utf-8'),
+            {'x': text_(b'La Pe\xc3\xb1a', 'utf-8')},
+        )
         # '/La%20Pe%C3%B1a/x'
-        self.matches('*traverse', text_(b'/La Pe\xc3\xb1a/x', 'utf-8'),
-                     {'traverse':(text_(b'La Pe\xc3\xb1a', 'utf-8'), 'x')})
-        self.matches('/foo/:id.html', '/foo/bar.html', {'id':'bar'})
-        self.matches('/foo/:id_html', '/foo/bar_html', {'id_html':'bar_html'})
-        self.matches('zzz/:_', '/zzz/abc', {'_':'abc'})
-        self.matches('zzz/:_abc', '/zzz/abc', {'_abc':'abc'})
-        self.matches('zzz/:abc_def', '/zzz/abc', {'abc_def':'abc'})
+        self.matches(
+            '*traverse',
+            text_(b'/La Pe\xc3\xb1a/x', 'utf-8'),
+            {'traverse': (text_(b'La Pe\xc3\xb1a', 'utf-8'), 'x')},
+        )
+        self.matches('/foo/:id.html', '/foo/bar.html', {'id': 'bar'})
+        self.matches('/foo/:id_html', '/foo/bar_html', {'id_html': 'bar_html'})
+        self.matches('zzz/:_', '/zzz/abc', {'_': 'abc'})
+        self.matches('zzz/:_abc', '/zzz/abc', {'_abc': 'abc'})
+        self.matches('zzz/:abc_def', '/zzz/abc', {'abc_def': 'abc'})
 
     def test_generator_functional_notdynamic(self):
         self.generates('', {}, '/')
         self.generates('/', {}, '/')
 
     def test_generator_functional_newstyle(self):
-        self.generates('/{x}', {'x':''}, '/')
-        self.generates('/{x}', {'x':'a'}, '/a')
-        self.generates('/{x}', {'x':'a/b/c'}, '/a/b/c')
-        self.generates('/{x}', {'x':':@&+$,'}, '/:@&+$,')
-        self.generates('zzz/{x}', {'x':'abc'}, '/zzz/abc')
-        self.generates('zzz/{x}*traverse', {'x':'abc', 'traverse':''},
-                       '/zzz/abc')
-        self.generates('zzz/{x}*traverse', {'x':'abc', 'traverse':'/def/g'},
-                       '/zzz/abc/def/g')
-        self.generates('zzz/{x}*traverse', {'x':':@&+$,', 'traverse':'/:@&+$,'},
-                       '/zzz/:@&+$,/:@&+$,')
-        self.generates('/{x}', {'x':text_(b'/La Pe\xc3\xb1a', 'utf-8')},
-                       '//La%20Pe%C3%B1a')
-        self.generates('/{x}*y', {'x':text_(b'/La Pe\xc3\xb1a', 'utf-8'),
-                                 'y':'/rest/of/path'},
-                       '//La%20Pe%C3%B1a/rest/of/path')
-        self.generates('*traverse', {'traverse':('a', text_(b'La Pe\xf1a'))},
-                       '/a/La%20Pe%C3%B1a')
-        self.generates('/foo/{id}.html', {'id':'bar'}, '/foo/bar.html')
-        self.generates('/foo/{_}', {'_':'20'}, '/foo/20')
-        self.generates('/foo/{_abc}', {'_abc':'20'}, '/foo/20')
-        self.generates('/foo/{abc_def}', {'abc_def':'20'}, '/foo/20')
-        
+        self.generates('/{x}', {'x': ''}, '/')
+        self.generates('/{x}', {'x': 'a'}, '/a')
+        self.generates('/{x}', {'x': 'a/b/c'}, '/a/b/c')
+        self.generates('/{x}', {'x': ':@&+$,'}, '/:@&+$,')
+        self.generates('zzz/{x}', {'x': 'abc'}, '/zzz/abc')
+        self.generates(
+            'zzz/{x}*traverse', {'x': 'abc', 'traverse': ''}, '/zzz/abc'
+        )
+        self.generates(
+            'zzz/{x}*traverse',
+            {'x': 'abc', 'traverse': '/def/g'},
+            '/zzz/abc/def/g',
+        )
+        self.generates(
+            'zzz/{x}*traverse',
+            {'x': ':@&+$,', 'traverse': '/:@&+$,'},
+            '/zzz/:@&+$,/:@&+$,',
+        )
+        self.generates(
+            '/{x}',
+            {'x': text_(b'/La Pe\xc3\xb1a', 'utf-8')},
+            '//La%20Pe%C3%B1a',
+        )
+        self.generates(
+            '/{x}*y',
+            {'x': text_(b'/La Pe\xc3\xb1a', 'utf-8'), 'y': '/rest/of/path'},
+            '//La%20Pe%C3%B1a/rest/of/path',
+        )
+        self.generates(
+            '*traverse',
+            {'traverse': ('a', text_(b'La Pe\xf1a'))},
+            '/a/La%20Pe%C3%B1a',
+        )
+        self.generates('/foo/{id}.html', {'id': 'bar'}, '/foo/bar.html')
+        self.generates('/foo/{_}', {'_': '20'}, '/foo/20')
+        self.generates('/foo/{_abc}', {'_abc': '20'}, '/foo/20')
+        self.generates('/foo/{abc_def}', {'abc_def': '20'}, '/foo/20')
+
     def test_generator_functional_oldstyle(self):
-        self.generates('/:x', {'x':''}, '/')
-        self.generates('/:x', {'x':'a'}, '/a')
-        self.generates('zzz/:x', {'x':'abc'}, '/zzz/abc')
-        self.generates('zzz/:x*traverse', {'x':'abc', 'traverse':''},
-                       '/zzz/abc')
-        self.generates('zzz/:x*traverse', {'x':'abc', 'traverse':'/def/g'},
-                       '/zzz/abc/def/g')
-        self.generates('/:x', {'x':text_(b'/La Pe\xc3\xb1a', 'utf-8')},
-                       '//La%20Pe%C3%B1a')
-        self.generates('/:x*y', {'x':text_(b'/La Pe\xc3\xb1a', 'utf-8'),
-                                 'y':'/rest/of/path'},
-                       '//La%20Pe%C3%B1a/rest/of/path')
-        self.generates('*traverse', {'traverse':('a', text_(b'La Pe\xf1a'))},
-                       '/a/La%20Pe%C3%B1a')
-        self.generates('/foo/:id.html', {'id':'bar'}, '/foo/bar.html')
-        self.generates('/foo/:_', {'_':'20'}, '/foo/20')
-        self.generates('/foo/:_abc', {'_abc':'20'}, '/foo/20')
-        self.generates('/foo/:abc_def', {'abc_def':'20'}, '/foo/20')
+        self.generates('/:x', {'x': ''}, '/')
+        self.generates('/:x', {'x': 'a'}, '/a')
+        self.generates('zzz/:x', {'x': 'abc'}, '/zzz/abc')
+        self.generates(
+            'zzz/:x*traverse', {'x': 'abc', 'traverse': ''}, '/zzz/abc'
+        )
+        self.generates(
+            'zzz/:x*traverse',
+            {'x': 'abc', 'traverse': '/def/g'},
+            '/zzz/abc/def/g',
+        )
+        self.generates(
+            '/:x',
+            {'x': text_(b'/La Pe\xc3\xb1a', 'utf-8')},
+            '//La%20Pe%C3%B1a',
+        )
+        self.generates(
+            '/:x*y',
+            {'x': text_(b'/La Pe\xc3\xb1a', 'utf-8'), 'y': '/rest/of/path'},
+            '//La%20Pe%C3%B1a/rest/of/path',
+        )
+        self.generates(
+            '*traverse',
+            {'traverse': ('a', text_(b'La Pe\xf1a'))},
+            '/a/La%20Pe%C3%B1a',
+        )
+        self.generates('/foo/:id.html', {'id': 'bar'}, '/foo/bar.html')
+        self.generates('/foo/:_', {'_': '20'}, '/foo/20')
+        self.generates('/foo/:_abc', {'_abc': '20'}, '/foo/20')
+        self.generates('/foo/:abc_def', {'abc_def': '20'}, '/foo/20')
+
 
 class DummyContext(object):
     """ """
-        
+
+
 class DummyRequest(object):
     def __init__(self, environ):
         self.environ = environ
-    
+
+
 class DummyRoute(object):
     def __init__(self, generator):
         self.generate = generator
-        
diff --git a/tests/test_util.py b/tests/test_util.py
index 469cabadb..307c1a5f8 100644
--- a/tests/test_util.py
+++ b/tests/test_util.py
@@ -1,9 +1,5 @@
 import unittest
-from pyramid.compat import (
-    PY2,
-    text_,
-    bytes_,
-    )
+from pyramid.compat import PY2, text_, bytes_
 
 
 class Test_InstancePropertyHelper(unittest.TestCase):
@@ -13,11 +9,13 @@ class Test_InstancePropertyHelper(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.util import InstancePropertyHelper
+
         return InstancePropertyHelper
 
     def test_callable(self):
         def worker(obj):
             return obj.bar
+
         foo = Dummy()
         helper = self._getTargetClass()
         helper.set_property(foo, worker)
@@ -29,6 +27,7 @@ class Test_InstancePropertyHelper(unittest.TestCase):
     def test_callable_with_name(self):
         def worker(obj):
             return obj.bar
+
         foo = Dummy()
         helper = self._getTargetClass()
         helper.set_property(foo, worker, name='x')
@@ -40,6 +39,7 @@ class Test_InstancePropertyHelper(unittest.TestCase):
     def test_callable_with_reify(self):
         def worker(obj):
             return obj.bar
+
         foo = Dummy()
         helper = self._getTargetClass()
         helper.set_property(foo, worker, reify=True)
@@ -51,6 +51,7 @@ class Test_InstancePropertyHelper(unittest.TestCase):
     def test_callable_with_name_reify(self):
         def worker(obj):
             return obj.bar
+
         foo = Dummy()
         helper = self._getTargetClass()
         helper.set_property(foo, worker, name='x')
@@ -63,14 +64,19 @@ class Test_InstancePropertyHelper(unittest.TestCase):
         self.assertEqual(1, foo.y)
 
     def test_property_without_name(self):
-        def worker(obj): pass
+        def worker(obj):
+            pass
+
         foo = Dummy()
         helper = self._getTargetClass()
-        self.assertRaises(ValueError, helper.set_property, foo, property(worker))
+        self.assertRaises(
+            ValueError, helper.set_property, foo, property(worker)
+        )
 
     def test_property_with_name(self):
         def worker(obj):
             return obj.bar
+
         foo = Dummy()
         helper = self._getTargetClass()
         helper.set_property(foo, property(worker), name='x')
@@ -80,23 +86,37 @@ class Test_InstancePropertyHelper(unittest.TestCase):
         self.assertEqual(2, foo.x)
 
     def test_property_with_reify(self):
-        def worker(obj): pass
+        def worker(obj):
+            pass
+
         foo = Dummy()
         helper = self._getTargetClass()
-        self.assertRaises(ValueError, helper.set_property,
-                          foo, property(worker), name='x', reify=True)
+        self.assertRaises(
+            ValueError,
+            helper.set_property,
+            foo,
+            property(worker),
+            name='x',
+            reify=True,
+        )
 
     def test_override_property(self):
-        def worker(obj): pass
+        def worker(obj):
+            pass
+
         foo = Dummy()
         helper = self._getTargetClass()
         helper.set_property(foo, worker, name='x')
+
         def doit():
             foo.x = 1
+
         self.assertRaises(AttributeError, doit)
 
     def test_override_reify(self):
-        def worker(obj): pass
+        def worker(obj):
+            pass
+
         foo = Dummy()
         helper = self._getTargetClass()
         helper.set_property(foo, worker, name='x', reify=True)
@@ -125,6 +145,7 @@ class Test_InstancePropertyHelper(unittest.TestCase):
 
     def test_make_property(self):
         from pyramid.decorator import reify
+
         helper = self._getTargetClass()
         name, fn = helper.make_property(lambda x: 1, name='x', reify=True)
         self.assertEqual(name, 'x')
@@ -188,21 +209,25 @@ class Test_InstancePropertyHelper(unittest.TestCase):
         self.assertEqual(foo.x, 1)
         self.assertEqual(bar.x, 2)
 
+
 class Test_InstancePropertyMixin(unittest.TestCase):
     def _makeOne(self):
         cls = self._getTargetClass()
 
         class Foo(cls):
             pass
+
         return Foo()
 
     def _getTargetClass(self):
         from pyramid.util import InstancePropertyMixin
+
         return InstancePropertyMixin
 
     def test_callable(self):
         def worker(obj):
             return obj.bar
+
         foo = self._makeOne()
         foo.set_property(worker)
         foo.bar = 1
@@ -213,6 +238,7 @@ class Test_InstancePropertyMixin(unittest.TestCase):
     def test_callable_with_name(self):
         def worker(obj):
             return obj.bar
+
         foo = self._makeOne()
         foo.set_property(worker, name='x')
         foo.bar = 1
@@ -223,6 +249,7 @@ class Test_InstancePropertyMixin(unittest.TestCase):
     def test_callable_with_reify(self):
         def worker(obj):
             return obj.bar
+
         foo = self._makeOne()
         foo.set_property(worker, reify=True)
         foo.bar = 1
@@ -233,6 +260,7 @@ class Test_InstancePropertyMixin(unittest.TestCase):
     def test_callable_with_name_reify(self):
         def worker(obj):
             return obj.bar
+
         foo = self._makeOne()
         foo.set_property(worker, name='x')
         foo.set_property(worker, name='y', reify=True)
@@ -244,13 +272,16 @@ class Test_InstancePropertyMixin(unittest.TestCase):
         self.assertEqual(1, foo.y)
 
     def test_property_without_name(self):
-        def worker(obj): pass
+        def worker(obj):
+            pass
+
         foo = self._makeOne()
         self.assertRaises(ValueError, foo.set_property, property(worker))
 
     def test_property_with_name(self):
         def worker(obj):
             return obj.bar
+
         foo = self._makeOne()
         foo.set_property(property(worker), name='x')
         foo.bar = 1
@@ -259,21 +290,34 @@ class Test_InstancePropertyMixin(unittest.TestCase):
         self.assertEqual(2, foo.x)
 
     def test_property_with_reify(self):
-        def worker(obj): pass
+        def worker(obj):
+            pass
+
         foo = self._makeOne()
-        self.assertRaises(ValueError, foo.set_property,
-                          property(worker), name='x', reify=True)
+        self.assertRaises(
+            ValueError,
+            foo.set_property,
+            property(worker),
+            name='x',
+            reify=True,
+        )
 
     def test_override_property(self):
-        def worker(obj): pass
+        def worker(obj):
+            pass
+
         foo = self._makeOne()
         foo.set_property(worker, name='x')
+
         def doit():
             foo.x = 1
+
         self.assertRaises(AttributeError, doit)
 
     def test_override_reify(self):
-        def worker(obj): pass
+        def worker(obj):
+            pass
+
         foo = self._makeOne()
         foo.set_property(worker, name='x', reify=True)
         foo.x = 1
@@ -305,9 +349,11 @@ class Test_InstancePropertyMixin(unittest.TestCase):
         self.assertEqual(foo.__module__, 'tests.test_util')
         self.assertEqual(foo.__class__.__module__, 'tests.test_util')
 
+
 class Test_WeakOrderedSet(unittest.TestCase):
     def _makeOne(self):
         from pyramid.config import WeakOrderedSet
+
         return WeakOrderedSet()
 
     def test_ctor(self):
@@ -376,9 +422,11 @@ class Test_WeakOrderedSet(unittest.TestCase):
         self.assertEqual(list(wos), [])
         self.assertEqual(wos.last, None)
 
+
 class Test_strings_differ(unittest.TestCase):
     def _callFUT(self, *args, **kw):
         from pyramid.util import strings_differ
+
         return strings_differ(*args, **kw)
 
     def test_it_bytes(self):
@@ -401,6 +449,7 @@ class Test_strings_differ(unittest.TestCase):
     def test_it_with_external_comparator(self):
         class DummyComparator(object):
             called = False
+
             def __init__(self, ret_val):
                 self.ret_val = ret_val
 
@@ -423,9 +472,11 @@ class Test_strings_differ(unittest.TestCase):
         self.assertTrue(dummy_compare.called)
         self.assertTrue(result)
 
+
 class Test_object_description(unittest.TestCase):
     def _callFUT(self, object):
         from pyramid.util import object_description
+
         return object_description(object)
 
     def test_string(self):
@@ -456,7 +507,7 @@ class Test_object_description(unittest.TestCase):
         self.assertEqual(self._callFUT(['a']), "['a']")
 
     def test_dict(self):
-        self.assertEqual(self._callFUT({'a':1}), "{'a': 1}")
+        self.assertEqual(self._callFUT({'a': 1}), "{'a': 1}")
 
     def test_nomodule(self):
         o = object()
@@ -464,39 +515,40 @@ class Test_object_description(unittest.TestCase):
 
     def test_module(self):
         import pyramid
+
         self.assertEqual(self._callFUT(pyramid), 'module pyramid')
 
     def test_method(self):
         self.assertEqual(
             self._callFUT(self.test_method),
             'method test_method of class tests.test_util.'
-            'Test_object_description')
+            'Test_object_description',
+        )
 
     def test_class(self):
         self.assertEqual(
             self._callFUT(self.__class__),
-            'class tests.test_util.Test_object_description')
+            'class tests.test_util.Test_object_description',
+        )
 
     def test_function(self):
         self.assertEqual(
-            self._callFUT(dummyfunc),
-            'function tests.test_util.dummyfunc')
+            self._callFUT(dummyfunc), 'function tests.test_util.dummyfunc'
+        )
 
     def test_instance(self):
         inst = Dummy()
-        self.assertEqual(
-            self._callFUT(inst),
-            "object %s" % str(inst))
+        self.assertEqual(self._callFUT(inst), "object %s" % str(inst))
 
     def test_shortened_repr(self):
         inst = ['1'] * 1000
-        self.assertEqual(
-            self._callFUT(inst),
-            str(inst)[:100] + ' ... ]')
+        self.assertEqual(self._callFUT(inst), str(inst)[:100] + ' ... ]')
+
 
 class TestTopologicalSorter(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.util import TopologicalSorter
+
         return TopologicalSorter(*arg, **kw)
 
     def test_remove(self):
@@ -520,71 +572,72 @@ class TestTopologicalSorter(unittest.TestCase):
 
     def test_add(self):
         from pyramid.util import LAST
+
         sorter = self._makeOne()
         sorter.add('name', 'factory')
         self.assertEqual(sorter.names, ['name'])
-        self.assertEqual(sorter.name2val,
-                         {'name':'factory'})
+        self.assertEqual(sorter.name2val, {'name': 'factory'})
         self.assertEqual(sorter.order, [('name', LAST)])
         sorter.add('name2', 'factory2')
-        self.assertEqual(sorter.names, ['name',  'name2'])
-        self.assertEqual(sorter.name2val,
-                         {'name':'factory', 'name2':'factory2'})
-        self.assertEqual(sorter.order,
-                         [('name', LAST), ('name2', LAST)])
+        self.assertEqual(sorter.names, ['name', 'name2'])
+        self.assertEqual(
+            sorter.name2val, {'name': 'factory', 'name2': 'factory2'}
+        )
+        self.assertEqual(sorter.order, [('name', LAST), ('name2', LAST)])
         sorter.add('name3', 'factory3', before='name2')
-        self.assertEqual(sorter.names,
-                         ['name',  'name2', 'name3'])
-        self.assertEqual(sorter.name2val,
-                         {'name':'factory', 'name2':'factory2',
-                          'name3':'factory3'})
-        self.assertEqual(sorter.order,
-                         [('name', LAST), ('name2', LAST),
-                          ('name3', 'name2')])
+        self.assertEqual(sorter.names, ['name', 'name2', 'name3'])
+        self.assertEqual(
+            sorter.name2val,
+            {'name': 'factory', 'name2': 'factory2', 'name3': 'factory3'},
+        )
+        self.assertEqual(
+            sorter.order, [('name', LAST), ('name2', LAST), ('name3', 'name2')]
+        )
 
     def test_sorted_ordering_1(self):
         sorter = self._makeOne()
         sorter.add('name1', 'factory1')
         sorter.add('name2', 'factory2')
-        self.assertEqual(sorter.sorted(),
-                         [
-                             ('name1', 'factory1'),
-                             ('name2', 'factory2'),
-                             ])
+        self.assertEqual(
+            sorter.sorted(), [('name1', 'factory1'), ('name2', 'factory2')]
+        )
 
     def test_sorted_ordering_2(self):
         from pyramid.util import FIRST
+
         sorter = self._makeOne()
         sorter.add('name1', 'factory1')
         sorter.add('name2', 'factory2', after=FIRST)
-        self.assertEqual(sorter.sorted(),
-                         [
-                             ('name2', 'factory2'),
-                             ('name1', 'factory1'),
-                             ])
+        self.assertEqual(
+            sorter.sorted(), [('name2', 'factory2'), ('name1', 'factory1')]
+        )
 
     def test_sorted_ordering_3(self):
         from pyramid.util import FIRST
+
         sorter = self._makeOne()
         add = sorter.add
         add('auth', 'auth_factory', after='browserid')
-        add('dbt', 'dbt_factory') 
+        add('dbt', 'dbt_factory')
         add('retry', 'retry_factory', before='txnmgr', after='exceptionview')
         add('browserid', 'browserid_factory')
         add('txnmgr', 'txnmgr_factory', after='exceptionview')
         add('exceptionview', 'excview_factory', after=FIRST)
-        self.assertEqual(sorter.sorted(),
-                         [
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ('txnmgr', 'txnmgr_factory'),
-                             ('dbt', 'dbt_factory'),
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ])
+        self.assertEqual(
+            sorter.sorted(),
+            [
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+                ('txnmgr', 'txnmgr_factory'),
+                ('dbt', 'dbt_factory'),
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+            ],
+        )
 
     def test_sorted_ordering_4(self):
         from pyramid.util import FIRST
+
         sorter = self._makeOne()
         add = sorter.add
         add('exceptionview', 'excview_factory', after=FIRST)
@@ -592,19 +645,22 @@ class TestTopologicalSorter(unittest.TestCase):
         add('retry', 'retry_factory', before='txnmgr', after='exceptionview')
         add('browserid', 'browserid_factory')
         add('txnmgr', 'txnmgr_factory', after='exceptionview')
-        add('dbt', 'dbt_factory') 
-        self.assertEqual(sorter.sorted(),
-                         [
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ('txnmgr', 'txnmgr_factory'),
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ('dbt', 'dbt_factory'),
-                             ])
+        add('dbt', 'dbt_factory')
+        self.assertEqual(
+            sorter.sorted(),
+            [
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+                ('txnmgr', 'txnmgr_factory'),
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+                ('dbt', 'dbt_factory'),
+            ],
+        )
 
     def test_sorted_ordering_5(self):
         from pyramid.util import LAST, FIRST
+
         sorter = self._makeOne()
         add = sorter.add
         add('exceptionview', 'excview_factory')
@@ -612,19 +668,22 @@ class TestTopologicalSorter(unittest.TestCase):
         add('retry', 'retry_factory', before='txnmgr', after='exceptionview')
         add('browserid', 'browserid_factory', after=FIRST)
         add('txnmgr', 'txnmgr_factory', after='exceptionview', before=LAST)
-        add('dbt', 'dbt_factory') 
-        self.assertEqual(sorter.sorted(),
-                         [
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ('txnmgr', 'txnmgr_factory'), 
-                             ('dbt', 'dbt_factory'),
-                             ])
+        add('dbt', 'dbt_factory')
+        self.assertEqual(
+            sorter.sorted(),
+            [
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+                ('txnmgr', 'txnmgr_factory'),
+                ('dbt', 'dbt_factory'),
+            ],
+        )
 
     def test_sorted_ordering_missing_before_partial(self):
         from pyramid.exceptions import ConfigurationError
+
         sorter = self._makeOne()
         add = sorter.add
         add('dbt', 'dbt_factory')
@@ -635,6 +694,7 @@ class TestTopologicalSorter(unittest.TestCase):
 
     def test_sorted_ordering_missing_after_partial(self):
         from pyramid.exceptions import ConfigurationError
+
         sorter = self._makeOne()
         add = sorter.add
         add('dbt', 'dbt_factory')
@@ -645,6 +705,7 @@ class TestTopologicalSorter(unittest.TestCase):
 
     def test_sorted_ordering_missing_before_and_after_partials(self):
         from pyramid.exceptions import ConfigurationError
+
         sorter = self._makeOne()
         add = sorter.add
         add('dbt', 'dbt_factory')
@@ -655,72 +716,93 @@ class TestTopologicalSorter(unittest.TestCase):
 
     def test_sorted_ordering_missing_before_partial_with_fallback(self):
         from pyramid.util import LAST
+
         sorter = self._makeOne()
         add = sorter.add
         add('exceptionview', 'excview_factory', before=LAST)
         add('auth', 'auth_factory', after='browserid')
-        add('retry', 'retry_factory', before=('txnmgr', LAST),
-                                      after='exceptionview')
+        add(
+            'retry',
+            'retry_factory',
+            before=('txnmgr', LAST),
+            after='exceptionview',
+        )
         add('browserid', 'browserid_factory')
-        add('dbt', 'dbt_factory') 
-        self.assertEqual(sorter.sorted(),
-                         [
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ('dbt', 'dbt_factory'),
-                             ])
+        add('dbt', 'dbt_factory')
+        self.assertEqual(
+            sorter.sorted(),
+            [
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+                ('dbt', 'dbt_factory'),
+            ],
+        )
 
     def test_sorted_ordering_missing_after_partial_with_fallback(self):
         from pyramid.util import FIRST
+
         sorter = self._makeOne()
         add = sorter.add
         add('exceptionview', 'excview_factory', after=FIRST)
-        add('auth', 'auth_factory', after=('txnmgr','browserid'))
+        add('auth', 'auth_factory', after=('txnmgr', 'browserid'))
         add('retry', 'retry_factory', after='exceptionview')
         add('browserid', 'browserid_factory')
         add('dbt', 'dbt_factory')
-        self.assertEqual(sorter.sorted(),
-                         [
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ('browserid', 'browserid_factory'),
-                             ('auth', 'auth_factory'),
-                             ('dbt', 'dbt_factory'),
-                             ])
+        self.assertEqual(
+            sorter.sorted(),
+            [
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+                ('browserid', 'browserid_factory'),
+                ('auth', 'auth_factory'),
+                ('dbt', 'dbt_factory'),
+            ],
+        )
 
     def test_sorted_ordering_with_partial_fallbacks(self):
         from pyramid.util import LAST
+
         sorter = self._makeOne()
         add = sorter.add
         add('exceptionview', 'excview_factory', before=('wontbethere', LAST))
         add('retry', 'retry_factory', after='exceptionview')
-        add('browserid', 'browserid_factory', before=('wont2', 'exceptionview'))
-        self.assertEqual(sorter.sorted(),
-                         [
-                             ('browserid', 'browserid_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ])
+        add(
+            'browserid', 'browserid_factory', before=('wont2', 'exceptionview')
+        )
+        self.assertEqual(
+            sorter.sorted(),
+            [
+                ('browserid', 'browserid_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+            ],
+        )
 
     def test_sorted_ordering_with_multiple_matching_fallbacks(self):
         from pyramid.util import LAST
+
         sorter = self._makeOne()
         add = sorter.add
         add('exceptionview', 'excview_factory', before=LAST)
         add('retry', 'retry_factory', after='exceptionview')
-        add('browserid', 'browserid_factory', before=('retry', 'exceptionview'))
-        self.assertEqual(sorter.sorted(),
-                         [
-                             ('browserid', 'browserid_factory'),
-                             ('exceptionview', 'excview_factory'),
-                             ('retry', 'retry_factory'),
-                             ])
+        add(
+            'browserid', 'browserid_factory', before=('retry', 'exceptionview')
+        )
+        self.assertEqual(
+            sorter.sorted(),
+            [
+                ('browserid', 'browserid_factory'),
+                ('exceptionview', 'excview_factory'),
+                ('retry', 'retry_factory'),
+            ],
+        )
 
     def test_sorted_ordering_with_missing_fallbacks(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.util import LAST
+
         sorter = self._makeOne()
         add = sorter.add
         add('exceptionview', 'excview_factory', before=LAST)
@@ -730,6 +812,7 @@ class TestTopologicalSorter(unittest.TestCase):
 
     def test_sorted_ordering_conflict_direct(self):
         from pyramid.exceptions import CyclicDependencyError
+
         sorter = self._makeOne()
         add = sorter.add
         add('browserid', 'browserid_factory')
@@ -738,6 +821,7 @@ class TestTopologicalSorter(unittest.TestCase):
 
     def test_sorted_ordering_conflict_indirect(self):
         from pyramid.exceptions import CyclicDependencyError
+
         sorter = self._makeOne()
         add = sorter.add
         add('browserid', 'browserid_factory')
@@ -745,9 +829,11 @@ class TestTopologicalSorter(unittest.TestCase):
         add('dbt', 'dbt_factory', after='browserid', before='auth')
         self.assertRaises(CyclicDependencyError, sorter.sorted)
 
+
 class TestSentinel(unittest.TestCase):
     def test_repr(self):
         from pyramid.util import Sentinel
+
         r = repr(Sentinel('ABC'))
         self.assertEqual(r, 'ABC')
 
@@ -783,16 +869,19 @@ class TestCallableName(unittest.TestCase):
 class Test_hide_attrs(unittest.TestCase):
     def _callFUT(self, obj, *attrs):
         from pyramid.util import hide_attrs
+
         return hide_attrs(obj, *attrs)
 
     def _makeDummy(self):
         from pyramid.decorator import reify
+
         class Dummy(object):
             x = 1
 
             @reify
             def foo(self):
                 return self.x
+
         return Dummy()
 
     def test_restores_attrs(self):
@@ -814,7 +903,7 @@ class Test_hide_attrs(unittest.TestCase):
                 raise RuntimeError()
         except RuntimeError:
             self.assertEqual(obj.foo, orig_foo)
-        else:                   # pragma: no cover
+        else:  # pragma: no cover
             self.fail("RuntimeError not raised")
 
     def test_restores_attrs_to_none(self):
@@ -837,7 +926,8 @@ class Test_hide_attrs(unittest.TestCase):
         self.assertTrue('foo' not in obj.__dict__)
 
 
-def dummyfunc(): pass
+def dummyfunc():
+    pass
 
 
 class Dummy(object):
@@ -847,6 +937,7 @@ class Dummy(object):
 class Test_is_same_domain(unittest.TestCase):
     def _callFUT(self, *args, **kw):
         from pyramid.util import is_same_domain
+
         return is_same_domain(*args, **kw)
 
     def test_it(self):
@@ -868,6 +959,7 @@ class Test_is_same_domain(unittest.TestCase):
 class Test_make_contextmanager(unittest.TestCase):
     def _callFUT(self, *args, **kw):
         from pyramid.util import make_contextmanager
+
         return make_contextmanager(*args, **kw)
 
     def test_with_None(self):
@@ -878,6 +970,7 @@ class Test_make_contextmanager(unittest.TestCase):
     def test_with_generator(self):
         def mygen(ctx):
             yield ctx
+
         mgr = self._callFUT(mygen)
         with mgr('a') as ctx:
             self.assertEqual(ctx, 'a')
@@ -886,6 +979,7 @@ class Test_make_contextmanager(unittest.TestCase):
         def mygen():
             yield 'a'
             yield 'b'
+
         mgr = self._callFUT(mygen)
         try:
             with mgr() as ctx:
@@ -898,6 +992,7 @@ class Test_make_contextmanager(unittest.TestCase):
     def test_with_regular_fn(self):
         def mygen():
             return 'a'
+
         mgr = self._callFUT(mygen)
         with mgr() as ctx:
             self.assertEqual(ctx, 'a')
@@ -906,146 +1001,173 @@ class Test_make_contextmanager(unittest.TestCase):
 class Test_takes_one_arg(unittest.TestCase):
     def _callFUT(self, view, attr=None, argname=None):
         from pyramid.util import takes_one_arg
+
         return takes_one_arg(view, attr=attr, argname=argname)
 
     def test_requestonly_newstyle_class_no_init(self):
         class foo(object):
             """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_requestonly_newstyle_class_init_toomanyargs(self):
         class foo(object):
             def __init__(self, context, request):
                 """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_requestonly_newstyle_class_init_onearg_named_request(self):
         class foo(object):
             def __init__(self, request):
                 """ """
+
         self.assertTrue(self._callFUT(foo))
 
     def test_newstyle_class_init_onearg_named_somethingelse(self):
         class foo(object):
             def __init__(self, req):
                 """ """
+
         self.assertTrue(self._callFUT(foo))
 
     def test_newstyle_class_init_defaultargs_firstname_not_request(self):
         class foo(object):
             def __init__(self, context, request=None):
                 """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_newstyle_class_init_defaultargs_firstname_request(self):
         class foo(object):
             def __init__(self, request, foo=1, bar=2):
                 """ """
+
         self.assertTrue(self._callFUT(foo, argname='request'))
 
     def test_newstyle_class_init_firstname_request_with_secondname(self):
         class foo(object):
             def __init__(self, request, two):
                 """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_newstyle_class_init_noargs(self):
         class foo(object):
             def __init__():
                 """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_oldstyle_class_no_init(self):
         class foo:
             """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_oldstyle_class_init_toomanyargs(self):
         class foo:
             def __init__(self, context, request):
                 """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_oldstyle_class_init_onearg_named_request(self):
         class foo:
             def __init__(self, request):
                 """ """
+
         self.assertTrue(self._callFUT(foo))
 
     def test_oldstyle_class_init_onearg_named_somethingelse(self):
         class foo:
             def __init__(self, req):
                 """ """
+
         self.assertTrue(self._callFUT(foo))
 
     def test_oldstyle_class_init_defaultargs_firstname_not_request(self):
         class foo:
             def __init__(self, context, request=None):
                 """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_oldstyle_class_init_defaultargs_firstname_request(self):
         class foo:
             def __init__(self, request, foo=1, bar=2):
                 """ """
+
         self.assertTrue(self._callFUT(foo, argname='request'), True)
 
     def test_oldstyle_class_init_noargs(self):
         class foo:
             def __init__():
                 """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_function_toomanyargs(self):
         def foo(context, request):
             """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_function_with_attr_false(self):
         def bar(context, request):
             """ """
+
         def foo(context, request):
             """ """
+
         foo.bar = bar
         self.assertFalse(self._callFUT(foo, 'bar'))
 
     def test_function_with_attr_true(self):
         def bar(context, request):
             """ """
+
         def foo(request):
             """ """
+
         foo.bar = bar
         self.assertTrue(self._callFUT(foo, 'bar'))
 
     def test_function_onearg_named_request(self):
         def foo(request):
             """ """
+
         self.assertTrue(self._callFUT(foo))
 
     def test_function_onearg_named_somethingelse(self):
         def foo(req):
             """ """
+
         self.assertTrue(self._callFUT(foo))
 
     def test_function_defaultargs_firstname_not_request(self):
         def foo(context, request=None):
             """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_function_defaultargs_firstname_request(self):
         def foo(request, foo=1, bar=2):
             """ """
+
         self.assertTrue(self._callFUT(foo, argname='request'))
 
     def test_function_noargs(self):
         def foo():
             """ """
+
         self.assertFalse(self._callFUT(foo))
 
     def test_instance_toomanyargs(self):
         class Foo:
             def __call__(self, context, request):
                 """ """
+
         foo = Foo()
         self.assertFalse(self._callFUT(foo))
 
@@ -1053,6 +1175,7 @@ class Test_takes_one_arg(unittest.TestCase):
         class Foo:
             def __call__(self, request):
                 """ """
+
         foo = Foo()
         self.assertTrue(self._callFUT(foo))
 
@@ -1060,6 +1183,7 @@ class Test_takes_one_arg(unittest.TestCase):
         class Foo:
             def __call__(self, req):
                 """ """
+
         foo = Foo()
         self.assertTrue(self._callFUT(foo))
 
@@ -1067,6 +1191,7 @@ class Test_takes_one_arg(unittest.TestCase):
         class Foo:
             def __call__(self, context, request=None):
                 """ """
+
         foo = Foo()
         self.assertFalse(self._callFUT(foo))
 
@@ -1074,11 +1199,14 @@ class Test_takes_one_arg(unittest.TestCase):
         class Foo:
             def __call__(self, request, foo=1, bar=2):
                 """ """
+
         foo = Foo()
         self.assertTrue(self._callFUT(foo, argname='request'), True)
 
     def test_instance_nocall(self):
-        class Foo: pass
+        class Foo:
+            pass
+
         foo = Foo()
         self.assertFalse(self._callFUT(foo))
 
@@ -1086,12 +1214,14 @@ class Test_takes_one_arg(unittest.TestCase):
         class Foo:
             def method(self, request):
                 """ """
+
         foo = Foo()
         self.assertTrue(self._callFUT(foo.method))
 
     def test_function_annotations(self):
         def foo(bar):
             """ """
+
         # avoid SyntaxErrors in python2, this if effectively nop
         getattr(foo, '__annotations__', {}).update({'bar': 'baz'})
         self.assertTrue(self._callFUT(foo))
@@ -1100,6 +1230,7 @@ class Test_takes_one_arg(unittest.TestCase):
 class TestSimpleSerializer(unittest.TestCase):
     def _makeOne(self):
         from pyramid.util import SimpleSerializer
+
         return SimpleSerializer()
 
     def test_loads(self):
diff --git a/tests/test_view.py b/tests/test_view.py
index 279777f89..039605408 100644
--- a/tests/test_view.py
+++ b/tests/test_view.py
@@ -7,6 +7,7 @@ from pyramid import testing
 
 from pyramid.interfaces import IRequest
 
+
 class BaseTest(object):
     def setUp(self):
         self.config = testing.setUp()
@@ -16,25 +17,28 @@ class BaseTest(object):
 
     def _registerView(self, reg, app, name):
         from pyramid.interfaces import IViewClassifier
+
         for_ = (IViewClassifier, IRequest, IContext)
         from pyramid.interfaces import IView
+
         reg.registerAdapter(app, for_, IView, name)
 
     def _makeEnviron(self, **extras):
         environ = {
-            'wsgi.url_scheme':'http',
-            'wsgi.version':(1,0),
-            'SERVER_NAME':'localhost',
-            'SERVER_PORT':'8080',
-            'REQUEST_METHOD':'GET',
-            'PATH_INFO':'/',
-            }
+            'wsgi.url_scheme': 'http',
+            'wsgi.version': (1, 0),
+            'SERVER_NAME': 'localhost',
+            'SERVER_PORT': '8080',
+            'REQUEST_METHOD': 'GET',
+            'PATH_INFO': '/',
+        }
         environ.update(extras)
         return environ
 
     def _makeRequest(self, **environ):
         from pyramid.request import Request
         from pyramid.registry import Registry
+
         environ = self._makeEnviron(**environ)
         request = Request(environ)
         request.registry = Registry()
@@ -42,26 +46,34 @@ class BaseTest(object):
 
     def _makeContext(self):
         from zope.interface import directlyProvides
+
         context = DummyContext()
         directlyProvides(context, IContext)
         return context
 
+
 class Test_notfound_view_config(BaseTest, unittest.TestCase):
     def _makeOne(self, **kw):
         from pyramid.view import notfound_view_config
+
         return notfound_view_config(**kw)
 
     def test_ctor(self):
-        inst = self._makeOne(attr='attr', path_info='path_info', 
-                             append_slash=True)
-        self.assertEqual(inst.__dict__,
-                         {'attr':'attr', 'path_info':'path_info',
-                          'append_slash':True})
+        inst = self._makeOne(
+            attr='attr', path_info='path_info', append_slash=True
+        )
+        self.assertEqual(
+            inst.__dict__,
+            {'attr': 'attr', 'path_info': 'path_info', 'append_slash': True},
+        )
 
     def test_it_function(self):
-        def view(request): pass
-        decorator = self._makeOne(attr='attr', renderer='renderer',
-                                  append_slash=True)
+        def view(request):
+            pass
+
+        decorator = self._makeOne(
+            attr='attr', renderer='renderer', append_slash=True
+        )
         venusian = DummyVenusian()
         decorator.venusian = venusian
         wrapped = decorator(view)
@@ -69,17 +81,28 @@ class Test_notfound_view_config(BaseTest, unittest.TestCase):
         config = call_venusian(venusian)
         settings = config.settings
         self.assertEqual(
-            settings, 
-            [{'attr': 'attr', 'venusian': venusian, 'append_slash': True, 
-              'renderer': 'renderer', '_info': 'codeinfo', 'view': None}]
-            )
+            settings,
+            [
+                {
+                    'attr': 'attr',
+                    'venusian': venusian,
+                    'append_slash': True,
+                    'renderer': 'renderer',
+                    '_info': 'codeinfo',
+                    'view': None,
+                }
+            ],
+        )
 
     def test_it_class(self):
         decorator = self._makeOne()
         venusian = DummyVenusian()
         decorator.venusian = venusian
         decorator.venusian.info.scope = 'class'
-        class view(object): pass
+
+        class view(object):
+            pass
+
         wrapped = decorator(view)
         self.assertTrue(wrapped is view)
         config = call_venusian(venusian)
@@ -87,7 +110,7 @@ class Test_notfound_view_config(BaseTest, unittest.TestCase):
         self.assertEqual(len(settings), 1)
         self.assertEqual(len(settings[0]), 4)
         self.assertEqual(settings[0]['venusian'], venusian)
-        self.assertEqual(settings[0]['view'], None) # comes from call_venusian
+        self.assertEqual(settings[0]['view'], None)  # comes from call_venusian
         self.assertEqual(settings[0]['attr'], 'view')
         self.assertEqual(settings[0]['_info'], 'codeinfo')
 
@@ -95,7 +118,10 @@ class Test_notfound_view_config(BaseTest, unittest.TestCase):
         decorator = self._makeOne(_depth=1, _category='foo')
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         decorator(foo)
         attachments = venusian.attachments
         category = attachments[0][2]
@@ -103,18 +129,23 @@ class Test_notfound_view_config(BaseTest, unittest.TestCase):
         self.assertEqual(depth, 2)
         self.assertEqual(category, 'foo')
 
+
 class Test_forbidden_view_config(BaseTest, unittest.TestCase):
     def _makeOne(self, **kw):
         from pyramid.view import forbidden_view_config
+
         return forbidden_view_config(**kw)
 
     def test_ctor(self):
         inst = self._makeOne(attr='attr', path_info='path_info')
-        self.assertEqual(inst.__dict__,
-                         {'attr':'attr', 'path_info':'path_info'})
+        self.assertEqual(
+            inst.__dict__, {'attr': 'attr', 'path_info': 'path_info'}
+        )
 
     def test_it_function(self):
-        def view(request): pass
+        def view(request):
+            pass
+
         decorator = self._makeOne(attr='attr', renderer='renderer')
         venusian = DummyVenusian()
         decorator.venusian = venusian
@@ -123,17 +154,27 @@ class Test_forbidden_view_config(BaseTest, unittest.TestCase):
         config = call_venusian(venusian)
         settings = config.settings
         self.assertEqual(
-            settings, 
-            [{'attr': 'attr', 'venusian': venusian, 
-              'renderer': 'renderer', '_info': 'codeinfo', 'view': None}]
-            )
+            settings,
+            [
+                {
+                    'attr': 'attr',
+                    'venusian': venusian,
+                    'renderer': 'renderer',
+                    '_info': 'codeinfo',
+                    'view': None,
+                }
+            ],
+        )
 
     def test_it_class(self):
         decorator = self._makeOne()
         venusian = DummyVenusian()
         decorator.venusian = venusian
         decorator.venusian.info.scope = 'class'
-        class view(object): pass
+
+        class view(object):
+            pass
+
         wrapped = decorator(view)
         self.assertTrue(wrapped is view)
         config = call_venusian(venusian)
@@ -141,7 +182,7 @@ class Test_forbidden_view_config(BaseTest, unittest.TestCase):
         self.assertEqual(len(settings), 1)
         self.assertEqual(len(settings[0]), 4)
         self.assertEqual(settings[0]['venusian'], venusian)
-        self.assertEqual(settings[0]['view'], None) # comes from call_venusian
+        self.assertEqual(settings[0]['view'], None)  # comes from call_venusian
         self.assertEqual(settings[0]['attr'], 'view')
         self.assertEqual(settings[0]['_info'], 'codeinfo')
 
@@ -149,7 +190,10 @@ class Test_forbidden_view_config(BaseTest, unittest.TestCase):
         decorator = self._makeOne(_depth=1, _category='foo')
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         decorator(foo)
         attachments = venusian.attachments
         category = attachments[0][2]
@@ -157,27 +201,36 @@ class Test_forbidden_view_config(BaseTest, unittest.TestCase):
         self.assertEqual(depth, 2)
         self.assertEqual(category, 'foo')
 
+
 class Test_exception_view_config(BaseTest, unittest.TestCase):
     def _makeOne(self, *args, **kw):
         from pyramid.view import exception_view_config
+
         return exception_view_config(*args, **kw)
 
     def test_ctor(self):
         inst = self._makeOne(context=Exception, path_info='path_info')
-        self.assertEqual(inst.__dict__,
-                         {'context':Exception, 'path_info':'path_info'})
+        self.assertEqual(
+            inst.__dict__, {'context': Exception, 'path_info': 'path_info'}
+        )
 
     def test_ctor_positional_exception(self):
         inst = self._makeOne(Exception, path_info='path_info')
-        self.assertEqual(inst.__dict__,
-                         {'context':Exception, 'path_info':'path_info'})
+        self.assertEqual(
+            inst.__dict__, {'context': Exception, 'path_info': 'path_info'}
+        )
 
     def test_ctor_positional_extras(self):
         from pyramid.exceptions import ConfigurationError
-        self.assertRaises(ConfigurationError, lambda: self._makeOne(Exception, True))
+
+        self.assertRaises(
+            ConfigurationError, lambda: self._makeOne(Exception, True)
+        )
 
     def test_it_function(self):
-        def view(request): pass
+        def view(request):
+            pass
+
         decorator = self._makeOne(context=Exception, renderer='renderer')
         venusian = DummyVenusian()
         decorator.venusian = venusian
@@ -187,16 +240,26 @@ class Test_exception_view_config(BaseTest, unittest.TestCase):
         settings = config.settings
         self.assertEqual(
             settings,
-            [{'venusian': venusian, 'context': Exception,
-              'renderer': 'renderer', '_info': 'codeinfo', 'view': None}]
-            )
+            [
+                {
+                    'venusian': venusian,
+                    'context': Exception,
+                    'renderer': 'renderer',
+                    '_info': 'codeinfo',
+                    'view': None,
+                }
+            ],
+        )
 
     def test_it_class(self):
         decorator = self._makeOne()
         venusian = DummyVenusian()
         decorator.venusian = venusian
         decorator.venusian.info.scope = 'class'
-        class view(object): pass
+
+        class view(object):
+            pass
+
         wrapped = decorator(view)
         self.assertTrue(wrapped is view)
         config = call_venusian(venusian)
@@ -204,7 +267,7 @@ class Test_exception_view_config(BaseTest, unittest.TestCase):
         self.assertEqual(len(settings), 1)
         self.assertEqual(len(settings[0]), 4)
         self.assertEqual(settings[0]['venusian'], venusian)
-        self.assertEqual(settings[0]['view'], None) # comes from call_venusian
+        self.assertEqual(settings[0]['view'], None)  # comes from call_venusian
         self.assertEqual(settings[0]['attr'], 'view')
         self.assertEqual(settings[0]['_info'], 'codeinfo')
 
@@ -212,7 +275,10 @@ class Test_exception_view_config(BaseTest, unittest.TestCase):
         decorator = self._makeOne(_depth=1, _category='foo')
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         decorator(foo)
         attachments = venusian.attachments
         category = attachments[0][2]
@@ -220,11 +286,13 @@ class Test_exception_view_config(BaseTest, unittest.TestCase):
         self.assertEqual(depth, 2)
         self.assertEqual(category, 'foo')
 
+
 class RenderViewToResponseTests(BaseTest, unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from pyramid.view import render_view_to_response
+
         return render_view_to_response(*arg, **kw)
-    
+
     def test_call_no_view_registered(self):
         request = self._makeRequest()
         context = self._makeContext()
@@ -244,8 +312,9 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase):
         response = DummyResponse()
         view = make_view(response)
         self._registerView(request.registry, view, 'registered')
-        response = self._callFUT(context, request, name='registered',
-                                 secure=True)
+        response = self._callFUT(
+            context, request, name='registered', secure=True
+        )
         self.assertEqual(response.status, '200 OK')
 
     def test_call_view_registered_insecure_no_call_permissive(self):
@@ -254,8 +323,9 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase):
         response = DummyResponse()
         view = make_view(response)
         self._registerView(request.registry, view, 'registered')
-        response = self._callFUT(context, request, name='registered',
-                                 secure=False)
+        response = self._callFUT(
+            context, request, name='registered', secure=False
+        )
         self.assertEqual(response.status, '200 OK')
 
     def test_call_view_registered_insecure_with_call_permissive(self):
@@ -263,19 +333,25 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase):
         request = self._makeRequest()
         response = DummyResponse()
         view = make_view(response)
+
         def anotherview(context, request):
             return DummyResponse('anotherview')
+
         view.__call_permissive__ = anotherview
         self._registerView(request.registry, view, 'registered')
-        response = self._callFUT(context, request, name='registered',
-                                 secure=False)
+        response = self._callFUT(
+            context, request, name='registered', secure=False
+        )
         self.assertEqual(response.status, '200 OK')
         self.assertEqual(response.app_iter, ['anotherview'])
 
     def test_call_view_with_request_iface_on_request(self):
         # See https://github.com/Pylons/pyramid/issues/1643
         from zope.interface import Interface
-        class IWontBeFound(Interface): pass
+
+        class IWontBeFound(Interface):
+            pass
+
         context = self._makeContext()
         request = self._makeRequest()
         request.request_iface = IWontBeFound
@@ -286,11 +362,13 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase):
         self.assertEqual(response.status, '200 OK')
         self.assertEqual(response.app_iter, ['aview'])
 
+
 class RenderViewToIterableTests(BaseTest, unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from pyramid.view import render_view_to_iterable
+
         return render_view_to_iterable(*arg, **kw)
-    
+
     def test_call_no_view_registered(self):
         request = self._makeRequest()
         context = self._makeContext()
@@ -303,8 +381,9 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
         response = DummyResponse()
         view = make_view(response)
         self._registerView(request.registry, view, 'registered')
-        iterable = self._callFUT(context, request, name='registered',
-                                 secure=True)
+        iterable = self._callFUT(
+            context, request, name='registered', secure=True
+        )
         self.assertEqual(iterable, ())
 
     def test_call_view_registered_insecure_no_call_permissive(self):
@@ -313,8 +392,9 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
         response = DummyResponse()
         view = make_view(response)
         self._registerView(request.registry, view, 'registered')
-        iterable = self._callFUT(context, request, name='registered',
-                                 secure=False)
+        iterable = self._callFUT(
+            context, request, name='registered', secure=False
+        )
         self.assertEqual(iterable, ())
 
     def test_call_view_registered_insecure_with_call_permissive(self):
@@ -322,12 +402,15 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
         request = self._makeRequest()
         response = DummyResponse()
         view = make_view(response)
+
         def anotherview(context, request):
             return DummyResponse(b'anotherview')
+
         view.__call_permissive__ = anotherview
         self._registerView(request.registry, view, 'registered')
-        iterable = self._callFUT(context, request, name='registered',
-                                 secure=False)
+        iterable = self._callFUT(
+            context, request, name='registered', secure=False
+        )
         self.assertEqual(iterable, [b'anotherview'])
 
     def test_verify_output_bytestring(self):
@@ -335,7 +418,9 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
         from pyramid.config import Configurator
         from pyramid.view import render_view
         from webob.compat import text_type
+
         config = Configurator(settings={})
+
         def view(request):
             request.response.text = text_type('<body></body>')
             return request.response
@@ -355,15 +440,18 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
         response = DummyResponse()
         view = make_view(response)
         self._registerView(registry, view, 'registered')
-        iterable = self._callFUT(context, request, name='registered',
-                                 secure=True)
+        iterable = self._callFUT(
+            context, request, name='registered', secure=True
+        )
         self.assertEqual(iterable, ())
 
+
 class RenderViewTests(BaseTest, unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from pyramid.view import render_view
+
         return render_view(*arg, **kw)
-    
+
     def test_call_no_view_registered(self):
         request = self._makeRequest()
         context = self._makeContext()
@@ -393,13 +481,16 @@ class RenderViewTests(BaseTest, unittest.TestCase):
         request = self._makeRequest()
         response = DummyResponse()
         view = make_view(response)
+
         def anotherview(context, request):
             return DummyResponse(b'anotherview')
+
         view.__call_permissive__ = anotherview
         self._registerView(request.registry, view, 'registered')
         s = self._callFUT(context, request, name='registered', secure=False)
         self.assertEqual(s, b'anotherview')
 
+
 class TestViewConfigDecorator(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -409,6 +500,7 @@ class TestViewConfigDecorator(unittest.TestCase):
 
     def _getTargetClass(self):
         from pyramid.view import view_config
+
         return view_config
 
     def _makeOne(self, *arg, **kw):
@@ -425,13 +517,17 @@ class TestViewConfigDecorator(unittest.TestCase):
     def test_create_for_trumps_context_None(self):
         decorator = self._makeOne(context=None, for_='456')
         self.assertEqual(decorator.context, '456')
-        
+
     def test_create_nondefaults(self):
         decorator = self._makeOne(
-            name=None, request_type=None, for_=None,
-            permission='foo', mapper='mapper',
-            decorator='decorator', match_param='match_param'
-            )
+            name=None,
+            request_type=None,
+            for_=None,
+            permission='foo',
+            mapper='mapper',
+            decorator='decorator',
+            match_param='match_param',
+        )
         self.assertEqual(decorator.name, None)
         self.assertEqual(decorator.request_type, None)
         self.assertEqual(decorator.context, None)
@@ -447,12 +543,15 @@ class TestViewConfigDecorator(unittest.TestCase):
     def test_create_decorator_tuple(self):
         decorator = self._makeOne(decorator=('decorator1', 'decorator2'))
         self.assertEqual(decorator.decorator, ('decorator1', 'decorator2'))
-        
+
     def test_call_function(self):
         decorator = self._makeOne()
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         wrapped = decorator(foo)
         self.assertTrue(wrapped is foo)
         config = call_venusian(venusian)
@@ -461,7 +560,7 @@ class TestViewConfigDecorator(unittest.TestCase):
         self.assertEqual(len(settings), 1)
         self.assertEqual(len(settings[0]), 3)
         self.assertEqual(settings[0]['venusian'], venusian)
-        self.assertEqual(settings[0]['view'], None) # comes from call_venusian
+        self.assertEqual(settings[0]['view'], None)  # comes from call_venusian
         self.assertEqual(settings[0]['_info'], 'codeinfo')
 
     def test_call_class(self):
@@ -469,7 +568,10 @@ class TestViewConfigDecorator(unittest.TestCase):
         venusian = DummyVenusian()
         decorator.venusian = venusian
         decorator.venusian.info.scope = 'class'
-        class foo(object): pass
+
+        class foo(object):
+            pass
+
         wrapped = decorator(foo)
         self.assertTrue(wrapped is foo)
         config = call_venusian(venusian)
@@ -477,7 +579,7 @@ class TestViewConfigDecorator(unittest.TestCase):
         self.assertEqual(len(settings), 1)
         self.assertEqual(len(settings[0]), 4)
         self.assertEqual(settings[0]['venusian'], venusian)
-        self.assertEqual(settings[0]['view'], None) # comes from call_venusian
+        self.assertEqual(settings[0]['view'], None)  # comes from call_venusian
         self.assertEqual(settings[0]['attr'], 'foo')
         self.assertEqual(settings[0]['_info'], 'codeinfo')
 
@@ -486,7 +588,10 @@ class TestViewConfigDecorator(unittest.TestCase):
         venusian = DummyVenusian()
         decorator.venusian = venusian
         decorator.venusian.info.scope = 'class'
-        class foo(object): pass
+
+        class foo(object):
+            pass
+
         wrapped = decorator(foo)
         self.assertTrue(wrapped is foo)
         config = call_venusian(venusian)
@@ -494,7 +599,7 @@ class TestViewConfigDecorator(unittest.TestCase):
         self.assertEqual(len(settings), 1)
         self.assertEqual(len(settings[0]), 4)
         self.assertEqual(settings[0]['venusian'], venusian)
-        self.assertEqual(settings[0]['view'], None) # comes from call_venusian
+        self.assertEqual(settings[0]['view'], None)  # comes from call_venusian
         self.assertEqual(settings[0]['attr'], 'abc')
         self.assertEqual(settings[0]['_info'], 'codeinfo')
 
@@ -505,7 +610,10 @@ class TestViewConfigDecorator(unittest.TestCase):
         venusian2 = DummyVenusian()
         decorator2 = self._makeOne(name='2')
         decorator2.venusian = venusian2
-        def foo(): pass
+
+        def foo():
+            pass
+
         wrapped1 = decorator1(foo)
         wrapped2 = decorator2(wrapped1)
         self.assertTrue(wrapped1 is foo)
@@ -522,11 +630,17 @@ class TestViewConfigDecorator(unittest.TestCase):
         venusian = DummyVenusian()
         decorator.venusian = venusian
         decorator.venusian.info.scope = 'class'
-        def foo(self): pass
-        def bar(self): pass
+
+        def foo(self):
+            pass
+
+        def bar(self):
+            pass
+
         class foo(object):
             foomethod = decorator(foo)
             barmethod = decorator(bar)
+
         config = call_venusian(venusian)
         settings = config.settings
         self.assertEqual(len(settings), 2)
@@ -537,7 +651,10 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator = self._makeOne(custom_predicates=(1,))
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(context, request): pass
+
+        def foo(context, request):
+            pass
+
         decorated = decorator(foo)
         self.assertTrue(decorated is foo)
         config = call_venusian(venusian)
@@ -546,10 +663,14 @@ class TestViewConfigDecorator(unittest.TestCase):
 
     def test_call_with_renderer_string(self):
         import tests
+
         decorator = self._makeOne(renderer='fixtures/minimal.pt')
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         wrapped = decorator(foo)
         self.assertTrue(wrapped is foo)
         config = call_venusian(venusian)
@@ -561,29 +682,38 @@ class TestViewConfigDecorator(unittest.TestCase):
 
     def test_call_with_renderer_dict(self):
         import tests
-        decorator = self._makeOne(renderer={'a':1})
+
+        decorator = self._makeOne(renderer={'a': 1})
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         wrapped = decorator(foo)
         self.assertTrue(wrapped is foo)
         config = call_venusian(venusian)
         settings = config.settings
         self.assertEqual(len(settings), 1)
-        self.assertEqual(settings[0]['renderer'], {'a':1})
+        self.assertEqual(settings[0]['renderer'], {'a': 1})
         self.assertEqual(config.pkg, tests)
 
     def test_call_with_renderer_IRendererInfo(self):
         import tests
         from pyramid.interfaces import IRendererInfo
+
         @implementer(IRendererInfo)
         class DummyRendererHelper(object):
             pass
+
         renderer_helper = DummyRendererHelper()
         decorator = self._makeOne(renderer=renderer_helper)
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         wrapped = decorator(foo)
         self.assertTrue(wrapped is foo)
         context = DummyVenusianContext()
@@ -598,7 +728,10 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator = self._makeOne(_depth=1)
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         decorator(foo)
         attachments = venusian.attachments
         depth = attachments[0][3]
@@ -608,7 +741,10 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator = self._makeOne()
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         decorator(foo)
         attachments = venusian.attachments
         category = attachments[0][2]
@@ -618,29 +754,39 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator = self._makeOne(_category='not_pyramid')
         venusian = DummyVenusian()
         decorator.venusian = venusian
-        def foo(): pass
+
+        def foo():
+            pass
+
         decorator(foo)
         attachments = venusian.attachments
         category = attachments[0][2]
         self.assertEqual(category, 'not_pyramid')
 
+
 class Test_append_slash_notfound_view(BaseTest, unittest.TestCase):
     def _callFUT(self, context, request):
         from pyramid.view import append_slash_notfound_view
+
         return append_slash_notfound_view(context, request)
 
     def _registerMapper(self, reg, match=True):
         from pyramid.interfaces import IRoutesMapper
+
         class DummyRoute(object):
             def __init__(self, val):
                 self.val = val
+
             def match(self, path):
                 return self.val
+
         class DummyMapper(object):
             def __init__(self):
-                self.routelist = [ DummyRoute(match) ]
+                self.routelist = [DummyRoute(match)]
+
             def get_routes(self):
                 return self.routelist
+
         mapper = DummyMapper()
         reg.registerUtility(mapper, IRoutesMapper)
         return mapper
@@ -705,23 +851,29 @@ class Test_append_slash_notfound_view(BaseTest, unittest.TestCase):
         self.assertEqual(response.status, '307 Temporary Redirect')
         self.assertEqual(response.location, '/abc/?a=1&b=2')
 
+
 class TestAppendSlashNotFoundViewFactory(BaseTest, unittest.TestCase):
     def _makeOne(self, notfound_view):
         from pyramid.view import AppendSlashNotFoundViewFactory
+
         return AppendSlashNotFoundViewFactory(notfound_view)
-    
+
     def test_custom_notfound_view(self):
         request = self._makeRequest(PATH_INFO='/abc')
         context = ExceptionResponse()
+
         def custom_notfound(context, request):
             return 'OK'
+
         view = self._makeOne(custom_notfound)
         response = view(context, request)
         self.assertEqual(response, 'OK')
 
+
 class Test_default_exceptionresponse_view(unittest.TestCase):
     def _callFUT(self, context, request):
         from pyramid.view import default_exceptionresponse_view
+
         return default_exceptionresponse_view(context, request)
 
     def test_is_exception(self):
@@ -749,39 +901,59 @@ class Test_default_exceptionresponse_view(unittest.TestCase):
         result = self._callFUT(context, request)
         self.assertEqual(result, 'abc')
 
+
 class Test_view_defaults(unittest.TestCase):
     def test_it(self):
         from pyramid.view import view_defaults
+
         @view_defaults(route_name='abc', renderer='def')
-        class Foo(object): pass
-        self.assertEqual(Foo.__view_defaults__['route_name'],'abc')
-        self.assertEqual(Foo.__view_defaults__['renderer'],'def')
+        class Foo(object):
+            pass
+
+        self.assertEqual(Foo.__view_defaults__['route_name'], 'abc')
+        self.assertEqual(Foo.__view_defaults__['renderer'], 'def')
 
     def test_it_inheritance_not_overridden(self):
         from pyramid.view import view_defaults
+
         @view_defaults(route_name='abc', renderer='def')
-        class Foo(object): pass
-        class Bar(Foo): pass
-        self.assertEqual(Bar.__view_defaults__['route_name'],'abc')
-        self.assertEqual(Bar.__view_defaults__['renderer'],'def')
+        class Foo(object):
+            pass
+
+        class Bar(Foo):
+            pass
+
+        self.assertEqual(Bar.__view_defaults__['route_name'], 'abc')
+        self.assertEqual(Bar.__view_defaults__['renderer'], 'def')
 
     def test_it_inheritance_overriden(self):
         from pyramid.view import view_defaults
+
         @view_defaults(route_name='abc', renderer='def')
-        class Foo(object): pass
+        class Foo(object):
+            pass
+
         @view_defaults(route_name='ghi')
-        class Bar(Foo): pass
-        self.assertEqual(Bar.__view_defaults__['route_name'],'ghi')
+        class Bar(Foo):
+            pass
+
+        self.assertEqual(Bar.__view_defaults__['route_name'], 'ghi')
         self.assertFalse('renderer' in Bar.__view_defaults__)
 
     def test_it_inheritance_overriden_empty(self):
         from pyramid.view import view_defaults
+
         @view_defaults(route_name='abc', renderer='def')
-        class Foo(object): pass
+        class Foo(object):
+            pass
+
         @view_defaults()
-        class Bar(Foo): pass
+        class Bar(Foo):
+            pass
+
         self.assertEqual(Bar.__view_defaults__, {})
 
+
 class TestViewMethodsMixin(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
@@ -792,8 +964,10 @@ class TestViewMethodsMixin(unittest.TestCase):
     def _makeOne(self, environ=None):
         from pyramid.decorator import reify
         from pyramid.view import ViewMethodsMixin
+
         if environ is None:
             environ = {}
+
         class Request(ViewMethodsMixin):
             def __init__(self, environ):
                 self.environ = environ
@@ -801,6 +975,7 @@ class TestViewMethodsMixin(unittest.TestCase):
             @reify
             def response(self):
                 return DummyResponse()
+
         request = Request(environ)
         request.registry = self.config.registry
         return request
@@ -810,6 +985,7 @@ class TestViewMethodsMixin(unittest.TestCase):
             self.assertTrue(exc is dummy_exc)
             self.assertTrue(request.exception is dummy_exc)
             return DummyResponse(b'foo')
+
         self.config.add_view(exc_view, context=RuntimeError)
         request = self._makeOne()
         dummy_exc = RuntimeError()
@@ -818,7 +994,7 @@ class TestViewMethodsMixin(unittest.TestCase):
         except RuntimeError:
             response = request.invoke_exception_view()
             self.assertEqual(response.app_iter, [b'foo'])
-        else: # pragma: no cover
+        else:  # pragma: no cover
             self.fail()
 
     def test_it_hides_attrs(self):
@@ -829,6 +1005,7 @@ class TestViewMethodsMixin(unittest.TestCase):
             self.assertTrue(request.response is not orig_response)
             request.response.app_iter = [b'bar']
             return request.response
+
         self.config.add_view(exc_view, context=RuntimeError)
         request = self._makeOne()
         orig_exc = request.exception = DummyContext()
@@ -842,15 +1019,17 @@ class TestViewMethodsMixin(unittest.TestCase):
             self.assertTrue(request.exception is ex)
             self.assertTrue(request.exc_info[1] is ex)
             self.assertTrue(request.response is orig_response)
-        else: # pragma: no cover
+        else:  # pragma: no cover
             self.fail()
 
     def test_it_supports_alternate_requests(self):
         def exc_view(exc, request):
             self.assertTrue(request is other_req)
             from pyramid.threadlocal import get_current_request
+
             self.assertTrue(get_current_request() is other_req)
             return DummyResponse(b'foo')
+
         self.config.add_view(exc_view, context=RuntimeError)
         request = self._makeOne()
         other_req = self._makeOne()
@@ -859,12 +1038,13 @@ class TestViewMethodsMixin(unittest.TestCase):
         except RuntimeError:
             response = request.invoke_exception_view(request=other_req)
             self.assertEqual(response.app_iter, [b'foo'])
-        else: # pragma: no cover
+        else:  # pragma: no cover
             self.fail()
 
     def test_it_supports_threadlocal_registry(self):
         def exc_view(exc, request):
             return DummyResponse(b'foo')
+
         self.config.add_view(exc_view, context=RuntimeError)
         request = self._makeOne()
         del request.registry
@@ -873,13 +1053,14 @@ class TestViewMethodsMixin(unittest.TestCase):
         except RuntimeError:
             response = request.invoke_exception_view()
             self.assertEqual(response.app_iter, [b'foo'])
-        else: # pragma: no cover
+        else:  # pragma: no cover
             self.fail()
 
     def test_it_raises_if_no_registry(self):
         request = self._makeOne()
         del request.registry
         from pyramid.threadlocal import manager
+
         manager.push({'registry': None, 'request': request})
         try:
             raise RuntimeError
@@ -888,7 +1069,7 @@ class TestViewMethodsMixin(unittest.TestCase):
                 request.invoke_exception_view()
             except RuntimeError as e:
                 self.assertEqual(e.args[0], "Unable to retrieve registry")
-        else: # pragma: no cover
+        else:  # pragma: no cover
             self.fail()
         finally:
             manager.pop()
@@ -897,6 +1078,7 @@ class TestViewMethodsMixin(unittest.TestCase):
         def exc_view(exc, request):
             self.assertTrue(request.exc_info is exc_info)
             return DummyResponse(b'foo')
+
         self.config.add_view(exc_view, context=RuntimeError)
         request = self._makeOne()
         try:
@@ -908,7 +1090,10 @@ class TestViewMethodsMixin(unittest.TestCase):
 
     def test_it_rejects_secured_view(self):
         from pyramid.exceptions import Forbidden
-        def exc_view(exc, request): pass
+
+        def exc_view(exc, request):
+            pass
+
         self.config.testing_securitypolicy(permissive=False)
         self.config.add_view(exc_view, context=RuntimeError, permission='view')
         request = self._makeOne()
@@ -916,12 +1101,13 @@ class TestViewMethodsMixin(unittest.TestCase):
             raise RuntimeError
         except RuntimeError:
             self.assertRaises(Forbidden, request.invoke_exception_view)
-        else: # pragma: no cover
+        else:  # pragma: no cover
             self.fail()
 
     def test_it_allows_secured_view(self):
         def exc_view(exc, request):
             return DummyResponse(b'foo')
+
         self.config.testing_securitypolicy(permissive=False)
         self.config.add_view(exc_view, context=RuntimeError, permission='view')
         request = self._makeOne()
@@ -930,18 +1116,19 @@ class TestViewMethodsMixin(unittest.TestCase):
         except RuntimeError:
             response = request.invoke_exception_view(secure=False)
             self.assertEqual(response.app_iter, [b'foo'])
-        else: # pragma: no cover
+        else:  # pragma: no cover
             self.fail()
 
     def test_it_raises_if_not_found(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         request = self._makeOne()
         dummy_exc = RuntimeError()
         try:
             raise dummy_exc
         except RuntimeError:
             self.assertRaises(HTTPNotFound, request.invoke_exception_view)
-        else: # pragma: no cover
+        else:  # pragma: no cover
             self.fail()
 
     def test_it_reraises_if_not_found(self):
@@ -952,14 +1139,20 @@ class TestViewMethodsMixin(unittest.TestCase):
         except RuntimeError:
             self.assertRaises(
                 RuntimeError,
-                lambda: request.invoke_exception_view(reraise=True))
-        else: # pragma: no cover
+                lambda: request.invoke_exception_view(reraise=True),
+            )
+        else:  # pragma: no cover
             self.fail()
 
     def test_it_raises_predicate_mismatch(self):
         from pyramid.exceptions import PredicateMismatch
-        def exc_view(exc, request): pass
-        self.config.add_view(exc_view, context=Exception, request_method='POST')
+
+        def exc_view(exc, request):
+            pass
+
+        self.config.add_view(
+            exc_view, context=Exception, request_method='POST'
+        )
         request = self._makeOne()
         request.method = 'GET'
         dummy_exc = RuntimeError()
@@ -967,12 +1160,16 @@ class TestViewMethodsMixin(unittest.TestCase):
             raise dummy_exc
         except RuntimeError:
             self.assertRaises(PredicateMismatch, request.invoke_exception_view)
-        else: # pragma: no cover
+        else:  # pragma: no cover
             self.fail()
 
     def test_it_reraises_after_predicate_mismatch(self):
-        def exc_view(exc, request): pass
-        self.config.add_view(exc_view, context=Exception, request_method='POST')
+        def exc_view(exc, request):
+            pass
+
+        self.config.add_view(
+            exc_view, context=Exception, request_method='POST'
+        )
         request = self._makeOne()
         request.method = 'GET'
         dummy_exc = RuntimeError()
@@ -981,23 +1178,29 @@ class TestViewMethodsMixin(unittest.TestCase):
         except RuntimeError:
             self.assertRaises(
                 RuntimeError,
-                lambda: request.invoke_exception_view(reraise=True))
-        else: # pragma: no cover
+                lambda: request.invoke_exception_view(reraise=True),
+            )
+        else:  # pragma: no cover
             self.fail()
 
+
 class ExceptionResponse(Exception):
     status = '404 Not Found'
     app_iter = ['Not Found']
     headerlist = []
 
+
 class DummyContext:
     pass
 
+
 def make_view(response):
     def view(context, request):
         return response
+
     return view
 
+
 class DummyRequest:
     exception = None
     request_iface = IRequest
@@ -1006,30 +1209,38 @@ class DummyRequest:
         if environ is None:
             environ = {}
         self.environ = environ
-        
+
+
 from pyramid.interfaces import IResponse
 
+
 @implementer(IResponse)
 class DummyResponse(object):
     headerlist = ()
     app_iter = ()
     status = '200 OK'
     environ = None
+
     def __init__(self, body=None):
         if body is None:
             self.app_iter = ()
         else:
             self.app_iter = [body]
 
+
 from zope.interface import Interface
+
+
 class IContext(Interface):
     pass
 
+
 class DummyVenusianInfo(object):
     scope = 'notaclass'
     module = sys.modules['tests']
     codeinfo = 'codeinfo'
 
+
 class DummyVenusian(object):
     def __init__(self, info=None):
         if info is None:
@@ -1041,9 +1252,11 @@ class DummyVenusian(object):
         self.attachments.append((wrapped, callback, category, depth))
         return self.info
 
+
 class DummyRegistry(object):
     pass
 
+
 class DummyConfig(object):
     def __init__(self):
         self.settings = []
@@ -1058,14 +1271,15 @@ class DummyConfig(object):
         self.pkg = pkg
         return self
 
+
 class DummyVenusianContext(object):
     def __init__(self):
         self.config = DummyConfig()
-        
+
+
 def call_venusian(venusian, context=None):
     if context is None:
         context = DummyVenusianContext()
     for wrapped, callback, category, depth in venusian.attachments:
         callback(context, None, None)
     return context.config
-
diff --git a/tests/test_viewderivers.py b/tests/test_viewderivers.py
index 69dcc7d08..4ce0b8a9e 100644
--- a/tests/test_viewderivers.py
+++ b/tests/test_viewderivers.py
@@ -3,13 +3,10 @@ from zope.interface import implementer
 
 from pyramid import testing
 from pyramid.exceptions import ConfigurationError
-from pyramid.interfaces import (
-    IResponse,
-    IRequest,
-    )
+from pyramid.interfaces import IResponse, IRequest
 
-class TestDeriveView(unittest.TestCase):
 
+class TestDeriveView(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
         self.config.set_default_csrf_options(require_csrf=False)
@@ -25,6 +22,7 @@ class TestDeriveView(unittest.TestCase):
 
     def _registerLogger(self):
         from pyramid.interfaces import IDebugLogger
+
         logger = DummyLogger()
         self.config.registry.registerUtility(logger, IDebugLogger)
         return logger
@@ -32,6 +30,7 @@ class TestDeriveView(unittest.TestCase):
     def _registerSecurityPolicy(self, permissive):
         from pyramid.interfaces import IAuthenticationPolicy
         from pyramid.interfaces import IAuthorizationPolicy
+
         policy = DummySecurityPolicy(permissive)
         self.config.registry.registerUtility(policy, IAuthenticationPolicy)
         self.config.registry.registerUtility(policy, IAuthorizationPolicy)
@@ -39,6 +38,7 @@ class TestDeriveView(unittest.TestCase):
     def test_function_returns_non_adaptable(self):
         def view(request):
             return None
+
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
         try:
@@ -49,14 +49,15 @@ class TestDeriveView(unittest.TestCase):
                 'Could not convert return value of the view callable function '
                 'tests.test_viewderivers.view into a response '
                 'object. The value returned was None. You may have forgotten '
-                'to return a value from the view callable.'
-                )
-        else: # pragma: no cover
+                'to return a value from the view callable.',
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_function_returns_non_adaptable_dict(self):
         def view(request):
-            return {'a':1}
+            return {'a': 1}
+
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
         try:
@@ -67,15 +68,16 @@ class TestDeriveView(unittest.TestCase):
                 "Could not convert return value of the view callable function "
                 "tests.test_viewderivers.view into a response "
                 "object. The value returned was {'a': 1}. You may have "
-                "forgotten to define a renderer in the view configuration."
-                )
-        else: # pragma: no cover
+                "forgotten to define a renderer in the view configuration.",
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_instance_returns_non_adaptable(self):
         class AView(object):
             def __call__(self, request):
                 return None
+
         view = AView()
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
@@ -83,20 +85,29 @@ class TestDeriveView(unittest.TestCase):
             result(None, None)
         except ValueError as e:
             msg = e.args[0]
-            self.assertTrue(msg.startswith(
-                'Could not convert return value of the view callable object '
-                '<tests.test_viewderivers.'))
-            self.assertTrue(msg.endswith(
-                '> into a response object. The value returned was None. You '
-                'may have forgotten to return a value from the view callable.'))
-        else: # pragma: no cover
+            self.assertTrue(
+                msg.startswith(
+                    'Could not convert return value of the view callable object '
+                    '<tests.test_viewderivers.'
+                )
+            )
+            self.assertTrue(
+                msg.endswith(
+                    '> into a response object. The value returned was None. You '
+                    'may have forgotten to return a value from the view callable.'
+                )
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_function_returns_true_Response_no_renderer(self):
         from pyramid.response import Response
+
         r = Response('Hello')
+
         def view(request):
             return r
+
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
         response = result(None, None)
@@ -104,9 +115,12 @@ class TestDeriveView(unittest.TestCase):
 
     def test_function_returns_true_Response_with_renderer(self):
         from pyramid.response import Response
+
         r = Response('Hello')
+
         def view(request):
             return r
+
         renderer = object()
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
@@ -115,11 +129,14 @@ class TestDeriveView(unittest.TestCase):
 
     def test_requestonly_default_method_returns_non_adaptable(self):
         request = DummyRequest()
+
         class AView(object):
             def __init__(self, request):
                 pass
+
             def __call__(self):
                 return None
+
         result = self.config.derive_view(AView)
         self.assertFalse(result is AView)
         try:
@@ -131,18 +148,21 @@ class TestDeriveView(unittest.TestCase):
                 'method __call__ of '
                 'class tests.test_viewderivers.AView into a '
                 'response object. The value returned was None. You may have '
-                'forgotten to return a value from the view callable.'
-                )
-        else: # pragma: no cover
+                'forgotten to return a value from the view callable.',
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_requestonly_nondefault_method_returns_non_adaptable(self):
         request = DummyRequest()
+
         class AView(object):
             def __init__(self, request):
                 pass
+
             def theviewmethod(self):
                 return None
+
         result = self.config.derive_view(AView, attr='theviewmethod')
         self.assertFalse(result is AView)
         try:
@@ -154,21 +174,24 @@ class TestDeriveView(unittest.TestCase):
                 'method theviewmethod of '
                 'class tests.test_viewderivers.AView into a '
                 'response object. The value returned was None. You may have '
-                'forgotten to return a value from the view callable.'
-                )
-        else: # pragma: no cover
+                'forgotten to return a value from the view callable.',
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_requestonly_function(self):
         response = DummyResponse()
+
         def view(request):
             return response
+
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
         self.assertEqual(result(None, None), response)
 
     def test_requestonly_function_with_renderer(self):
         response = DummyResponse()
+
         class moo(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
@@ -176,10 +199,13 @@ class TestDeriveView(unittest.TestCase):
                 self.assertEqual(view_inst, view)
                 self.assertEqual(ctx, context)
                 return response
+
             def clone(self):
                 return self
+
         def view(request):
             return 'OK'
+
         result = self.config.derive_view(view, renderer=moo())
         self.assertFalse(result.__wraps__ is view)
         request = self._makeRequest()
@@ -193,9 +219,12 @@ class TestDeriveView(unittest.TestCase):
                 self.assertEqual(system['request'], request)
                 self.assertEqual(system['context'], context)
                 return b'moo'
+
             return inner
+
         def view(request):
             return 'OK'
+
         self.config.add_renderer('moo', moo)
         result = self.config.derive_view(view, renderer='string')
         self.assertFalse(result is view)
@@ -206,6 +235,7 @@ class TestDeriveView(unittest.TestCase):
 
     def test_requestonly_function_with_renderer_request_has_view(self):
         response = DummyResponse()
+
         class moo(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
@@ -213,10 +243,13 @@ class TestDeriveView(unittest.TestCase):
                 self.assertEqual(view_inst, 'view')
                 self.assertEqual(ctx, context)
                 return response
+
             def clone(self):
                 return self
+
         def view(request):
             return 'OK'
+
         result = self.config.derive_view(view, renderer=moo())
         self.assertFalse(result.__wraps__ is view)
         request = self._makeRequest()
@@ -228,11 +261,14 @@ class TestDeriveView(unittest.TestCase):
 
     def test_class_without_attr(self):
         response = DummyResponse()
+
         class View(object):
             def __init__(self, request):
                 pass
+
             def __call__(self):
                 return response
+
         result = self.config.derive_view(View)
         request = self._makeRequest()
         self.assertEqual(result(None, request), response)
@@ -240,11 +276,14 @@ class TestDeriveView(unittest.TestCase):
 
     def test_class_with_attr(self):
         response = DummyResponse()
+
         class View(object):
             def __init__(self, request):
                 pass
+
             def another(self):
                 return response
+
         result = self.config.derive_view(View, attr='another')
         request = self._makeRequest()
         self.assertEqual(result(None, request), response)
@@ -253,6 +292,7 @@ class TestDeriveView(unittest.TestCase):
     def test_as_function_context_and_request(self):
         def view(context, request):
             return 'OK'
+
         result = self.config.derive_view(view)
         self.assertTrue(result.__wraps__ is view)
         self.assertFalse(hasattr(result, '__call_permissive__'))
@@ -260,8 +300,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_function_requestonly(self):
         response = DummyResponse()
+
         def view(request):
             return response
+
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
         self.assertEqual(view.__module__, result.__module__)
@@ -272,11 +314,14 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_newstyle_class_context_and_request(self):
         response = DummyResponse()
+
         class view(object):
             def __init__(self, context, request):
                 pass
+
             def __call__(self):
                 return response
+
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
         self.assertEqual(view.__module__, result.__module__)
@@ -289,11 +334,14 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_newstyle_class_requestonly(self):
         response = DummyResponse()
+
         class view(object):
             def __init__(self, context, request):
                 pass
+
             def __call__(self):
                 return response
+
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
         self.assertEqual(view.__module__, result.__module__)
@@ -306,11 +354,14 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_oldstyle_class_context_and_request(self):
         response = DummyResponse()
+
         class view:
             def __init__(self, context, request):
                 pass
+
             def __call__(self):
                 return response
+
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
         self.assertEqual(view.__module__, result.__module__)
@@ -323,11 +374,14 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_oldstyle_class_requestonly(self):
         response = DummyResponse()
+
         class view:
             def __init__(self, context, request):
                 pass
+
             def __call__(self):
                 return response
+
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
         self.assertEqual(view.__module__, result.__module__)
@@ -340,9 +394,11 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_instance_context_and_request(self):
         response = DummyResponse()
+
         class View:
             def __call__(self, context, request):
                 return response
+
         view = View()
         result = self.config.derive_view(view)
         self.assertTrue(result.__wraps__ is view)
@@ -351,9 +407,11 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_instance_requestonly(self):
         response = DummyResponse()
+
         class View:
             def __call__(self, request):
                 return response
+
         view = View()
         result = self.config.derive_view(view)
         self.assertFalse(result is view)
@@ -367,7 +425,8 @@ class TestDeriveView(unittest.TestCase):
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = dict(
-            debug_authorization=True, reload_templates=True)
+            debug_authorization=True, reload_templates=True
+        )
         logger = self._registerLogger()
         result = self.config._derive_view(view, permission='view')
         self.assertEqual(view.__module__, result.__module__)
@@ -379,16 +438,19 @@ class TestDeriveView(unittest.TestCase):
         request.url = 'url'
         self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
-        self.assertEqual(logger.messages[0],
-                         "debug_authorization of url url (view name "
-                         "'view_name' against context None): Allowed "
-                         "(no authorization policy in use)")
+        self.assertEqual(
+            logger.messages[0],
+            "debug_authorization of url url (view name "
+            "'view_name' against context None): Allowed "
+            "(no authorization policy in use)",
+        )
 
     def test_with_debug_authorization_authn_policy_no_authz_policy(self):
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = dict(debug_authorization=True)
         from pyramid.interfaces import IAuthenticationPolicy
+
         policy = DummySecurityPolicy(False)
         self.config.registry.registerUtility(policy, IAuthenticationPolicy)
         logger = self._registerLogger()
@@ -402,16 +464,19 @@ class TestDeriveView(unittest.TestCase):
         request.url = 'url'
         self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
-        self.assertEqual(logger.messages[0],
-                         "debug_authorization of url url (view name "
-                         "'view_name' against context None): Allowed "
-                         "(no authorization policy in use)")
+        self.assertEqual(
+            logger.messages[0],
+            "debug_authorization of url url (view name "
+            "'view_name' against context None): Allowed "
+            "(no authorization policy in use)",
+        )
 
     def test_with_debug_authorization_authz_policy_no_authn_policy(self):
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = dict(debug_authorization=True)
         from pyramid.interfaces import IAuthorizationPolicy
+
         policy = DummySecurityPolicy(False)
         self.config.registry.registerUtility(policy, IAuthorizationPolicy)
         logger = self._registerLogger()
@@ -425,16 +490,19 @@ class TestDeriveView(unittest.TestCase):
         request.url = 'url'
         self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
-        self.assertEqual(logger.messages[0],
-                         "debug_authorization of url url (view name "
-                         "'view_name' against context None): Allowed "
-                         "(no authorization policy in use)")
+        self.assertEqual(
+            logger.messages[0],
+            "debug_authorization of url url (view name "
+            "'view_name' against context None): Allowed "
+            "(no authorization policy in use)",
+        )
 
     def test_with_debug_authorization_no_permission(self):
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = dict(
-            debug_authorization=True, reload_templates=True)
+            debug_authorization=True, reload_templates=True
+        )
         self._registerSecurityPolicy(True)
         logger = self._registerLogger()
         result = self.config._derive_view(view)
@@ -447,16 +515,19 @@ class TestDeriveView(unittest.TestCase):
         request.url = 'url'
         self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
-        self.assertEqual(logger.messages[0],
-                         "debug_authorization of url url (view name "
-                         "'view_name' against context None): Allowed ("
-                         "no permission registered)")
+        self.assertEqual(
+            logger.messages[0],
+            "debug_authorization of url url (view name "
+            "'view_name' against context None): Allowed ("
+            "no permission registered)",
+        )
 
     def test_debug_auth_permission_authpol_permitted(self):
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = dict(
-            debug_authorization=True, reload_templates=True)
+            debug_authorization=True, reload_templates=True
+        )
         logger = self._registerLogger()
         self._registerSecurityPolicy(True)
         result = self.config._derive_view(view, permission='view')
@@ -469,15 +540,18 @@ class TestDeriveView(unittest.TestCase):
         request.url = 'url'
         self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
-        self.assertEqual(logger.messages[0],
-                         "debug_authorization of url url (view name "
-                         "'view_name' against context None): True")
+        self.assertEqual(
+            logger.messages[0],
+            "debug_authorization of url url (view name "
+            "'view_name' against context None): True",
+        )
 
     def test_debug_auth_permission_authpol_permitted_no_request(self):
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = dict(
-            debug_authorization=True, reload_templates=True)
+            debug_authorization=True, reload_templates=True
+        )
         logger = self._registerLogger()
         self._registerSecurityPolicy(True)
         result = self.config._derive_view(view, permission='view')
@@ -487,16 +561,20 @@ class TestDeriveView(unittest.TestCase):
         self.assertEqual(result.__call_permissive__.__wraps__, view)
         self.assertEqual(result(None, None), response)
         self.assertEqual(len(logger.messages), 1)
-        self.assertEqual(logger.messages[0],
-                         "debug_authorization of url None (view name "
-                         "None against context None): True")
+        self.assertEqual(
+            logger.messages[0],
+            "debug_authorization of url None (view name "
+            "None against context None): True",
+        )
 
     def test_debug_auth_permission_authpol_denied(self):
         from pyramid.httpexceptions import HTTPForbidden
+
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = dict(
-            debug_authorization=True, reload_templates=True)
+            debug_authorization=True, reload_templates=True
+        )
         logger = self._registerLogger()
         self._registerSecurityPolicy(False)
         result = self.config._derive_view(view, permission='view')
@@ -509,14 +587,17 @@ class TestDeriveView(unittest.TestCase):
         request.url = 'url'
         self.assertRaises(HTTPForbidden, result, None, request)
         self.assertEqual(len(logger.messages), 1)
-        self.assertEqual(logger.messages[0],
-                         "debug_authorization of url url (view name "
-                         "'view_name' against context None): False")
+        self.assertEqual(
+            logger.messages[0],
+            "debug_authorization of url url (view name "
+            "'view_name' against context None): False",
+        )
 
     def test_debug_auth_permission_authpol_denied2(self):
         view = lambda *arg: 'OK'
         self.config.registry.settings = dict(
-            debug_authorization=True, reload_templates=True)
+            debug_authorization=True, reload_templates=True
+        )
         self._registerLogger()
         self._registerSecurityPolicy(False)
         result = self.config._derive_view(view, permission='view')
@@ -531,13 +612,17 @@ class TestDeriveView(unittest.TestCase):
 
     def test_debug_auth_permission_authpol_overridden(self):
         from pyramid.security import NO_PERMISSION_REQUIRED
+
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = dict(
-            debug_authorization=True, reload_templates=True)
+            debug_authorization=True, reload_templates=True
+        )
         logger = self._registerLogger()
         self._registerSecurityPolicy(False)
-        result = self.config._derive_view(view, permission=NO_PERMISSION_REQUIRED)
+        result = self.config._derive_view(
+            view, permission=NO_PERMISSION_REQUIRED
+        )
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
@@ -547,20 +632,24 @@ class TestDeriveView(unittest.TestCase):
         request.url = 'url'
         self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
-        self.assertEqual(logger.messages[0],
-                         "debug_authorization of url url (view name "
-                         "'view_name' against context None): "
-                         "Allowed (NO_PERMISSION_REQUIRED)")
+        self.assertEqual(
+            logger.messages[0],
+            "debug_authorization of url url (view name "
+            "'view_name' against context None): "
+            "Allowed (NO_PERMISSION_REQUIRED)",
+        )
 
     def test_debug_auth_permission_authpol_permitted_excview(self):
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = dict(
-            debug_authorization=True, reload_templates=True)
+            debug_authorization=True, reload_templates=True
+        )
         logger = self._registerLogger()
         self._registerSecurityPolicy(True)
         result = self.config._derive_view(
-            view, context=Exception, permission='view')
+            view, context=Exception, permission='view'
+        )
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
@@ -570,15 +659,18 @@ class TestDeriveView(unittest.TestCase):
         request.url = 'url'
         self.assertEqual(result(Exception(), request), response)
         self.assertEqual(len(logger.messages), 1)
-        self.assertEqual(logger.messages[0],
-                         "debug_authorization of url url (view name "
-                         "'view_name' against context Exception()): True")
+        self.assertEqual(
+            logger.messages[0],
+            "debug_authorization of url url (view name "
+            "'view_name' against context Exception()): True",
+        )
 
     def test_secured_view_authn_policy_no_authz_policy(self):
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = {}
         from pyramid.interfaces import IAuthenticationPolicy
+
         policy = DummySecurityPolicy(False)
         self.config.registry.registerUtility(policy, IAuthenticationPolicy)
         result = self.config._derive_view(view, permission='view')
@@ -596,6 +688,7 @@ class TestDeriveView(unittest.TestCase):
         view = lambda *arg: response
         self.config.registry.settings = {}
         from pyramid.interfaces import IAuthorizationPolicy
+
         policy = DummySecurityPolicy(False)
         self.config.registry.registerUtility(policy, IAuthorizationPolicy)
         result = self.config._derive_view(view, permission='view')
@@ -612,6 +705,7 @@ class TestDeriveView(unittest.TestCase):
         from pyramid.interfaces import IAuthenticationPolicy
         from pyramid.interfaces import IAuthorizationPolicy
         from pyramid.httpexceptions import HTTPForbidden
+
         response = DummyResponse()
         view = lambda *arg: response
         self.config.registry.settings = {}
@@ -625,16 +719,20 @@ class TestDeriveView(unittest.TestCase):
         try:
             result(None, request)
         except HTTPForbidden as e:
-            self.assertEqual(e.message,
-                             'Unauthorized: <lambda> failed permission check')
-        else: # pragma: no cover
+            self.assertEqual(
+                e.message, 'Unauthorized: <lambda> failed permission check'
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_secured_view_raises_forbidden_with_name(self):
         from pyramid.interfaces import IAuthenticationPolicy
         from pyramid.interfaces import IAuthorizationPolicy
         from pyramid.httpexceptions import HTTPForbidden
-        def myview(request): pass
+
+        def myview(request):
+            pass
+
         self.config.registry.settings = {}
         policy = DummySecurityPolicy(False)
         self.config.registry.registerUtility(policy, IAuthenticationPolicy)
@@ -646,22 +744,28 @@ class TestDeriveView(unittest.TestCase):
         try:
             result(None, request)
         except HTTPForbidden as e:
-            self.assertEqual(e.message,
-                             'Unauthorized: myview failed permission check')
-        else: # pragma: no cover
+            self.assertEqual(
+                e.message, 'Unauthorized: myview failed permission check'
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_secured_view_skipped_by_default_on_exception_view(self):
         from pyramid.request import Request
         from pyramid.security import NO_PERMISSION_REQUIRED
+
         def view(request):
             raise ValueError
+
         def excview(request):
             return 'hello'
+
         self._registerSecurityPolicy(False)
         self.config.add_settings({'debug_authorization': True})
         self.config.set_default_permission('view')
-        self.config.add_view(view, name='foo', permission=NO_PERMISSION_REQUIRED)
+        self.config.add_view(
+            view, name='foo', permission=NO_PERMISSION_REQUIRED
+        )
         self.config.add_view(excview, context=ValueError, renderer='string')
         app = self.config.make_wsgi_app()
         request = Request.blank('/foo', base_url='http://example.com')
@@ -673,13 +777,20 @@ class TestDeriveView(unittest.TestCase):
         from pyramid.httpexceptions import HTTPForbidden
         from pyramid.request import Request
         from pyramid.security import NO_PERMISSION_REQUIRED
+
         def view(request):
             raise ValueError
-        def excview(request): pass
+
+        def excview(request):
+            pass
+
         self._registerSecurityPolicy(False)
-        self.config.add_view(view, name='foo', permission=NO_PERMISSION_REQUIRED)
-        self.config.add_view(excview, context=ValueError, renderer='string',
-                             permission='view')
+        self.config.add_view(
+            view, name='foo', permission=NO_PERMISSION_REQUIRED
+        )
+        self.config.add_view(
+            excview, context=ValueError, renderer='string', permission='view'
+        )
         app = self.config.make_wsgi_app()
         request = Request.blank('/foo', base_url='http://example.com')
         request.method = 'POST'
@@ -687,20 +798,26 @@ class TestDeriveView(unittest.TestCase):
             request.get_response(app)
         except HTTPForbidden:
             pass
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_secured_view_passed_on_explicit_exception_view(self):
         from pyramid.request import Request
         from pyramid.security import NO_PERMISSION_REQUIRED
+
         def view(request):
             raise ValueError
+
         def excview(request):
             return 'hello'
+
         self._registerSecurityPolicy(True)
-        self.config.add_view(view, name='foo', permission=NO_PERMISSION_REQUIRED)
-        self.config.add_view(excview, context=ValueError, renderer='string',
-                             permission='view')
+        self.config.add_view(
+            view, name='foo', permission=NO_PERMISSION_REQUIRED
+        )
+        self.config.add_view(
+            excview, context=ValueError, renderer='string', permission='view'
+        )
         app = self.config.make_wsgi_app()
         request = Request.blank('/foo', base_url='http://example.com')
         request.method = 'POST'
@@ -710,10 +827,13 @@ class TestDeriveView(unittest.TestCase):
 
     def test_predicate_mismatch_view_has_no_name(self):
         from pyramid.exceptions import PredicateMismatch
+
         response = DummyResponse()
         view = lambda *arg: response
+
         def predicate1(context, request):
             return False
+
         predicate1.text = lambda *arg: 'text'
         result = self.config._derive_view(view, predicates=[predicate1])
         request = self._makeRequest()
@@ -721,16 +841,21 @@ class TestDeriveView(unittest.TestCase):
         try:
             result(None, None)
         except PredicateMismatch as e:
-            self.assertEqual(e.detail,
-                             'predicate mismatch for view <lambda> (text)')
-        else: # pragma: no cover
+            self.assertEqual(
+                e.detail, 'predicate mismatch for view <lambda> (text)'
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_predicate_mismatch_view_has_name(self):
         from pyramid.exceptions import PredicateMismatch
-        def myview(request): pass
+
+        def myview(request):
+            pass
+
         def predicate1(context, request):
             return False
+
         predicate1.text = lambda *arg: 'text'
         result = self.config._derive_view(myview, predicates=[predicate1])
         request = self._makeRequest()
@@ -738,44 +863,57 @@ class TestDeriveView(unittest.TestCase):
         try:
             result(None, None)
         except PredicateMismatch as e:
-            self.assertEqual(e.detail,
-                             'predicate mismatch for view myview (text)')
-        else: # pragma: no cover
+            self.assertEqual(
+                e.detail, 'predicate mismatch for view myview (text)'
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_predicate_mismatch_exception_has_text_in_detail(self):
         from pyramid.exceptions import PredicateMismatch
-        def myview(request): pass
+
+        def myview(request):
+            pass
+
         def predicate1(context, request):
             return True
+
         predicate1.text = lambda *arg: 'pred1'
+
         def predicate2(context, request):
             return False
+
         predicate2.text = lambda *arg: 'pred2'
-        result = self.config._derive_view(myview, 
-            predicates=[predicate1, predicate2])
+        result = self.config._derive_view(
+            myview, predicates=[predicate1, predicate2]
+        )
         request = self._makeRequest()
         request.method = 'POST'
         try:
             result(None, None)
         except PredicateMismatch as e:
-            self.assertEqual(e.detail,
-                             'predicate mismatch for view myview (pred2)')
-        else: # pragma: no cover
+            self.assertEqual(
+                e.detail, 'predicate mismatch for view myview (pred2)'
+            )
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_with_predicates_all(self):
         response = DummyResponse()
         view = lambda *arg: response
         predicates = []
+
         def predicate1(context, request):
             predicates.append(True)
             return True
+
         def predicate2(context, request):
             predicates.append(True)
             return True
-        result = self.config._derive_view(view, 
-            predicates=[predicate1, predicate2])
+
+        result = self.config._derive_view(
+            view, predicates=[predicate1, predicate2]
+        )
         request = self._makeRequest()
         request.method = 'POST'
         next = result(None, None)
@@ -785,14 +923,18 @@ class TestDeriveView(unittest.TestCase):
     def test_with_predicates_checker(self):
         view = lambda *arg: 'OK'
         predicates = []
+
         def predicate1(context, request):
             predicates.append(True)
             return True
+
         def predicate2(context, request):
             predicates.append(True)
             return True
-        result = self.config._derive_view(view, 
-            predicates=[predicate1, predicate2])
+
+        result = self.config._derive_view(
+            view, predicates=[predicate1, predicate2]
+        )
         request = self._makeRequest()
         request.method = 'POST'
         next = result.__predicated__(None, None)
@@ -801,18 +943,24 @@ class TestDeriveView(unittest.TestCase):
 
     def test_with_predicates_notall(self):
         from pyramid.httpexceptions import HTTPNotFound
+
         view = lambda *arg: 'OK'
         predicates = []
+
         def predicate1(context, request):
             predicates.append(True)
             return True
+
         predicate1.text = lambda *arg: 'text'
+
         def predicate2(context, request):
             predicates.append(True)
             return False
+
         predicate2.text = lambda *arg: 'text'
-        result = self.config._derive_view(view, 
-            predicates=[predicate1, predicate2])
+        result = self.config._derive_view(
+            view, predicates=[predicate1, predicate2]
+        )
         request = self._makeRequest()
         request.method = 'POST'
         self.assertRaises(HTTPNotFound, result, None, None)
@@ -822,19 +970,26 @@ class TestDeriveView(unittest.TestCase):
         from pyramid.response import Response
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
+
         inner_response = Response('OK')
+
         def inner_view(context, request):
             return inner_response
+
         def outer_view(context, request):
             self.assertEqual(request.wrapped_response, inner_response)
             self.assertEqual(request.wrapped_body, inner_response.body)
-            self.assertEqual(request.wrapped_view.__original_view__,
-                             inner_view)
+            self.assertEqual(
+                request.wrapped_view.__original_view__, inner_view
+            )
             return Response(b'outer ' + request.wrapped_body)
+
         self.config.registry.registerAdapter(
-            outer_view, (IViewClassifier, None, None), IView, 'owrap')
-        result = self.config._derive_view(inner_view, viewname='inner',
-                                wrapper_viewname='owrap')
+            outer_view, (IViewClassifier, None, None), IView, 'owrap'
+        )
+        result = self.config._derive_view(
+            inner_view, viewname='inner', wrapper_viewname='owrap'
+        )
         self.assertFalse(result is inner_view)
         self.assertEqual(inner_view.__module__, result.__module__)
         self.assertEqual(inner_view.__doc__, result.__doc__)
@@ -844,32 +999,42 @@ class TestDeriveView(unittest.TestCase):
 
     def test_with_wrapper_viewname_notfound(self):
         from pyramid.response import Response
+
         inner_response = Response('OK')
+
         def inner_view(context, request):
             return inner_response
-        wrapped = self.config._derive_view(inner_view, viewname='inner',
-                                wrapper_viewname='owrap')
+
+        wrapped = self.config._derive_view(
+            inner_view, viewname='inner', wrapper_viewname='owrap'
+        )
         request = self._makeRequest()
         self.assertRaises(ValueError, wrapped, None, request)
 
     def test_as_newstyle_class_context_and_request_attr_and_renderer(self):
         response = DummyResponse()
+
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
-                self.assertEqual(resp, {'a':'1'})
+                self.assertEqual(resp, {'a': '1'})
                 self.assertEqual(view_inst.__class__, View)
                 self.assertEqual(ctx, context)
                 return response
+
             def clone(self):
                 return self
+
         class View(object):
             def __init__(self, context, request):
                 pass
+
             def index(self):
-                return {'a':'1'}
-        result = self.config._derive_view(View, 
-            renderer=renderer(), attr='index')
+                return {'a': '1'}
+
+        result = self.config._derive_view(
+            View, renderer=renderer(), attr='index'
+        )
         self.assertFalse(result is View)
         self.assertEqual(result.__module__, View.__module__)
         self.assertEqual(result.__doc__, View.__doc__)
@@ -880,22 +1045,28 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_newstyle_class_requestonly_attr_and_renderer(self):
         response = DummyResponse()
+
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
-                self.assertEqual(resp, {'a':'1'})
+                self.assertEqual(resp, {'a': '1'})
                 self.assertEqual(view_inst.__class__, View)
                 self.assertEqual(ctx, context)
                 return response
+
             def clone(self):
                 return self
+
         class View(object):
             def __init__(self, request):
                 pass
+
             def index(self):
-                return {'a':'1'}
-        result = self.config.derive_view(View, 
-            renderer=renderer(), attr='index')
+                return {'a': '1'}
+
+        result = self.config.derive_view(
+            View, renderer=renderer(), attr='index'
+        )
         self.assertFalse(result is View)
         self.assertEqual(result.__module__, View.__module__)
         self.assertEqual(result.__doc__, View.__doc__)
@@ -906,22 +1077,28 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_oldstyle_cls_context_request_attr_and_renderer(self):
         response = DummyResponse()
+
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
-                self.assertEqual(resp, {'a':'1'})
+                self.assertEqual(resp, {'a': '1'})
                 self.assertEqual(view_inst.__class__, View)
                 self.assertEqual(ctx, context)
                 return response
+
             def clone(self):
                 return self
+
         class View:
             def __init__(self, context, request):
                 pass
+
             def index(self):
-                return {'a':'1'}
-        result = self.config.derive_view(View, 
-            renderer=renderer(), attr='index')
+                return {'a': '1'}
+
+        result = self.config.derive_view(
+            View, renderer=renderer(), attr='index'
+        )
         self.assertFalse(result is View)
         self.assertEqual(result.__module__, View.__module__)
         self.assertEqual(result.__doc__, View.__doc__)
@@ -932,22 +1109,28 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_oldstyle_cls_requestonly_attr_and_renderer(self):
         response = DummyResponse()
+
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
-                self.assertEqual(resp, {'a':'1'})
+                self.assertEqual(resp, {'a': '1'})
                 self.assertEqual(view_inst.__class__, View)
                 self.assertEqual(ctx, context)
                 return response
+
             def clone(self):
                 return self
+
         class View:
             def __init__(self, request):
                 pass
+
             def index(self):
-                return {'a':'1'}
-        result = self.config.derive_view(View, 
-            renderer=renderer(), attr='index')
+                return {'a': '1'}
+
+        result = self.config.derive_view(
+            View, renderer=renderer(), attr='index'
+        )
         self.assertFalse(result is View)
         self.assertEqual(result.__module__, View.__module__)
         self.assertEqual(result.__doc__, View.__doc__)
@@ -958,21 +1141,26 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_instance_context_and_request_attr_and_renderer(self):
         response = DummyResponse()
+
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
-                self.assertEqual(resp, {'a':'1'})
+                self.assertEqual(resp, {'a': '1'})
                 self.assertEqual(view_inst, view)
                 self.assertEqual(ctx, context)
                 return response
+
             def clone(self):
                 return self
+
         class View:
             def index(self, context, request):
-                return {'a':'1'}
+                return {'a': '1'}
+
         view = View()
-        result = self.config.derive_view(view, 
-            renderer=renderer(), attr='index')
+        result = self.config.derive_view(
+            view, renderer=renderer(), attr='index'
+        )
         self.assertFalse(result is view)
         self.assertEqual(result.__module__, view.__module__)
         self.assertEqual(result.__doc__, view.__doc__)
@@ -982,21 +1170,26 @@ class TestDeriveView(unittest.TestCase):
 
     def test_as_instance_requestonly_attr_and_renderer(self):
         response = DummyResponse()
+
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
-                self.assertEqual(resp, {'a':'1'})
+                self.assertEqual(resp, {'a': '1'})
                 self.assertEqual(view_inst, view)
                 self.assertEqual(ctx, context)
                 return response
+
             def clone(self):
                 return self
+
         class View:
             def index(self, request):
-                return {'a':'1'}
+                return {'a': '1'}
+
         view = View()
-        result = self.config.derive_view(view, 
-            renderer=renderer(), attr='index')
+        result = self.config.derive_view(
+            view, renderer=renderer(), attr='index'
+        )
         self.assertFalse(result is view)
         self.assertEqual(result.__module__, view.__module__)
         self.assertEqual(result.__doc__, view.__doc__)
@@ -1006,29 +1199,42 @@ class TestDeriveView(unittest.TestCase):
 
     def test_with_view_mapper_config_specified(self):
         response = DummyResponse()
+
         class mapper(object):
             def __init__(self, **kw):
                 self.kw = kw
+
             def __call__(self, view):
                 def wrapped(context, request):
                     return response
+
                 return wrapped
-        def view(context, request): return 'NOTOK'
+
+        def view(context, request):
+            return 'NOTOK'
+
         result = self.config._derive_view(view, mapper=mapper)
         self.assertFalse(result.__wraps__ is view)
         self.assertEqual(result(None, None), response)
 
     def test_with_view_mapper_view_specified(self):
         from pyramid.response import Response
+
         response = Response()
+
         def mapper(**kw):
             def inner(view):
                 def superinner(context, request):
                     self.assertEqual(request, None)
                     return response
+
                 return superinner
+
             return inner
-        def view(context, request): return 'NOTOK'
+
+        def view(context, request):
+            return 'NOTOK'
+
         view.__view_mapper__ = mapper
         result = self.config.derive_view(view)
         self.assertFalse(result.__wraps__ is view)
@@ -1036,37 +1242,53 @@ class TestDeriveView(unittest.TestCase):
 
     def test_with_view_mapper_default_mapper_specified(self):
         from pyramid.response import Response
+
         response = Response()
+
         def mapper(**kw):
             def inner(view):
                 def superinner(context, request):
                     self.assertEqual(request, None)
-                    return  response
+                    return response
+
                 return superinner
+
             return inner
+
         self.config.set_view_mapper(mapper)
-        def view(context, request): return 'NOTOK'
+
+        def view(context, request):
+            return 'NOTOK'
+
         result = self.config.derive_view(view)
         self.assertFalse(result.__wraps__ is view)
         self.assertEqual(result(None, None), response)
 
     def test_attr_wrapped_view_branching_default_phash(self):
         from pyramid.config.util import DEFAULT_PHASH
-        def view(context, request): pass
+
+        def view(context, request):
+            pass
+
         result = self.config._derive_view(view, phash=DEFAULT_PHASH)
         self.assertEqual(result.__wraps__, view)
 
     def test_attr_wrapped_view_branching_nondefault_phash(self):
-        def view(context, request): pass
+        def view(context, request):
+            pass
+
         result = self.config._derive_view(view, phash='nondefault')
         self.assertNotEqual(result, view)
 
     def test_http_cached_view_integer(self):
         import datetime
         from pyramid.response import Response
+
         response = Response('OK')
+
         def inner_view(context, request):
             return response
+
         result = self.config._derive_view(inner_view, http_cache=3600)
         self.assertFalse(result is inner_view)
         self.assertEqual(inner_view.__module__, result.__module__)
@@ -1083,11 +1305,15 @@ class TestDeriveView(unittest.TestCase):
     def test_http_cached_view_timedelta(self):
         import datetime
         from pyramid.response import Response
+
         response = Response('OK')
+
         def inner_view(context, request):
             return response
-        result = self.config._derive_view(inner_view, 
-            http_cache=datetime.timedelta(hours=1))
+
+        result = self.config._derive_view(
+            inner_view, http_cache=datetime.timedelta(hours=1)
+        )
         self.assertFalse(result is inner_view)
         self.assertEqual(inner_view.__module__, result.__module__)
         self.assertEqual(inner_view.__doc__, result.__doc__)
@@ -1103,11 +1329,15 @@ class TestDeriveView(unittest.TestCase):
     def test_http_cached_view_tuple(self):
         import datetime
         from pyramid.response import Response
+
         response = Response('OK')
+
         def inner_view(context, request):
             return response
-        result = self.config._derive_view(inner_view,
-            http_cache=(3600, {'public':True}))
+
+        result = self.config._derive_view(
+            inner_view, http_cache=(3600, {'public': True})
+        )
         self.assertFalse(result is inner_view)
         self.assertEqual(inner_view.__module__, result.__module__)
         self.assertEqual(inner_view.__doc__, result.__doc__)
@@ -1122,11 +1352,15 @@ class TestDeriveView(unittest.TestCase):
 
     def test_http_cached_view_tuple_seconds_None(self):
         from pyramid.response import Response
+
         response = Response('OK')
+
         def inner_view(context, request):
             return response
-        result = self.config._derive_view(inner_view,
-            http_cache=(None, {'public':True}))
+
+        result = self.config._derive_view(
+            inner_view, http_cache=(None, {'public': True})
+        )
         self.assertFalse(result is inner_view)
         self.assertEqual(inner_view.__module__, result.__module__)
         self.assertEqual(inner_view.__doc__, result.__doc__)
@@ -1139,14 +1373,17 @@ class TestDeriveView(unittest.TestCase):
 
     def test_http_cached_view_prevent_auto_set(self):
         from pyramid.response import Response
+
         response = Response()
         response.cache_control.prevent_auto = True
+
         def inner_view(context, request):
             return response
+
         result = self.config._derive_view(inner_view, http_cache=3600)
         request = self._makeRequest()
         result = result(None, request)
-        self.assertEqual(result, response) # doesn't blow up
+        self.assertEqual(result, response)  # doesn't blow up
         headers = dict(result.headerlist)
         self.assertFalse('Expires' in headers)
         self.assertFalse('Cache-Control' in headers)
@@ -1154,9 +1391,12 @@ class TestDeriveView(unittest.TestCase):
     def test_http_cached_prevent_http_cache_in_settings(self):
         self.config.registry.settings['prevent_http_cache'] = True
         from pyramid.response import Response
+
         response = Response()
+
         def inner_view(context, request):
             return response
+
         result = self.config._derive_view(inner_view, http_cache=3600)
         request = self._makeRequest()
         result = result(None, request)
@@ -1166,14 +1406,22 @@ class TestDeriveView(unittest.TestCase):
         self.assertFalse('Cache-Control' in headers)
 
     def test_http_cached_view_bad_tuple(self):
-        def view(request): pass
-        self.assertRaises(ConfigurationError, self.config._derive_view, 
-            view, http_cache=(None,))
+        def view(request):
+            pass
+
+        self.assertRaises(
+            ConfigurationError,
+            self.config._derive_view,
+            view,
+            http_cache=(None,),
+        )
 
     def test_csrf_view_ignores_GET(self):
         response = DummyResponse()
+
         def inner_view(request):
             return response
+
         request = self._makeRequest()
         request.method = 'GET'
         view = self.config._derive_view(inner_view, require_csrf=True)
@@ -1182,7 +1430,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_fails_with_bad_POST_header(self):
         from pyramid.exceptions import BadCSRFToken
-        def inner_view(request): pass
+
+        def inner_view(request):
+            pass
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
@@ -1193,8 +1444,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_passes_with_good_POST_header(self):
         response = DummyResponse()
+
         def inner_view(request):
             return response
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
@@ -1206,7 +1459,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_fails_with_bad_POST_token(self):
         from pyramid.exceptions import BadCSRFToken
-        def inner_view(request): pass
+
+        def inner_view(request):
+            pass
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
@@ -1217,8 +1473,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_passes_with_good_POST_token(self):
         response = DummyResponse()
+
         def inner_view(request):
             return response
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
@@ -1230,8 +1488,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_https_domain(self):
         response = DummyResponse()
+
         def inner_view(request):
             return response
+
         request = self._makeRequest()
         request.scheme = "https"
         request.domain = "example.com"
@@ -1246,7 +1506,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_fails_on_bad_PUT_header(self):
         from pyramid.exceptions import BadCSRFToken
-        def inner_view(request): pass
+
+        def inner_view(request):
+            pass
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'PUT'
@@ -1257,7 +1520,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_fails_on_bad_referrer(self):
         from pyramid.exceptions import BadCSRFOrigin
-        def inner_view(request): pass
+
+        def inner_view(request):
+            pass
+
         request = self._makeRequest()
         request.method = "POST"
         request.scheme = "https"
@@ -1270,7 +1536,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_fails_on_bad_origin(self):
         from pyramid.exceptions import BadCSRFOrigin
-        def inner_view(request): pass
+
+        def inner_view(request):
+            pass
+
         request = self._makeRequest()
         request.method = "POST"
         request.scheme = "https"
@@ -1283,7 +1552,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_enabled_by_default(self):
         from pyramid.exceptions import BadCSRFToken
-        def inner_view(request): pass
+
+        def inner_view(request):
+            pass
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
@@ -1295,35 +1567,48 @@ class TestDeriveView(unittest.TestCase):
     def test_csrf_view_enabled_via_callback(self):
         def callback(request):
             return True
+
         from pyramid.exceptions import BadCSRFToken
-        def inner_view(request): pass
+
+        def inner_view(request):
+            pass
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
         request.session = DummySession({'csrf_token': 'foo'})
-        self.config.set_default_csrf_options(require_csrf=True, callback=callback)
+        self.config.set_default_csrf_options(
+            require_csrf=True, callback=callback
+        )
         view = self.config._derive_view(inner_view)
         self.assertRaises(BadCSRFToken, lambda: view(None, request))
 
     def test_csrf_view_disabled_via_callback(self):
         def callback(request):
             return False
+
         response = DummyResponse()
+
         def inner_view(request):
             return response
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
         request.session = DummySession({'csrf_token': 'foo'})
-        self.config.set_default_csrf_options(require_csrf=True, callback=callback)
+        self.config.set_default_csrf_options(
+            require_csrf=True, callback=callback
+        )
         view = self.config._derive_view(inner_view)
         result = view(None, request)
         self.assertTrue(result is response)
 
     def test_csrf_view_uses_custom_csrf_token(self):
         response = DummyResponse()
+
         def inner_view(request):
             return response
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
@@ -1336,8 +1621,10 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_uses_custom_csrf_header(self):
         response = DummyResponse()
+
         def inner_view(request):
             return response
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
@@ -1350,22 +1637,27 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_uses_custom_methods(self):
         response = DummyResponse()
+
         def inner_view(request):
             return response
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'PUT'
         request.session = DummySession({'csrf_token': 'foo'})
         self.config.set_default_csrf_options(
-            require_csrf=True, safe_methods=['PUT'])
+            require_csrf=True, safe_methods=['PUT']
+        )
         view = self.config._derive_view(inner_view)
         result = view(None, request)
         self.assertTrue(result is response)
 
     def test_csrf_view_uses_view_option_override(self):
         response = DummyResponse()
+
         def inner_view(request):
             return response
+
         request = self._makeRequest()
         request.scheme = "http"
         request.method = 'POST'
@@ -1378,13 +1670,17 @@ class TestDeriveView(unittest.TestCase):
 
     def test_csrf_view_skipped_by_default_on_exception_view(self):
         from pyramid.request import Request
+
         def view(request):
             raise ValueError
+
         def excview(request):
             return 'hello'
+
         self.config.set_default_csrf_options(require_csrf=True)
         self.config.set_session_factory(
-            lambda request: DummySession({'csrf_token': 'foo'}))
+            lambda request: DummySession({'csrf_token': 'foo'})
+        )
         self.config.add_view(view, name='foo', require_csrf=False)
         self.config.add_view(excview, context=ValueError, renderer='string')
         app = self.config.make_wsgi_app()
@@ -1396,15 +1692,21 @@ class TestDeriveView(unittest.TestCase):
     def test_csrf_view_failed_on_explicit_exception_view(self):
         from pyramid.exceptions import BadCSRFToken
         from pyramid.request import Request
+
         def view(request):
             raise ValueError
-        def excview(request): pass
+
+        def excview(request):
+            pass
+
         self.config.set_default_csrf_options(require_csrf=True)
         self.config.set_session_factory(
-            lambda request: DummySession({'csrf_token': 'foo'}))
+            lambda request: DummySession({'csrf_token': 'foo'})
+        )
         self.config.add_view(view, name='foo', require_csrf=False)
-        self.config.add_view(excview, context=ValueError, renderer='string',
-                             require_csrf=True)
+        self.config.add_view(
+            excview, context=ValueError, renderer='string', require_csrf=True
+        )
         app = self.config.make_wsgi_app()
         request = Request.blank('/foo', base_url='http://example.com')
         request.method = 'POST'
@@ -1412,21 +1714,26 @@ class TestDeriveView(unittest.TestCase):
             request.get_response(app)
         except BadCSRFToken:
             pass
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_csrf_view_passed_on_explicit_exception_view(self):
         from pyramid.request import Request
+
         def view(request):
             raise ValueError
+
         def excview(request):
             return 'hello'
+
         self.config.set_default_csrf_options(require_csrf=True)
         self.config.set_session_factory(
-            lambda request: DummySession({'csrf_token': 'foo'}))
+            lambda request: DummySession({'csrf_token': 'foo'})
+        )
         self.config.add_view(view, name='foo', require_csrf=False)
-        self.config.add_view(excview, context=ValueError, renderer='string',
-                             require_csrf=True)
+        self.config.add_view(
+            excview, context=ValueError, renderer='string', require_csrf=True
+        )
         app = self.config.make_wsgi_app()
         request = Request.blank('/foo', base_url='http://example.com')
         request.method = 'POST'
@@ -1447,24 +1754,29 @@ class TestDerivationOrder(unittest.TestCase):
         from pyramid.interfaces import IViewDerivers
 
         self.config.add_view_deriver(None, 'deriv1')
-        self.config.add_view_deriver(None, 'deriv2', 'decorated_view', 'deriv1')
+        self.config.add_view_deriver(
+            None, 'deriv2', 'decorated_view', 'deriv1'
+        )
         self.config.add_view_deriver(None, 'deriv3', 'deriv2', 'deriv1')
 
         derivers = self.config.registry.getUtility(IViewDerivers)
         derivers_sorted = derivers.sorted()
         dlist = [d for (d, _) in derivers_sorted]
-        self.assertEqual([
-            'secured_view',
-            'csrf_view',
-            'owrapped_view',
-            'http_cached_view',
-            'decorated_view',
-            'deriv2',
-            'deriv3',
-            'deriv1',
-            'rendered_view',
-            'mapped_view',
-            ], dlist)
+        self.assertEqual(
+            [
+                'secured_view',
+                'csrf_view',
+                'owrapped_view',
+                'http_cached_view',
+                'decorated_view',
+                'deriv2',
+                'deriv3',
+                'deriv1',
+                'rendered_view',
+                'mapped_view',
+            ],
+            dlist,
+        )
 
     def test_right_order_implicit(self):
         from pyramid.interfaces import IViewDerivers
@@ -1476,65 +1788,76 @@ class TestDerivationOrder(unittest.TestCase):
         derivers = self.config.registry.getUtility(IViewDerivers)
         derivers_sorted = derivers.sorted()
         dlist = [d for (d, _) in derivers_sorted]
-        self.assertEqual([
-            'secured_view',
-            'csrf_view',
-            'owrapped_view',
-            'http_cached_view',
-            'decorated_view',
-            'deriv3',
-            'deriv2',
-            'deriv1',
-            'rendered_view',
-            'mapped_view',
-            ], dlist)
+        self.assertEqual(
+            [
+                'secured_view',
+                'csrf_view',
+                'owrapped_view',
+                'http_cached_view',
+                'decorated_view',
+                'deriv3',
+                'deriv2',
+                'deriv1',
+                'rendered_view',
+                'mapped_view',
+            ],
+            dlist,
+        )
 
     def test_right_order_under_rendered_view(self):
         from pyramid.interfaces import IViewDerivers
 
-        self.config.add_view_deriver(None, 'deriv1', 'rendered_view', 'mapped_view')
+        self.config.add_view_deriver(
+            None, 'deriv1', 'rendered_view', 'mapped_view'
+        )
 
         derivers = self.config.registry.getUtility(IViewDerivers)
         derivers_sorted = derivers.sorted()
         dlist = [d for (d, _) in derivers_sorted]
-        self.assertEqual([
-            'secured_view',
-            'csrf_view',
-            'owrapped_view',
-            'http_cached_view',
-            'decorated_view',
-            'rendered_view',
-            'deriv1',
-            'mapped_view',
-            ], dlist)
-
+        self.assertEqual(
+            [
+                'secured_view',
+                'csrf_view',
+                'owrapped_view',
+                'http_cached_view',
+                'decorated_view',
+                'rendered_view',
+                'deriv1',
+                'mapped_view',
+            ],
+            dlist,
+        )
 
     def test_right_order_under_rendered_view_others(self):
         from pyramid.interfaces import IViewDerivers
 
-        self.config.add_view_deriver(None, 'deriv1', 'rendered_view', 'mapped_view')
+        self.config.add_view_deriver(
+            None, 'deriv1', 'rendered_view', 'mapped_view'
+        )
         self.config.add_view_deriver(None, 'deriv2')
         self.config.add_view_deriver(None, 'deriv3')
 
         derivers = self.config.registry.getUtility(IViewDerivers)
         derivers_sorted = derivers.sorted()
         dlist = [d for (d, _) in derivers_sorted]
-        self.assertEqual([
-            'secured_view',
-            'csrf_view',
-            'owrapped_view',
-            'http_cached_view',
-            'decorated_view',
-            'deriv3',
-            'deriv2',
-            'rendered_view',
-            'deriv1',
-            'mapped_view',
-            ], dlist)
+        self.assertEqual(
+            [
+                'secured_view',
+                'csrf_view',
+                'owrapped_view',
+                'http_cached_view',
+                'decorated_view',
+                'deriv3',
+                'deriv2',
+                'rendered_view',
+                'deriv1',
+                'mapped_view',
+            ],
+            dlist,
+        )
 
 
 class TestAddDeriver(unittest.TestCase):
-
     def setUp(self):
         self.config = testing.setUp()
 
@@ -1589,6 +1912,7 @@ class TestAddDeriver(unittest.TestCase):
 
     def test_override_mapped_view(self):
         from pyramid.viewderivers import VIEW
+
         response = DummyResponse()
         view = lambda *arg: response
         flags = {}
@@ -1602,12 +1926,14 @@ class TestAddDeriver(unittest.TestCase):
 
         flags.clear()
         self.config.add_view_deriver(
-            deriv1, name='mapped_view', under='rendered_view', over=VIEW)
+            deriv1, name='mapped_view', under='rendered_view', over=VIEW
+        )
         result = self.config._derive_view(view)
         self.assertTrue(flags.get('deriv1'))
 
     def test_add_multi_derivers_ordered(self):
         from pyramid.viewderivers import INGRESS
+
         response = DummyResponse()
         view = lambda *arg: response
         response.deriv = []
@@ -1632,7 +1958,10 @@ class TestAddDeriver(unittest.TestCase):
 
     def test_add_deriver_without_name(self):
         from pyramid.interfaces import IViewDerivers
-        def deriv1(view, info): pass
+
+        def deriv1(view, info):
+            pass
+
         self.config.add_view_deriver(deriv1)
         derivers = self.config.registry.getUtility(IViewDerivers)
         self.assertTrue('deriv1' in derivers.names)
@@ -1640,40 +1969,53 @@ class TestAddDeriver(unittest.TestCase):
     def test_add_deriver_reserves_ingress(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.viewderivers import INGRESS
-        def deriv1(view, info): pass
+
+        def deriv1(view, info):
+            pass
+
         self.assertRaises(
-            ConfigurationError, self.config.add_view_deriver, deriv1, INGRESS)
+            ConfigurationError, self.config.add_view_deriver, deriv1, INGRESS
+        )
 
     def test_add_deriver_enforces_ingress_is_first(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.viewderivers import INGRESS
-        def deriv1(view, info): pass
+
+        def deriv1(view, info):
+            pass
+
         try:
             self.config.add_view_deriver(deriv1, over=INGRESS)
         except ConfigurationError as ex:
             self.assertTrue('cannot be over INGRESS' in ex.args[0])
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_add_deriver_enforces_view_is_last(self):
         from pyramid.exceptions import ConfigurationError
         from pyramid.viewderivers import VIEW
-        def deriv1(view, info): pass
+
+        def deriv1(view, info):
+            pass
+
         try:
             self.config.add_view_deriver(deriv1, under=VIEW)
         except ConfigurationError as ex:
             self.assertTrue('cannot be under VIEW' in ex.args[0])
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
     def test_add_deriver_enforces_mapped_view_is_last(self):
         from pyramid.exceptions import ConfigurationError
-        def deriv1(view, info): pass
+
+        def deriv1(view, info):
+            pass
+
         try:
             self.config.add_view_deriver(deriv1, 'deriv1', under='mapped_view')
         except ConfigurationError as ex:
             self.assertTrue('cannot be under "mapped_view"' in ex.args[0])
-        else: # pragma: no cover
+        else:  # pragma: no cover
             raise AssertionError
 
 
@@ -1685,20 +2027,25 @@ class TestDeriverIntegration(unittest.TestCase):
         self.config = None
         testing.tearDown()
 
-    def _getViewCallable(self, config, ctx_iface=None, request_iface=None,
-                         name=''):
+    def _getViewCallable(
+        self, config, ctx_iface=None, request_iface=None, name=''
+    ):
         from zope.interface import Interface
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
+
         classifier = IViewClassifier
         if ctx_iface is None:
             ctx_iface = Interface
         if request_iface is None:
             request_iface = IRequest
         return config.registry.adapters.lookup(
-            (classifier, request_iface, ctx_iface), IView, name=name,
-            default=None)
+            (classifier, request_iface, ctx_iface),
+            IView,
+            name=name,
+            default=None,
+        )
 
     def _makeRequest(self, config):
         request = DummyRequest()
@@ -1713,11 +2060,13 @@ class TestDeriverIntegration(unittest.TestCase):
         def deriv1(view, info):
             response.deriv.append(info.options['deriv1'])
             return view
+
         deriv1.options = ('deriv1',)
 
         def deriv2(view, info):
             response.deriv.append(info.options['deriv2'])
             return view
+
         deriv2.options = ('deriv2',)
 
         self.config.add_view_deriver(deriv1, 'deriv1')
@@ -1732,11 +2081,16 @@ class TestDeriverIntegration(unittest.TestCase):
 
     def test_unexpected_view_options(self):
         from pyramid.exceptions import ConfigurationError
-        def deriv1(view, info): pass
+
+        def deriv1(view, info):
+            pass
+
         self.config.add_view_deriver(deriv1, 'deriv1')
         self.assertRaises(
             ConfigurationError,
-            lambda: self.config.add_view(lambda r: {}, deriv1='test1'))
+            lambda: self.config.add_view(lambda r: {}, deriv1='test1'),
+        )
+
 
 @implementer(IResponse)
 class DummyResponse(object):
@@ -1744,10 +2098,11 @@ class DummyResponse(object):
     default_content_type = None
     body = None
 
+
 class DummyRequest:
     subpath = ()
     matchdict = None
-    request_iface  = IRequest
+    request_iface = IRequest
 
     def __init__(self, environ=None):
         if environ is None:
@@ -1759,14 +2114,18 @@ class DummyRequest:
         self.headers = {}
         self.response = DummyResponse()
 
+
 class DummyLogger:
     def __init__(self):
         self.messages = []
+
     def info(self, msg):
         self.messages.append(msg)
+
     warn = info
     debug = info
 
+
 class DummySecurityPolicy:
     def __init__(self, permitted=True):
         self.permitted = permitted
@@ -1777,19 +2136,23 @@ class DummySecurityPolicy:
     def permits(self, context, principals, permission):
         return self.permitted
 
+
 class DummySession(dict):
     def get_csrf_token(self):
         return self['csrf_token']
 
+
 def parse_httpdate(s):
     import datetime
+
     # cannot use %Z, must use literal GMT; Jython honors timezone
     # but CPython does not
     return datetime.datetime.strptime(s, "%a, %d %b %Y %H:%M:%S GMT")
 
+
 def assert_similar_datetime(one, two):
     for attr in ('year', 'month', 'day', 'hour', 'minute'):
         one_attr = getattr(one, attr)
         two_attr = getattr(two, attr)
-        if not one_attr == two_attr: # pragma: no cover
+        if not one_attr == two_attr:  # pragma: no cover
             raise AssertionError('%r != %r in %s' % (one_attr, two_attr, attr))
diff --git a/tests/test_wsgi.py b/tests/test_wsgi.py
index 4ddbc9201..a5a955621 100644
--- a/tests/test_wsgi.py
+++ b/tests/test_wsgi.py
@@ -1,8 +1,10 @@
 import unittest
 
+
 class WSGIAppTests(unittest.TestCase):
     def _callFUT(self, app):
         from pyramid.wsgi import wsgiapp
+
         return wsgiapp(app)
 
     def test_wsgiapp_none(self):
@@ -23,9 +25,11 @@ class WSGIAppTests(unittest.TestCase):
         response = decorator(context, request)
         self.assertEqual(response, app)
 
+
 class WSGIApp2Tests(unittest.TestCase):
     def _callFUT(self, app):
         from pyramid.wsgi import wsgiapp2
+
         return wsgiapp2(app)
 
     def test_wsgiapp2_none(self):
@@ -35,8 +39,10 @@ class WSGIApp2Tests(unittest.TestCase):
         context = DummyContext()
         request = DummyRequest()
         request.subpath = ('subpath',)
-        request.environ = {'SCRIPT_NAME':'/foo',
-                           'PATH_INFO':'/b/view_name/subpath'}
+        request.environ = {
+            'SCRIPT_NAME': '/foo',
+            'PATH_INFO': '/b/view_name/subpath',
+        }
         decorator = self._callFUT(dummyapp)
         response = decorator(context, request)
         self.assertEqual(response, dummyapp)
@@ -47,7 +53,7 @@ class WSGIApp2Tests(unittest.TestCase):
         context = DummyContext()
         request = DummyRequest()
         request.subpath = ('subpath',)
-        request.environ = {'SCRIPT_NAME':'/foo', 'PATH_INFO':'/b/subpath'}
+        request.environ = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/b/subpath'}
         decorator = self._callFUT(dummyapp)
         response = decorator(context, request)
         self.assertEqual(response, dummyapp)
@@ -58,7 +64,7 @@ class WSGIApp2Tests(unittest.TestCase):
         context = DummyContext()
         request = DummyRequest()
         request.subpath = ()
-        request.environ = {'SCRIPT_NAME':'/foo', 'PATH_INFO':'/b/view_name'}
+        request.environ = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/b/view_name'}
         decorator = self._callFUT(dummyapp)
         response = decorator(context, request)
         self.assertEqual(response, dummyapp)
@@ -69,7 +75,7 @@ class WSGIApp2Tests(unittest.TestCase):
         context = DummyContext()
         request = DummyRequest()
         request.subpath = ()
-        request.environ = {'SCRIPT_NAME':'/foo', 'PATH_INFO':'/view_name'}
+        request.environ = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/view_name'}
         decorator = self._callFUT(dummyapp)
         response = decorator(context, request)
         self.assertEqual(response, dummyapp)
@@ -80,7 +86,7 @@ class WSGIApp2Tests(unittest.TestCase):
         context = DummyContext()
         request = DummyRequest()
         request.subpath = ()
-        request.environ = {'SCRIPT_NAME':'/foo', 'PATH_INFO':'/'}
+        request.environ = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/'}
         decorator = self._callFUT(dummyapp)
         response = decorator(context, request)
         self.assertEqual(response, dummyapp)
@@ -91,7 +97,7 @@ class WSGIApp2Tests(unittest.TestCase):
         context = DummyContext()
         request = DummyRequest()
         request.subpath = ()
-        request.environ = {'SCRIPT_NAME':'', 'PATH_INFO':'/'}
+        request.environ = {'SCRIPT_NAME': '', 'PATH_INFO': '/'}
         decorator = self._callFUT(dummyapp)
         response = decorator(context, request)
         self.assertEqual(response, dummyapp)
@@ -102,7 +108,7 @@ class WSGIApp2Tests(unittest.TestCase):
         context = DummyContext()
         request = DummyRequest()
         request.subpath = ()
-        request.environ = {'SCRIPT_NAME':'/foo', 'PATH_INFO':'/'}
+        request.environ = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/'}
         app = DummyApp()
         decorator = self._callFUT(app)
         response = decorator(context, request)
@@ -110,16 +116,20 @@ class WSGIApp2Tests(unittest.TestCase):
         self.assertEqual(request.environ['PATH_INFO'], '/')
         self.assertEqual(request.environ['SCRIPT_NAME'], '/foo')
 
+
 def dummyapp(environ, start_response):
     """ """
 
+
 class DummyApp(object):
     def __call__(self, environ, start_response):
         """ """
 
+
 class DummyContext:
     pass
 
+
 class DummyRequest:
     def get_response(self, application):
         return application
@@ -127,4 +137,3 @@ class DummyRequest:
     def copy(self):
         self.copied = True
         return self
-