fix!: remove deprecated guessing key from bytes and string

Author: lepture

src/joserfc/jwe.py

@@ -32,17 +32,26 @@
 from .registry import Header
 
 __all__ = [
+    # types
+    "GeneralJSONSerialization",
+    "FlattenedJSONSerialization",
+
+    # modules
     "JWERegistry",
     "JWEEncModel",
     "JWEZipModel",
     "Recipient",
     "CompactEncryption",
     "GeneralJSONEncryption",
     "FlattenedJSONEncryption",
+
+    # methods
     "encrypt_compact",
     "decrypt_compact",
     "encrypt_json",
     "decrypt_json",
+
+    # consts
     "default_registry",
     "JWE_ALG_MODELS",
     "JWE_ENC_MODELS",

src/joserfc/jwk.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 import typing as t
-import warnings
 from ._keys import (
     JWKRegistry,
     KeySet,
@@ -17,19 +16,25 @@
 
 
 __all__ = [
-    "JWKRegistry",
+    # types
     "Key",
     "DictKey",
+    "KeyParameters",
     "KeyCallable",
     "KeyFlexible",
     "KeySetSerialization",
+    "KeyBase",
+    "GuestProtocol",
+
+    # modules
+    "JWKRegistry",
     "OctKey",
     "RSAKey",
     "ECKey",
     "OKPKey",
     "KeySet",
-    "KeyBase",
-    "GuestProtocol",
+
+    # methods
     "guess_key",
     "import_key",
     "generate_key",
@@ -44,7 +49,7 @@ def headers(self) -> Header: ...
     def set_kid(self, kid: str) -> None: ...
 
 
-KeyBase = t.Union[str, bytes, Key, KeySet]
+KeyBase = t.Union[Key, KeySet]
 KeyCallable = t.Callable[[GuestProtocol], KeyBase]
 KeyFlexible = t.Union[KeyBase, KeyCallable]
 
@@ -56,43 +61,29 @@ def guess_key(key: KeyFlexible, obj: GuestProtocol, use_random: bool = False) ->
     :param obj: a protocol that has ``headers`` and ``set_kid`` methods
     :param use_random: pick a random key from key set
     """
-
-    _norm_key: t.Union[Key, KeySet]
+    resolved_key: KeyBase
     if callable(key):
-        _norm_key = _normalize_key(key(obj))
+        resolved_key = key(obj)
     else:
-        _norm_key = _normalize_key(key)
+        resolved_key = key
 
-    rv_key: Key
-    if isinstance(_norm_key, KeySet):
+    if isinstance(resolved_key, (OctKey, RSAKey, ECKey, OKPKey)):
+        return resolved_key
+    elif isinstance(resolved_key, KeySet):
         headers = obj.headers()
-        kid = headers.get("kid")
+        kid: str | None = headers.get("kid")
         if not kid and use_random:
             # choose one key by random
-            rv_key = _norm_key.pick_random_key(headers["alg"])  # type: ignore[assignment]
-            if rv_key is None:
+            return_key = resolved_key.pick_random_key(headers["alg"])
+            if return_key is None:
                 raise ValueError("Invalid key")
-            rv_key.ensure_kid()
-            assert rv_key.kid is not None  # for mypy
-            obj.set_kid(rv_key.kid)
+            return_key.ensure_kid()
+            obj.set_kid(t.cast(str, return_key.kid))
         else:
-            rv_key = _norm_key.get_by_kid(kid)
-    elif isinstance(_norm_key, (OctKey, RSAKey, ECKey, OKPKey)):
-        rv_key = _norm_key
+            return_key = resolved_key.get_by_kid(kid)
+        return return_key
     else:
         raise ValueError("Invalid key")
-    return rv_key
-
-
-def _normalize_key(key: KeyBase) -> Key | KeySet:
-    if isinstance(key, (str, bytes)):  # pragma: no cover
-        warnings.warn(
-            "Please use a Key object instead of bytes or string.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return OctKey.import_key(key)
-    return key
 
 
 def import_key(data: AnyKey, key_type: str | None = None, parameters: KeyParameters | None = None) -> Key:

src/joserfc/jws.py

@@ -47,15 +47,20 @@
 from .registry import Header
 
 __all__ = [
+    # types
+    "HeaderDict",
+    "GeneralJSONSerialization",
+    "FlattenedJSONSerialization",
+
+    # modules
     "JWSAlgModel",
     "JWSRegistry",
-    "HeaderDict",
     "HeaderMember",
     "CompactSignature",
     "GeneralJSONSignature",
     "FlattenedJSONSignature",
-    "GeneralJSONSerialization",
-    "FlattenedJSONSerialization",
+
+    # methods
     "serialize_compact",
     "deserialize_compact",
     "extract_compact",

src/joserfc/jwt.py

@@ -28,11 +28,16 @@
 from .registry import Header
 
 __all__ = [
+    # types
     "Claims",
-    "Token",
     "ClaimsOption",
+
+    # modules
     "ClaimsRegistry",
     "JWTClaimsRegistry",
+    "Token",
+
+    # methods
     "encode",
     "decode",
     "check_sensitive_data",

tests/jwk/test_key_methods.py

@@ -1,5 +1,6 @@
 from unittest import TestCase
-from joserfc.jws import register_key_set
+# trigger register_key_set
+import joserfc.jws  # noqa: F401
 from joserfc.jwk import guess_key, import_key, generate_key
 from joserfc.jwk import KeySet, OctKey, RSAKey, ECKey, OKPKey
 from joserfc.errors import (
@@ -11,8 +12,6 @@
     InvalidKeyIdError,
 )
 
-register_key_set()
-
 
 class Guest:
     def __init__(self):
@@ -26,49 +25,23 @@ def set_kid(self, kid):
 
 
 class TestKeyMethods(TestCase):
-    def test_guess_str_key(self):
-        self.assertRaises(
-            DeprecationWarning,
-            guess_key,
-            "key",
-            Guest(),
-        )
-
-    def test_guess_bytes_key(self):
-        self.assertRaises(
-            DeprecationWarning,
-            guess_key,
-            b"key",
-            Guest(),
-        )
-
     def test_guess_callable_key(self):
         oct_key = OctKey.generate_key(parameters={"kid": "1"})
         rsa_key = RSAKey.generate_key(parameters={"kid": "2"})
 
-        def key_func1(obj):
-            return "key"
-
-        def key_func2(obj):
+        def rsa_key_func(obj):
             return rsa_key
 
-        def key_func3(obj):
+        def key_set_func(obj):
             return KeySet([oct_key, rsa_key])
 
-        self.assertRaises(
-            DeprecationWarning,
-            guess_key,
-            key_func1,
-            Guest(),
-        )
-
-        key2 = guess_key(key_func2, Guest())
-        self.assertIsInstance(key2, RSAKey)
+        key = guess_key(rsa_key_func, Guest())
+        self.assertIsInstance(key, RSAKey)
 
         guest = Guest()
         guest.set_kid("2")
-        key3 = guess_key(key_func3, guest)
-        self.assertIsInstance(key3, RSAKey)
+        key = guess_key(key_set_func, guest)
+        self.assertIsInstance(key, RSAKey)
 
     def test_guess_key_set(self):
         key_set = KeySet([OctKey.generate_key(), RSAKey.generate_key()])