automatic fixes by ruff

Author: jschlyter

src/cryptojwt/jwe/__init__.py

@@ -38,7 +38,7 @@
 }
 
 
-class Encrypter(object):
+class Encrypter:
     """Abstract base class for encryption algorithms."""
 
     def __init__(self, with_digest=False):

src/cryptojwt/jwe/aes.py

@@ -30,7 +30,7 @@ def __init__(self, key_len=32, key=None, msg_padding="PKCS7"):
             self.padder = PKCS7(128).padder()
             self.unpadder = PKCS7(128).unpadder()
         else:
-            raise Unsupported("Message padding: {}".format(msg_padding))
+            raise Unsupported(f"Message padding: {msg_padding}")
 
         self.iv = None
 

src/cryptojwt/jwe/jwe.py

@@ -4,11 +4,9 @@
 from ..jwk.ec import ECKey
 from ..jwk.hmac import SYMKey
 from ..jwk.jwk import key_from_jwk_dict
-from ..jwk.rsa import RSAKey
 from ..jwx import JWx
 from .exception import DecryptionFailed
 from .exception import NoSuitableDecryptionKey
-from .exception import NoSuitableECDHKey
 from .exception import NoSuitableEncryptionKey
 from .exception import NotSupportedAlgorithm
 from .exception import WrongEncryptionAlgorithm
@@ -133,7 +131,7 @@ def encrypt(self, keys=None, cek="", iv="", **kwargs):
             except TypeError as err:
                 raise err
             else:
-                logger.debug("Encrypted message using key with kid={}".format(key.kid))
+                logger.debug(f"Encrypted message using key with kid={key.kid}")
                 return token
 
         # logger.error("Could not find any suitable encryption key")

src/cryptojwt/jwe/utils.py

@@ -7,8 +7,6 @@
 from cryptography.hazmat.primitives.hashes import SHA384
 from cryptography.hazmat.primitives.hashes import SHA512
 
-from ..utils import b64e
-
 LENMET = {32: (16, SHA256), 48: (24, SHA384), 64: (32, SHA512)}
 
 

src/cryptojwt/jwk/__init__.py

@@ -14,7 +14,7 @@
 USE = {"sign": "sig", "decrypt": "enc", "encrypt": "enc", "verify": "sig"}
 
 
-class JWK(object):
+class JWK:
     """
     Basic JSON Web key class. Jason Web keys are described in
     RFC 7517 (https://tools.ietf.org/html/rfc7517).
@@ -56,7 +56,7 @@ def __init__(
                     "ECDH-ES+A192KW",
                     "ECDH-ES+A256KW",
                 ]:
-                    raise UnsupportedAlgorithm("Unknown algorithm: {}".format(alg))
+                    raise UnsupportedAlgorithm(f"Unknown algorithm: {alg}")
             elif use == "sig":
                 # The list comes from https://tools.ietf.org/html/rfc7518#page-6
                 # Should map against SIGNER_ALGS in cryptojwt.jws.jws
@@ -79,7 +79,7 @@ def __init__(
                     "Ed448",
                     "none",
                 ]:
-                    raise UnsupportedAlgorithm("Unknown algorithm: {}".format(alg))
+                    raise UnsupportedAlgorithm(f"Unknown algorithm: {alg}")
             else:  # potentially used both for encryption and signing
                 if alg not in [
                     "HS256",
@@ -110,7 +110,7 @@ def __init__(
                     "ECDH-ES+A192KW",
                     "ECDH-ES+A256KW",
                 ]:
-                    raise UnsupportedAlgorithm("Unknown algorithm: {}".format(alg))
+                    raise UnsupportedAlgorithm(f"Unknown algorithm: {alg}")
         self.alg = alg
 
         if isinstance(use, str):
@@ -271,7 +271,7 @@ def thumbprint(self, hash_function, members=None):
             else:
                 if isinstance(_val, bytes):
                     _val = as_unicode(_val)
-                _se.append('"{}":{}'.format(elem, json.dumps(_val)))
+                _se.append(f'"{elem}":{json.dumps(_val)}')
         _json = "{{{}}}".format(",".join(_se))
 
         return b64e(DIGEST_HASH[hash_function](_json))
@@ -298,7 +298,7 @@ def update(self):
         pass
 
     def key_len(self):
-        raise NotImplemented
+        raise NotImplementedError
 
 
 def pems_to_x5c(cert_chain):
@@ -360,7 +360,7 @@ def certificate_fingerprint(der, hash="sha256"):
 
 
 def pem_hash(pem_file):
-    with open(pem_file, "r") as fp:
+    with open(pem_file) as fp:
         pem = fp.read()
 
     der = ssl.PEM_cert_to_DER_cert(pem)

src/cryptojwt/jwk/ec.py

@@ -339,5 +339,5 @@ def import_ec_key(pem_data):
 
 
 def import_ec_key_from_cert_file(pem_file):
-    with open(pem_file, "r") as cert_file:
+    with open(pem_file) as cert_file:
         return import_ec_key(cert_file.read())

src/cryptojwt/jwk/hmac.py

@@ -90,7 +90,7 @@ def appropriate_for(self, usage, alg="HS256"):
                 else:
                     return self.encryption_key(alg)
 
-            raise WrongUsage("This key can't be used for {}".format(usage))
+            raise WrongUsage(f"This key can't be used for {usage}")
 
     def encryption_key(self, alg, **kwargs):
         """
