Run black

Author: David Robertson

pyproject.toml

@@ -40,3 +40,6 @@ multi_line_output = 3
 include_trailing_comma = true
 combine_as_imports = true
 known_first_party = ["signedjson", "tests"]
+
+[tool.black]
+# Placeholder for now.

signedjson/key.py

@@ -125,7 +125,7 @@ def decode_verify_key_bytes(key_id, key_bytes):
         A VerifyKey object.
     """
     if key_id.startswith(NACL_ED25519 + ":"):
-        version = key_id[len(NACL_ED25519) + 1:]
+        version = key_id[len(NACL_ED25519) + 1 :]
         key = nacl.signing.VerifyKey(key_bytes)
         key.version = version
         key.alg = NACL_ED25519
@@ -176,4 +176,11 @@ def write_signing_keys(stream, keys):
     """
     for key in keys:
         key_base64 = encode_signing_key_base64(key)
-        stream.write("%s %s %s\n" % (key.alg, key.version, key_base64,))
+        stream.write(
+            "%s %s %s\n"
+            % (
+                key.alg,
+                key.version,
+                key_base64,
+            )
+        )

signedjson/sign.py

@@ -61,8 +61,9 @@ def sign_json(json_object, signature_name, signing_key):
     return json_object
 
 
-def signature_ids(json_object, signature_name,
-                  supported_algorithms=SUPPORTED_ALGORITHMS):
+def signature_ids(
+    json_object, signature_name, supported_algorithms=SUPPORTED_ALGORITHMS
+):
     # type: (JsonDict, str, Iterable[str]) -> List[str]
     """Does the JSON object have a signature for the given name?
     Args:
@@ -75,13 +76,13 @@ def signature_ids(json_object, signature_name,
     """
     key_ids = json_object.get("signatures", {}).get(signature_name, {}).keys()
     return list(
-        key_id for key_id in key_ids
-        if key_id.split(":")[0] in supported_algorithms
+        key_id for key_id in key_ids if key_id.split(":")[0] in supported_algorithms
     )
 
 
 class SignatureVerifyException(Exception):
     """A signature could not be verified"""
+
     pass
 
 
