Blacken, 2.2 edition

18 files changed, 168 insertions, 106 deletions

diff --git a/paramiko/auth_handler.py b/paramiko/auth_handler.py
index 04ee2d75..c1616a5e 100644
--- a/paramiko/auth_handler.py
+++ b/paramiko/auth_handler.py
@@ -228,7 +228,7 @@ class AuthHandler(object):
             if event.is_set():
                 break
             if max_ts is not None and max_ts <= time.time():
-                raise AuthenticationException('Authentication timeout.')
+                raise AuthenticationException("Authentication timeout.")
 
         if not self.is_authenticated():
             e = self.transport.get_exception()
diff --git a/paramiko/channel.py b/paramiko/channel.py
index bf8fcb09..fd61bd65 100644
--- a/paramiko/channel.py
+++ b/paramiko/channel.py
@@ -25,6 +25,7 @@ import os
 import socket
 import time
 import threading
+
 # TODO: switch as much of py3compat.py to 'six' as possible, then use six.wraps
 from functools import wraps
 
diff --git a/paramiko/ecdsakey.py b/paramiko/ecdsakey.py
index 7cfed333..e2e6604f 100644
--- a/paramiko/ecdsakey.py
+++ b/paramiko/ecdsakey.py
@@ -179,8 +179,13 @@ class ECDSAKey(PKey):
         return self.asbytes()
 
     def __hash__(self):
-        return hash((self.get_name(), self.verifying_key.public_numbers().x,
-                     self.verifying_key.public_numbers().y))
+        return hash(
+            (
+                self.get_name(),
+                self.verifying_key.public_numbers().x,
+                self.verifying_key.public_numbers().y,
+            )
+        )
 
     def get_name(self):
         return self.ecdsa_curve.key_format_identifier
diff --git a/paramiko/ed25519key.py b/paramiko/ed25519key.py
index 1557c5b2..77d4d37d 100644
--- a/paramiko/ed25519key.py
+++ b/paramiko/ed25519key.py
@@ -67,6 +67,7 @@ class Ed25519Key(PKey):
 
     def _parse_signing_key_data(self, data, password):
         from paramiko.transport import Transport
+
         # We may eventually want this to be usable for other key types, as
         # OpenSSH moves to it, but for now this is just for Ed25519 keys.
         # This format is described here:
@@ -123,9 +124,9 @@ class Ed25519Key(PKey):
                 ignore_few_rounds=True,
             )
             decryptor = Cipher(
-                cipher["class"](key[:cipher["key-size"]]),
-                cipher["mode"](key[cipher["key-size"]:]),
-                backend=default_backend()
+                cipher["class"](key[: cipher["key-size"]]),
+                cipher["mode"](key[cipher["key-size"] :]),
+                backend=default_backend(),
             ).decryptor()
             private_data = (
                 decryptor.update(private_ciphertext) + decryptor.finalize()
@@ -147,8 +148,10 @@ class Ed25519Key(PKey):
             signing_key = nacl.signing.SigningKey(key_data[:32])
             # Verify that all the public keys are the same...
             assert (
-                signing_key.verify_key.encode() == public == public_keys[i] ==
-                key_data[32:]
+                signing_key.verify_key.encode()
+                == public
+                == public_keys[i]
+                == key_data[32:]
             )
             signing_keys.append(signing_key)
             # Comment, ignore.
diff --git a/paramiko/hostkeys.py b/paramiko/hostkeys.py
index 20a2d93c..1cdddb62 100644
--- a/paramiko/hostkeys.py
+++ b/paramiko/hostkeys.py
@@ -360,7 +360,7 @@ class HostKeyEntry:
                 key = DSSKey(data=decodebytes(key))
             elif keytype in ECDSAKey.supported_key_format_identifiers():
                 key = ECDSAKey(data=decodebytes(key), validate_point=False)
-            elif keytype == 'ssh-ed25519':
+            elif keytype == "ssh-ed25519":
                 key = Ed25519Key(data=decodebytes(key))
             else:
                 log.info("Unable to handle key of type %s" % (keytype,))
diff --git a/paramiko/kex_ecdh_nist.py b/paramiko/kex_ecdh_nist.py
index 702a872d..496805ab 100644
--- a/paramiko/kex_ecdh_nist.py
+++ b/paramiko/kex_ecdh_nist.py
@@ -15,7 +15,7 @@ _MSG_KEXECDH_INIT, _MSG_KEXECDH_REPLY = range(30, 32)
 c_MSG_KEXECDH_INIT, c_MSG_KEXECDH_REPLY = [byte_chr(c) for c in range(30, 32)]
 
 
-class KexNistp256():
+class KexNistp256:
 
     name = "ecdh-sha2-nistp256"
     hash_algo = sha256
@@ -45,7 +45,7 @@ class KexNistp256():
             return self._parse_kexecdh_init(m)
         elif not self.transport.server_mode and (ptype == _MSG_KEXECDH_REPLY):
             return self._parse_kexecdh_reply(m)
-        raise SSHException('KexECDH asked to handle packet type %d' % ptype)
+        raise SSHException("KexECDH asked to handle packet type %d" % ptype)
 
     def _generate_key_pair(self):
         self.P = ec.generate_private_key(self.curve, default_backend())
@@ -64,8 +64,12 @@ class KexNistp256():
         K = long(hexlify(K), 16)
         # compute exchange hash
         hm = Message()
-        hm.add(self.transport.remote_version, self.transport.local_version,
-               self.transport.remote_kex_init, self.transport.local_kex_init)
+        hm.add(
+            self.transport.remote_version,
+            self.transport.local_version,
+            self.transport.remote_kex_init,
+            self.transport.local_kex_init,
+        )
         hm.add_string(K_S)
         hm.add_string(Q_C_bytes)
         # SEC1: V2.0  2.3.3 Elliptic-Curve-Point-to-Octet-String Conversion
@@ -94,8 +98,12 @@ class KexNistp256():
         K = long(hexlify(K), 16)
         # compute exchange hash and verify signature
         hm = Message()
-        hm.add(self.transport.local_version, self.transport.remote_version,
-               self.transport.local_kex_init, self.transport.remote_kex_init)
+        hm.add(
+            self.transport.local_version,
+            self.transport.remote_version,
+            self.transport.local_kex_init,
+            self.transport.remote_kex_init,
+        )
         hm.add_string(K_S)
         # SEC1: V2.0  2.3.3 Elliptic-Curve-Point-to-Octet-String Conversion
         hm.add_string(self.Q_C.public_numbers().encode_point())
diff --git a/paramiko/kex_gss.py b/paramiko/kex_gss.py
index 362d211c..d76bb2dd 100644
--- a/paramiko/kex_gss.py
+++ b/paramiko/kex_gss.py
@@ -225,8 +225,9 @@ class KexGSSGroup1(object):
         H = sha1(str(hm)).digest()
         self.transport._set_K_H(K, H)
         if srv_token is not None:
-            self.kexgss.ssh_init_sec_context(target=self.gss_host,
-                                             recv_token=srv_token)
+            self.kexgss.ssh_init_sec_context(
+                target=self.gss_host, recv_token=srv_token
+            )
             self.kexgss.ssh_check_mic(mic_token, H)
         else:
             self.kexgss.ssh_check_mic(mic_token, H)
@@ -619,8 +620,9 @@ class KexGSSGex(object):
         H = sha1(hm.asbytes()).digest()
         self.transport._set_K_H(K, H)
         if srv_token is not None:
-            self.kexgss.ssh_init_sec_context(target=self.gss_host,
-                                             recv_token=srv_token)
+            self.kexgss.ssh_init_sec_context(
+                target=self.gss_host, recv_token=srv_token
+            )
             self.kexgss.ssh_check_mic(mic_token, H)
         else:
             self.kexgss.ssh_check_mic(mic_token, H)
diff --git a/paramiko/rsakey.py b/paramiko/rsakey.py
index bf7f5750..d6230989 100644
--- a/paramiko/rsakey.py
+++ b/paramiko/rsakey.py
@@ -97,8 +97,9 @@ class RSAKey(PKey):
             return self.asbytes().decode("utf8", errors="ignore")
 
     def __hash__(self):
-        return hash((self.get_name(), self.public_numbers.e,
-                     self.public_numbers.n))
+        return hash(
+            (self.get_name(), self.public_numbers.e, self.public_numbers.n)
+        )
 
     def get_name(self):
         return "ssh-rsa"
diff --git a/paramiko/sftp_client.py b/paramiko/sftp_client.py
index ea81fa5a..425aa87d 100644
--- a/paramiko/sftp_client.py
+++ b/paramiko/sftp_client.py
@@ -30,12 +30,37 @@ from paramiko.message import Message
 from paramiko.common import INFO, DEBUG, o777
 from paramiko.py3compat import bytestring, b, u, long
 from paramiko.sftp import (
-    BaseSFTP, CMD_OPENDIR, CMD_HANDLE, SFTPError, CMD_READDIR, CMD_NAME,
-    CMD_CLOSE, SFTP_FLAG_READ, SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,
-    SFTP_FLAG_TRUNC, SFTP_FLAG_APPEND, SFTP_FLAG_EXCL, CMD_OPEN, CMD_REMOVE,
-    CMD_RENAME, CMD_MKDIR, CMD_RMDIR, CMD_STAT, CMD_ATTRS, CMD_LSTAT,
-    CMD_SYMLINK, CMD_SETSTAT, CMD_READLINK, CMD_REALPATH, CMD_STATUS,
-    CMD_EXTENDED, SFTP_OK, SFTP_EOF, SFTP_NO_SUCH_FILE, SFTP_PERMISSION_DENIED,
+    BaseSFTP,
+    CMD_OPENDIR,
+    CMD_HANDLE,
+    SFTPError,
+    CMD_READDIR,
+    CMD_NAME,
+    CMD_CLOSE,
+    SFTP_FLAG_READ,
+    SFTP_FLAG_WRITE,
+    SFTP_FLAG_CREATE,
+    SFTP_FLAG_TRUNC,
+    SFTP_FLAG_APPEND,
+    SFTP_FLAG_EXCL,
+    CMD_OPEN,
+    CMD_REMOVE,
+    CMD_RENAME,
+    CMD_MKDIR,
+    CMD_RMDIR,
+    CMD_STAT,
+    CMD_ATTRS,
+    CMD_LSTAT,
+    CMD_SYMLINK,
+    CMD_SETSTAT,
+    CMD_READLINK,
+    CMD_REALPATH,
+    CMD_STATUS,
+    CMD_EXTENDED,
+    SFTP_OK,
+    SFTP_EOF,
+    SFTP_NO_SUCH_FILE,
+    SFTP_PERMISSION_DENIED,
 )
 
 from paramiko.sftp_attr import SFTPAttributes
@@ -406,7 +431,7 @@ class SFTPClient(BaseSFTP, ClosingContextManager):
         """
         oldpath = self._adjust_cwd(oldpath)
         newpath = self._adjust_cwd(newpath)
-        self._log(DEBUG, 'posix_rename(%r, %r)' % (oldpath, newpath))
+        self._log(DEBUG, "posix_rename(%r, %r)" % (oldpath, newpath))
         self._request(
             CMD_EXTENDED, "posix-rename@openssh.com", oldpath, newpath
         )
diff --git a/paramiko/sftp_server.py b/paramiko/sftp_server.py
index 8c5e68fc..5c23ea2b 100644
--- a/paramiko/sftp_server.py
+++ b/paramiko/sftp_server.py
@@ -526,7 +526,7 @@ class SFTPServer(BaseSFTP, SubsystemHandler):
             tag = msg.get_text()
             if tag == "check-file":
                 self._check_file(request_number, msg)
-            elif tag == 'posix-rename@openssh.com':
+            elif tag == "posix-rename@openssh.com":
                 oldpath = msg.get_text()
                 newpath = msg.get_text()
                 self._send_status(
diff --git a/paramiko/transport.py b/paramiko/transport.py
index a0890805..d1aa6b19 100644
--- a/paramiko/transport.py
+++ b/paramiko/transport.py
@@ -160,21 +160,21 @@ class Transport(threading.Thread, ClosingContextManager):
         "hmac-md5-96",
     )
     _preferred_keys = (
-        'ssh-ed25519',
-        'ecdsa-sha2-nistp256',
-        'ecdsa-sha2-nistp384',
-        'ecdsa-sha2-nistp521',
-        'ssh-rsa',
-        'ssh-dss',
+        "ssh-ed25519",
+        "ecdsa-sha2-nistp256",
+        "ecdsa-sha2-nistp384",
+        "ecdsa-sha2-nistp521",
+        "ssh-rsa",
+        "ssh-dss",
     )
     _preferred_kex = (
-        'ecdh-sha2-nistp256',
-        'ecdh-sha2-nistp384',
-        'ecdh-sha2-nistp521',
-        'diffie-hellman-group-exchange-sha256',
-        'diffie-hellman-group-exchange-sha1',
-        'diffie-hellman-group14-sha1',
-        'diffie-hellman-group1-sha1',
+        "ecdh-sha2-nistp256",
+        "ecdh-sha2-nistp384",
+        "ecdh-sha2-nistp521",
+        "diffie-hellman-group-exchange-sha256",
+        "diffie-hellman-group-exchange-sha1",
+        "diffie-hellman-group14-sha1",
+        "diffie-hellman-group1-sha1",
     )
     _preferred_gsskex = (
         "gss-gex-sha1-toWM5Slw5Ew8Mqkay+al2g==",
@@ -244,25 +244,25 @@ class Transport(threading.Thread, ClosingContextManager):
     }
 
     _key_info = {
-        'ssh-rsa': RSAKey,
-        'ssh-dss': DSSKey,
-        'ecdsa-sha2-nistp256': ECDSAKey,
-        'ecdsa-sha2-nistp384': ECDSAKey,
-        'ecdsa-sha2-nistp521': ECDSAKey,
-        'ssh-ed25519': Ed25519Key,
+        "ssh-rsa": RSAKey,
+        "ssh-dss": DSSKey,
+        "ecdsa-sha2-nistp256": ECDSAKey,
+        "ecdsa-sha2-nistp384": ECDSAKey,
+        "ecdsa-sha2-nistp521": ECDSAKey,
+        "ssh-ed25519": Ed25519Key,
     }
 
     _kex_info = {
-        'diffie-hellman-group1-sha1': KexGroup1,
-        'diffie-hellman-group14-sha1': KexGroup14,
-        'diffie-hellman-group-exchange-sha1': KexGex,
-        'diffie-hellman-group-exchange-sha256': KexGexSHA256,
-        'gss-group1-sha1-toWM5Slw5Ew8Mqkay+al2g==': KexGSSGroup1,
-        'gss-group14-sha1-toWM5Slw5Ew8Mqkay+al2g==': KexGSSGroup14,
-        'gss-gex-sha1-toWM5Slw5Ew8Mqkay+al2g==': KexGSSGex,
-        'ecdh-sha2-nistp256': KexNistp256,
-        'ecdh-sha2-nistp384': KexNistp384,
-        'ecdh-sha2-nistp521': KexNistp521,
+        "diffie-hellman-group1-sha1": KexGroup1,
+        "diffie-hellman-group14-sha1": KexGroup14,
+        "diffie-hellman-group-exchange-sha1": KexGex,
+        "diffie-hellman-group-exchange-sha256": KexGexSHA256,
+        "gss-group1-sha1-toWM5Slw5Ew8Mqkay+al2g==": KexGSSGroup1,
+        "gss-group14-sha1-toWM5Slw5Ew8Mqkay+al2g==": KexGSSGroup14,
+        "gss-gex-sha1-toWM5Slw5Ew8Mqkay+al2g==": KexGSSGex,
+        "ecdh-sha2-nistp256": KexNistp256,
+        "ecdh-sha2-nistp384": KexNistp384,
+        "ecdh-sha2-nistp521": KexNistp521,
     }
 
     _compression_info = {
diff --git a/setup.py b/setup.py
index 49fe63e3..608c9161 100644
--- a/setup.py
+++ b/setup.py
@@ -75,9 +75,9 @@ setup(
         "Programming Language :: Python :: 3.6",
     ],
     install_requires=[
-        'bcrypt>=3.1.3',
-        'cryptography>=1.1',
-        'pynacl>=1.0.1',
-        'pyasn1>=0.1.7',
+        "bcrypt>=3.1.3",
+        "cryptography>=1.1",
+        "pynacl>=1.0.1",
+        "pyasn1>=0.1.7",
     ],
 )
diff --git a/tests/stub_sftp.py b/tests/stub_sftp.py
index 13e7f3b4..100076d6 100644
--- a/tests/stub_sftp.py
+++ b/tests/stub_sftp.py
@@ -168,7 +168,6 @@ class StubSFTPServer(SFTPServerInterface):
             return SFTPServer.convert_errno(e.errno)
         return SFTP_OK
 
-
     def mkdir(self, path, attr):
         path = self._realpath(path)
         try:
diff --git a/tests/test_auth.py b/tests/test_auth.py
index 14d465ca..6358a053 100644
--- a/tests/test_auth.py
+++ b/tests/test_auth.py
@@ -85,7 +85,7 @@ class NullServer(ServerInterface):
             return AUTH_SUCCESSFUL
         if username == "bad-server":
             raise Exception("Ack!")
-        if username == 'unresponsive-server':
+        if username == "unresponsive-server":
             sleep(5)
             return AUTH_SUCCESSFUL
         return AUTH_FAILED
@@ -264,8 +264,8 @@ class AuthTest(unittest.TestCase):
         self.start_server()
         self.tc.connect()
         try:
-            remain = self.tc.auth_password('unresponsive-server', 'hello')
+            remain = self.tc.auth_password("unresponsive-server", "hello")
         except:
             etype, evalue, etb = sys.exc_info()
             self.assertTrue(issubclass(etype, AuthenticationException))
-            self.assertTrue('Authentication timeout' in str(evalue))
+            self.assertTrue("Authentication timeout" in str(evalue))
diff --git a/tests/test_client.py b/tests/test_client.py
index 53ba53e4..87f7bcb2 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -41,10 +41,10 @@ from .util import _support, slow
 
 
 FINGERPRINTS = {
-    'ssh-dss': b'\x44\x78\xf0\xb9\xa2\x3c\xc5\x18\x20\x09\xff\x75\x5b\xc1\xd2\x6c',
-    'ssh-rsa': b'\x60\x73\x38\x44\xcb\x51\x86\x65\x7f\xde\xda\xa2\x2b\x5a\x57\xd5',
-    'ecdsa-sha2-nistp256': b'\x25\x19\xeb\x55\xe6\xa1\x47\xff\x4f\x38\xd2\x75\x6f\xa5\xd5\x60',
-    'ssh-ed25519': b'\xb3\xd5"\xaa\xf9u^\xe8\xcd\x0e\xea\x02\xb9)\xa2\x80',
+    "ssh-dss": b"\x44\x78\xf0\xb9\xa2\x3c\xc5\x18\x20\x09\xff\x75\x5b\xc1\xd2\x6c",
+    "ssh-rsa": b"\x60\x73\x38\x44\xcb\x51\x86\x65\x7f\xde\xda\xa2\x2b\x5a\x57\xd5",
+    "ecdsa-sha2-nistp256": b"\x25\x19\xeb\x55\xe6\xa1\x47\xff\x4f\x38\xd2\x75\x6f\xa5\xd5\x60",
+    "ssh-ed25519": b'\xb3\xd5"\xaa\xf9u^\xe8\xcd\x0e\xea\x02\xb9)\xa2\x80',
 }
 
 
@@ -62,7 +62,7 @@ class NullServer(paramiko.ServerInterface):
     def check_auth_password(self, username, password):
         if (username == "slowdive") and (password == "pygmalion"):
             return paramiko.AUTH_SUCCESSFUL
-        if (username == 'slowdive') and (password == 'unresponsive-server'):
+        if (username == "slowdive") and (password == "unresponsive-server"):
             time.sleep(5)
             return paramiko.AUTH_SUCCESSFUL
         return paramiko.AUTH_FAILED
@@ -208,7 +208,7 @@ class SSHClientTest(unittest.TestCase):
         self._test_connection(key_filename=_support("test_ecdsa_256.key"))
 
     def test_client_ed25519(self):
-        self._test_connection(key_filename=_support('test_ed25519.key'))
+        self._test_connection(key_filename=_support("test_ed25519.key"))
 
     def test_3_multiple_key_files(self):
         """
@@ -408,7 +408,7 @@ class SSHClientTest(unittest.TestCase):
         self.assertRaises(
             AuthenticationException,
             self._test_connection,
-            password='unresponsive-server',
+            password="unresponsive-server",
             auth_timeout=0.5,
         )
 
diff --git a/tests/test_kex.py b/tests/test_kex.py
index b9b59db1..65eb9a17 100644
--- a/tests/test_kex.py
+++ b/tests/test_kex.py
@@ -40,15 +40,24 @@ from cryptography.hazmat.primitives.asymmetric import ec
 def dummy_urandom(n):
     return byte_chr(0xcc) * n
 
+
 def dummy_generate_key_pair(obj):
     private_key_value = 94761803665136558137557783047955027733968423115106677159790289642479432803037
     public_key_numbers = "042bdab212fa8ba1b7c843301682a4db424d307246c7e1e6083c41d9ca7b098bf30b3d63e2ec6278488c135360456cc054b3444ecc45998c08894cbc1370f5f989"
-    public_key_numbers_obj = ec.EllipticCurvePublicNumbers.from_encoded_point(ec.SECP256R1(), unhexlify(public_key_numbers))
-    obj.P = ec.EllipticCurvePrivateNumbers(private_value=private_key_value, public_numbers=public_key_numbers_obj).private_key(default_backend())
+    public_key_numbers_obj = ec.EllipticCurvePublicNumbers.from_encoded_point(
+        ec.SECP256R1(), unhexlify(public_key_numbers)
+    )
+    obj.P = ec.EllipticCurvePrivateNumbers(
+        private_value=private_key_value, public_numbers=public_key_numbers_obj
+    ).private_key(default_backend())
     if obj.transport.server_mode:
-        obj.Q_S = ec.EllipticCurvePublicNumbers.from_encoded_point(ec.SECP256R1(), unhexlify(public_key_numbers)).public_key(default_backend())
+        obj.Q_S = ec.EllipticCurvePublicNumbers.from_encoded_point(
+            ec.SECP256R1(), unhexlify(public_key_numbers)
+        ).public_key(default_backend())
         return
-    obj.Q_C = ec.EllipticCurvePublicNumbers.from_encoded_point(ec.SECP256R1(), unhexlify(public_key_numbers)).public_key(default_backend())
+    obj.Q_C = ec.EllipticCurvePublicNumbers.from_encoded_point(
+        ec.SECP256R1(), unhexlify(public_key_numbers)
+    ).public_key(default_backend())
 
 
 class FakeKey(object):
@@ -446,20 +455,24 @@ class KexTest(unittest.TestCase):
         transport.server_mode = False
         kex = KexNistp256(transport)
         kex.start_kex()
-        self.assertEqual((paramiko.kex_ecdh_nist._MSG_KEXECDH_REPLY,), transport._expect)
+        self.assertEqual(
+            (paramiko.kex_ecdh_nist._MSG_KEXECDH_REPLY,), transport._expect
+        )
 
-        #fake reply
+        # fake reply
         msg = Message()
-        msg.add_string('fake-host-key')
-        Q_S = unhexlify("043ae159594ba062efa121480e9ef136203fa9ec6b6e1f8723a321c16e62b945f573f3b822258cbcd094b9fa1c125cbfe5f043280893e66863cc0cb4dccbe70210")
+        msg.add_string("fake-host-key")
+        Q_S = unhexlify(
+            "043ae159594ba062efa121480e9ef136203fa9ec6b6e1f8723a321c16e62b945f573f3b822258cbcd094b9fa1c125cbfe5f043280893e66863cc0cb4dccbe70210"
+        )
         msg.add_string(Q_S)
-        msg.add_string('fake-sig')
+        msg.add_string("fake-sig")
         msg.rewind()
         kex.parse_next(paramiko.kex_ecdh_nist._MSG_KEXECDH_REPLY, msg)
-        H = b'BAF7CE243A836037EB5D2221420F35C02B9AB6C957FE3BDE3369307B9612570A'
+        H = b"BAF7CE243A836037EB5D2221420F35C02B9AB6C957FE3BDE3369307B9612570A"
         self.assertEqual(K, kex.transport._K)
         self.assertEqual(H, hexlify(transport._H).upper())
-        self.assertEqual((b'fake-host-key', b'fake-sig'), transport._verify)
+        self.assertEqual((b"fake-host-key", b"fake-sig"), transport._verify)
         self.assertTrue(transport._activated)
 
     def test_12_kex_nistp256_server(self):
@@ -468,12 +481,16 @@ class KexTest(unittest.TestCase):
         transport.server_mode = True
         kex = KexNistp256(transport)
         kex.start_kex()
-        self.assertEqual((paramiko.kex_ecdh_nist._MSG_KEXECDH_INIT,), transport._expect)
+        self.assertEqual(
+            (paramiko.kex_ecdh_nist._MSG_KEXECDH_INIT,), transport._expect
+        )
 
-        #fake init
-        msg=Message()
-        Q_C = unhexlify("043ae159594ba062efa121480e9ef136203fa9ec6b6e1f8723a321c16e62b945f573f3b822258cbcd094b9fa1c125cbfe5f043280893e66863cc0cb4dccbe70210")
-        H = b'2EF4957AFD530DD3F05DBEABF68D724FACC060974DA9704F2AEE4C3DE861E7CA'
+        # fake init
+        msg = Message()
+        Q_C = unhexlify(
+            "043ae159594ba062efa121480e9ef136203fa9ec6b6e1f8723a321c16e62b945f573f3b822258cbcd094b9fa1c125cbfe5f043280893e66863cc0cb4dccbe70210"
+        )
+        H = b"2EF4957AFD530DD3F05DBEABF68D724FACC060974DA9704F2AEE4C3DE861E7CA"
         msg.add_string(Q_C)
         msg.rewind()
         kex.parse_next(paramiko.kex_ecdh_nist._MSG_KEXECDH_INIT, msg)
diff --git a/tests/test_pkey.py b/tests/test_pkey.py
index a70671b5..3a1279b6 100644
--- a/tests/test_pkey.py
+++ b/tests/test_pkey.py
@@ -462,15 +462,15 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(str(key), comparable)
 
     def test_ed25519(self):
-        key1 = Ed25519Key.from_private_key_file(_support('test_ed25519.key'))
+        key1 = Ed25519Key.from_private_key_file(_support("test_ed25519.key"))
         key2 = Ed25519Key.from_private_key_file(
-            _support('test_ed25519_password.key'), b'abc123'
+            _support("test_ed25519_password.key"), b"abc123"
         )
         self.assertNotEqual(key1.asbytes(), key2.asbytes())
 
     def test_ed25519_compare(self):
         # verify that the private & public keys compare equal
-        key = Ed25519Key.from_private_key_file(_support('test_ed25519.key'))
+        key = Ed25519Key.from_private_key_file(_support("test_ed25519.key"))
         self.assertEqual(key, key)
         pub = Ed25519Key(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -480,10 +480,10 @@ class KeyTest(unittest.TestCase):
     def test_ed25519_nonbytes_password(self):
         # https://github.com/paramiko/paramiko/issues/1039
         key = Ed25519Key.from_private_key_file(
-            _support('test_ed25519_password.key'),
+            _support("test_ed25519_password.key"),
             # NOTE: not a bytes. Amusingly, the test above for same key DOES
             # explicitly cast to bytes...code smell!
-            'abc123',
+            "abc123",
         )
         # No exception -> it's good. Meh.
 
diff --git a/tests/test_sftp.py b/tests/test_sftp.py
index a86fca5d..87c57340 100644
--- a/tests/test_sftp.py
+++ b/tests/test_sftp.py
@@ -189,35 +189,36 @@ class TestSFTP(object):
         """Test posix-rename@openssh.com protocol extension."""
         try:
             # first check that the normal rename works as specified
-            with sftp.open(sftp.FOLDER + '/a', 'w') as f:
-                f.write('one')
-            sftp.rename(sftp.FOLDER + '/a', sftp.FOLDER + '/b')
-            with sftp.open(sftp.FOLDER + '/a', 'w') as f:
-                f.write('two')
+            with sftp.open(sftp.FOLDER + "/a", "w") as f:
+                f.write("one")
+            sftp.rename(sftp.FOLDER + "/a", sftp.FOLDER + "/b")
+            with sftp.open(sftp.FOLDER + "/a", "w") as f:
+                f.write("two")
             try:
-                sftp.rename(sftp.FOLDER + '/a', sftp.FOLDER + '/b')
-                self.assertTrue(False, 'no exception when rename-ing onto existing file')
+                sftp.rename(sftp.FOLDER + "/a", sftp.FOLDER + "/b")
+                self.assertTrue(
+                    False, "no exception when rename-ing onto existing file"
+                )
             except (OSError, IOError):
                 pass
 
             # now check with the posix_rename
-            sftp.posix_rename(sftp.FOLDER + '/a', sftp.FOLDER + '/b')
-            with sftp.open(sftp.FOLDER + '/b', 'r') as f:
+            sftp.posix_rename(sftp.FOLDER + "/a", sftp.FOLDER + "/b")
+            with sftp.open(sftp.FOLDER + "/b", "r") as f:
                 data = u(f.read())
             err = "Contents of renamed file not the same as original file"
             assert data == "two", err
 
         finally:
             try:
-                sftp.remove(sftp.FOLDER + '/a')
+                sftp.remove(sftp.FOLDER + "/a")
             except:
                 pass
             try:
-                sftp.remove(sftp.FOLDER + '/b')
+                sftp.remove(sftp.FOLDER + "/b")
             except:
                 pass
 
-
     def test_6_folder(self, sftp):
         """
         create a temporary folder, verify that we can create a file in it, then