Update code to to use python 3.6+ syntax. (#241)

asherf · web-flow · commit c9e10353f84c · 2021-05-05T06:03:04.000-07:00
diff --git a/jose/__init__.py b/jose/__init__.py
@@ -1,4 +1,3 @@
-
 __version__ = "3.2.0"
 __author__ = 'Michael Davis'
 __license__ = 'MIT'
diff --git a/jose/backends/base.py b/jose/backends/base.py
@@ -3,7 +3,7 @@
 from ..utils import base64url_encode
 
 
-class Key(object):
+class Key:
     """
     A simple interface for implementing JWK keys.
     """
diff --git a/jose/backends/cryptography_backend.py b/jose/backends/cryptography_backend.py
@@ -1,5 +1,3 @@
-from __future__ import division
-
 import math
 import warnings
 
@@ -79,10 +77,10 @@ def __init__(self, key, algorithm, cryptography_backend=default_backend):
             self.prepared_key = self._process_jwk(key)
             return
 
-        if isinstance(key, six.string_types):
+        if isinstance(key, str):
             key = key.encode('utf-8')
 
-        if isinstance(key, six.binary_type):
+        if isinstance(key, bytes):
             # Attempt to load key. We don't know if it's
             # a Public Key or a Private Key, so we try
             # the Public Key first.
@@ -258,10 +256,10 @@ def __init__(self, key, algorithm, cryptography_backend=default_backend):
             self.prepared_key = self._process_jwk(key)
             return
 
-        if isinstance(key, six.string_types):
+        if isinstance(key, str):
             key = key.encode('utf-8')
 
-        if isinstance(key, six.binary_type):
+        if isinstance(key, bytes):
             try:
                 if key.startswith(b'-----BEGIN CERTIFICATE-----'):
                     self._process_cert(key)
@@ -468,15 +466,15 @@ def __init__(self, key, algorithm):
         self._mode = self.MODES.get(self._algorithm)
 
         if algorithm in self.KEY_128 and len(key) != 16:
-            raise JWKError("Key must be 128 bit for alg {}".format(algorithm))
+            raise JWKError(f"Key must be 128 bit for alg {algorithm}")
         elif algorithm in self.KEY_192 and len(key) != 24:
-            raise JWKError("Key must be 192 bit for alg {}".format(algorithm))
+            raise JWKError(f"Key must be 192 bit for alg {algorithm}")
         elif algorithm in self.KEY_256 and len(key) != 32:
-            raise JWKError("Key must be 256 bit for alg {}".format(algorithm))
+            raise JWKError(f"Key must be 256 bit for alg {algorithm}")
         elif algorithm in self.KEY_384 and len(key) != 48:
-            raise JWKError("Key must be 384 bit for alg {}".format(algorithm))
+            raise JWKError(f"Key must be 384 bit for alg {algorithm}")
         elif algorithm in self.KEY_512 and len(key) != 64:
-            raise JWKError("Key must be 512 bit for alg {}".format(algorithm))
+            raise JWKError(f"Key must be 512 bit for alg {algorithm}")
 
         self._key = key
 
@@ -575,10 +573,10 @@ def __init__(self, key, algorithm):
             self.prepared_key = self._process_jwk(key)
             return
 
-        if not isinstance(key, six.string_types) and not isinstance(key, bytes):
+        if not isinstance(key, str) and not isinstance(key, bytes):
             raise JWKError('Expecting a string- or bytes-formatted key.')
 
-        if isinstance(key, six.text_type):
+        if isinstance(key, str):
             key = key.encode('utf-8')
 
         invalid_strings = [
diff --git a/jose/backends/ecdsa_backend.py b/jose/backends/ecdsa_backend.py
@@ -1,5 +1,4 @@
 import hashlib
-import six
 
 from jose.backends.base import Key
 import ecdsa
@@ -49,10 +48,10 @@ def __init__(self, key, algorithm):
             self.prepared_key = self._process_jwk(key)
             return
 
-        if isinstance(key, six.string_types):
+        if isinstance(key, str):
             key = key.encode('utf-8')
 
-        if isinstance(key, six.binary_type):
+        if isinstance(key, bytes):
             # Attempt to load key. We don't know if it's
             # a Signing Key or a Verifying Key, so we try
             # the Verifying Key first.
@@ -85,7 +84,7 @@ def _process_jwk(self, jwk_dict):
             y = base64_to_long(jwk_dict.get('y'))
 
             if not ecdsa.ecdsa.point_is_valid(self.curve.generator, x, y):
-                raise JWKError("Point: %s, %s is not a valid point" % (x, y))
+                raise JWKError(f"Point: {x}, {y} is not a valid point")
 
             point = ecdsa.ellipticcurve.Point(self.curve.curve, x, y, self.curve.order)
             return ecdsa.keys.VerifyingKey.from_public_point(point, self.curve)
diff --git a/jose/backends/native.py b/jose/backends/native.py
@@ -2,7 +2,6 @@
 import hmac
 import os
 
-import six
 
 from jose.backends.base import Key
 from jose.constants import ALGORITHMS
@@ -35,10 +34,10 @@ def __init__(self, key, algorithm):
             self.prepared_key = self._process_jwk(key)
             return
 
-        if not isinstance(key, six.string_types) and not isinstance(key, bytes):
+        if not isinstance(key, str) and not isinstance(key, bytes):
             raise JWKError('Expecting a string- or bytes-formatted key.')
 
-        if isinstance(key, six.text_type):
+        if isinstance(key, str):
             key = key.encode('utf-8')
 
         invalid_strings = [
diff --git a/jose/backends/rsa_backend.py b/jose/backends/rsa_backend.py
@@ -1,6 +1,5 @@
 import binascii
 
-import six
 import warnings
 
 from pyasn1.error import PyAsn1Error
@@ -147,10 +146,10 @@ def __init__(self, key, algorithm):
             self._prepared_key = key
             return
 
-        if isinstance(key, six.string_types):
+        if isinstance(key, str):
             key = key.encode('utf-8')
 
-        if isinstance(key, six.binary_type):
+        if isinstance(key, bytes):
             try:
                 self._prepared_key = pyrsa.PublicKey.load_pkcs1(key)
             except ValueError:
@@ -234,7 +233,7 @@ def to_pem(self, pem_format='PKCS8'):
             elif pem_format == 'PKCS1':
                 pem = pyrsa_pem.save_pem(der, pem_marker='RSA PRIVATE KEY')
             else:
-                raise ValueError("Invalid pem format specified: %r" % (pem_format,))
+                raise ValueError(f"Invalid pem format specified: {pem_format!r}")
         else:
             if pem_format == 'PKCS8':
                 pkcs1_der = self._prepared_key.save_pkcs1(format="DER")
@@ -244,7 +243,7 @@ def to_pem(self, pem_format='PKCS8'):
                 der = self._prepared_key.save_pkcs1(format='DER')
                 pem = pyrsa_pem.save_pem(der, pem_marker='RSA PUBLIC KEY')
             else:
-                raise ValueError("Invalid pem format specified: %r" % (pem_format,))
+                raise ValueError(f"Invalid pem format specified: {pem_format!r}")
         return pem
 
     def to_dict(self):
diff --git a/jose/constants.py b/jose/constants.py
@@ -1,7 +1,7 @@
 import hashlib
 
 
-class Algorithms(object):
+class Algorithms:
     # DS Algorithms
     NONE = 'none'
     HS256 = 'HS256'
@@ -92,7 +92,7 @@ class Algorithms(object):
 ALGORITHMS = Algorithms()
 
 
-class Zips(object):
+class Zips:
     DEF = "DEF"
     NONE = None
     SUPPORTED = {DEF, NONE}
diff --git a/jose/exceptions.py b/jose/exceptions.py
@@ -1,5 +1,3 @@
-
-
 class JOSEError(Exception):
     pass
 
diff --git a/jose/jwe.py b/jose/jwe.py
@@ -146,7 +146,7 @@ def decrypt(jwe_str, key):
             # recipient or not.
             cek_valid = True
         except NotImplementedError:
-            raise JWEError("alg {} is not implemented".format(alg))
+            raise JWEError(f"alg {alg} is not implemented")
         except Exception:
             # Record whether the CEK could be successfully determined for this
             # recipient or not.
@@ -186,7 +186,7 @@ def decrypt(jwe_str, key):
     try:
         plain_text = _decrypt_and_auth(cek_bytes, enc, cipher_text, iv, aad, auth_tag)
     except NotImplementedError:
-        raise JWEError("enc {} is not implemented".format(enc))
+        raise JWEError(f"enc {enc} is not implemented")
     except Exception as e:
         raise JWEError(e)
 
@@ -243,7 +243,7 @@ def _decrypt_and_auth(cek_bytes, enc, cipher_text, iv, aad, auth_tag):
         encryption_key = jwk.construct(cek_bytes, enc)
         auth_tag_check = auth_tag  # GCM check auth on decrypt
     else:
-        raise NotImplementedError("enc {} is not implemented!".format(enc))
+        raise NotImplementedError(f"enc {enc} is not implemented!")
 
     plaintext = encryption_key.decrypt(cipher_text, iv, aad, auth_tag)
     if auth_tag != auth_tag_check:
@@ -389,7 +389,7 @@ def _encrypt_and_auth(key, alg, enc, zip, plaintext, aad):
     try:
         cek_bytes, kw_cek = _get_cek(enc, alg, key)
     except NotImplementedError:
-        raise JWEError("alg {} is not implemented".format(alg))
+        raise JWEError(f"alg {alg} is not implemented")
 
     if enc in ALGORITHMS.HMAC_AUTH_TAG:
         encryption_key, mac_key, key_len = _get_encryption_key_mac_key_and_key_length_from_cek(cek_bytes, enc)
@@ -399,7 +399,7 @@ def _encrypt_and_auth(key, alg, enc, zip, plaintext, aad):
         encryption_key = jwk.construct(cek_bytes, enc)
         iv, ciphertext, auth_tag = encryption_key.encrypt(plaintext, aad)
     else:
-        raise NotImplementedError("enc {} is not implemented!".format(enc))
+        raise NotImplementedError(f"enc {enc} is not implemented!")
 
     return kw_cek, iv, ciphertext, auth_tag
 
@@ -558,7 +558,7 @@ def _get_random_cek_bytes_for_enc(enc):
     elif enc == ALGORITHMS.A256CBC_HS512:
         num_bits = 512
     else:
-        raise NotImplementedError("{} not supported".format(enc))
+        raise NotImplementedError(f"{enc} not supported")
     cek_bytes = get_random_bytes(num_bits // 8)
     return cek_bytes
 
diff --git a/jose/jws.py b/jose/jws.py
@@ -1,12 +1,6 @@
-
 import binascii
 import json
-import six
-
-try:
-    from collections.abc import Mapping, Iterable  # Python 3
-except ImportError:
-    from collections import Mapping, Iterable  # Python 2, will be deprecated in Python 3.8
+from collections.abc import Mapping, Iterable
 
 from jose import jwk
 from jose.backends.base import Key
@@ -181,7 +175,7 @@ def _sign_header_and_claims(encoded_header, encoded_claims, algorithm, key):
 
 
 def _load(jwt):
-    if isinstance(jwt, six.text_type):
+    if isinstance(jwt, str):
         jwt = jwt.encode('utf-8')
     try:
         signing_input, crypto_segment = jwt.rsplit(b'.', 1)
@@ -251,7 +245,7 @@ def _get_keys(key):
 
     # Iterable but not text or mapping => list- or tuple-like
     elif (isinstance(key, Iterable) and
-          not (isinstance(key, six.string_types) or isinstance(key, six.binary_type))):
+          not (isinstance(key, str) or isinstance(key, bytes))):
         return key
 
     # Scalar value, wrap in tuple.
diff --git a/jose/jwt.py b/jose/jwt.py
@@ -1,21 +1,12 @@
-
 import json
 
 from calendar import timegm
-try:
-    from collections.abc import Mapping  # Python3
-except ImportError:
-    from collections import Mapping  # Python2, will be deprecated in Python 3.8
-from datetime import datetime
-from datetime import timedelta
-from six import string_types
+from collections.abc import Mapping
+from datetime import datetime, timedelta
 
 from jose import jws
 
-from .exceptions import JWSError
-from .exceptions import JWTClaimsError
-from .exceptions import JWTError
-from .exceptions import ExpiredSignatureError
+from .exceptions import JWSError, JWTClaimsError, JWTError, ExpiredSignatureError
 from .constants import ALGORITHMS
 from .utils import timedelta_total_seconds, calculate_at_hash
 
@@ -347,11 +338,11 @@ def _validate_aud(claims, audience=None):
         return
 
     audience_claims = claims['aud']
-    if isinstance(audience_claims, string_types):
+    if isinstance(audience_claims, str):
         audience_claims = [audience_claims]
     if not isinstance(audience_claims, list):
         raise JWTClaimsError('Invalid claim format in token')
-    if any(not isinstance(c, string_types) for c in audience_claims):
+    if any(not isinstance(c, str) for c in audience_claims):
         raise JWTClaimsError('Invalid claim format in token')
     if audience not in audience_claims:
         raise JWTClaimsError('Invalid audience')
@@ -372,7 +363,7 @@ def _validate_iss(claims, issuer=None):
     """
 
     if issuer is not None:
-        if isinstance(issuer, string_types):
+        if isinstance(issuer, str):
             issuer = (issuer,)
         if claims.get('iss') not in issuer:
             raise JWTClaimsError('Invalid issuer')
@@ -397,7 +388,7 @@ def _validate_sub(claims, subject=None):
     if 'sub' not in claims:
         return
 
-    if not isinstance(claims['sub'], string_types):
+    if not isinstance(claims['sub'], str):
         raise JWTClaimsError('Subject must be a string.')
 
     if subject is not None:
@@ -423,7 +414,7 @@ def _validate_jti(claims):
     if 'jti' not in claims:
         return
 
-    if not isinstance(claims['jti'], string_types):
+    if not isinstance(claims['jti'], str):
         raise JWTClaimsError('JWT ID must be a string.')
 
 
@@ -479,7 +470,7 @@ def _validate_claims(claims, audience=None, issuer=None, subject=None,
         else:
             options['verify_' + require_claim] = True  # override verify when required
 
-    if not isinstance(audience, (string_types, type(None))):
+    if not isinstance(audience, ((str,), type(None))):
         raise JWTError('audience must be a string or None')
 
     if options.get('verify_iat'):
diff --git a/jose/utils.py b/jose/utils.py
@@ -1,4 +1,3 @@
-
 import base64
 import struct
 

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-`
`2`	`1`	`__version__ = "3.2.0"`
`3`	`2`	`__author__ = 'Michael Davis'`
`4`	`3`	`__license__ = 'MIT'`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,3 @@`
`1`		`-`
`2`		`-`
`3`	`1`	`class JOSEError(Exception):`
`4`	`2`	`pass`
`5`	`3`