Modernize type stub

* Import from collections.abc/re/contextlib instead of typing where
  possible.
* Use builtin types where possible.
* Use "|" operator instead of Optional and Union.
* Tighten JSON type.
* Use object instead of Any where applicable.
* Replace typing.Text with str.

Author: srittau

NEWS.md

@@ -4,6 +4,10 @@
 
 - Drop support for Python 3.6.
 
+### Other Changes
+
+- Modernize the type stubs.
+
 ## News in asserts 0.11.1
 
 ### API Additions

asserts/__init__.pyi

@@ -1,169 +1,163 @@
 import datetime
-
+from collections.abc import Callable, Container, Iterable
+from contextlib import AbstractContextManager as ContextManager
+from re import Pattern
 from types import TracebackType
-from typing import (
-    Any,
-    Callable,
-    Container,
-    ContextManager,
-    Generic,
-    Iterable,
-    NoReturn,
-    Optional,
-    Pattern,
-    Text,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+from typing import Any, Generic, NoReturn, TypeVar
 
 _E = TypeVar("_E", bound=BaseException)
 _S = TypeVar("_S")
 
 class AssertRaisesContext(Generic[_E]):
-    exception: Type[_E]
-    msg_fmt: Text
-    def __init__(self, exception: Type[_E], msg_fmt: Text = ...) -> None: ...
+    exception: type[_E]
+    msg_fmt: str
+    def __init__(self, exception: type[_E], msg_fmt: str = ...) -> None: ...
     def __enter__(self: _S) -> _S: ...
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> bool: ...
-    def format_message(self, default_msg: Text) -> Text: ...
-    def add_test(self, cb: Callable[[_E], Any]) -> None: ...
+    def format_message(self, default_msg: str) -> str: ...
+    def add_test(self, cb: Callable[[_E], object]) -> None: ...
     @property
     def exc_val(self) -> _E: ...
 
 class AssertRaisesErrnoContext(AssertRaisesContext[_E]):
     expected_errno: int
     def __init__(
-        self, exception: Type[_E], expected_errno: int, msg_fmt: Text = ...
+        self, exception: type[_E], expected_errno: int, msg_fmt: str = ...
     ) -> None: ...
 
 class AssertRaisesRegexContext(AssertRaisesContext[_E]):
-    pattern: Text
+    pattern: str
     def __init__(
-        self, exception: Type[_E], pattern: Text, msg_fmt: Text = ...
+        self, exception: type[_E], pattern: str, msg_fmt: str = ...
     ) -> None: ...
 
 class AssertWarnsContext:
     def __init__(
-        self, warning_class: Type[Warning], msg_fmt: Text = ...
+        self, warning_class: type[Warning], msg_fmt: str = ...
     ) -> None: ...
     def __enter__(self: _S) -> _S: ...
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None: ...
-    def format_message(self) -> Text: ...
+    def format_message(self) -> str: ...
     def add_test(self, cb: Callable[[Warning], bool]) -> None: ...
 
 class AssertWarnsRegexContext(AssertWarnsContext):
-    pattern: Text
+    pattern: str
     def __init__(
-        self, warning_class: Type[Warning], msg_fmt: Text = ...
+        self, warning_class: type[Warning], msg_fmt: str = ...
     ) -> None: ...
 
-def fail(msg: Text = ...) -> NoReturn: ...
-def assert_true(expr: Any, msg_fmt: Text = ...) -> None: ...
-def assert_false(expr: Any, msg_fmt: Text = ...) -> None: ...
-def assert_boolean_true(expr: Any, msg_fmt: Text = ...) -> None: ...
-def assert_boolean_false(expr: Any, msg_fmt: Text = ...) -> None: ...
-def assert_is_none(expr: Any, msg_fmt: Text = ...) -> None: ...
-def assert_is_not_none(expr: Any, msg_fmt: Text = ...) -> None: ...
-def assert_equal(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
-def assert_not_equal(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
+def fail(msg: str = ...) -> NoReturn: ...
+def assert_true(expr: object, msg_fmt: str = ...) -> None: ...
+def assert_false(expr: object, msg_fmt: str = ...) -> None: ...
+def assert_boolean_true(expr: object, msg_fmt: str = ...) -> None: ...
+def assert_boolean_false(expr: object, msg_fmt: str = ...) -> None: ...
+def assert_is_none(expr: object, msg_fmt: str = ...) -> None: ...
+def assert_is_not_none(expr: object, msg_fmt: str = ...) -> None: ...
+def assert_equal(
+    first: object, second: object, msg_fmt: str = ...
+) -> None: ...
+def assert_not_equal(
+    first: object, second: object, msg_fmt: str = ...
+) -> None: ...
 def assert_almost_equal(
     first: float,
     second: float,
-    msg_fmt: Text = ...,
+    msg_fmt: str = ...,
     places: int = ...,
     delta: float = ...,
 ) -> None: ...
 def assert_not_almost_equal(
     first: float,
     second: float,
-    msg_fmt: Text = ...,
+    msg_fmt: str = ...,
     places: int = ...,
     delta: float = ...,
 ) -> None: ...
 def assert_dict_equal(
     first: dict,
     second: dict,
-    key_msg_fmt: Text = ...,
-    value_msg_fmt: Text = ...,
+    key_msg_fmt: str = ...,
+    value_msg_fmt: str = ...,
 ) -> None: ...
 def assert_dict_superset(
     first: dict,
     second: dict,
-    key_msg_fmt: Text = ...,
-    value_msg_fmt: Text = ...,
-) -> None: ...
-def assert_less(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
-def assert_less_equal(
-    first: Any, second: Any, msg_fmt: Text = ...
+    key_msg_fmt: str = ...,
+    value_msg_fmt: str = ...,
 ) -> None: ...
-def assert_greater(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
+def assert_less(first: Any, second: Any, msg_fmt: str = ...) -> None: ...
+def assert_less_equal(first: Any, second: Any, msg_fmt: str = ...) -> None: ...
+def assert_greater(first: Any, second: Any, msg_fmt: str = ...) -> None: ...
 def assert_greater_equal(
-    first: Any, second: Any, msg_fmt: Text = ...
+    first: Any, second: Any, msg_fmt: str = ...
 ) -> None: ...
 def assert_regex(
-    text: Text, regex: Union[Text, Pattern[Text]], msg_fmt: Text = ...
+    text: str, regex: str | Pattern[str], msg_fmt: str = ...
+) -> None: ...
+def assert_is(first: object, second: object, msg_fmt: str = ...) -> None: ...
+def assert_is_not(
+    first: object, second: object, msg_fmt: str = ...
 ) -> None: ...
-def assert_is(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
-def assert_is_not(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
 def assert_in(
-    first: Any, second: Container[Any], msg_fmt: Text = ...
+    first: Any, second: Container[Any], msg_fmt: str = ...
 ) -> None: ...
 def assert_not_in(
-    first: Any, second: Container[Any], msg_fmt: Text = ...
+    first: Any, second: Container[Any], msg_fmt: str = ...
 ) -> None: ...
 def assert_between(
-    lower_bound: Any, upper_bound: Any, expr: Any, msg_fmt: Text = ...
+    lower_bound: Any, upper_bound: Any, expr: Any, msg_fmt: str = ...
 ) -> None: ...
 def assert_is_instance(
-    obj: Any, cls: Union[type, Tuple[type, ...]], msg_fmt: Text = ...
+    obj: object, cls: type | tuple[type, ...], msg_fmt: str = ...
 ) -> None: ...
 def assert_not_is_instance(
-    obj: Any, cls: Union[type, Tuple[type, ...]], msg_fmt: Text = ...
+    obj: object, cls: type | tuple[type, ...], msg_fmt: str = ...
 ) -> None: ...
 def assert_count_equal(
-    sequence1: Iterable[Any], sequence2: Iterable[Any], msg_fmt: Text = ...
+    sequence1: Iterable[Any], sequence2: Iterable[Any], msg_fmt: str = ...
+) -> None: ...
+def assert_has_attr(
+    obj: object, attribute: str, msg_fmt: str = ...
 ) -> None: ...
-def assert_has_attr(obj: Any, attribute: str, msg_fmt: Text = ...) -> None: ...
 def assert_datetime_about_now(
-    actual: Optional[datetime.datetime], msg_fmt: Text = ...
+    actual: datetime.datetime | None, msg_fmt: str = ...
 ) -> None: ...
 def assert_datetime_about_now_utc(
-    actual: Optional[datetime.datetime], msg_fmt: Text = ...
+    actual: datetime.datetime | None, msg_fmt: str = ...
 ) -> None: ...
 def assert_raises(
-    exception: Type[BaseException], msg_fmt: Text = ...
+    exception: type[BaseException], msg_fmt: str = ...
 ) -> AssertRaisesContext: ...
 def assert_raises_regex(
-    exception: Type[BaseException],
-    regex: Union[Text, Pattern[Text]],
-    msg_fmt: Text = ...,
+    exception: type[BaseException],
+    regex: str | Pattern[str],
+    msg_fmt: str = ...,
 ) -> AssertRaisesContext: ...
 def assert_raises_errno(
-    exception: Type[BaseException], errno: int, msg_fmt: Text = ...
+    exception: type[BaseException], errno: int, msg_fmt: str = ...
 ) -> AssertRaisesContext: ...
 def assert_succeeds(
-    exception: Type[BaseException], msg_fmt: Text = ...
+    exception: type[BaseException], msg_fmt: str = ...
 ) -> ContextManager: ...
 def assert_warns(
-    warning_type: Type[Warning], msg_fmt: Text = ...
+    warning_type: type[Warning], msg_fmt: str = ...
 ) -> AssertWarnsContext: ...
 def assert_warns_regex(
-    warning_type: Type[Warning], regex: Text, msg_fmt: Text = ...
+    warning_type: type[Warning], regex: str, msg_fmt: str = ...
 ) -> AssertWarnsContext: ...
 def assert_json_subset(
-    first: Union[dict, list], second: Union[dict, list, str, bytes]
+    first: dict[str, Any] | list[Any],
+    second: dict[str, Any] | list[Any] | str | bytes,
 ) -> None: ...
 
 class Exists: