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

[Jürgen Gmach]

Apply black code formatter

[Colin Watson (cjwatson)]

review: Approve

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 0000000..3a635e3
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,2 @@
+# apply black
+a08ff20b65010305eaf0a4de60c7913146658a76
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index d62393a..d4436ec 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,14 +2,27 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v3.2.0
+    rev: v4.0.1
     hooks:
     -   id: check-added-large-files
+    -   id: check-ast
+    -   id: check-json
     -   id: check-merge-conflict
+    -   id: check-toml
     -   id: check-xml
     -   id: check-yaml
     -   id: debug-statements
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+-   repo: https://github.com/psf/black
+    rev: 21.10b0
+    hooks:
+    -   id: black
 -   repo: https://github.com/PyCQA/flake8
-    rev: 3.9.2
+    rev: 4.0.1
     hooks:
     -   id: flake8
+-   repo: https://github.com/PyCQA/isort
+    rev: 5.10.1
+    hooks:
+    - id: isort
diff --git a/NEWS.txt b/NEWS.txt
index 2981bee..43c2138 100644
--- a/NEWS.txt
+++ b/NEWS.txt
@@ -7,6 +7,8 @@ NEWS for lazr.sshserver
 
 - Officially add support for Python 3.9 and 3.10.
 - Add basic pre-commit configuration.
+- Apply black code formatter.
+- Add isort pre-commit hook.
 
 0.1.12 (2021-09-13)
 ===================
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..15e7219
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,8 @@
+[tool.black]
+line-length = 79
+target-version = ['py27']
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 79
diff --git a/setup.py b/setup.py
index 2d54c2e..ce0f879 100755
--- a/setup.py
+++ b/setup.py
@@ -16,52 +16,52 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with lazr.sshserver.  If not, see <http://www.gnu.org/licenses/>.
 
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
 
 
 # generic helpers primarily for the long_description
 def generate(*docname_or_string):
     res = []
     for value in docname_or_string:
-        if value.endswith('.txt'):
+        if value.endswith(".txt"):
             f = open(value)
             value = f.read()
             f.close()
         res.append(value)
-        if not value.endswith('\n'):
-            res.append('')
-    return '\n'.join(res)
+        if not value.endswith("\n"):
+            res.append("")
+    return "\n".join(res)
+
+
 # end generic helpers
 
 
 setup(
-    name='lazr.sshserver',
-    version='0.1.12',
-    namespace_packages=['lazr'],
-    packages=find_packages('src'),
-    package_dir={'': 'src'},
+    name="lazr.sshserver",
+    version="0.1.12",
+    namespace_packages=["lazr"],
+    packages=find_packages("src"),
+    package_dir={"": "src"},
     include_package_data=True,
     zip_safe=False,
-    maintainer='LAZR Developers',
-    maintainer_email='[e-mail]',
-    description=open('README.txt').readline().strip(),
-    long_description=generate(
-        'src/lazr/sshserver/README.txt',
-        'NEWS.txt'),
-    license='LGPL v3',
+    maintainer="LAZR Developers",
+    maintainer_email="[e-mail]",
+    description=open("README.txt").readline().strip(),
+    long_description=generate("src/lazr/sshserver/README.txt", "NEWS.txt"),
+    license="LGPL v3",
     install_requires=[
-        'setuptools',
-        'Twisted[conch]>=16.2.0',
-        'zope.component',
-        'zope.event',
-        'zope.interface',
-        ],
-    url='https://launchpad.net/lazr.sshserver',
+        "setuptools",
+        "Twisted[conch]>=16.2.0",
+        "zope.component",
+        "zope.event",
+        "zope.interface",
+    ],
+    url="https://launchpad.net/lazr.sshserver",
     project_urls={
         "Source": "https://code.launchpad.net/lazr.sshserver",
         "Issue Tracker": "https://bugs.launchpad.net/lazr.sshserver",
     },
-    download_url='https://launchpad.net/lazr.sshserver/+download',
+    download_url="https://launchpad.net/lazr.sshserver/+download",
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Developers",
@@ -77,16 +77,16 @@ setup(
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
-        ],
+    ],
     extras_require=dict(
-        docs=['Sphinx'],
+        docs=["Sphinx"],
         test=[
             'bzr; python_version < "3.0"',
-            'fixtures',
-            'flake8',
-            'testtools',
-            'zope.testrunner',
-            ],
+            "fixtures",
+            "flake8",
+            "testtools",
+            "zope.testrunner",
+        ],
     ),
-    test_suite='lazr.sshserver.tests',
-    )
+    test_suite="lazr.sshserver.tests",
+)
diff --git a/src/lazr/__init__.py b/src/lazr/__init__.py
index ee457d8..1b88851 100644
--- a/src/lazr/__init__.py
+++ b/src/lazr/__init__.py
@@ -17,7 +17,9 @@
 # this is a namespace package
 try:
     import pkg_resources
+
     pkg_resources.declare_namespace(__name__)
 except ImportError:
     import pkgutil
+
     __path__ = pkgutil.extend_path(__path__, __name__)
diff --git a/src/lazr/sshserver/accesslog.py b/src/lazr/sshserver/accesslog.py
index 7471d7d..c18c7a9 100644
--- a/src/lazr/sshserver/accesslog.py
+++ b/src/lazr/sshserver/accesslog.py
@@ -7,19 +7,15 @@ from __future__ import absolute_import, print_function
 
 __metaclass__ = type
 __all__ = [
-    'LoggingManager',
-    ]
+    "LoggingManager",
+]
 
 import logging
 from logging.handlers import WatchedFileHandler
 
-from zope.component import (
-    adapter,
-    getGlobalSiteManager,
-    provideHandler,
-    )
 # This non-standard import is necessary to hook up the event system.
 import zope.component.event  # noqa: F401
+from zope.component import adapter, getGlobalSiteManager, provideHandler
 
 from lazr.sshserver.events import ILoggingEvent
 
@@ -55,7 +51,8 @@ class LoggingManager:
         log.addHandler(self._main_handler)
         self._access_handler = WatchedFileHandler(self._access_log_path)
         self._access_handler.setFormatter(
-            logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+            logging.Formatter("%(asctime)s %(levelname)s %(message)s")
+        )
         self._access_log.addHandler(self._access_handler)
         self._access_log.setLevel(logging.INFO)
         # Make sure that our logging event handler is there, ready to receive
diff --git a/src/lazr/sshserver/auth.py b/src/lazr/sshserver/auth.py
index f5510e9..3d88930 100644
--- a/src/lazr/sshserver/auth.py
+++ b/src/lazr/sshserver/auth.py
@@ -13,29 +13,20 @@ from __future__ import absolute_import, print_function
 
 __metaclass__ = type
 __all__ = [
-    'LaunchpadAvatar',
-    'PublicKeyFromLaunchpadChecker',
-    'SSHUserAuthServer',
-    ]
+    "LaunchpadAvatar",
+    "PublicKeyFromLaunchpadChecker",
+    "SSHUserAuthServer",
+]
 
 import base64
 import binascii
 import sys
 
 from twisted.conch import avatar
-from twisted.conch.error import (
-    ConchError,
-    ValidPublicKey,
-    )
+from twisted.conch.error import ConchError, ValidPublicKey
 from twisted.conch.interfaces import IConchUser
-from twisted.conch.ssh import (
-    keys,
-    userauth,
-    )
-from twisted.conch.ssh.common import (
-    getNS,
-    NS,
-    )
+from twisted.conch.ssh import keys, userauth
+from twisted.conch.ssh.common import NS, getNS
 from twisted.cred import credentials
 from twisted.cred.checkers import ICredentialsChecker
 from twisted.cred.error import UnauthorizedLogin
@@ -50,7 +41,6 @@ from lazr.sshserver import events
 from lazr.sshserver.session import PatchedSSHSession
 from lazr.sshserver.sftp import FileTransferServer
 
-
 log = Logger()
 
 
@@ -77,11 +67,12 @@ class NoSuchPersonWithName(xmlrpc.Fault):
     """There's no Person with the specified name registered in Launchpad."""
 
     error_code = 200
-    msg_template = 'No such person or team: %(person_name)s'
+    msg_template = "No such person or team: %(person_name)s"
 
     def __init__(self, person_name):
         super(NoSuchPersonWithName, self).__init__(
-            self.error_code, self.msg_template % {"person_name": person_name})
+            self.error_code, self.msg_template % {"person_name": person_name}
+        )
 
 
 class LaunchpadAvatar(avatar.ConchUser):
@@ -100,14 +91,14 @@ class LaunchpadAvatar(avatar.ConchUser):
             `IAuthServer.getUserAndSSHKeys`.
         """
         avatar.ConchUser.__init__(self)
-        self.user_id = user_dict['id']
-        self.username = user_dict['name']
+        self.user_id = user_dict["id"]
+        self.username = user_dict["name"]
 
         # Set the only channel as a standard SSH session (with a couple of bug
         # fixes).
-        self.channelLookup = {b'session': PatchedSSHSession}
+        self.channelLookup = {b"session": PatchedSSHSession}
         # ...and set the only subsystem to be SFTP.
-        self.subsystemLookup = {b'sftp': FileTransferServer}
+        self.subsystemLookup = {b"sftp": FileTransferServer}
 
     def logout(self):
         notify(events.UserLoggedOut(self))
@@ -127,7 +118,8 @@ class SSHPrivateKeyWithMind(credentials.SSHPrivateKey):
 
     def __init__(self, username, algName, blob, sigData, signature, mind):
         credentials.SSHPrivateKey.__init__(
-            self, username, algName, blob, sigData, signature)
+            self, username, algName, blob, sigData, signature
+        )
         self.mind = mind
 
 
@@ -154,11 +146,11 @@ class UserDetailsMind:
             endpoint.
         :param username: The username to look up.
         """
-        username = username.decode('UTF-8')
+        username = username.decode("UTF-8")
         if username in self.cache:
             return defer.succeed(self.cache[username])
         else:
-            d = proxy.callRemote('getUserAndSSHKeys', username)
+            d = proxy.callRemote("getUserAndSSHKeys", username)
             d.addBoth(self._add_to_cache, username)
             return d
 
@@ -189,12 +181,13 @@ class SSHUserAuthServer(userauth.SSHUserAuthServer):
         self._configured_banner_sent = False
         self._mind = UserDetailsMind()
         self.interfaceToMethod = userauth.SSHUserAuthServer.interfaceToMethod
-        self.interfaceToMethod[ISSHPrivateKeyWithMind] = b'publickey'
+        self.interfaceToMethod[ISSHPrivateKeyWithMind] = b"publickey"
 
-    def sendBanner(self, text, language='en'):
-        bytes = b'\r\n'.join(text.encode('UTF8').splitlines() + [b''])
-        self.transport.sendPacket(userauth.MSG_USERAUTH_BANNER,
-                                  NS(bytes) + NS(language))
+    def sendBanner(self, text, language="en"):
+        bytes = b"\r\n".join(text.encode("UTF8").splitlines() + [b""])
+        self.transport.sendPacket(
+            userauth.MSG_USERAUTH_BANNER, NS(bytes) + NS(language)
+        )
 
     def _sendConfiguredBanner(self, passed_through):
         if not self._configured_banner_sent and self._banner:
@@ -214,7 +207,7 @@ class SSHUserAuthServer(userauth.SSHUserAuthServer):
         self.method = method
         d = self.tryAuth(method, user, rest)
         if not d:
-            self._ebBadAuth(failure.Failure(ConchError('auth returned none')))
+            self._ebBadAuth(failure.Failure(ConchError("auth returned none")))
             return
         d.addCallback(self._sendConfiguredBanner)
         d.addCallback(self._cbFinishedAuth)
@@ -246,8 +239,9 @@ class SSHUserAuthServer(userauth.SSHUserAuthServer):
         """
         return self._mind
 
-    def makePublicKeyCredentials(self, username, algName, blob, sigData,
-                                 signature):
+    def makePublicKeyCredentials(
+        self, username, algName, blob, sigData, signature
+    ):
         """Construct credentials for a request to login with a public key.
 
         Our implementation returns a SSHPrivateKeyWithMind.
@@ -261,7 +255,8 @@ class SSHUserAuthServer(userauth.SSHUserAuthServer):
         """
         mind = self.getMind()
         return SSHPrivateKeyWithMind(
-                username, algName, blob, sigData, signature, mind)
+            username, algName, blob, sigData, signature, mind
+        )
 
     def auth_publickey(self, packet):
         # This is copied and pasted from twisted/conch/ssh/userauth.py in
@@ -278,30 +273,38 @@ class SSHUserAuthServer(userauth.SSHUserAuthServer):
             # Work around a bug in paramiko < 2.0.0: if the most significant
             # byte of an RSA signature is zero, then it strips leading zero
             # bytes rather than zero-padding it to the correct length.
-            if algName == b'ssh-rsa':
+            if algName == b"ssh-rsa":
                 signatureType, rawSignature, rest = getNS(signature, 2)
                 pubKeyLen = (pubKey.size() + 7) // 8
                 if len(rawSignature) < pubKeyLen:
                     rawSignature = (
-                        b'\x00' * (pubKeyLen - len(rawSignature)) +
-                        rawSignature)
+                        b"\x00" * (pubKeyLen - len(rawSignature))
+                        + rawSignature
+                    )
                     signature = NS(signatureType) + NS(rawSignature) + rest
             b = (
-                NS(self.transport.sessionID) +
-                _bytesChr(userauth.MSG_USERAUTH_REQUEST) + NS(self.user) +
-                NS(self.nextService) + NS(b'publickey') +
-                _bytesChr(hasSig) + NS(pubKey.sshType()) + NS(blob))
+                NS(self.transport.sessionID)
+                + _bytesChr(userauth.MSG_USERAUTH_REQUEST)
+                + NS(self.user)
+                + NS(self.nextService)
+                + NS(b"publickey")
+                + _bytesChr(hasSig)
+                + NS(pubKey.sshType())
+                + NS(blob)
+            )
             # The next three lines are different from the original.
             c = self.makePublicKeyCredentials(
-                self.user, algName, blob, b, signature)
+                self.user, algName, blob, b, signature
+            )
             return self.portal.login(c, self.getMind(), IConchUser)
         else:
             # The next four lines are different from the original.
             c = self.makePublicKeyCredentials(
-                self.user, algName, blob, None, None)
-            return self.portal.login(
-                c, self.getMind(), IConchUser).addErrback(
-                    self._ebCheckKey, packet[1:])
+                self.user, algName, blob, None, None
+            )
+            return self.portal.login(c, self.getMind(), IConchUser).addErrback(
+                self._ebCheckKey, packet[1:]
+            )
 
 
 # XXX cjwatson 2019-10-18: Ideally we'd use
@@ -315,6 +318,7 @@ class PublicKeyFromLaunchpadChecker:
 
     It knows how to get the public keys from the authserver.
     """
+
     credentialInterfaces = (ISSHPrivateKeyWithMind,)
 
     def __init__(self, authserver):
@@ -333,13 +337,17 @@ class PublicKeyFromLaunchpadChecker:
         has registered in Launchpad.
         """
         try:
-            username = credentials.username.decode('UTF-8')
+            username = credentials.username.decode("UTF-8")
         except UnicodeDecodeError:
             # Launchpad account names must be valid UTF-8.
-            return defer.fail(UserDisplayedUnauthorizedLogin(
-                "No such Launchpad account: %r" % credentials.username))
+            return defer.fail(
+                UserDisplayedUnauthorizedLogin(
+                    "No such Launchpad account: %r" % credentials.username
+                )
+            )
         d = credentials.mind.lookupUserDetails(
-            self.authserver, credentials.username)
+            self.authserver, credentials.username
+        )
         d.addCallback(self._checkForAuthorizedKey, credentials)
         d.addErrback(self._reportNoSuchUser, username)
         return d
@@ -350,29 +358,31 @@ class PublicKeyFromLaunchpadChecker:
         fault = failure.value
         if fault.faultCode == NoSuchPersonWithName.error_code:
             raise UserDisplayedUnauthorizedLogin(
-                "No such Launchpad account: %s" % username)
+                "No such Launchpad account: %s" % username
+            )
         raise failure
 
     def _checkForAuthorizedKey(self, user_dict, credentials):
         """Check the key data in credentials against the keys found in LP."""
-        if credentials.algName == b'ssh-dss':
-            wantKeyType = 'DSA'
-        elif credentials.algName == b'ssh-rsa':
-            wantKeyType = 'RSA'
-        elif credentials.algName.startswith(b'ecdsa-sha2-'):
-            wantKeyType = 'ECDSA'
-        elif credentials.algName == b'ssh-ed25519':
-            wantKeyType = 'ED25519'
+        if credentials.algName == b"ssh-dss":
+            wantKeyType = "DSA"
+        elif credentials.algName == b"ssh-rsa":
+            wantKeyType = "RSA"
+        elif credentials.algName.startswith(b"ecdsa-sha2-"):
+            wantKeyType = "ECDSA"
+        elif credentials.algName == b"ssh-ed25519":
+            wantKeyType = "ED25519"
         else:
             # unknown key type
             return False
 
-        if len(user_dict['keys']) == 0:
+        if len(user_dict["keys"]) == 0:
             raise UserDisplayedUnauthorizedLogin(
                 "Launchpad user '%s' doesn't have a registered SSH key"
-                % user_dict['name'])
+                % user_dict["name"]
+            )
 
-        for keytype, keytext in user_dict['keys']:
+        for keytype, keytext in user_dict["keys"]:
             if keytype != wantKeyType:
                 continue
             try:
@@ -383,7 +393,8 @@ class PublicKeyFromLaunchpadChecker:
 
         raise UnauthorizedLogin(
             "Your SSH key does not match any key registered for Launchpad "
-            "user %s" % user_dict['name'])
+            "user %s" % user_dict["name"]
+        )
 
     def _verifyKey(self, validKey, credentials):
         """Check whether the credentials themselves are valid.
diff --git a/src/lazr/sshserver/events.py b/src/lazr/sshserver/events.py
index ccc59be..5d0165b 100644
--- a/src/lazr/sshserver/events.py
+++ b/src/lazr/sshserver/events.py
@@ -7,27 +7,23 @@ from __future__ import absolute_import, print_function
 
 __metaclass__ = type
 __all__ = [
-    'AuthenticationFailed',
-    'AvatarEvent',
-    'ILoggingEvent',
-    'LoggingEvent',
-    'ServerStarting',
-    'ServerStopped',
-    'SFTPClosed',
-    'SFTPStarted',
-    'UserConnected',
-    'UserDisconnected',
-    'UserLoggedIn',
-    'UserLoggedOut',
-    ]
+    "AuthenticationFailed",
+    "AvatarEvent",
+    "ILoggingEvent",
+    "LoggingEvent",
+    "ServerStarting",
+    "ServerStopped",
+    "SFTPClosed",
+    "SFTPStarted",
+    "UserConnected",
+    "UserDisconnected",
+    "UserLoggedIn",
+    "UserLoggedOut",
+]
 
 import logging
 
