format source using black

111 files changed, 10010 insertions, 4846 deletions

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
-