@@ -131,7 +132,10 @@ def verify_signed_json(json_object, signature_name, verify_key):
         verify_key.verify(message, signature)
     except Exception as e:
         raise SignatureVerifyException(
-            "Unable to verify signature for %s: %s %s" % (
-                signature_name, type(e), e,
+            "Unable to verify signature for %s: %s %s"
+            % (
+                signature_name,
+                type(e),
+                e,
             )
         )

signedjson/types.py

@@ -26,28 +26,31 @@
 
 class BaseKey(Protocol):
     """Common base type for VerifyKey and SigningKey"""
+
     version = ""  # type: str
     alg = ""  # type: str
 
     def encode(self):
         # type: () -> bytes
-        pass   # pragma: nocover
+        pass  # pragma: nocover
 
 
 class VerifyKey(BaseKey):
     """The public part of a key pair, for use with verify_signed_json"""
+
     def verify(self, message, signature):
         # type: (bytes, bytes) -> bytes
-        pass   # pragma: nocover
+        pass  # pragma: nocover
 
 
 class SigningKey(BaseKey):
     """The private part of a key pair, for use with sign_json"""
+
     def sign(self, message):
         # type: (bytes) -> nacl.signing.SignedMessage
-        pass   # pragma: nocover
+        pass  # pragma: nocover
 
     @property
     def verify_key(self):
         # type: () -> nacl.signing.VerifyKey
-        pass   # pragma: nocover
+        pass  # pragma: nocover

tests/test_key.py

@@ -19,7 +19,7 @@ class GenerateTestCase(unittest.TestCase):
     def test_generate_key(self):
         my_version = "my_version"
         my_key = generate_signing_key(my_version)
-        self.assertEqual(my_key.alg, 'ed25519')
+        self.assertEqual(my_key.alg, "ed25519")
         self.assertEqual(my_key.version, my_version)
 
 
@@ -35,7 +35,7 @@ def test_decode(self):
         decoded_key = decode_signing_key_base64(
             "ed25519", self.version, self.key_base64
         )
-        self.assertEqual(decoded_key.alg, 'ed25519')
+        self.assertEqual(decoded_key.alg, "ed25519")
         self.assertEqual(decoded_key.version, self.version)
 
     def test_decode_invalid_base64(self):
@@ -54,7 +54,7 @@ def test_decode_verify_key(self):
         decoded_key = decode_verify_key_base64(
             "ed25519", self.version, self.verify_key_base64
         )
-        self.assertEqual(decoded_key.alg, 'ed25519')
+        self.assertEqual(decoded_key.alg, "ed25519")
         self.assertEqual(decoded_key.version, self.version)
 
     def test_decode_verify_key_invalid_base64(self):

tests/test_known_key.py

@@ -21,18 +21,16 @@
 
 from signedjson.sign import sign_json
 
-SIGNING_KEY_SEED = decode_base64(
-    "YJDBA9Xnr2sVqXD9Vj7XVUnmFZcZrlw8Md7kMW+3XA1"
-)
+SIGNING_KEY_SEED = decode_base64("YJDBA9Xnr2sVqXD9Vj7XVUnmFZcZrlw8Md7kMW+3XA1")
 
 KEY_ALG = "ed25519"
 KEY_VER = 1
 KEY_NAME = "%s:%d" % (KEY_ALG, KEY_VER)
 
 
 class KnownKeyTestCase(unittest.TestCase):
-    """ An entirely deterministic test using a given signing key seed, so that
-    other implementations can compare that they get the same result. """
+    """An entirely deterministic test using a given signing key seed, so that
+    other implementations can compare that they get the same result."""
 
     def setUp(self):
         self.signing_key = nacl.signing.SigningKey(SIGNING_KEY_SEED)
@@ -43,26 +41,26 @@ def test_sign_minimal(self):
         self.assertEqual(
             sign_json({}, "domain", self.signing_key),
             {
-                'signatures': {
-                    'domain': {
+                "signatures": {
+                    "domain": {
                         KEY_NAME: "K8280/U9SSy9IVtjBuVeLr+HpOB4BQFWbg+UZaADMt"
                         "TdGYI7Geitb76LTrr5QV/7Xg4ahLwYGYZzuHGZKM5ZAQ"
                     },
                 }
-            }
+            },
         )
 
     def test_sign_with_data(self):
         self.assertEqual(
-            sign_json({'one': 1, 'two': "Two"}, "domain", self.signing_key),
+            sign_json({"one": 1, "two": "Two"}, "domain", self.signing_key),
             {
-                'one': 1,
-                'two': "Two",
-                'signatures': {
-                    'domain': {
+                "one": 1,
+                "two": "Two",
+                "signatures": {
+                    "domain": {
                         KEY_NAME: "KqmLSbO39/Bzb0QIYE82zqLwsA+PDzYIpIRA2sRQ4s"
                         "L53+sN6/fpNSoqE7BP7vBZhG6kYdD13EIMJpvhJI+6Bw"
                     },
-                }
-            }
+                },
+            },
         )

tests/test_sign.py

@@ -28,48 +28,45 @@
 
 class JsonSignTestCase(unittest.TestCase):
     def setUp(self):
-        self.message = {'foo': 'bar', 'unsigned': {}}
+        self.message = {"foo": "bar", "unsigned": {}}
         self.sigkey = MockSigningKey()
-        self.assertEqual(self.sigkey.alg, 'mock')
-        self.signed = sign_json(self.message, 'Alice', self.sigkey)
+        self.assertEqual(self.sigkey.alg, "mock")
+        self.signed = sign_json(self.message, "Alice", self.sigkey)
         self.verkey = MockVerifyKey()
 
     def test_sign_and_verify(self):
-        self.assertIn('signatures', self.signed)
-        self.assertIn('Alice', self.signed['signatures'])
-        self.assertIn('mock:test', self.signed['signatures']['Alice'])
+        self.assertIn("signatures", self.signed)
+        self.assertIn("Alice", self.signed["signatures"])
+        self.assertIn("mock:test", self.signed["signatures"]["Alice"])
         self.assertEqual(
-            self.signed['signatures']['Alice']['mock:test'],
-            encode_base64(b'x_______')
+            self.signed["signatures"]["Alice"]["mock:test"], encode_base64(b"x_______")
         )
         self.assertEqual(self.sigkey.signed_bytes, b'{"foo":"bar"}')
-        verify_signed_json(self.signed, 'Alice', self.verkey)
+        verify_signed_json(self.signed, "Alice", self.verkey)
 
     def test_signature_ids(self):
-        key_ids = signature_ids(
-            self.signed, 'Alice', supported_algorithms=['mock']
-        )
-        self.assertListEqual(key_ids, ['mock:test'])
+        key_ids = signature_ids(self.signed, "Alice", supported_algorithms=["mock"])
+        self.assertListEqual(key_ids, ["mock:test"])
 
     def test_verify_fail(self):
-        self.signed['signatures']['Alice']['mock:test'] = encode_base64(
-            b'not a signature'
+        self.signed["signatures"]["Alice"]["mock:test"] = encode_base64(
+            b"not a signature"
         )
         with self.assertRaises(SignatureVerifyException):
-            verify_signed_json(self.signed, 'Alice', self.verkey)
+            verify_signed_json(self.signed, "Alice", self.verkey)
 
     def test_verify_fail_no_signatures(self):
         with self.assertRaises(SignatureVerifyException):
-            verify_signed_json({}, 'Alice', self.verkey)
+            verify_signed_json({}, "Alice", self.verkey)
 
     def test_verify_fail_no_signature_for_alice(self):
         with self.assertRaises(SignatureVerifyException):
-            verify_signed_json({'signatures': {}}, 'Alice', self.verkey)
+            verify_signed_json({"signatures": {}}, "Alice", self.verkey)
 
     def test_verify_fail_not_base64(self):
-        invalid = {'signatures': {'Alice': {'mock:test': 'not base64'}}}
+        invalid = {"signatures": {"Alice": {"mock:test": "not base64"}}}
         with self.assertRaises(SignatureVerifyException):
-            verify_signed_json(invalid, 'Alice', self.verkey)
+            verify_signed_json(invalid, "Alice", self.verkey)
 
 
 class MockSigningKey(object):