Blacken Paramiko on 2.4

1 files changed, 126 insertions, 113 deletions

diff --git a/tests/test_pkey.py b/tests/test_pkey.py
index 1827d2a9..66bebc43 100644
--- a/tests/test_pkey.py
+++ b/tests/test_pkey.py
@@ -34,18 +34,18 @@ from .util import _support
 
 
 # from openssh's ssh-keygen
-PUB_RSA = 'ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEA049W6geFpmsljTwfvI1UmKWWJPNFI74+vNKTk4dmzkQY2yAMs6FhlvhlI8ysU4oj71ZsRYMecHbBbxdN79+JRFVYTKaLqjwGENeTd+yv4q+V2PvZv3fLnzApI3l7EJCqhWwJUHJ1jAkZzqDx0tyOL4uoZpww3nmE0kb3y21tH4c='
-PUB_DSS = 'ssh-dss AAAAB3NzaC1kc3MAAACBAOeBpgNnfRzr/twmAQRu2XwWAp3CFtrVnug6s6fgwj/oLjYbVtjAy6pl/h0EKCWx2rf1IetyNsTxWrniA9I6HeDj65X1FyDkg6g8tvCnaNB8Xp/UUhuzHuGsMIipRxBxw9LF608EqZcj1E3ytktoW5B5OcjrkEoz3xG7C+rpIjYvAAAAFQDwz4UnmsGiSNu5iqjn3uTzwUpshwAAAIEAkxfFeY8P2wZpDjX0MimZl5wkoFQDL25cPzGBuB4OnB8NoUk/yjAHIIpEShw8V+LzouMK5CTJQo5+Ngw3qIch/WgRmMHy4kBq1SsXMjQCte1So6HBMvBPIW5SiMTmjCfZZiw4AYHK+B/JaOwaG9yRg2Ejg4Ok10+XFDxlqZo8Y+wAAACARmR7CCPjodxASvRbIyzaVpZoJ/Z6x7dAumV+ysrV1BVYd0lYukmnjO1kKBWApqpH1ve9XDQYN8zgxM4b16L21kpoWQnZtXrY3GZ4/it9kUgyB7+NwacIBlXa8cMDL7Q/69o0d54U0X/NeX5QxuYR6OMJlrkQB7oiW/P/1mwjQgE='
-PUB_ECDSA_256 = 'ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJSPZm3ZWkvk/Zx8WP+fZRZ5/NBBHnGQwR6uIC6XHGPDIHuWUzIjAwA0bzqkOUffEsbLe+uQgKl5kbc/L8KA/eo='
-PUB_ECDSA_384 = 'ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBBbGibQLW9AAZiGN2hEQxWYYoFaWKwN3PKSaDJSMqmIn1Z9sgRUuw8Y/w502OGvXL/wFk0i2z50l3pWZjD7gfMH7gX5TUiCzwrQkS+Hn1U2S9aF5WJp0NcIzYxXw2r4M2A=='
-PUB_ECDSA_521 = 'ecdsa-sha2-nistp521 AAAAE2VjZHNhLXNoYTItbmlzdHA1MjEAAAAIbmlzdHA1MjEAAACFBACaOaFLZGuxa5AW16qj6VLypFbLrEWrt9AZUloCMefxO8bNLjK/O5g0rAVasar1TnyHE9qj4NwzANZASWjQNbc4MAG8vzqezFwLIn/kNyNTsXNfqEko9OgHZknlj2Z79dwTJcRAL4QLcT5aND0EHZLB2fAUDXiWIb2j4rg1mwPlBMiBXA=='
-
-FINGER_RSA = '1024 60:73:38:44:cb:51:86:65:7f:de:da:a2:2b:5a:57:d5'
-FINGER_DSS = '1024 44:78:f0:b9:a2:3c:c5:18:20:09:ff:75:5b:c1:d2:6c'
-FINGER_ECDSA_256 = '256 25:19:eb:55:e6:a1:47:ff:4f:38:d2:75:6f:a5:d5:60'
-FINGER_ECDSA_384 = '384 c1:8d:a0:59:09:47:41:8e:a8:a6:07:01:29:23:b4:65'
-FINGER_ECDSA_521 = '521 44:58:22:52:12:33:16:0e:ce:0e:be:2c:7c:7e:cc:1e'
-SIGNED_RSA = '20:d7:8a:31:21:cb:f7:92:12:f2:a4:89:37:f5:78:af:e6:16:b6:25:b9:97:3d:a2:cd:5f:ca:20:21:73:4c:ad:34:73:8f:20:77:28:e2:94:15:08:d8:91:40:7a:85:83:bf:18:37:95:dc:54:1a:9b:88:29:6c:73:ca:38:b4:04:f1:56:b9:f2:42:9d:52:1b:29:29:b4:4f:fd:c9:2d:af:47:d2:40:76:30:f3:63:45:0c:d9:1d:43:86:0f:1c:70:e2:93:12:34:f3:ac:c5:0a:2f:14:50:66:59:f1:88:ee:c1:4a:e9:d1:9c:4e:46:f0:0e:47:6f:38:74:f1:44:a8'
+PUB_RSA = "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEA049W6geFpmsljTwfvI1UmKWWJPNFI74+vNKTk4dmzkQY2yAMs6FhlvhlI8ysU4oj71ZsRYMecHbBbxdN79+JRFVYTKaLqjwGENeTd+yv4q+V2PvZv3fLnzApI3l7EJCqhWwJUHJ1jAkZzqDx0tyOL4uoZpww3nmE0kb3y21tH4c="
+PUB_DSS = "ssh-dss AAAAB3NzaC1kc3MAAACBAOeBpgNnfRzr/twmAQRu2XwWAp3CFtrVnug6s6fgwj/oLjYbVtjAy6pl/h0EKCWx2rf1IetyNsTxWrniA9I6HeDj65X1FyDkg6g8tvCnaNB8Xp/UUhuzHuGsMIipRxBxw9LF608EqZcj1E3ytktoW5B5OcjrkEoz3xG7C+rpIjYvAAAAFQDwz4UnmsGiSNu5iqjn3uTzwUpshwAAAIEAkxfFeY8P2wZpDjX0MimZl5wkoFQDL25cPzGBuB4OnB8NoUk/yjAHIIpEShw8V+LzouMK5CTJQo5+Ngw3qIch/WgRmMHy4kBq1SsXMjQCte1So6HBMvBPIW5SiMTmjCfZZiw4AYHK+B/JaOwaG9yRg2Ejg4Ok10+XFDxlqZo8Y+wAAACARmR7CCPjodxASvRbIyzaVpZoJ/Z6x7dAumV+ysrV1BVYd0lYukmnjO1kKBWApqpH1ve9XDQYN8zgxM4b16L21kpoWQnZtXrY3GZ4/it9kUgyB7+NwacIBlXa8cMDL7Q/69o0d54U0X/NeX5QxuYR6OMJlrkQB7oiW/P/1mwjQgE="
+PUB_ECDSA_256 = "ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJSPZm3ZWkvk/Zx8WP+fZRZ5/NBBHnGQwR6uIC6XHGPDIHuWUzIjAwA0bzqkOUffEsbLe+uQgKl5kbc/L8KA/eo="
+PUB_ECDSA_384 = "ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBBbGibQLW9AAZiGN2hEQxWYYoFaWKwN3PKSaDJSMqmIn1Z9sgRUuw8Y/w502OGvXL/wFk0i2z50l3pWZjD7gfMH7gX5TUiCzwrQkS+Hn1U2S9aF5WJp0NcIzYxXw2r4M2A=="
+PUB_ECDSA_521 = "ecdsa-sha2-nistp521 AAAAE2VjZHNhLXNoYTItbmlzdHA1MjEAAAAIbmlzdHA1MjEAAACFBACaOaFLZGuxa5AW16qj6VLypFbLrEWrt9AZUloCMefxO8bNLjK/O5g0rAVasar1TnyHE9qj4NwzANZASWjQNbc4MAG8vzqezFwLIn/kNyNTsXNfqEko9OgHZknlj2Z79dwTJcRAL4QLcT5aND0EHZLB2fAUDXiWIb2j4rg1mwPlBMiBXA=="
+
+FINGER_RSA = "1024 60:73:38:44:cb:51:86:65:7f:de:da:a2:2b:5a:57:d5"
+FINGER_DSS = "1024 44:78:f0:b9:a2:3c:c5:18:20:09:ff:75:5b:c1:d2:6c"
+FINGER_ECDSA_256 = "256 25:19:eb:55:e6:a1:47:ff:4f:38:d2:75:6f:a5:d5:60"
+FINGER_ECDSA_384 = "384 c1:8d:a0:59:09:47:41:8e:a8:a6:07:01:29:23:b4:65"
+FINGER_ECDSA_521 = "521 44:58:22:52:12:33:16:0e:ce:0e:be:2c:7c:7e:cc:1e"
+SIGNED_RSA = "20:d7:8a:31:21:cb:f7:92:12:f2:a4:89:37:f5:78:af:e6:16:b6:25:b9:97:3d:a2:cd:5f:ca:20:21:73:4c:ad:34:73:8f:20:77:28:e2:94:15:08:d8:91:40:7a:85:83:bf:18:37:95:dc:54:1a:9b:88:29:6c:73:ca:38:b4:04:f1:56:b9:f2:42:9d:52:1b:29:29:b4:4f:fd:c9:2d:af:47:d2:40:76:30:f3:63:45:0c:d9:1d:43:86:0f:1c:70:e2:93:12:34:f3:ac:c5:0a:2f:14:50:66:59:f1:88:ee:c1:4a:e9:d1:9c:4e:46:f0:0e:47:6f:38:74:f1:44:a8"
 
 RSA_PRIVATE_OUT = """\
 -----BEGIN RSA PRIVATE KEY-----
@@ -107,10 +107,10 @@ L4QLcT5aND0EHZLB2fAUDXiWIb2j4rg1mwPlBMiBXA==
 -----END EC PRIVATE KEY-----
 """
 
