fix: using built-in types since python 3.8 is dropped.

lepture · lepture · commit cba4132b1d88 · 2025-07-15T14:14:11.000+09:00
diff --git a/pyproject.toml b/pyproject.toml
@@ -103,7 +103,7 @@ exclude_lines = [
 
 [tool.mypy]
 strict = true
-python_version = "3.8"
+python_version = "3.9"
 files = ["src/joserfc"]
 show_error_codes = true
 pretty = true
diff --git a/src/joserfc/_keys.py b/src/joserfc/_keys.py
@@ -44,7 +44,7 @@ class JWKRegistry:
         key = JWKRegistry.import_key(data)
     """
 
-    key_types: t.Dict[str, t.Type[Key]] = {
+    key_types: dict[str, t.Type[Key]] = {
         OctKey.key_type: OctKey,
         RSAKey.key_type: RSAKey,
         ECKey.key_type: ECKey,
@@ -103,15 +103,15 @@ def generate_key(
         return key_cls.generate_key(crv_or_size, parameters, private, auto_kid)  # type: ignore[arg-type]
 
 
-KeySetSerialization = t.TypedDict("KeySetSerialization", {"keys": t.List[DictKey]})
+KeySetSerialization = t.TypedDict("KeySetSerialization", {"keys": list[DictKey]})
 
 
 class KeySet:
     #: keys in the key set
     keys: list[Key]
 
     registry_cls: t.Type[JWKRegistry] = JWKRegistry
-    algorithm_keys: t.ClassVar[t.Dict[str, list[str]]] = {}
+    algorithm_keys: t.ClassVar[dict[str, list[str]]] = {}
 
     def __init__(self, keys: list[Key]):
         for key in keys:
diff --git a/src/joserfc/_rfc7515/compact.py b/src/joserfc/_rfc7515/compact.py
@@ -43,9 +43,9 @@ def detach_compact_content(value: str) -> str:
     return ".".join(parts)
 
 
-def decode_header(header_segment: bytes) -> t.Dict[str, t.Any]:
+def decode_header(header_segment: bytes) -> dict[str, t.Any]:
     try:
-        protected: t.Dict[str, t.Any] = json_b64decode(header_segment)
+        protected: dict[str, t.Any] = json_b64decode(header_segment)
         if "alg" not in protected:
             raise MissingAlgorithmError()
     except (TypeError, ValueError):
diff --git a/src/joserfc/_rfc7515/json.py b/src/joserfc/_rfc7515/json.py
@@ -147,7 +147,7 @@ def verify_signature(
     return alg.verify(signing_input, sig, key)
 
 
-def detach_json_content(value: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+def detach_json_content(value: dict[str, t.Any]) -> dict[str, t.Any]:
     # https://www.rfc-editor.org/rfc/rfc7515#appendix-F
     rv = copy.deepcopy(value)  # don't alter original value
     if "payload" in rv:
diff --git a/src/joserfc/_rfc7515/types.py b/src/joserfc/_rfc7515/types.py
@@ -30,7 +30,7 @@ class JSONSignatureDict(t.TypedDict, total=False):
 @t.final
 class GeneralJSONSerialization(t.TypedDict):
     payload: str
-    signatures: t.List[JSONSignatureDict]
+    signatures: list[JSONSignatureDict]
 
 
 @t.final
diff --git a/src/joserfc/_rfc7516/json.py b/src/joserfc/_rfc7516/json.py
@@ -56,7 +56,7 @@ def represent_flattened_json(obj: FlattenedJSONEncryption) -> FlattenedJSONSeria
 
 
 def __represent_json_serialization(obj: BaseJSONEncryption):  # type: ignore[no-untyped-def]
-    data: t.Dict[str, t.Union[str, Header, t.List[Header]]] = {
+    data: dict[str, t.Union[str, Header, list[Header]]] = {
         "protected": to_str(json_b64encode(obj.protected)),
         "iv": to_str(obj.base64_segments["iv"]),
         "ciphertext": to_str(obj.base64_segments["ciphertext"]),
@@ -102,13 +102,13 @@ def extract_flattened_json(data: FlattenedJSONSerialization) -> FlattenedJSONEnc
 
 def __extract_segments(
     data: t.Union[GeneralJSONSerialization, FlattenedJSONSerialization],
-) -> t.Tuple[t.Dict[str, bytes], t.Dict[str, bytes], t.Optional[bytes]]:
-    base64_segments: t.Dict[str, bytes] = {
+) -> tuple[dict[str, bytes], dict[str, bytes], t.Optional[bytes]]:
+    base64_segments: dict[str, bytes] = {
         "iv": to_bytes(data["iv"]),
         "ciphertext": to_bytes(data["ciphertext"]),
         "tag": to_bytes(data["tag"]),
     }
-    bytes_segments: t.Dict[str, bytes] = {
+    bytes_segments: dict[str, bytes] = {
         "iv": urlsafe_b64decode(base64_segments["iv"]),
         "ciphertext": urlsafe_b64decode(base64_segments["ciphertext"]),
         "tag": urlsafe_b64decode(base64_segments["tag"]),
diff --git a/src/joserfc/_rfc7516/message.py b/src/joserfc/_rfc7516/message.py
@@ -136,10 +136,10 @@ def _perform_decrypt(obj: EncryptionData, registry: JWERegistry) -> None:
 
 
 def pre_encrypt_recipients(
-    enc: JWEEncModel, recipients: t.List[Recipient[t.Any]], registry: JWERegistry
-) -> t.Tuple[bytes, t.List[t.Tuple[JWEKeyAgreement, Recipient[t.Any]]]]:
+    enc: JWEEncModel, recipients: list[Recipient[t.Any]], registry: JWERegistry
+) -> tuple[bytes, list[tuple[JWEKeyAgreement, Recipient[t.Any]]]]:
     cek: bytes = b""
-    delayed_tasks: t.List[t.Tuple[JWEKeyAgreement, Recipient[t.Any]]] = []
+    delayed_tasks: list[tuple[JWEKeyAgreement, Recipient[t.Any]]] = []
     for recipient in recipients:
         alg = __prepare_recipient_algorithm(recipient, registry)
 
@@ -201,7 +201,7 @@ def __pre_encrypt_direct_mode(alg: JWEAlgModel, enc: JWEEncModel, recipient: Rec
 
 
 def post_encrypt_recipients(
-    enc: JWEEncModel, tasks: t.List[t.Tuple[JWEKeyAgreement, Recipient[t.Any]]], cek: bytes, tag: bytes
+    enc: JWEEncModel, tasks: list[tuple[JWEKeyAgreement, Recipient[t.Any]]], cek: bytes, tag: bytes
 ) -> None:
     for alg, recipient in tasks:
         if alg.tag_aware:
diff --git a/src/joserfc/_rfc7516/models.py b/src/joserfc/_rfc7516/models.py
@@ -71,8 +71,8 @@ def __init__(self, protected: Header, plaintext: bytes | None = None):
         #: the plaintext in bytes
         self.plaintext = plaintext
         self.recipient: Recipient[t.Any] | None = None
-        self.bytes_segments: t.Dict[str, bytes] = {}  # store the decoded segments
-        self.base64_segments: t.Dict[str, bytes] = {}  # store the encoded segments
+        self.bytes_segments: dict[str, bytes] = {}  # store the decoded segments
+        self.base64_segments: dict[str, bytes] = {}  # store the encoded segments
 
     def headers(self) -> Header:
         """Returns the protected header values in dict."""
@@ -109,7 +109,7 @@ class BaseJSONEncryption(metaclass=ABCMeta):
     #: an optional additional authenticated data
     aad: t.Optional[bytes]
     #: a list of recipients
-    recipients: t.List[Recipient[t.Any]]
+    recipients: list[Recipient[t.Any]]
 
     def __init__(
         self,
@@ -123,8 +123,8 @@ def __init__(
         self.unprotected = unprotected
         self.aad = aad
         self.recipients = []
-        self.bytes_segments: t.Dict[str, bytes] = {}  # store the decoded segments
-        self.base64_segments: t.Dict[str, bytes] = {}  # store the encoded segments
+        self.bytes_segments: dict[str, bytes] = {}  # store the decoded segments
+        self.base64_segments: dict[str, bytes] = {}  # store the encoded segments
 
     @abstractmethod
     def add_recipient(self, header: Header | None = None, key: Key | None = None) -> None:
@@ -230,7 +230,7 @@ class KeyManagement:
     description: str
     recommended: bool = False
     key_size: int | None = None
-    key_types: t.List[str]
+    key_types: list[str]
     security_warning: str | None = None
 
     algorithm_type: t.Literal["JWE"] = "JWE"
diff --git a/src/joserfc/_rfc7516/registry.py b/src/joserfc/_rfc7516/registry.py
@@ -23,9 +23,9 @@
 AlgorithmsDict = t.TypedDict(
     "AlgorithmsDict",
     {
-        "alg": t.Dict[str, JWEAlgModel],
-        "enc": t.Dict[str, JWEEncModel],
-        "zip": t.Dict[str, JWEZipModel],
+        "alg": dict[str, JWEAlgModel],
+        "enc": dict[str, JWEEncModel],
+        "zip": dict[str, JWEZipModel],
     },
 )
 
@@ -46,7 +46,7 @@ class JWERegistry:
         "enc": {},
         "zip": {},
     }
-    recommended: t.ClassVar[t.List[str]] = []
+    recommended: t.ClassVar[list[str]] = []
 
     def __init__(
         self,
diff --git a/src/joserfc/_rfc7516/types.py b/src/joserfc/_rfc7516/types.py
@@ -8,26 +8,26 @@
 
 
 class JSONRecipientDict(t.TypedDict, total=False):
-    header: t.Dict[str, t.Any]
+    header: dict[str, t.Any]
     encrypted_key: str
 
 
 class GeneralJSONSerialization(t.TypedDict, total=False):
     protected: str
-    unprotected: t.Dict[str, t.Any]
+    unprotected: dict[str, t.Any]
     iv: str
     aad: str
     ciphertext: str
     tag: str
-    recipients: t.List[JSONRecipientDict]
+    recipients: list[JSONRecipientDict]
 
 
 class FlattenedJSONSerialization(t.TypedDict, total=False):
     protected: str
-    unprotected: t.Dict[str, t.Any]
+    unprotected: dict[str, t.Any]
     iv: str
     aad: str
     ciphertext: str
     tag: str
-    header: t.Dict[str, t.Any]
+    header: dict[str, t.Any]
     encrypted_key: str
diff --git a/src/joserfc/_rfc7517/models.py b/src/joserfc/_rfc7517/models.py
@@ -25,7 +25,7 @@
 
 
 class NativeKeyBinding(metaclass=ABCMeta):
-    use_key_ops_registry: t.ClassVar[t.Dict[str, t.List[str]]] = {
+    use_key_ops_registry: t.ClassVar[dict[str, list[str]]] = {
         "sig": ["sign", "verify"],
         "enc": ["encrypt", "decrypt", "wrapKey", "unwrapKey", "deriveKey", "deriveBits"],
     }
diff --git a/src/joserfc/_rfc7517/types.py b/src/joserfc/_rfc7517/types.py
@@ -3,7 +3,7 @@
 __all__ = ["DictKey", "AnyKey", "KeyParameters"]
 
 #: JSON Web Key in dict
-DictKey = t.Dict[str, t.Union[str, t.List[str]]]
+DictKey = dict[str, t.Union[str, list[str]]]
 
 #: Key in str, bytes and dict
 AnyKey = t.Union[str, bytes, DictKey]
@@ -13,11 +13,11 @@
     "KeyParameters",
     {
         "use": str,
-        "key_ops": t.List[str],
+        "key_ops": list[str],
         "alg": str,
         "kid": str,
         "x5u": str,
-        "x5c": t.List[str],
+        "x5c": list[str],
         "x5t": str,
         "x5t#S256": str,
     },
diff --git a/src/joserfc/_rfc7518/ec_key.py b/src/joserfc/_rfc7518/ec_key.py
@@ -38,8 +38,8 @@
 class ECBinding(CryptographyBinding):
     ssh_type = b"ecdsa-sha2-"
 
-    _dss_curves: t.Dict[str, t.Type[EllipticCurve]] = {}
-    _curves_dss: t.Dict[str, str] = {}
+    _dss_curves: dict[str, t.Type[EllipticCurve]] = {}
+    _curves_dss: dict[str, str] = {}
 
     @classmethod
     def register_curve(cls, name: str, curve: t.Type[EllipticCurve]) -> None:
diff --git a/src/joserfc/_rfc7518/jws_algs.py b/src/joserfc/_rfc7518/jws_algs.py
@@ -189,7 +189,7 @@ def verify(self, msg: bytes, sig: bytes, key: RSAKey) -> bool:
             return False
 
 
-JWS_ALGORITHMS: t.List[JWSAlgModel] = [
+JWS_ALGORITHMS: list[JWSAlgModel] = [
     NoneAlgModel(),  # none
     HMACAlgModel(256, True),  # HS256
     HMACAlgModel(384),  # HS384
diff --git a/src/joserfc/_rfc7638/__init__.py b/src/joserfc/_rfc7638/__init__.py
@@ -6,7 +6,7 @@
 
 
 def calculate_thumbprint(
-    value: t.Dict[str, t.Any],
+    value: dict[str, t.Any],
     digest_method: t.Literal["sha256", "sha384", "sha512"] = "sha256",
 ) -> str:
     """Calculate the thumbprint value of a Key, per RFC 7638.
diff --git a/src/joserfc/_rfc8037/okp_key.py b/src/joserfc/_rfc8037/okp_key.py
@@ -30,13 +30,13 @@
     },
     total=False,
 )