@@ -121,7 +121,7 @@ def encryption_key(self, alg, **kwargs):
         else:
             raise JWKException("No support for symmetric keys > 512 bits")
 
-        logger.debug("Symmetric encryption key: {}".format(as_unicode(b64e(_enc_key))))
+        logger.debug(f"Symmetric encryption key: {as_unicode(b64e(_enc_key))}")
 
         return _enc_key
 

src/cryptojwt/jwk/jwk.py

@@ -74,7 +74,7 @@ def ensure_params(kty, provided, required):
     """Ensure all required parameters are present in dictionary"""
     if not required <= provided:
         missing = required - provided
-        raise MissingValue("Missing properties for kty={}, {}".format(kty, str(list(missing))))
+        raise MissingValue(f"Missing properties for kty={kty}, {str(list(missing))}")
 
 
 def key_from_jwk_dict(jwk_dict, private=None):

src/cryptojwt/jwk/okp.py

@@ -146,15 +146,15 @@ def deserialize(self):
                     try:
                         self.priv_key = OKP_CRV2PRIVATE[self.crv].from_private_bytes(deser(self.d))
                     except KeyError:
-                        raise UnsupportedOKPCurve("Unsupported OKP curve: {}".format(self.crv))
+                        raise UnsupportedOKPCurve(f"Unsupported OKP curve: {self.crv}")
                     self.pub_key = self.priv_key.public_key()
             except ValueError as err:
                 raise DeSerializationNotPossible(str(err))
         else:
             try:
                 self.pub_key = OKP_CRV2PUBLIC[self.crv].from_public_bytes(_x)
             except KeyError:
-                raise UnsupportedOKPCurve("Unsupported OKP curve: {}".format(self.crv))
+                raise UnsupportedOKPCurve(f"Unsupported OKP curve: {self.crv}")
 
     def _serialize_public(self, key):
         self.x = b64e(
@@ -376,5 +376,5 @@ def import_okp_key(pem_data):
 
 
 def import_okp_key_from_cert_file(pem_file):
-    with open(pem_file, "r") as cert_file:
+    with open(pem_file) as cert_file:
         return import_okp_key(cert_file.read())

src/cryptojwt/jwk/rsa.py

@@ -105,7 +105,7 @@ def import_rsa_key(pem_data):
 
 
 def import_rsa_key_from_cert_file(pem_file):
-    with open(pem_file, "r") as cert_file:
+    with open(pem_file) as cert_file:
         return import_rsa_key(cert_file.read())
 
 
@@ -284,9 +284,7 @@ def __init__(
             self.pub_key = self.priv_key.public_key()
         elif self.pub_key:
             self._serialize(self.pub_key)
-        elif has_public_key_parts:
-            self.deserialize()
-        elif has_x509_cert_chain:
+        elif has_public_key_parts or has_x509_cert_chain:
             self.deserialize()
         elif not self.n and not self.e:
             pass