-from zope.interface import (
-    Attribute,
-    implementer,
-    Interface,
-    )
+from zope.interface import Attribute, Interface, implementer
 
 
 class ILoggingEvent(Interface):
@@ -81,29 +77,28 @@ class LoggingEvent:
 class ServerStarting(LoggingEvent):
 
     level = logging.INFO
-    template = '---- Server started ----'
+    template = "---- Server started ----"
 
 
 class ServerStopped(LoggingEvent):
 
     level = logging.INFO
-    template = '---- Server stopped ----'
+    template = "---- Server stopped ----"
 
 
 class UserConnected(LoggingEvent):
 
     level = logging.INFO
-    template = '[%(session_id)s] %(address)s connected.'
+    template = "[%(session_id)s] %(address)s connected."
 
     def __init__(self, transport, address):
-        LoggingEvent.__init__(
-            self, session_id=id(transport), address=address)
+        LoggingEvent.__init__(self, session_id=id(transport), address=address)
 
 
 class AuthenticationFailed(LoggingEvent):
 
     level = logging.INFO
-    template = '[%(session_id)s] failed to authenticate.'
+    template = "[%(session_id)s] failed to authenticate."
 
     def __init__(self, transport):
         LoggingEvent.__init__(self, session_id=id(transport))
@@ -112,7 +107,7 @@ class AuthenticationFailed(LoggingEvent):
 class UserDisconnected(LoggingEvent):
 
     level = logging.INFO
-    template = '[%(session_id)s] disconnected.'
+    template = "[%(session_id)s] disconnected."
 
     def __init__(self, transport):
         LoggingEvent.__init__(self, session_id=id(transport))
@@ -126,24 +121,25 @@ class AvatarEvent(LoggingEvent):
     def __init__(self, avatar):
         self.avatar = avatar
         LoggingEvent.__init__(
-            self, session_id=id(avatar.transport), username=avatar.username)
+            self, session_id=id(avatar.transport), username=avatar.username
+        )
 
 
 class UserLoggedIn(AvatarEvent):
 
-    template = '[%(session_id)s] %(username)s logged in.'
+    template = "[%(session_id)s] %(username)s logged in."
 
 
 class UserLoggedOut(AvatarEvent):
 
-    template = '[%(session_id)s] %(username)s disconnected.'
+    template = "[%(session_id)s] %(username)s disconnected."
 
 
 class SFTPStarted(AvatarEvent):
 
-    template = '[%(session_id)s] %(username)s started SFTP session.'
+    template = "[%(session_id)s] %(username)s started SFTP session."
 
 
 class SFTPClosed(AvatarEvent):
 
-    template = '[%(session_id)s] %(username)s closed SFTP session.'
+    template = "[%(session_id)s] %(username)s closed SFTP session."
diff --git a/src/lazr/sshserver/service.py b/src/lazr/sshserver/service.py
index 023d866..2d0622f 100644
--- a/src/lazr/sshserver/service.py
+++ b/src/lazr/sshserver/service.py
@@ -10,17 +10,14 @@ from __future__ import absolute_import, print_function
 
 __metaclass__ = type
 __all__ = [
-    'SSHService',
-    ]
+    "SSHService",
+]
 
 
 import logging
 import os
 
-from twisted.application import (
-    service,
-    strports,
-    )
+from twisted.application import service, strports
 from twisted.conch.openssh_compat import primes
 from twisted.conch.ssh.factory import SSHFactory
 from twisted.conch.ssh.keys import Key
@@ -28,10 +25,7 @@ from twisted.conch.ssh.transport import SSHServerTransport
 from twisted.internet import defer
 from zope.event import notify
 
-from lazr.sshserver import (
-    accesslog,
-    events,
-    )
+from lazr.sshserver import accesslog, events
 from lazr.sshserver.auth import SSHUserAuthServer
 
 
@@ -48,6 +42,7 @@ def gatherResults(deferredList):
     :type deferredList:  list of `defer.Deferred`s.
     :return: `defer.Deferred`.
     """
+
     def convert_first_error_to_real(failure):
         failure.trap(defer.FirstError)
         return failure.value.subFailure
@@ -59,7 +54,6 @@ def gatherResults(deferredList):
 
 
 class KeepAliveSettingSSHServerTransport(SSHServerTransport):
-
     def connectionMade(self):
         SSHServerTransport.connectionMade(self)
         self.transport.setTcpKeepAlive(True)
@@ -75,8 +69,9 @@ class Factory(SSHFactory):
 
     protocol = KeepAliveSettingSSHServerTransport
 
-    def __init__(self, portal, private_key, public_key, banner=None,
-                 moduli_path=None):
+    def __init__(
+        self, portal, private_key, public_key, banner=None, moduli_path=None
+    ):
         """Construct an SSH factory.
 
         :param portal: The portal used to turn credentials into users.
@@ -92,14 +87,14 @@ class Factory(SSHFactory):
         # at it. (Look for the beautiful line "self.portal =
         # self.transport.factory.portal").
         self.portal = portal
-        self.services[b'ssh-userauth'] = self._makeAuthServer
+        self.services[b"ssh-userauth"] = self._makeAuthServer
         self._private_key = private_key
         self._public_key = public_key
         self._banner = banner
         self._moduli_path = moduli_path
 
     def _makeAuthServer(self, *args, **kwargs):
-        kwargs['banner'] = self._banner
+        kwargs["banner"] = self._banner
         return SSHUserAuthServer(*args, **kwargs)
 
     def buildProtocol(self, address):
@@ -110,8 +105,9 @@ class Factory(SSHFactory):
         """
         transport = SSHFactory.buildProtocol(self, address)
         transport._realConnectionLost = transport.connectionLost
-        transport.connectionLost = (
-            lambda reason: self.connectionLost(transport, reason))
+        transport.connectionLost = lambda reason: self.connectionLost(
+            transport, reason
+        )
         notify(events.UserConnected(transport, address))
         return transport
 
@@ -130,7 +126,7 @@ class Factory(SSHFactory):
             #
             # b) the server doesn't normally generate a "go away" event.
             # Rather, the client simply stops trying.
-            if getattr(transport, 'avatar', None) is None:
+            if getattr(transport, "avatar", None) is None:
                 notify(events.AuthenticationFailed(transport))
             notify(events.UserDisconnected(transport))
 
@@ -139,14 +135,14 @@ class Factory(SSHFactory):
 
         See `SSHFactory.getPublicKeys`.
         """
-        return {b'ssh-rsa': self._public_key}
+        return {b"ssh-rsa": self._public_key}
 
     def getPrivateKeys(self):
         """Return the server's configured private key.
 
         See `SSHFactory.getPrivateKeys`.
         """
-        return {b'ssh-rsa': self._private_key}
+        return {b"ssh-rsa": self._private_key}
 
     def getPrimes(self):
         try:
@@ -160,9 +156,19 @@ class Factory(SSHFactory):
 class SSHService(service.Service):
     """A Twisted service for the SSH server."""
 
