Big diff: use lower-case list and dict (#5888)

stdlib/unittest/case.pyi

@@ -13,7 +13,6 @@ from typing import (
     ContextManager,
     Generic,
     Iterable,
-    List,
     Mapping,
     NamedTuple,
     NoReturn,
@@ -166,7 +165,7 @@ class TestCase:
     def assertSequenceEqual(
         self, seq1: Sequence[Any], seq2: Sequence[Any], msg: Any = ..., seq_type: Type[Sequence[Any]] | None = ...
     ) -> None: ...
-    def assertListEqual(self, list1: List[Any], list2: List[Any], msg: Any = ...) -> None: ...
+    def assertListEqual(self, list1: list[Any], list2: list[Any], msg: Any = ...) -> None: ...
     def assertTupleEqual(self, tuple1: Tuple[Any, ...], tuple2: Tuple[Any, ...], msg: Any = ...) -> None: ...
     def assertSetEqual(self, set1: Set[object], set2: Set[object], msg: Any = ...) -> None: ...
     def assertDictEqual(self, d1: Mapping[Any, object], d2: Mapping[Any, object], msg: Any = ...) -> None: ...
@@ -242,8 +241,8 @@ class FunctionTestCase(TestCase):
     def runTest(self) -> None: ...
 
 class _LoggingWatcher(NamedTuple):
-    records: List[logging.LogRecord]
-    output: List[str]
+    records: list[logging.LogRecord]
+    output: list[str]
 
 class _AssertRaisesContext(Generic[_E]):
     exception: _E
@@ -258,7 +257,7 @@ class _AssertWarnsContext:
     warning: WarningMessage
     filename: str
     lineno: int
-    warnings: List[WarningMessage]
+    warnings: list[WarningMessage]
     def __enter__(self: Self) -> Self: ...
     def __exit__(
         self, exc_type: Type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
@@ -266,8 +265,8 @@ class _AssertWarnsContext:
 
 class _AssertLogsContext:
     LOGGING_FORMAT: str
-    records: List[logging.LogRecord]
-    output: List[str]
+    records: list[logging.LogRecord]
+    output: list[str]
     def __init__(self, test_case: TestCase, logger_name: str, level: int) -> None: ...
     if sys.version_info >= (3, 10):
         def __enter__(self) -> _LoggingWatcher | None: ...

stdlib/unittest/loader.pyi

@@ -9,12 +9,12 @@ _SortComparisonMethod = Callable[[str, str], int]
 _SuiteClass = Callable[[List[unittest.case.TestCase]], unittest.suite.TestSuite]
 
 class TestLoader:
-    errors: List[Type[BaseException]]
+    errors: list[Type[BaseException]]
     testMethodPrefix: str
     sortTestMethodsUsing: _SortComparisonMethod
 
     if sys.version_info >= (3, 7):
-        testNamePatterns: List[str] | None
+        testNamePatterns: list[str] | None
 
     suiteClass: _SuiteClass
     def loadTestsFromTestCase(self, testCaseClass: Type[unittest.case.TestCase]) -> unittest.suite.TestSuite: ...
@@ -31,7 +31,7 @@ if sys.version_info >= (3, 7):
         testCaseClass: Type[unittest.case.TestCase],
         prefix: str,
         sortUsing: _SortComparisonMethod = ...,
-        testNamePatterns: List[str] | None = ...,
+        testNamePatterns: list[str] | None = ...,
     ) -> Sequence[str]: ...
 
 else:

stdlib/unittest/main.pyi

@@ -4,7 +4,7 @@ import unittest.loader
 import unittest.result
 import unittest.suite
 from types import ModuleType
-from typing import Any, Iterable, List, Protocol, Type
+from typing import Any, Iterable, Protocol, Type
 
 class _TestRunner(Protocol):
     def run(self, test: unittest.suite.TestSuite | unittest.case.TestCase) -> unittest.result.TestResult: ...
@@ -21,12 +21,12 @@ class TestProgram:
     warnings: str | None
 
     if sys.version_info >= (3, 7):
-        testNamePatterns: List[str] | None
+        testNamePatterns: list[str] | None
     def __init__(
         self,
         module: None | str | ModuleType = ...,
         defaultTest: str | Iterable[str] | None = ...,
-        argv: List[str] | None = ...,
+        argv: list[str] | None = ...,
         testRunner: Type[_TestRunner] | _TestRunner | None = ...,
         testLoader: unittest.loader.TestLoader = ...,
         exit: bool = ...,
@@ -39,7 +39,7 @@ class TestProgram:
         tb_locals: bool = ...,
     ) -> None: ...
     def usageExit(self, msg: Any = ...) -> None: ...
-    def parseArgs(self, argv: List[str]) -> None: ...
+    def parseArgs(self, argv: list[str]) -> None: ...
     if sys.version_info >= (3, 7):
         def createTests(self, from_discovery: bool = ..., Loader: unittest.loader.TestLoader | None = ...) -> None: ...
     else:

stdlib/unittest/mock.pyi

@@ -76,10 +76,10 @@ class NonCallableMock(Base, Any):  # type: ignore
     def __new__(__cls, *args: Any, **kw: Any) -> NonCallableMock: ...
     def __init__(
         self,
-        spec: List[str] | object | Type[object] | None = ...,
+        spec: list[str] | object | Type[object] | None = ...,
         wraps: Any | None = ...,
         name: str | None = ...,
-        spec_set: List[str] | object | Type[object] | None = ...,
+        spec_set: list[str] | object | Type[object] | None = ...,
         parent: NonCallableMock | None = ...,
         _spec_state: Any | None = ...,
         _new_name: str = ...,

stdlib/unittest/result.pyi

@@ -1,6 +1,6 @@
 import unittest.case
 from types import TracebackType
-from typing import Any, Callable, List, TextIO, Tuple, Type, TypeVar, Union
+from typing import Any, Callable, TextIO, Tuple, Type, TypeVar, Union
 
 _SysExcInfoType = Union[Tuple[Type[BaseException], BaseException, TracebackType], Tuple[None, None, None]]
 
@@ -10,11 +10,11 @@ _F = TypeVar("_F", bound=Callable[..., Any])
 def failfast(method: _F) -> _F: ...
 
 class TestResult:
-    errors: List[Tuple[unittest.case.TestCase, str]]
-    failures: List[Tuple[unittest.case.TestCase, str]]
-    skipped: List[Tuple[unittest.case.TestCase, str]]
-    expectedFailures: List[Tuple[unittest.case.TestCase, str]]
-    unexpectedSuccesses: List[unittest.case.TestCase]
+    errors: list[Tuple[unittest.case.TestCase, str]]
+    failures: list[Tuple[unittest.case.TestCase, str]]
+    skipped: list[Tuple[unittest.case.TestCase, str]]
+    expectedFailures: list[Tuple[unittest.case.TestCase, str]]
+    unexpectedSuccesses: list[unittest.case.TestCase]
     shouldStop: bool
     testsRun: int
     buffer: bool

stdlib/unittest/suite.pyi

@@ -1,11 +1,11 @@
 import unittest.case
 import unittest.result
-from typing import Iterable, Iterator, List, Union
+from typing import Iterable, Iterator, Union
 
 _TestType = Union[unittest.case.TestCase, TestSuite]
 
 class BaseTestSuite(Iterable[_TestType]):
-    _tests: List[unittest.case.TestCase]
+    _tests: list[unittest.case.TestCase]
     _removed_tests: int
     def __init__(self, tests: Iterable[_TestType] = ...) -> None: ...
     def __call__(self, result: unittest.result.TestResult) -> unittest.result.TestResult: ...

stdlib/unittest/util.pyi

@@ -1,4 +1,4 @@
-from typing import Any, List, Sequence, Tuple, TypeVar
+from typing import Any, Sequence, Tuple, TypeVar
 
 _T = TypeVar("_T")
 _Mismatch = Tuple[_T, _T, int]
@@ -14,8 +14,8 @@ def _shorten(s: str, prefixlen: int, suffixlen: int) -> str: ...
 def _common_shorten_repr(*args: str) -> Tuple[str]: ...
 def safe_repr(obj: object, short: bool = ...) -> str: ...
 def strclass(cls: type) -> str: ...
-def sorted_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[List[_T], List[_T]]: ...
-def unorderable_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[List[_T], List[_T]]: ...
+def sorted_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[list[_T], list[_T]]: ...
+def unorderable_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[list[_T], list[_T]]: ...
 def three_way_cmp(x: Any, y: Any) -> int: ...
-def _count_diff_all_purpose(actual: Sequence[_T], expected: Sequence[_T]) -> List[_Mismatch[_T]]: ...
-def _count_diff_hashable(actual: Sequence[_T], expected: Sequence[_T]) -> List[_Mismatch[_T]]: ...
+def _count_diff_all_purpose(actual: Sequence[_T], expected: Sequence[_T]) -> list[_Mismatch[_T]]: ...
+def _count_diff_hashable(actual: Sequence[_T], expected: Sequence[_T]) -> list[_Mismatch[_T]]: ...