-PUBLIC_KEYS_MAP: t.Dict[str, t.Type[PublicOKPKey]] = {
+PUBLIC_KEYS_MAP: dict[str, t.Type[PublicOKPKey]] = {
     "Ed25519": Ed25519PublicKey,
     "Ed448": Ed448PublicKey,
     "X25519": X25519PublicKey,
     "X448": X448PublicKey,
 }
-PRIVATE_KEYS_MAP: t.Dict[str, t.Type[PrivateOKPKey]] = {
+PRIVATE_KEYS_MAP: dict[str, t.Type[PrivateOKPKey]] = {
     "Ed25519": Ed25519PrivateKey,
     "Ed448": Ed448PrivateKey,
     "X25519": X25519PrivateKey,
@@ -61,14 +61,14 @@ def import_public_key(obj: OKPDictKey) -> PublicOKPKey:
         return crv_key.from_public_bytes(x_bytes)
 
     @staticmethod
-    def export_private_key(key: PrivateOKPKey) -> t.Dict[str, str]:
+    def export_private_key(key: PrivateOKPKey) -> dict[str, str]:
         obj = OKPBinding.export_public_key(key.public_key())
         d_bytes = key.private_bytes(Encoding.Raw, PrivateFormat.Raw, NoEncryption())
         obj["d"] = urlsafe_b64encode(d_bytes).decode("utf-8")
         return obj
 
     @staticmethod
-    def export_public_key(key: PublicOKPKey) -> t.Dict[str, str]:
+    def export_public_key(key: PublicOKPKey) -> dict[str, str]:
         x_bytes = key.public_bytes(Encoding.Raw, PublicFormat.Raw)
         return {
             "crv": get_key_curve(key),
diff --git a/src/joserfc/_rfc9278/__init__.py b/src/joserfc/_rfc9278/__init__.py
@@ -5,7 +5,7 @@
 
 
 def calculate_thumbprint_uri(
-    value: t.Dict[str, t.Any],
+    value: dict[str, t.Any],
     digest_method: t.Literal["sha256", "sha384", "sha512"] = "sha256",
 ) -> str:
     """Calculate JWK thumbprint URI, defined by RFC9278.

Original file line number	Diff line number	Diff line change
`@@ -23,9 +23,9 @@`
`23`	`23`	`AlgorithmsDict = t.TypedDict(`
`24`	`24`	`"AlgorithmsDict",`
`25`	`25`	`{`
`26`		`- "alg": t.Dict[str, JWEAlgModel],`
`27`		`- "enc": t.Dict[str, JWEEncModel],`
`28`		`- "zip": t.Dict[str, JWEZipModel],`
	`26`	`+ "alg": dict[str, JWEAlgModel],`
	`27`	`+ "enc": dict[str, JWEEncModel],`
	`28`	`+ "zip": dict[str, JWEZipModel],`
`29`	`29`	`},`
`30`	`30`	`)`
`31`	`31`
`@@ -46,7 +46,7 @@ class JWERegistry:`
`46`	`46`	`"enc": {},`
`47`	`47`	`"zip": {},`
`48`	`48`	`}`
`49`		`- recommended: t.ClassVar[t.List[str]] = []`
	`49`	`+ recommended: t.ClassVar[list[str]] = []`
`50`	`50`
`51`	`51`	`def __init__(`
`52`	`52`	`self,`