-    def __init__(self, portal, private_key_path, public_key_path,
-                 main_log, access_log, access_log_path, strport='tcp:22',
-                 factory_decorator=None, banner=None, moduli_path=None):
+    def __init__(
+        self,
+        portal,
+        private_key_path,
+        public_key_path,
+        main_log,
+        access_log,
+        access_log_path,
+        strport="tcp:22",
+        factory_decorator=None,
+        banner=None,
+        moduli_path=None,
+    ):
         """Construct an SSH service.
 
         :param portal: The `twisted.cred.portal.Portal` that turns
@@ -189,7 +195,8 @@ class SSHService(service.Service):
             private_key=Key.fromFile(private_key_path),
             public_key=Key.fromFile(public_key_path),
             banner=banner,
-            moduli_path=moduli_path)
+            moduli_path=moduli_path,
+        )
         if factory_decorator is not None:
             ssh_factory = factory_decorator(ssh_factory)
         self.service = strports.service(strport, ssh_factory)
@@ -202,7 +209,8 @@ class SSHService(service.Service):
         self.manager = accesslog.LoggingManager(
             logging.getLogger(self._main_log),
             logging.getLogger(self._access_log_path),
-            self._access_log_path)
+            self._access_log_path,
+        )
         self.manager.setUp()
         notify(events.ServerStarting())
         # By default, only the owner of files should be able to write to them.
@@ -214,9 +222,12 @@ class SSHService(service.Service):
 
     def stopService(self):
         """Stop the SSH service."""
-        deferred = gatherResults([
-            defer.maybeDeferred(service.Service.stopService, self),
-            defer.maybeDeferred(self.service.stopService)])
+        deferred = gatherResults(
+            [
+                defer.maybeDeferred(service.Service.stopService, self),
+                defer.maybeDeferred(self.service.stopService),
+            ]
+        )
 
         def log_stopped(ignored):
             notify(events.ServerStopped())
diff --git a/src/lazr/sshserver/session.py b/src/lazr/sshserver/session.py
index 44c20a2..29bde10 100644
--- a/src/lazr/sshserver/session.py
+++ b/src/lazr/sshserver/session.py
@@ -7,16 +7,12 @@ from __future__ import absolute_import, print_function
 
 __metaclass__ = type
 __all__ = [
-    'DoNothingSession',
-    'PatchedSSHSession',
-    ]
+    "DoNothingSession",
+    "PatchedSSHSession",
+]
 
 from twisted.conch.interfaces import ISession
-from twisted.conch.ssh import (
-    channel,
-    connection,
-    session,
-    )
+from twisted.conch.ssh import channel, connection, session
 from zope.interface import implementer
 
 
@@ -42,7 +38,7 @@ class PatchedSSHSession(session.SSHSession, object):
         # transport even if it's None. I don't know *why* it is None, so this
         # doesn't necessarily address the root cause.
         # See http://twistedmatrix.com/trac/ticket/2754.
-        transport = getattr(self.client, 'transport', None)
+        transport = getattr(self.client, "transport", None)
         if transport is not None:
             transport.loseConnection()
         # This is called by session.SSHSession.loseConnection. SSHChannel is
@@ -59,12 +55,12 @@ class PatchedSSHSession(session.SSHSession, object):
         # self.client.transport is entirely paranoia inspired by the comment
         # in `loseConnection` above. It would be good to know if and why it is
         # necessary. See http://twistedmatrix.com/trac/ticket/2754.
-        transport = getattr(self.client, 'transport', None)
+        transport = getattr(self.client, "transport", None)
         if transport is not None:
             # For SFTP connections, 'transport' is actually a _DummyTransport
             # instance. Neither _DummyTransport nor the protocol it wraps
             # (filetransfer.FileTransferServer) support pausing.
-            pauseProducing = getattr(transport, 'pauseProducing', None)
+            pauseProducing = getattr(transport, "pauseProducing", None)
             if pauseProducing is not None:
                 pauseProducing()
 
@@ -78,12 +74,12 @@ class PatchedSSHSession(session.SSHSession, object):
         # self.client.transport is entirely paranoia inspired by the comment
         # in `loseConnection` above. It would be good to know if and why it is
         # necessary. See http://twistedmatrix.com/trac/ticket/2754.
-        transport = getattr(self.client, 'transport', None)
+        transport = getattr(self.client, "transport", None)
         if transport is not None:
             # For SFTP connections, 'transport' is actually a _DummyTransport
             # instance. Neither _DummyTransport nor the protocol it wraps
             # (filetransfer.FileTransferServer) support pausing.
-            resumeProducing = getattr(transport, 'resumeProducing', None)
+            resumeProducing = getattr(transport, "resumeProducing", None)
             if resumeProducing is not None:
                 resumeProducing()
 
@@ -102,14 +98,14 @@ class DoNothingSession:
         """See ISession."""
 
     def errorWithMessage(self, protocol, msg):
-        protocol.session.writeExtended(
-            connection.EXTENDED_DATA_STDERR, msg)
+        protocol.session.writeExtended(connection.EXTENDED_DATA_STDERR, msg)
         protocol.loseConnection()
 
     def execCommand(self, protocol, command):
         """See ISession."""
         self.errorWithMessage(
-            protocol, "Not allowed to execute commands on this server.\r\n")
+            protocol, "Not allowed to execute commands on this server.\r\n"
+        )
 
     def getPty(self, term, windowSize, modes):
         """See ISession."""
diff --git a/src/lazr/sshserver/sftp.py b/src/lazr/sshserver/sftp.py
index 64c54c7..1335ce8 100644
--- a/src/lazr/sshserver/sftp.py
+++ b/src/lazr/sshserver/sftp.py
@@ -7,9 +7,9 @@ from __future__ import absolute_import, print_function
 
 __metaclass__ = type
 __all__ = [
-    'FileIsADirectory',
-    'FileTransferServer',
-    ]
+    "FileIsADirectory",
+    "FileTransferServer",
+]
 
 from twisted.conch.ssh import filetransfer
 from zope.event import notify
@@ -26,7 +26,8 @@ class FileIsADirectory(Exception):
     def __init__(self, path, extra=None):
         self.path = path
         super(FileIsADirectory, self).__init__(
-            "File is a directory: %r" % path)
+            "File is a directory: %r" % path
+        )
 
 
 class FileTransferServer(filetransfer.FileTransferServer):
diff --git a/src/lazr/sshserver/tests/test_accesslog.py b/src/lazr/sshserver/tests/test_accesslog.py
index 5b8a11a..5dad2f6 100644
--- a/src/lazr/sshserver/tests/test_accesslog.py
+++ b/src/lazr/sshserver/tests/test_accesslog.py
@@ -8,10 +8,10 @@ from __future__ import absolute_import, print_function
 __metaclass__ = type
 
 import logging
-from logging.handlers import WatchedFileHandler
 import os
 import sys
 import tempfile
+from logging.handlers import WatchedFileHandler
 
 try:
     from bzrlib.tests import TestCase as BzrTestCase
@@ -31,11 +31,12 @@ class LoggingManagerMixin:
     def makeLogger(self, name=None):
         if name is None:
             self._log_count += 1
-            name = '%s-%s' % (self.id().split('.')[-1], self._log_count)
+            name = "%s-%s" % (self.id().split(".")[-1], self._log_count)
         return logging.getLogger(name)
 
-    def installLoggingManager(self, main_log=None, access_log=None,
-                              access_log_path=None):
+    def installLoggingManager(
+        self, main_log=None, access_log=None, access_log_path=None
+    ):
         if main_log is None:
             main_log = self.makeLogger()
         if access_log is None:
@@ -51,17 +52,17 @@ class LoggingManagerMixin:
 
 
 if BzrTestCase is not None:
-    class TestLoggingBazaarInteraction(BzrTestCase, LoggingManagerMixin):
 
+    class TestLoggingBazaarInteraction(BzrTestCase, LoggingManagerMixin):
         def test_leaves_bzr_handlers_unchanged(self):
             # Bazaar's log handling is untouched by logging setup.
-            root_handlers = logging.getLogger('').handlers
-            bzr_handlers = logging.getLogger('bzr').handlers
+            root_handlers = logging.getLogger("").handlers
+            bzr_handlers = logging.getLogger("bzr").handlers
 
             self.apply_redirected(a_callable=self.installLoggingManager)
 
-            self.assertEqual(root_handlers, logging.getLogger('').handlers)
-            self.assertEqual(bzr_handlers, logging.getLogger('bzr').handlers)
+            self.assertEqual(root_handlers, logging.getLogger("").handlers)
+            self.assertEqual(bzr_handlers, logging.getLogger("bzr").handlers)
 
         def test_log_doesnt_go_to_stderr(self):
             # Once logging setup is called, any messages logged to the
@@ -73,15 +74,15 @@ if BzrTestCase is not None:
                 self.installLoggingManager(log)
 
                 # Make sure that a logged message does not go to stderr.
-                log.info('Hello hello')
-                self.assertEqual(sys.stderr.getvalue(), '')
+                log.info("Hello hello")
+                self.assertEqual(sys.stderr.getvalue(), "")
 
             self.apply_redirected(a_callable=inner)
 
 
 class TestLoggingManager(
-        testtools.TestCase, fixtures.TestWithFixtures, LoggingManagerMixin):
-
+    testtools.TestCase, fixtures.TestWithFixtures, LoggingManagerMixin
+):
     def test_main_log_handlers(self):
         # There needs to be at least one handler for the root logger. If there
         # isn't, we'll get constant errors complaining about the lack of
@@ -93,10 +94,9 @@ class TestLoggingManager(
 
     def _get_handlers(self):
         registrations = (
-            zope.component.getGlobalSiteManager().registeredHandlers())
-        return [
-            registration.factory
-            for registration in registrations]
+            zope.component.getGlobalSiteManager().registeredHandlers()
+        )
+        return [registration.factory for registration in registrations]
 
     def test_set_up_registers_event_handler(self):
         manager = self.installLoggingManager()
@@ -136,10 +136,10 @@ class TestLoggingManager(
         # to the SSH server access log.
         directory = self.useFixture(fixtures.TempDir()).path
         access_log = self.makeLogger()
-        access_log_path = os.path.join(directory, 'access.log')
+        access_log_path = os.path.join(directory, "access.log")
         self.installLoggingManager(
-            access_log=access_log,
-            access_log_path=access_log_path)
+            access_log=access_log, access_log_path=access_log_path
+        )
         [handler] = access_log.handlers
         self.assertIsInstance(handler, WatchedFileHandler)
         self.assertEqual(access_log_path, handler.baseFilename)
diff --git a/src/lazr/sshserver/tests/test_auth.py b/src/lazr/sshserver/tests/test_auth.py
index d146a19..7fb7f21 100644
--- a/src/lazr/sshserver/tests/test_auth.py
+++ b/src/lazr/sshserver/tests/test_auth.py
@@ -13,31 +13,19 @@ import sys
 
 import testtools
 from testtools.deferredruntest import (
-    assert_fails_with,
     AsynchronousDeferredRunTest,
+    assert_fails_with,
     flush_logged_errors,
-    )
+)
 from twisted.conch.error import ConchError
 from twisted.conch.ssh import userauth
-from twisted.conch.ssh.common import (
-    getNS,
-    NS,
-    )
-from twisted.conch.ssh.keys import (
-    BadKeyError,
-    Key,
-    )
-from twisted.conch.ssh.transport import (
-    SSHCiphers,
-    SSHServerTransport,
-    )
+from twisted.conch.ssh.common import NS, getNS
+from twisted.conch.ssh.keys import BadKeyError, Key
+from twisted.conch.ssh.transport import SSHCiphers, SSHServerTransport
 from twisted.cred.checkers import ICredentialsChecker
 from twisted.cred.credentials import ISSHPrivateKey
 from twisted.cred.error import UnauthorizedLogin
-from twisted.cred.portal import (
-    IRealm,
-    Portal,
-    )
+from twisted.cred.portal import IRealm, Portal
 from twisted.internet import defer
 from twisted.python import failure
 from twisted.python.util import sibpath
@@ -47,8 +35,8 @@ from lazr.sshserver import auth
 
 
 def suppress_stderr(function):
-    """Deferred friendly decorator that suppresses output from a function.
-    """
+    """Deferred friendly decorator that suppresses output from a function."""
+
     def set_stderr(result, stream):
         sys.stderr = stream
         return result
@@ -77,10 +65,12 @@ class MockRealm:
 
     def requestAvatar(self, avatar_id, mind, *interfaces):
         user_dict = {
-            'id': avatar_id, 'name': avatar_id, 'teams': [],
-            'initialBranches': []}
-        return (
-            interfaces[0], auth.LaunchpadAvatar(user_dict), lambda: None)
+            "id": avatar_id,
+            "name": avatar_id,
+            "teams": [],
+            "initialBranches": [],
+        }
+        return (interfaces[0], auth.LaunchpadAvatar(user_dict), lambda: None)
 
 
 class MockSSHTransport(SSHServerTransport):
@@ -103,7 +93,7 @@ class MockSSHTransport(SSHServerTransport):
         # In Twisted 8.0.1, Conch's transport starts referring to
         # currentEncryptions where it didn't before. Provide a dummy value for
         # it.
-        self.currentEncryptions = SSHCiphers('none', 'none', 'none', 'none')
+        self.currentEncryptions = SSHCiphers("none", "none", "none", "none")
         self.packets = []
         self.factory = self.Factory()
         self.factory.portal = portal
@@ -131,25 +121,27 @@ class UserAuthServerMixin(object):
         messages = userauth.SSHUserAuthServer.protocolMessages
         self.assertEqual(
             [messages[msg_type] for msg_type in message_types],
-            [messages[packet_type]
-             for packet_type, contents in self.transport.packets])
+            [
+                messages[packet_type]
+                for packet_type, contents in self.transport.packets
+            ],
+        )
 
-    def assertBannerSent(self, banner_message, expected_language='en'):
+    def assertBannerSent(self, banner_message, expected_language="en"):
         """Assert that 'banner_message' was sent as an SSH banner."""
         # Check that we received a BANNER, then a FAILURE.
         for packet_type, packet_content in self.transport.packets:
             if packet_type == userauth.MSG_USERAUTH_BANNER:
                 bytes, language, empty = getNS(packet_content, 2)
-                self.assertEqual(banner_message, bytes.decode('UTF8'))
-                self.assertEqual(expected_language, language.decode('UTF8'))
-                self.assertEqual(b'', empty)
+                self.assertEqual(banner_message, bytes.decode("UTF8"))
+                self.assertEqual(expected_language, language.decode("UTF8"))
+                self.assertEqual(b"", empty)
                 break
         else:
             self.fail("No banner logged.")
 
 
 class TestUserAuthServer(UserAuthServerMixin, testtools.TestCase):
-
     def test_sendBanner(self):
         # sendBanner should send an SSH 'packet' with type MSG_USERAUTH_BANNER
         # and two fields. The first field is the message itself, and the
@@ -160,11 +152,13 @@ class TestUserAuthServer(UserAuthServerMixin, testtools.TestCase):
         #
         # See RFC 4252, Section 5.4.
         message = u"test message"
-        self.user_auth.sendBanner(message, language='en-US')
-        self.assertBannerSent(message + '\r\n', 'en-US')
+        self.user_auth.sendBanner(message, language="en-US")
+        self.assertBannerSent(message + "\r\n", "en-US")
         self.assertEqual(
-            1, len(self.transport.packets),
-            "More than just banner was sent: %r" % self.transport.packets)
+            1,
+            len(self.transport.packets),
+            "More than just banner was sent: %r" % self.transport.packets,
+        )
 
     def test_sendBannerUsesCRLF(self):
         # sendBanner should make sure that any line breaks in the message are
@@ -174,7 +168,7 @@ class TestUserAuthServer(UserAuthServerMixin, testtools.TestCase):
         self.user_auth.sendBanner(u"test\nmessage")
         [(messageType, payload)] = self.transport.packets
         bytes, language, empty = getNS(payload, 2)
-        self.assertEqual(bytes.decode('UTF8'), u"test\r\nmessage\r\n")
+        self.assertEqual(bytes.decode("UTF8"), u"test\r\nmessage\r\n")
 
     def test_requestRaisesConchError(self):
         # ssh_USERAUTH_REQUEST should raise a ConchError if tryAuth returns
@@ -188,11 +182,13 @@ class TestUserAuthServer(UserAuthServerMixin, testtools.TestCase):
 
         tryAuth = self.user_auth.tryAuth
         self.user_auth.tryAuth = mock_try_auth
-        _ebBadAuth, self.user_auth._ebBadAuth = (self.user_auth._ebBadAuth,
-                                                 mock_eb_bad_auth)
+        _ebBadAuth, self.user_auth._ebBadAuth = (
+            self.user_auth._ebBadAuth,
+            mock_eb_bad_auth,
+        )
         self.user_auth.serviceStarted()
         try:
-            packet = NS(b'jml') + NS(b'foo') + NS(b'public_key') + NS(b'data')
+            packet = NS(b"jml") + NS(b"foo") + NS(b"public_key") + NS(b"data")
             self.user_auth.ssh_USERAUTH_REQUEST(packet)
         finally:
             self.user_auth.serviceStopped()
@@ -202,20 +198,25 @@ class TestUserAuthServer(UserAuthServerMixin, testtools.TestCase):
     def test_handlesBadKey(self):
         # auth_publickey handles the case where Twisted fails to load the
         # user-supplied public key.
-        self.transport.sessionID = ''
+        self.transport.sessionID = ""
         packet = (
-            NS(b'user') + NS(b'') + NS(b'publickey') +
-            b'\x01' + NS(b'ssh-rsa') + NS(b'badkey') +
-            NS(NS(b'ssh-rsa') + NS(b'\x01' * 128)))
+            NS(b"user")
+            + NS(b"")
+            + NS(b"publickey")
+            + b"\x01"
+            + NS(b"ssh-rsa")
+            + NS(b"badkey")
+            + NS(NS(b"ssh-rsa") + NS(b"\x01" * 128))
+        )
         self.user_auth.serviceStarted()
-        self.user_auth.supportedAuthentications.append(b'publickey')
+        self.user_auth.supportedAuthentications.append(b"publickey")
         try:
             self.user_auth.ssh_USERAUTH_REQUEST(packet)
             [(packet_type, packet_content)] = self.transport.packets
             self.assertEqual(userauth.MSG_USERAUTH_FAILURE, packet_type)
             name_list, partial_success = getNS(packet_content)
-            self.assertEqual(b'publickey', name_list)
-            self.assertEqual(b'\x00', partial_success)
+            self.assertEqual(b"publickey", name_list)
+            self.assertEqual(b"\x00", partial_success)
         finally:
             self.user_auth.serviceStopped()
 
@@ -229,19 +230,27 @@ class TestUserAuthServer(UserAuthServerMixin, testtools.TestCase):
 
             def __call__(self, credentials, mind, *interfaces):
                 self.credentials = credentials
-                return defer.succeed(self.portal.realm.requestAvatar(
-                    credentials.username, mind, *interfaces))
+                return defer.succeed(
+                    self.portal.realm.requestAvatar(
+                        credentials.username, mind, *interfaces
+                    )
+                )
 
-        self.transport.sessionID = ''
+        self.transport.sessionID = ""
         self.portal.login = MockLogin(self.portal)
-        keydir = sibpath(__file__, 'keys')
-        with open(os.path.join(keydir, 'ssh_host_key_rsa.pub'), 'rb') as f:
+        keydir = sibpath(__file__, "keys")
+        with open(os.path.join(keydir, "ssh_host_key_rsa.pub"), "rb") as f:
             public_key = Key.fromString(f.read())
         packet = (
-            NS(b'user') + NS(b'') + NS(b'publickey') +
-            b'\x00' + NS(b'ssh-rsa') + NS(public_key.blob()))
+            NS(b"user")
+            + NS(b"")
+            + NS(b"publickey")
+            + b"\x00"
+            + NS(b"ssh-rsa")
+            + NS(public_key.blob())
+        )
         self.user_auth.serviceStarted()
-        self.user_auth.supportedAuthentications.append(b'publickey')
+        self.user_auth.supportedAuthentications.append(b"publickey")
         try:
             self.user_auth.ssh_USERAUTH_REQUEST(packet)
             self.assertIsNone(self.portal.login.credentials.signature)
@@ -257,27 +266,36 @@ class TestUserAuthServer(UserAuthServerMixin, testtools.TestCase):
 
             def __call__(self, credentials, mind, *interfaces):
                 self.credentials = credentials
-                return defer.succeed(self.portal.realm.requestAvatar(
-                    credentials.username, mind, *interfaces))
+                return defer.succeed(
+                    self.portal.realm.requestAvatar(
+                        credentials.username, mind, *interfaces
+                    )
+                )
 
-        self.transport.sessionID = ''
+        self.transport.sessionID = ""
         self.portal.login = MockLogin(self.portal)
-        keydir = sibpath(__file__, 'keys')
-        with open(os.path.join(keydir, 'ssh_host_key_rsa.pub'), 'rb') as f:
+        keydir = sibpath(__file__, "keys")
+        with open(os.path.join(keydir, "ssh_host_key_rsa.pub"), "rb") as f:
             public_key = Key.fromString(f.read())
         public_key_len = (public_key.size() + 7) // 8
-        signature = b'\x01' * (public_key_len - 1)
+        signature = b"\x01" * (public_key_len - 1)
         packet = (
-            NS(b'user') + NS(b'') + NS(b'publickey') +
-            b'\x01' + NS(b'ssh-rsa') + NS(public_key.blob()) +
-            NS(NS(b'ssh-rsa') + NS(signature)))
+            NS(b"user")
+            + NS(b"")
+            + NS(b"publickey")
+            + b"\x01"
+            + NS(b"ssh-rsa")
+            + NS(public_key.blob())
+            + NS(NS(b"ssh-rsa") + NS(signature))
+        )
         self.user_auth.serviceStarted()
-        self.user_auth.supportedAuthentications.append(b'publickey')
+        self.user_auth.supportedAuthentications.append(b"publickey")
         try:
             self.user_auth.ssh_USERAUTH_REQUEST(packet)
             self.assertEqual(
-                NS(b'ssh-rsa') + NS(b'\x00' + signature),
-                self.portal.login.credentials.signature)
+                NS(b"ssh-rsa") + NS(b"\x00" + signature),
+                self.portal.login.credentials.signature,
+            )
         finally:
             self.user_auth.serviceStopped()
 
@@ -292,14 +310,15 @@ class MockChecker:
 
     credentialInterfaces = (ISSHPrivateKey,)
 
-    error_message = u'error message'
+    error_message = u"error message"
 
     def requestAvatarId(self, credentials):
-        if credentials.username == b'success':
+        if credentials.username == b"success":
             return credentials.username
         else:
             return failure.Failure(
-                auth.UserDisplayedUnauthorizedLogin(self.error_message))
+                auth.UserDisplayedUnauthorizedLogin(self.error_message)
+            )
 
 
 class TestAuthenticationBannerDisplay(UserAuthServerMixin, testtools.TestCase):
@@ -327,27 +346,30 @@ class TestAuthenticationBannerDisplay(UserAuthServerMixin, testtools.TestCase):
         super(TestAuthenticationBannerDisplay, self).tearDown()
 
     def _makeKey(self):
-        keydir = sibpath(__file__, 'keys')
-        with open(os.path.join(keydir, 'ssh_host_key_rsa.pub'), 'rb') as f:
+        keydir = sibpath(__file__, "keys")
+        with open(os.path.join(keydir, "ssh_host_key_rsa.pub"), "rb") as f:
             public_key = Key.fromString(f.read())
         if isinstance(public_key, str):
-            return b'\x00' + NS(b'rsa') + NS(public_key)
+            return b"\x00" + NS(b"rsa") + NS(public_key)
         else:
-            return b'\x00' + NS(b'rsa') + NS(public_key.blob())
+            return b"\x00" + NS(b"rsa") + NS(public_key.blob())
 
     def requestFailedAuthentication(self):
         return self.user_auth.ssh_USERAUTH_REQUEST(
-            NS(b'failure') + NS(b'') + NS(b'publickey') + self.key_data)
+            NS(b"failure") + NS(b"") + NS(b"publickey") + self.key_data
+        )
 
     def requestSuccessfulAuthentication(self):
         return self.user_auth.ssh_USERAUTH_REQUEST(
-            NS(b'success') + NS(b'') + NS(b'publickey') + self.key_data)
+            NS(b"success") + NS(b"") + NS(b"publickey") + self.key_data
+        )
 
     def requestUnsupportedAuthentication(self):
         # Note that it doesn't matter how the checker responds -- the server
         # doesn't get that far.
         return self.user_auth.ssh_USERAUTH_REQUEST(
-            NS(b'success') + NS(b'') + NS(b'none') + NS(b''))
+            NS(b"success") + NS(b"") + NS(b"none") + NS(b"")
+        )
 
     @defer.inlineCallbacks
     def test_bannerNotSentOnSuccess(self):
@@ -366,8 +388,9 @@ class TestAuthenticationBannerDisplay(UserAuthServerMixin, testtools.TestCase):
         self.user_auth._banner = "Boogedy boo"
         yield self.requestSuccessfulAuthentication()
         self.assertMessageOrder(
-            [userauth.MSG_USERAUTH_BANNER, userauth.MSG_USERAUTH_SUCCESS])
-        self.assertBannerSent(self.user_auth._banner + '\r\n')
+            [userauth.MSG_USERAUTH_BANNER, userauth.MSG_USERAUTH_SUCCESS]
+        )
+        self.assertBannerSent(self.user_auth._banner + "\r\n")
 
     @defer.inlineCallbacks
     def test_defaultBannerSentOnlyOnce(self):
@@ -381,9 +404,13 @@ class TestAuthenticationBannerDisplay(UserAuthServerMixin, testtools.TestCase):
 
         # Check that no banner was sent to the user.
         self.assertMessageOrder(
-            [userauth.MSG_USERAUTH_FAILURE, userauth.MSG_USERAUTH_BANNER,
-             userauth.MSG_USERAUTH_SUCCESS])
-        self.assertBannerSent(self.user_auth._banner + '\r\n')
+            [
+                userauth.MSG_USERAUTH_FAILURE,
+                userauth.MSG_USERAUTH_BANNER,
+                userauth.MSG_USERAUTH_SUCCESS,
+            ]
+        )
+        self.assertBannerSent(self.user_auth._banner + "\r\n")
 
     @defer.inlineCallbacks
     def test_defaultBannerNotSentOnFailure(self):
@@ -394,8 +421,9 @@ class TestAuthenticationBannerDisplay(UserAuthServerMixin, testtools.TestCase):
         yield self.requestFailedAuthentication()
 
         self.assertMessageOrder(
-            [userauth.MSG_USERAUTH_BANNER, userauth.MSG_USERAUTH_FAILURE])
-        self.assertBannerSent(MockChecker.error_message + '\r\n')
+            [userauth.MSG_USERAUTH_BANNER, userauth.MSG_USERAUTH_FAILURE]
+        )
+        self.assertBannerSent(MockChecker.error_message + "\r\n")
 
     @defer.inlineCallbacks
     def test_loggedToBanner(self):
@@ -404,8 +432,9 @@ class TestAuthenticationBannerDisplay(UserAuthServerMixin, testtools.TestCase):
         yield self.requestFailedAuthentication()
         # Check that we received a BANNER, then a FAILURE.
         self.assertMessageOrder(
-            [userauth.MSG_USERAUTH_BANNER, userauth.MSG_USERAUTH_FAILURE])
-        self.assertBannerSent(MockChecker.error_message + '\r\n')
+            [userauth.MSG_USERAUTH_BANNER, userauth.MSG_USERAUTH_FAILURE]
+        )
+        self.assertBannerSent(MockChecker.error_message + "\r\n")
 
     @defer.inlineCallbacks
     def test_unsupportedAuthMethodNotLogged(self):
@@ -431,40 +460,45 @@ class TestPublicKeyFromLaunchpadChecker(testtools.TestCase):
     run_tests_with = AsynchronousDeferredRunTest
 
     class FakeAuthenticationEndpoint:
-        """A fake client for enough of `IAuthServer` for this test.
-        """
+        """A fake client for enough of `IAuthServer` for this test."""
 
-        valid_user = 'valid_user'
-        no_key_user = 'no_key_user'
-        valid_key_rsa = b'valid_key_rsa'
-        valid_key_dsa = b'valid_key_dsa'
-        valid_key_ecdsa = b'valid_key_ecdsa'
-        valid_key_ed25519 = b'valid_key_ed25519'
+        valid_user = "valid_user"
+        no_key_user = "no_key_user"
+        valid_key_rsa = b"valid_key_rsa"
+        valid_key_dsa = b"valid_key_dsa"
+        valid_key_ecdsa = b"valid_key_ecdsa"
+        valid_key_ed25519 = b"valid_key_ed25519"
 
         def __init__(self):
             self.calls = []
 
         def callRemote(self, function_name, *args, **kwargs):
-            return getattr(
-                self, 'xmlrpc_%s' % function_name)(*args, **kwargs)
+            return getattr(self, "xmlrpc_%s" % function_name)(*args, **kwargs)
 
         def xmlrpc_getUserAndSSHKeys(self, username):
             self.calls.append(username)
             if username == self.valid_user:
-                return defer.succeed({
-                    'name': username,
-                    'keys': [
-                        ('RSA', base64.b64encode(self.valid_key_rsa)),
-                        ('DSA', base64.b64encode(self.valid_key_dsa)),
-                        ('ECDSA', base64.b64encode(self.valid_key_ecdsa)),
-                        ('ED25519', base64.b64encode(self.valid_key_ed25519)),
+                return defer.succeed(
+                    {
+                        "name": username,
+                        "keys": [
+                            ("RSA", base64.b64encode(self.valid_key_rsa)),
+                            ("DSA", base64.b64encode(self.valid_key_dsa)),
+                            ("ECDSA", base64.b64encode(self.valid_key_ecdsa)),
+                            (
+                                "ED25519",
+                                base64.b64encode(self.valid_key_ed25519),
+                            ),
                         ],
-                    })
+                    }
+                )
             elif username == self.no_key_user:
-                return defer.succeed({
-                    'name': username,
-                    'keys': [],
-                    })
+                return defer.succeed(
+                    {
+                        "name": username,
+                        "keys": [],
+                    }
+                )
             else:
                 try:
                     raise auth.NoSuchPersonWithName(username)
@@ -475,7 +509,8 @@ class TestPublicKeyFromLaunchpadChecker(testtools.TestCase):
         if mind is None:
             mind = auth.UserDetailsMind()
         return auth.SSHPrivateKeyWithMind(
-            username, key_type, public_key, '', None, mind)
+            username, key_type, public_key, "", None, mind
+        )
 
     def makeChecker(self, do_signature_checking=False):
         """Construct a PublicKeyFromLaunchpadChecker.
