Use future import for type annotations

Use of the `__future__` import of annotations allows several niceties,
in particular:
- parametrization of builtin types as generics
- `|` syntax for unions (including `| None` for optionals)

Update to use the future import wherever it improves or simplifies
annotations.

jsonschema/_format.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from contextlib import suppress
 from uuid import UUID
 import datetime
@@ -8,7 +10,7 @@
 from jsonschema.exceptions import FormatError
 
 _FormatCheckerFunc = typing.Callable[[typing.Any], bool]
-_CheckerRaises = typing.Union[Exception, typing.Tuple[Exception, ...]]
+_CheckerRaises = Exception | typing.Tuple[Exception, ...]
 
 
 class FormatChecker(object):
@@ -34,9 +36,9 @@ class FormatChecker(object):
             limit which formats will be used during validation.
     """
 
-    checkers: typing.Dict[
+    checkers: dict[
         str,
-        typing.Tuple[_FormatCheckerFunc, _CheckerRaises],
+        tuple[_FormatCheckerFunc, _CheckerRaises],
     ] = {}
 
     def __init__(self, formats=None):

jsonschema/exceptions.py

@@ -1,18 +1,19 @@
 """
 Validation errors, and some surrounding helpers.
 """
+from __future__ import annotations
+
 from collections import defaultdict, deque
 from pprint import pformat
 from textwrap import dedent, indent
 import itertools
-import typing
 
 import attr
 
 from jsonschema import _utils
 
-WEAK_MATCHES: typing.FrozenSet[str] = frozenset(["anyOf", "oneOf"])
-STRONG_MATCHES: typing.FrozenSet[str] = frozenset()
+WEAK_MATCHES: frozenset[str] = frozenset(["anyOf", "oneOf"])
+STRONG_MATCHES: frozenset[str] = frozenset()
 
 _unset = _utils.Unset()
 

jsonschema/protocols.py

@@ -5,7 +5,9 @@
 # for reference material on Protocols, see
 #   https://www.python.org/dev/peps/pep-0544/
 
-from typing import Any, ClassVar, Iterator, Optional, Union
+from __future__ import annotations
+
+from typing import Any, ClassVar, Iterator
 import sys
 
 # doing these imports with `try ... except ImportError` doesn't pass mypy
@@ -73,13 +75,13 @@ class Validator(Protocol):
     TYPE_CHECKER: ClassVar[TypeChecker]
 
     #: The schema that was passed in when initializing the object.
-    schema: Union[dict, bool]
+    schema: dict | bool
 
     def __init__(
         self,
-        schema: Union[dict, bool],
-        resolver: Optional[RefResolver] = None,
-        format_checker: Optional[FormatChecker] = None,
+        schema: dict | bool,
+        resolver: RefResolver | None = None,
+        format_checker: FormatChecker | None = None,
     ) -> None:
         ...
 

jsonschema/tests/test_validators.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections import deque, namedtuple
 from contextlib import contextmanager
 from decimal import Decimal
@@ -8,7 +10,6 @@
 import os
 import sys
 import tempfile
-import typing
 import unittest
 import warnings
 
@@ -1663,7 +1664,7 @@ def test_False_is_not_a_schema_even_if_you_forget_to_check(self):
 
 class TestDraft3Validator(AntiDraft6LeakMixin, ValidatorTestMixin, TestCase):
     Validator = validators.Draft3Validator
-    valid: typing.Tuple[dict, dict] = ({}, {})
+    valid: tuple[dict, dict] = ({}, {})
     invalid = {"type": "integer"}, "foo"
 
     def test_any_type_is_valid_for_type_any(self):
@@ -1695,31 +1696,31 @@ def test_is_type_does_not_evade_bool_if_it_is_being_tested(self):
 
 class TestDraft4Validator(AntiDraft6LeakMixin, ValidatorTestMixin, TestCase):
     Validator = validators.Draft4Validator
-    valid: typing.Tuple[dict, dict] = ({}, {})
+    valid: tuple[dict, dict] = ({}, {})
     invalid = {"type": "integer"}, "foo"
 
 
 class TestDraft6Validator(ValidatorTestMixin, TestCase):
     Validator = validators.Draft6Validator
-    valid: typing.Tuple[dict, dict] = ({}, {})
+    valid: tuple[dict, dict] = ({}, {})
     invalid = {"type": "integer"}, "foo"
 
 
 class TestDraft7Validator(ValidatorTestMixin, TestCase):
     Validator = validators.Draft7Validator
-    valid: typing.Tuple[dict, dict] = ({}, {})
+    valid: tuple[dict, dict] = ({}, {})
     invalid = {"type": "integer"}, "foo"
 
 
 class TestDraft201909Validator(ValidatorTestMixin, TestCase):
     Validator = validators.Draft201909Validator
-    valid: typing.Tuple[dict, dict] = ({}, {})
+    valid: tuple[dict, dict] = ({}, {})
     invalid = {"type": "integer"}, "foo"
 
 
 class TestDraft202012Validator(ValidatorTestMixin, TestCase):
     Validator = validators.Draft202012Validator
-    valid: typing.Tuple[dict, dict] = ({}, {})
+    valid: tuple[dict, dict] = ({}, {})
     invalid = {"type": "integer"}, "foo"
 
 

jsonschema/validators.py

@@ -1,6 +1,8 @@
 """
 Creation and extension of validators, with implementations for existing drafts.
 """
+from __future__ import annotations
+
 from collections import deque
 from collections.abc import Sequence
 from functools import lru_cache
@@ -23,9 +25,9 @@
     exceptions,
 )
 
-_VALIDATORS: typing.Dict[str, typing.Any] = {}
+_VALIDATORS: dict[str, typing.Any] = {}
 _META_SCHEMAS = _utils.URIDict()
-_VOCABULARIES: typing.List[typing.Tuple[str, typing.Any]] = []
+_VOCABULARIES: list[tuple[str, typing.Any]] = []
 
 
 def __getattr__(name):