-x1234 = b'\x01\x02\x03\x04'
+x1234 = b"\x01\x02\x03\x04"
 
-TEST_KEY_BYTESTR_2 = '\x00\x00\x00\x07ssh-rsa\x00\x00\x00\x01#\x00\x00\x00\x81\x00\xd3\x8fV\xea\x07\x85\xa6k%\x8d<\x1f\xbc\x8dT\x98\xa5\x96$\xf3E#\xbe>\xbc\xd2\x93\x93\x87f\xceD\x18\xdb \x0c\xb3\xa1a\x96\xf8e#\xcc\xacS\x8a#\xefVlE\x83\x1epv\xc1o\x17M\xef\xdf\x89DUXL\xa6\x8b\xaa<\x06\x10\xd7\x93w\xec\xaf\xe2\xaf\x95\xd8\xfb\xd9\xbfw\xcb\x9f0)#y{\x10\x90\xaa\x85l\tPru\x8c\t\x19\xce\xa0\xf1\xd2\xdc\x8e/\x8b\xa8f\x9c0\xdey\x84\xd2F\xf7\xcbmm\x1f\x87'
-TEST_KEY_BYTESTR_3 = '\x00\x00\x00\x07ssh-rsa\x00\x00\x00\x01#\x00\x00\x00\x00ӏV\x07k%<\x1fT$E#>ғfD\x18 \x0cae#̬S#VlE\x1epvo\x17M߉DUXL<\x06\x10דw\u2bd5ٿw˟0)#y{\x10l\tPru\t\x19Π\u070e/f0yFmm\x1f'
+TEST_KEY_BYTESTR_2 = "\x00\x00\x00\x07ssh-rsa\x00\x00\x00\x01#\x00\x00\x00\x81\x00\xd3\x8fV\xea\x07\x85\xa6k%\x8d<\x1f\xbc\x8dT\x98\xa5\x96$\xf3E#\xbe>\xbc\xd2\x93\x93\x87f\xceD\x18\xdb \x0c\xb3\xa1a\x96\xf8e#\xcc\xacS\x8a#\xefVlE\x83\x1epv\xc1o\x17M\xef\xdf\x89DUXL\xa6\x8b\xaa<\x06\x10\xd7\x93w\xec\xaf\xe2\xaf\x95\xd8\xfb\xd9\xbfw\xcb\x9f0)#y{\x10\x90\xaa\x85l\tPru\x8c\t\x19\xce\xa0\xf1\xd2\xdc\x8e/\x8b\xa8f\x9c0\xdey\x84\xd2F\xf7\xcbmm\x1f\x87"
+TEST_KEY_BYTESTR_3 = "\x00\x00\x00\x07ssh-rsa\x00\x00\x00\x01#\x00\x00\x00\x00ӏV\x07k%<\x1fT$E#>ғfD\x18 \x0cae#̬S#VlE\x1epvo\x17M߉DUXL<\x06\x10דw\u2bd5ٿw˟0)#y{\x10l\tPru\t\x19Π\u070e/f0yFmm\x1f"
 
 
 class KeyTest(unittest.TestCase):