@@ -502,27 +537,32 @@ class TestPublicKeyFromLaunchpadChecker(testtools.TestCase):
         # Attempting to log in with a username and key known to the
         # authentication end-point succeeds.
         for key_type, public_key in (
-                (b'ssh-rsa', self.authserver.valid_key_rsa),
-                (b'ssh-dss', self.authserver.valid_key_dsa),
-                (b'ecdsa-sha2-nistp256', self.authserver.valid_key_ecdsa),
-                (b'ssh-ed25519', self.authserver.valid_key_ed25519),
-                ):
+            (b"ssh-rsa", self.authserver.valid_key_rsa),
+            (b"ssh-dss", self.authserver.valid_key_dsa),
+            (b"ecdsa-sha2-nistp256", self.authserver.valid_key_ecdsa),
+            (b"ssh-ed25519", self.authserver.valid_key_ed25519),
+        ):
             creds = self.makeCredentials(
-                self.authserver.valid_user.encode('UTF-8'), key_type,
-                public_key)
+                self.authserver.valid_user.encode("UTF-8"),
+                key_type,
+                public_key,
+            )
             checker = self.makeChecker()
             username = yield checker.requestAvatarId(creds)
             self.assertEqual(
-                self.authserver.valid_user.encode('UTF-8'), username)
+                self.authserver.valid_user.encode("UTF-8"), username
+            )
 
     @suppress_stderr
     def test_invalid_signature(self):
         # The checker requests attempts to authenticate if the requests have
         # an invalid signature.
         creds = self.makeCredentials(
-            self.authserver.valid_user.encode('UTF-8'), b'ssh-dss',
-            self.authserver.valid_key_dsa)
-        creds.signature = 'a'
+            self.authserver.valid_user.encode("UTF-8"),
+            b"ssh-dss",
+            self.authserver.valid_key_dsa,
+        )
+        creds.signature = "a"
         checker = self.makeChecker(True)
         d = checker.requestAvatarId(creds)
 