@@ -127,21 +127,20 @@ class KeyTest(unittest.TestCase):
         """
         with open(keyfile, "r") as fh:
             self.assertEqual(
-                fh.readline()[:-1],
-                "-----BEGIN RSA PRIVATE KEY-----"
+                fh.readline()[:-1], "-----BEGIN RSA PRIVATE KEY-----"
             )
             self.assertEqual(fh.readline()[:-1], "Proc-Type: 4,ENCRYPTED")
             self.assertEqual(fh.readline()[0:10], "DEK-Info: ")
 
     def test_1_generate_key_bytes(self):
-        key = util.generate_key_bytes(md5, x1234, 'happy birthday', 30)
-        exp = b'\x61\xE1\xF2\x72\xF4\xC1\xC4\x56\x15\x86\xBD\x32\x24\x98\xC0\xE9\x24\x67\x27\x80\xF4\x7B\xB3\x7D\xDA\x7D\x54\x01\x9E\x64'
+        key = util.generate_key_bytes(md5, x1234, "happy birthday", 30)
+        exp = b"\x61\xE1\xF2\x72\xF4\xC1\xC4\x56\x15\x86\xBD\x32\x24\x98\xC0\xE9\x24\x67\x27\x80\xF4\x7B\xB3\x7D\xDA\x7D\x54\x01\x9E\x64"
         self.assertEqual(exp, key)
 
     def test_2_load_rsa(self):
-        key = RSAKey.from_private_key_file(_support('test_rsa.key'))
-        self.assertEqual('ssh-rsa', key.get_name())
-        exp_rsa = b(FINGER_RSA.split()[1].replace(':', ''))
+        key = RSAKey.from_private_key_file(_support("test_rsa.key"))
+        self.assertEqual("ssh-rsa", key.get_name())
+        exp_rsa = b(FINGER_RSA.split()[1].replace(":", ""))
         my_rsa = hexlify(key.get_fingerprint())
         self.assertEqual(exp_rsa, my_rsa)
         self.assertEqual(PUB_RSA.split()[1], key.get_base64())
@@ -155,18 +154,20 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_3_load_rsa_password(self):
-        key = RSAKey.from_private_key_file(_support('test_rsa_password.key'), 'television')
-        self.assertEqual('ssh-rsa', key.get_name())
-        exp_rsa = b(FINGER_RSA.split()[1].replace(':', ''))
+        key = RSAKey.from_private_key_file(
+            _support("test_rsa_password.key"), "television"
+        )
+        self.assertEqual("ssh-rsa", key.get_name())
+        exp_rsa = b(FINGER_RSA.split()[1].replace(":", ""))
         my_rsa = hexlify(key.get_fingerprint())
         self.assertEqual(exp_rsa, my_rsa)
         self.assertEqual(PUB_RSA.split()[1], key.get_base64())
         self.assertEqual(1024, key.get_bits())
 
     def test_4_load_dss(self):
-        key = DSSKey.from_private_key_file(_support('test_dss.key'))
-        self.assertEqual('ssh-dss', key.get_name())
-        exp_dss = b(FINGER_DSS.split()[1].replace(':', ''))
+        key = DSSKey.from_private_key_file(_support("test_dss.key"))
+        self.assertEqual("ssh-dss", key.get_name())
+        exp_dss = b(FINGER_DSS.split()[1].replace(":", ""))
         my_dss = hexlify(key.get_fingerprint())
         self.assertEqual(exp_dss, my_dss)
         self.assertEqual(PUB_DSS.split()[1], key.get_base64())
@@ -180,9 +181,11 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_5_load_dss_password(self):
-        key = DSSKey.from_private_key_file(_support('test_dss_password.key'), 'television')
-        self.assertEqual('ssh-dss', key.get_name())
-        exp_dss = b(FINGER_DSS.split()[1].replace(':', ''))
+        key = DSSKey.from_private_key_file(
+            _support("test_dss_password.key"), "television"
+        )
+        self.assertEqual("ssh-dss", key.get_name())
+        exp_dss = b(FINGER_DSS.split()[1].replace(":", ""))
         my_dss = hexlify(key.get_fingerprint())
         self.assertEqual(exp_dss, my_dss)
         self.assertEqual(PUB_DSS.split()[1], key.get_base64())
@@ -190,7 +193,7 @@ class KeyTest(unittest.TestCase):
 
     def test_6_compare_rsa(self):
         # verify that the private & public keys compare equal
-        key = RSAKey.from_private_key_file(_support('test_rsa.key'))
+        key = RSAKey.from_private_key_file(_support("test_rsa.key"))
         self.assertEqual(key, key)
         pub = RSAKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -199,7 +202,7 @@ class KeyTest(unittest.TestCase):
 
     def test_7_compare_dss(self):
         # verify that the private & public keys compare equal
-        key = DSSKey.from_private_key_file(_support('test_dss.key'))
+        key = DSSKey.from_private_key_file(_support("test_dss.key"))
         self.assertEqual(key, key)
         pub = DSSKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -208,77 +211,79 @@ class KeyTest(unittest.TestCase):
 
     def test_8_sign_rsa(self):
         # verify that the rsa private key can sign and verify
-        key = RSAKey.from_private_key_file(_support('test_rsa.key'))
-        msg = key.sign_ssh_data(b'ice weasels')
+        key = RSAKey.from_private_key_file(_support("test_rsa.key"))
+        msg = key.sign_ssh_data(b"ice weasels")
         self.assertTrue(type(msg) is Message)
         msg.rewind()
-        self.assertEqual('ssh-rsa', msg.get_text())
-        sig = bytes().join([byte_chr(int(x, 16)) for x in SIGNED_RSA.split(':')])
+        self.assertEqual("ssh-rsa", msg.get_text())
+        sig = bytes().join(
+            [byte_chr(int(x, 16)) for x in SIGNED_RSA.split(":")]
+        )
         self.assertEqual(sig, msg.get_binary())
         msg.rewind()
         pub = RSAKey(data=key.asbytes())
-        self.assertTrue(pub.verify_ssh_sig(b'ice weasels', msg))
+        self.assertTrue(pub.verify_ssh_sig(b"ice weasels", msg))
 
     def test_9_sign_dss(self):
         # verify that the dss private key can sign and verify
-        key = DSSKey.from_private_key_file(_support('test_dss.key'))
-        msg = key.sign_ssh_data(b'ice weasels')
+        key = DSSKey.from_private_key_file(_support("test_dss.key"))
+        msg = key.sign_ssh_data(b"ice weasels")
         self.assertTrue(type(msg) is Message)
         msg.rewind()
-        self.assertEqual('ssh-dss', msg.get_text())
+        self.assertEqual("ssh-dss", msg.get_text())
         # can't do the same test as we do for RSA, because DSS signatures
         # are usually different each time.  but we can test verification
         # anyway so it's ok.
         self.assertEqual(40, len(msg.get_binary()))
         msg.rewind()
         pub = DSSKey(data=key.asbytes())
-        self.assertTrue(pub.verify_ssh_sig(b'ice weasels', msg))
+        self.assertTrue(pub.verify_ssh_sig(b"ice weasels", msg))
 
     def test_A_generate_rsa(self):
         key = RSAKey.generate(1024)
-        msg = key.sign_ssh_data(b'jerri blank')
+        msg = key.sign_ssh_data(b"jerri blank")
         msg.rewind()
-        self.assertTrue(key.verify_ssh_sig(b'jerri blank', msg))
+        self.assertTrue(key.verify_ssh_sig(b"jerri blank", msg))
 
     def test_B_generate_dss(self):
         key = DSSKey.generate(1024)
-        msg = key.sign_ssh_data(b'jerri blank')
+        msg = key.sign_ssh_data(b"jerri blank")
         msg.rewind()
-        self.assertTrue(key.verify_ssh_sig(b'jerri blank', msg))
+        self.assertTrue(key.verify_ssh_sig(b"jerri blank", msg))
 
     def test_C_generate_ecdsa(self):
         key = ECDSAKey.generate()
-        msg = key.sign_ssh_data(b'jerri blank')
+        msg = key.sign_ssh_data(b"jerri blank")
         msg.rewind()
-        self.assertTrue(key.verify_ssh_sig(b'jerri blank', msg))
+        self.assertTrue(key.verify_ssh_sig(b"jerri blank", msg))
         self.assertEqual(key.get_bits(), 256)
-        self.assertEqual(key.get_name(), 'ecdsa-sha2-nistp256')
+        self.assertEqual(key.get_name(), "ecdsa-sha2-nistp256")
 
         key = ECDSAKey.generate(bits=256)
-        msg = key.sign_ssh_data(b'jerri blank')
+        msg = key.sign_ssh_data(b"jerri blank")
         msg.rewind()
-        self.assertTrue(key.verify_ssh_sig(b'jerri blank', msg))
+        self.assertTrue(key.verify_ssh_sig(b"jerri blank", msg))
         self.assertEqual(key.get_bits(), 256)
-        self.assertEqual(key.get_name(), 'ecdsa-sha2-nistp256')
+        self.assertEqual(key.get_name(), "ecdsa-sha2-nistp256")
 
         key = ECDSAKey.generate(bits=384)
-        msg = key.sign_ssh_data(b'jerri blank')
+        msg = key.sign_ssh_data(b"jerri blank")
         msg.rewind()
-        self.assertTrue(key.verify_ssh_sig(b'jerri blank', msg))
+        self.assertTrue(key.verify_ssh_sig(b"jerri blank", msg))
         self.assertEqual(key.get_bits(), 384)
-        self.assertEqual(key.get_name(), 'ecdsa-sha2-nistp384')
+        self.assertEqual(key.get_name(), "ecdsa-sha2-nistp384")
 
         key = ECDSAKey.generate(bits=521)
-        msg = key.sign_ssh_data(b'jerri blank')
+        msg = key.sign_ssh_data(b"jerri blank")
         msg.rewind()
-        self.assertTrue(key.verify_ssh_sig(b'jerri blank', msg))
+        self.assertTrue(key.verify_ssh_sig(b"jerri blank", msg))
         self.assertEqual(key.get_bits(), 521)
-        self.assertEqual(key.get_name(), 'ecdsa-sha2-nistp521')
+        self.assertEqual(key.get_name(), "ecdsa-sha2-nistp521")
 
     def test_10_load_ecdsa_256(self):
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_256.key'))
-        self.assertEqual('ecdsa-sha2-nistp256', key.get_name())
-        exp_ecdsa = b(FINGER_ECDSA_256.split()[1].replace(':', ''))
+        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_256.key"))
+        self.assertEqual("ecdsa-sha2-nistp256", key.get_name())
+        exp_ecdsa = b(FINGER_ECDSA_256.split()[1].replace(":", ""))
         my_ecdsa = hexlify(key.get_fingerprint())
         self.assertEqual(exp_ecdsa, my_ecdsa)
         self.assertEqual(PUB_ECDSA_256.split()[1], key.get_base64())
@@ -292,9 +297,11 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_11_load_ecdsa_password_256(self):
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_password_256.key'), b'television')
-        self.assertEqual('ecdsa-sha2-nistp256', key.get_name())
-        exp_ecdsa = b(FINGER_ECDSA_256.split()[1].replace(':', ''))
+        key = ECDSAKey.from_private_key_file(
+            _support("test_ecdsa_password_256.key"), b"television"
+        )
+        self.assertEqual("ecdsa-sha2-nistp256", key.get_name())
+        exp_ecdsa = b(FINGER_ECDSA_256.split()[1].replace(":", ""))
         my_ecdsa = hexlify(key.get_fingerprint())
         self.assertEqual(exp_ecdsa, my_ecdsa)
         self.assertEqual(PUB_ECDSA_256.split()[1], key.get_base64())
@@ -302,7 +309,7 @@ class KeyTest(unittest.TestCase):
 
     def test_12_compare_ecdsa_256(self):
         # verify that the private & public keys compare equal
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_256.key'))
+        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_256.key"))
         self.assertEqual(key, key)
         pub = ECDSAKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -311,11 +318,11 @@ class KeyTest(unittest.TestCase):
 
     def test_13_sign_ecdsa_256(self):
         # verify that the rsa private key can sign and verify
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_256.key'))
-        msg = key.sign_ssh_data(b'ice weasels')
+        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_256.key"))
+        msg = key.sign_ssh_data(b"ice weasels")
         self.assertTrue(type(msg) is Message)
         msg.rewind()
-        self.assertEqual('ecdsa-sha2-nistp256', msg.get_text())
+        self.assertEqual("ecdsa-sha2-nistp256", msg.get_text())
         # ECDSA signatures, like DSS signatures, tend to be different
         # each time, so we can't compare against a "known correct"
         # signature.
@@ -323,12 +330,12 @@ class KeyTest(unittest.TestCase):
 
         msg.rewind()
         pub = ECDSAKey(data=key.asbytes())
-        self.assertTrue(pub.verify_ssh_sig(b'ice weasels', msg))
+        self.assertTrue(pub.verify_ssh_sig(b"ice weasels", msg))
 
     def test_14_load_ecdsa_384(self):
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_384.key'))
-        self.assertEqual('ecdsa-sha2-nistp384', key.get_name())
-        exp_ecdsa = b(FINGER_ECDSA_384.split()[1].replace(':', ''))
+        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_384.key"))
+        self.assertEqual("ecdsa-sha2-nistp384", key.get_name())
+        exp_ecdsa = b(FINGER_ECDSA_384.split()[1].replace(":", ""))
         my_ecdsa = hexlify(key.get_fingerprint())
         self.assertEqual(exp_ecdsa, my_ecdsa)
         self.assertEqual(PUB_ECDSA_384.split()[1], key.get_base64())
@@ -342,9 +349,11 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_15_load_ecdsa_password_384(self):
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_password_384.key'), b'television')
-        self.assertEqual('ecdsa-sha2-nistp384', key.get_name())
-        exp_ecdsa = b(FINGER_ECDSA_384.split()[1].replace(':', ''))
+        key = ECDSAKey.from_private_key_file(
+            _support("test_ecdsa_password_384.key"), b"television"
+        )
+        self.assertEqual("ecdsa-sha2-nistp384", key.get_name())
+        exp_ecdsa = b(FINGER_ECDSA_384.split()[1].replace(":", ""))
         my_ecdsa = hexlify(key.get_fingerprint())
         self.assertEqual(exp_ecdsa, my_ecdsa)
         self.assertEqual(PUB_ECDSA_384.split()[1], key.get_base64())
@@ -352,7 +361,7 @@ class KeyTest(unittest.TestCase):
 
     def test_16_compare_ecdsa_384(self):
         # verify that the private & public keys compare equal
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_384.key'))
+        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_384.key"))
         self.assertEqual(key, key)
         pub = ECDSAKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -361,11 +370,11 @@ class KeyTest(unittest.TestCase):
 
     def test_17_sign_ecdsa_384(self):
         # verify that the rsa private key can sign and verify
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_384.key'))
-        msg = key.sign_ssh_data(b'ice weasels')
+        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_384.key"))
+        msg = key.sign_ssh_data(b"ice weasels")
         self.assertTrue(type(msg) is Message)
         msg.rewind()
-        self.assertEqual('ecdsa-sha2-nistp384', msg.get_text())
+        self.assertEqual("ecdsa-sha2-nistp384", msg.get_text())
         # ECDSA signatures, like DSS signatures, tend to be different
         # each time, so we can't compare against a "known correct"
         # signature.
@@ -373,12 +382,12 @@ class KeyTest(unittest.TestCase):
 
         msg.rewind()
         pub = ECDSAKey(data=key.asbytes())
-        self.assertTrue(pub.verify_ssh_sig(b'ice weasels', msg))
+        self.assertTrue(pub.verify_ssh_sig(b"ice weasels", msg))
 
     def test_18_load_ecdsa_521(self):
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_521.key'))
-        self.assertEqual('ecdsa-sha2-nistp521', key.get_name())
-        exp_ecdsa = b(FINGER_ECDSA_521.split()[1].replace(':', ''))
+        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_521.key"))
+        self.assertEqual("ecdsa-sha2-nistp521", key.get_name())
+        exp_ecdsa = b(FINGER_ECDSA_521.split()[1].replace(":", ""))
         my_ecdsa = hexlify(key.get_fingerprint())
         self.assertEqual(exp_ecdsa, my_ecdsa)
         self.assertEqual(PUB_ECDSA_521.split()[1], key.get_base64())
@@ -395,9 +404,11 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_19_load_ecdsa_password_521(self):
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_password_521.key'), b'television')
-        self.assertEqual('ecdsa-sha2-nistp521', key.get_name())
-        exp_ecdsa = b(FINGER_ECDSA_521.split()[1].replace(':', ''))
+        key = ECDSAKey.from_private_key_file(
+            _support("test_ecdsa_password_521.key"), b"television"
+        )
+        self.assertEqual("ecdsa-sha2-nistp521", key.get_name())
+        exp_ecdsa = b(FINGER_ECDSA_521.split()[1].replace(":", ""))
         my_ecdsa = hexlify(key.get_fingerprint())
         self.assertEqual(exp_ecdsa, my_ecdsa)
         self.assertEqual(PUB_ECDSA_521.split()[1], key.get_base64())
@@ -405,7 +416,7 @@ class KeyTest(unittest.TestCase):
 
     def test_20_compare_ecdsa_521(self):
         # verify that the private & public keys compare equal
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_521.key'))
+        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_521.key"))
         self.assertEqual(key, key)
         pub = ECDSAKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -414,11 +425,11 @@ class KeyTest(unittest.TestCase):
 
     def test_21_sign_ecdsa_521(self):
         # verify that the rsa private key can sign and verify
-        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_521.key'))
-        msg = key.sign_ssh_data(b'ice weasels')
+        key = ECDSAKey.from_private_key_file(_support("test_ecdsa_521.key"))
+        msg = key.sign_ssh_data(b"ice weasels")
         self.assertTrue(type(msg) is Message)
         msg.rewind()
-        self.assertEqual('ecdsa-sha2-nistp521', msg.get_text())
+        self.assertEqual("ecdsa-sha2-nistp521", msg.get_text())
         # ECDSA signatures, like DSS signatures, tend to be different
         # each time, so we can't compare against a "known correct"
         # signature.
@@ -426,14 +437,14 @@ class KeyTest(unittest.TestCase):
 
         msg.rewind()
         pub = ECDSAKey(data=key.asbytes())
-        self.assertTrue(pub.verify_ssh_sig(b'ice weasels', msg))
+        self.assertTrue(pub.verify_ssh_sig(b"ice weasels", msg))
 
     def test_salt_size(self):
         # Read an existing encrypted private key
-        file_ = _support('test_rsa_password.key')
-        password = 'television'
-        newfile = file_ + '.new'
-        newpassword = 'radio'
+        file_ = _support("test_rsa_password.key")
+        password = "television"
+        newfile = file_ + ".new"
+        newpassword = "radio"
         key = RSAKey(filename=file_, password=password)
         # Write out a newly re-encrypted copy with a new password.
         # When the bug under test exists, this will ValueError.
@@ -447,20 +458,20 @@ class KeyTest(unittest.TestCase):
             os.remove(newfile)
 
     def test_stringification(self):
-        key = RSAKey.from_private_key_file(_support('test_rsa.key'))
+        key = RSAKey.from_private_key_file(_support("test_rsa.key"))
         comparable = TEST_KEY_BYTESTR_2 if PY2 else TEST_KEY_BYTESTR_3
         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())
@@ -470,25 +481,25 @@ 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.
 
     def test_ed25519_load_from_file_obj(self):
-        with open(_support('test_ed25519.key')) as pkey_fileobj:
+        with open(_support("test_ed25519.key")) as pkey_fileobj:
             key = Ed25519Key.from_private_key(pkey_fileobj)
         self.assertEqual(key, key)
         self.assertTrue(key.can_sign())
 
     def test_keyfile_is_actually_encrypted(self):
         # Read an existing encrypted private key
-        file_ = _support('test_rsa_password.key')
-        password = 'television'
-        newfile = file_ + '.new'
-        newpassword = 'radio'
+        file_ = _support("test_rsa_password.key")
+        password = "television"
+        newfile = file_ + ".new"
+        newpassword = "radio"
         key = RSAKey(filename=file_, password=password)
         # Write out a newly re-encrypted copy with a new password.
         # When the bug under test exists, this will ValueError.
@@ -503,19 +514,21 @@ class KeyTest(unittest.TestCase):
         # test_client.py; this and nearby cert tests are more about the gritty
         # details.
         # PKey.load_certificate
-        key_path = _support(os.path.join('cert_support', 'test_rsa.key'))
+        key_path = _support(os.path.join("cert_support", "test_rsa.key"))
         key = RSAKey.from_private_key_file(key_path)
         self.assertTrue(key.public_blob is None)
         cert_path = _support(
-            os.path.join('cert_support', 'test_rsa.key-cert.pub')
+            os.path.join("cert_support", "test_rsa.key-cert.pub")
         )
         key.load_certificate(cert_path)
         self.assertTrue(key.public_blob is not None)
-        self.assertEqual(key.public_blob.key_type, 'ssh-rsa-cert-v01@openssh.com')
-        self.assertEqual(key.public_blob.comment, 'test_rsa.key.pub')
+        self.assertEqual(
+            key.public_blob.key_type, "ssh-rsa-cert-v01@openssh.com"
+        )
+        self.assertEqual(key.public_blob.comment, "test_rsa.key.pub")
         # Delve into blob contents, for test purposes
         msg = Message(key.public_blob.key_blob)
-        self.assertEqual(msg.get_text(), 'ssh-rsa-cert-v01@openssh.com')
+        self.assertEqual(msg.get_text(), "ssh-rsa-cert-v01@openssh.com")
         nonce = msg.get_string()
         e = msg.get_mpint()
         n = msg.get_mpint()
@@ -525,10 +538,10 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(msg.get_int64(), 1234)
 
         # Prevented from loading certificate that doesn't match
-        key_path = _support(os.path.join('cert_support', 'test_ed25519.key'))
+        key_path = _support(os.path.join("cert_support", "test_ed25519.key"))
         key1 = Ed25519Key.from_private_key_file(key_path)
         self.assertRaises(
             ValueError,
             key1.load_certificate,
-            _support('test_rsa.key-cert.pub'),
+            _support("test_rsa.key-cert.pub"),
         )