@@ -545,19 +585,22 @@ class TestPublicKeyFromLaunchpadChecker(testtools.TestCase):
         :return: Deferred. You must return this from your test.
         """
         d = assert_fails_with(
-            checker.requestAvatarId(creds),
-            auth.UserDisplayedUnauthorizedLogin)
+            checker.requestAvatarId(creds), auth.UserDisplayedUnauthorizedLogin
+        )
         d.addCallback(
-            lambda exception: self.assertEqual(str(exception), error_message))
+            lambda exception: self.assertEqual(str(exception), error_message)
+        )
         return d
 
     def test_badUserEncoding(self):
         # Attempting to sign in using a non-UTF-8 user name fails.
         checker = self.makeChecker()
         creds = self.makeCredentials(
-            b'\x80', b'ssh-dss', self.authserver.valid_key_dsa)
+            b"\x80", b"ssh-dss", self.authserver.valid_key_dsa
+        )
         return self.assertLoginError(
-            checker, creds, 'No such Launchpad account: %r' % b'\x80')
+            checker, creds, "No such Launchpad account: %r" % b"\x80"
+        )
 
     def test_noSuchUser(self):
         # When someone signs in with a non-existent user, they should be told
@@ -565,21 +608,27 @@ class TestPublicKeyFromLaunchpadChecker(testtools.TestCase):
         # Launchpad user names is public.
         checker = self.makeChecker()
         creds = self.makeCredentials(
-            b'no-such-user', b'ssh-dss', self.authserver.valid_key_dsa)
+            b"no-such-user", b"ssh-dss", self.authserver.valid_key_dsa
+        )
         return self.assertLoginError(
-            checker, creds, 'No such Launchpad account: no-such-user')
+            checker, creds, "No such Launchpad account: no-such-user"
+        )
 
     def test_noKeys(self):
         # When you sign into an existing account with no SSH keys, the SSH
         # server informs you that the account has no keys.
         checker = self.makeChecker()
         creds = self.makeCredentials(
-            self.authserver.no_key_user.encode('UTF-8'), b'ssh-dss',
-            self.authserver.valid_key_dsa)
+            self.authserver.no_key_user.encode("UTF-8"),
+            b"ssh-dss",
+            self.authserver.valid_key_dsa,
+        )
         return self.assertLoginError(
-            checker, creds,
+            checker,
+            creds,
             "Launchpad user '%s' doesn't have a registered SSH key"
-            % self.authserver.no_key_user)
+            % self.authserver.no_key_user,
+        )
 
     def test_wrongKey(self):
         # When you sign into an existing account using the wrong key, you
@@ -587,34 +636,40 @@ class TestPublicKeyFromLaunchpadChecker(testtools.TestCase):
         # tries several keys as part of normal operation.
         checker = self.makeChecker()
         creds = self.makeCredentials(
-            self.authserver.valid_user.encode('UTF-8'), b'ssh-dss',
-            b'invalid key')
+            self.authserver.valid_user.encode("UTF-8"),
+            b"ssh-dss",
+            b"invalid key",
+        )
         # We cannot use assertLoginError because we are checking that we fail
         # with UnauthorizedLogin and not its subclass
         # UserDisplayedUnauthorizedLogin.
         d = assert_fails_with(
-            checker.requestAvatarId(creds),
-            UnauthorizedLogin)
+            checker.requestAvatarId(creds), UnauthorizedLogin
+        )
         d.addCallback(
-            lambda exception:
-            self.assertFalse(
+            lambda exception: self.assertFalse(
                 isinstance(exception, auth.UserDisplayedUnauthorizedLogin),
-                "Should not be a UserDisplayedUnauthorizedLogin"))
+                "Should not be a UserDisplayedUnauthorizedLogin",
+            )
+        )
         return d
 
     @defer.inlineCallbacks
     def test_unknownKeyType(self):
         # Authenticating using a key with an unknown type fails.
         creds = self.makeCredentials(
-            self.authserver.valid_user.encode('UTF-8'), b'nonsense',
-            self.authserver.valid_key_rsa)
+            self.authserver.valid_user.encode("UTF-8"),
+            b"nonsense",
+            self.authserver.valid_key_rsa,
+        )
         checker = self.makeChecker()
         exception = yield assert_fails_with(
-            checker.requestAvatarId(creds),
-            UnauthorizedLogin)
+            checker.requestAvatarId(creds), UnauthorizedLogin
+        )
         self.assertFalse(
             isinstance(exception, auth.UserDisplayedUnauthorizedLogin),
-            "Should not be a UserDisplayedUnauthorizedLogin")
+            "Should not be a UserDisplayedUnauthorizedLogin",
+        )
 
     @defer.inlineCallbacks
     def test_successful_with_second_key_calls_authserver_once(self):
@@ -625,16 +680,22 @@ class TestPublicKeyFromLaunchpadChecker(testtools.TestCase):
         checker = self.makeChecker()
         mind = auth.UserDetailsMind()
         wrong_key_creds = self.makeCredentials(
-            self.authserver.valid_user.encode('UTF-8'), b'ssh-dss',
-            b'invalid key', mind)
+            self.authserver.valid_user.encode("UTF-8"),
+            b"ssh-dss",
+            b"invalid key",
+            mind,
+        )
         right_key_creds = self.makeCredentials(
-            self.authserver.valid_user.encode('UTF-8'), b'ssh-dss',
-            self.authserver.valid_key_dsa, mind)
+            self.authserver.valid_user.encode("UTF-8"),
+            b"ssh-dss",
+            self.authserver.valid_key_dsa,
+            mind,
+        )
         try:
             username = yield checker.requestAvatarId(wrong_key_creds)
         except UnauthorizedLogin:
             username = yield checker.requestAvatarId(right_key_creds)
-        self.assertEqual(self.authserver.valid_user.encode('UTF-8'), username)
+        self.assertEqual(self.authserver.valid_user.encode("UTF-8"), username)
         self.assertEqual([self.authserver.valid_user], self.authserver.calls)
 
     def test_noSuchUser_with_two_keys_calls_authserver_once(self):
@@ -643,21 +704,22 @@ class TestPublicKeyFromLaunchpadChecker(testtools.TestCase):
         checker = self.makeChecker()
         mind = auth.UserDetailsMind()
         creds_1 = self.makeCredentials(
-            b'invalid-user', b'ssh-dss', b'invalid key 1', mind)
+            b"invalid-user", b"ssh-dss", b"invalid key 1", mind
+        )
         creds_2 = self.makeCredentials(
-            b'invalid-user', b'ssh-dss', b'invalid key 2', mind)
+            b"invalid-user", b"ssh-dss", b"invalid key 2", mind
+        )
         d = checker.requestAvatarId(creds_1)
 
         def try_second_key(failure):
             return assert_fails_with(
-                checker.requestAvatarId(creds_2),
-                UnauthorizedLogin)
+                checker.requestAvatarId(creds_2), UnauthorizedLogin
+            )
 
         d.addErrback(try_second_key)
 
         def check_one_call(r):
-            self.assertEqual(
-                ['invalid-user'], self.authserver.calls)
+            self.assertEqual(["invalid-user"], self.authserver.calls)
             return r
 
         d.addCallback(check_one_call)
diff --git a/src/lazr/sshserver/tests/test_docs.py b/src/lazr/sshserver/tests/test_docs.py
index a331bc7..c498504 100644
--- a/src/lazr/sshserver/tests/test_docs.py
+++ b/src/lazr/sshserver/tests/test_docs.py
@@ -21,39 +21,48 @@ from __future__ import absolute_import, print_function
 
 __metaclass__ = type
 __all__ = [
-    'load_tests',
-    ]
+    "load_tests",
+]
 
 import __future__
+
 import atexit
 import doctest
 import os
+
 # pylint: disable-msg=F0401
 from pkg_resources import (
-    resource_filename, resource_exists, resource_listdir, cleanup_resources)
-
+    cleanup_resources,
+    resource_exists,
+    resource_filename,
+    resource_listdir,
+)
 
 DOCTEST_FLAGS = (
-    doctest.ELLIPSIS |
-    doctest.NORMALIZE_WHITESPACE |
-    doctest.REPORT_NDIFF)
+    doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE | doctest.REPORT_NDIFF
+)
 
 
 def load_tests(loader, tests, pattern):
     """Load the doc tests (README.txt and docs/*, if any exist)."""
     doctest_files = [
-        os.path.abspath(resource_filename('lazr.sshserver', 'README.txt'))]
-    if resource_exists('lazr.sshserver', 'docs'):
-        for name in resource_listdir('lazr.sshserver', 'docs'):
-            if name.endswith('.txt'):
+        os.path.abspath(resource_filename("lazr.sshserver", "README.txt"))
+    ]
+    if resource_exists("lazr.sshserver", "docs"):
+        for name in resource_listdir("lazr.sshserver", "docs"):
+            if name.endswith(".txt"):
                 doctest_files.append(
                     os.path.abspath(
-                        resource_filename('lazr.sshserver', 'docs/%s' % name)))
+                        resource_filename("lazr.sshserver", "docs/%s" % name)
+                    )
+                )
     globs = {
         future_item: getattr(__future__, future_item)
-        for future_item in ('absolute_import', 'print_function')}
+        for future_item in ("absolute_import", "print_function")
+    }
     kwargs = dict(
-        module_relative=False, globs=globs, optionflags=DOCTEST_FLAGS)
+        module_relative=False, globs=globs, optionflags=DOCTEST_FLAGS
+    )
     atexit.register(cleanup_resources)
     tests.addTest(doctest.DocFileSuite(*doctest_files, **kwargs))
     return tests
diff --git a/src/lazr/sshserver/tests/test_events.py b/src/lazr/sshserver/tests/test_events.py
index f5fb161..a3e790a 100644
--- a/src/lazr/sshserver/tests/test_events.py
+++ b/src/lazr/sshserver/tests/test_events.py
@@ -10,19 +10,13 @@ __metaclass__ = type
 import logging
 
 import testtools
-from zope.component import (
-    adapter,
-    getGlobalSiteManager,
-    provideHandler,
-    )
+
 # This non-standard import is necessary to hook up the event system.
 import zope.component.event  # noqa: F401
+from zope.component import adapter, getGlobalSiteManager, provideHandler
 from zope.event import notify
 
-from lazr.sshserver.events import (
-    ILoggingEvent,
-    LoggingEvent,
-    )
+from lazr.sshserver.events import ILoggingEvent, LoggingEvent
 
 
 class ListHandler(logging.Handler):
@@ -48,7 +42,6 @@ class ListHandler(logging.Handler):
 
 
 class TestLoggingEvent(testtools.TestCase):
-
     def assertLogs(self, records, function, *args, **kwargs):
         """Assert 'function' logs 'records' when run with the given args."""
         logged_events = []
@@ -57,8 +50,12 @@ class TestLoggingEvent(testtools.TestCase):
         result = function(*args, **kwargs)
         self.logger.removeHandler(handler)
         self.assertEqual(
-            [(record.levelno, record.getMessage())
-             for record in logged_events], records)
+            [
+                (record.levelno, record.getMessage())
+                for record in logged_events
+            ],
+            records,
+        )
         return result
 
     def assertEventLogs(self, record, logging_event):
@@ -79,15 +76,17 @@ class TestLoggingEvent(testtools.TestCase):
 
     def test_level(self):
         event = LoggingEvent(logging.CRITICAL, "foo")
-        self.assertEventLogs((logging.CRITICAL, 'foo'), event)
+        self.assertEventLogs((logging.CRITICAL, "foo"), event)
 
     def test_formatting(self):
         event = LoggingEvent(logging.DEBUG, "foo: %(name)s", name="bar")
-        self.assertEventLogs((logging.DEBUG, 'foo: bar'), event)
+        self.assertEventLogs((logging.DEBUG, "foo: bar"), event)
 
     def test_subclass(self):
         class SomeEvent(LoggingEvent):
             template = "%(something)s happened."
             level = logging.INFO
+
         self.assertEventLogs(
-            (logging.INFO, 'foo happened.'), SomeEvent(something='foo'))
+            (logging.INFO, "foo happened."), SomeEvent(something="foo")
+        )
diff --git a/src/lazr/sshserver/tests/test_session.py b/src/lazr/sshserver/tests/test_session.py
index 13a4667..aebc200 100644
--- a/src/lazr/sshserver/tests/test_session.py
+++ b/src/lazr/sshserver/tests/test_session.py
@@ -21,7 +21,7 @@ class MockSSHSession:
         self.log = log
 
     def writeExtended(self, channel, data):
-        self.log.append(('writeExtended', channel, data))
+        self.log.append(("writeExtended", channel, data))
 
 
 class MockProcessTransport:
@@ -35,16 +35,16 @@ class MockProcessTransport:
         self.session = MockSSHSession(self.log)
 
     def closeStdin(self):
-        self.log.append(('closeStdin',))
+        self.log.append(("closeStdin",))
 
     def loseConnection(self):
-        self.log.append(('loseConnection',))
+        self.log.append(("loseConnection",))
 
     def signalProcess(self, signal):
-        self.log.append(('signalProcess', signal))
+        self.log.append(("signalProcess", signal))
 
     def write(self, data):
-        self.log.append(('write', data))
+        self.log.append(("write", data))
 
 
 class TestDoNothing(testtools.TestCase):
@@ -62,24 +62,33 @@ class TestDoNothing(testtools.TestCase):
 
     def test_openShellNotImplemented(self):
         # openShell closes the connection.
-        protocol = MockProcessTransport('bash')
+        protocol = MockProcessTransport("bash")
         self.session.openShell(protocol)
         self.assertEqual(
-            [('writeExtended', connection.EXTENDED_DATA_STDERR,
-              'No shells on this server.\r\n'),
-             ('loseConnection',)],
-            protocol.log)
+            [
+                (
+                    "writeExtended",
+                    connection.EXTENDED_DATA_STDERR,
+                    "No shells on this server.\r\n",
+                ),
+                ("loseConnection",),
+            ],
+            protocol.log,
+        )
 
     def test_windowChangedNotImplemented(self):
         # windowChanged raises a NotImplementedError. It doesn't matter what
         # we pass it.
-        self.assertRaises(NotImplementedError,
-                          self.session.windowChanged, None)
+        self.assertRaises(
+            NotImplementedError, self.session.windowChanged, None
+        )
 
     def test_providesISession(self):
         # DoNothingSession must provide ISession.
-        self.assertTrue(ISession.providedBy(self.session),
-                        "DoNothingSession doesn't implement ISession")
+        self.assertTrue(
+            ISession.providedBy(self.session),
+            "DoNothingSession doesn't implement ISession",
+        )
 
     def test_closedDoesNothing(self):
         # closed is a no-op.
@@ -87,14 +96,20 @@ class TestDoNothing(testtools.TestCase):
 
     def test_execCommandNotImplemented(self):
         # DoNothingSession.execCommand spawns the appropriate process.
-        protocol = MockProcessTransport('bash')
-        command = 'cat /etc/hostname'
+        protocol = MockProcessTransport("bash")
+        command = "cat /etc/hostname"
         self.session.execCommand(protocol, command)
         self.assertEqual(
-            [('writeExtended', connection.EXTENDED_DATA_STDERR,
-              'Not allowed to execute commands on this server.\r\n'),
-             ('loseConnection',)],
-            protocol.log)
+            [
+                (
+                    "writeExtended",
+                    connection.EXTENDED_DATA_STDERR,
+                    "Not allowed to execute commands on this server.\r\n",
+                ),
+                ("loseConnection",),
+            ],
+            protocol.log,
+        )
 
     def test_eofReceivedDoesNothingWhenNoCommand(self):
         # When no process has been created, 'eofReceived' is a no-op.
diff --git a/tox.ini b/tox.ini
index cc1721e..a7a7a95 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,5 +1,5 @@
 [tox]
-envlist = 
+envlist =
     py27,py35,py36,py37,py38,py39,py310
 
 [testenv]