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

Author: Akuli

stdlib/__future__.pyi

@@ -1,5 +1,4 @@
 import sys
-from typing import List
 
 class _Feature:
     def __init__(self, optionalRelease: sys._version_info, mandatoryRelease: sys._version_info, compiler_flag: int) -> None: ...
@@ -20,7 +19,7 @@ generator_stop: _Feature
 if sys.version_info >= (3, 7):
     annotations: _Feature
 
-all_feature_names: List[str]  # undocumented
+all_feature_names: list[str]  # undocumented
 
 if sys.version_info >= (3, 7):
     __all__ = [

stdlib/_ast.pyi

@@ -29,16 +29,16 @@ if sys.version_info >= (3, 8):
     class TypeIgnore(type_ignore):
         tag: str
     class FunctionType(mod):
-        argtypes: typing.List[expr]
+        argtypes: list[expr]
         returns: expr
 
 class Module(mod):
-    body: typing.List[stmt]
+    body: list[stmt]
     if sys.version_info >= (3, 8):
-        type_ignores: typing.List[TypeIgnore]
+        type_ignores: list[TypeIgnore]
 
 class Interactive(mod):
-    body: typing.List[stmt]
+    body: list[stmt]
 
 class Expression(mod):
     body: expr
@@ -48,32 +48,32 @@ class stmt(AST): ...
 class FunctionDef(stmt):
     name: _identifier
     args: arguments
-    body: typing.List[stmt]
-    decorator_list: typing.List[expr]
+    body: list[stmt]
+    decorator_list: list[expr]
     returns: expr | None
 
 class AsyncFunctionDef(stmt):
     name: _identifier
     args: arguments
-    body: typing.List[stmt]
-    decorator_list: typing.List[expr]
+    body: list[stmt]
+    decorator_list: list[expr]
     returns: expr | None
 
 class ClassDef(stmt):
     name: _identifier
-    bases: typing.List[expr]
-    keywords: typing.List[keyword]
-    body: typing.List[stmt]
-    decorator_list: typing.List[expr]
+    bases: list[expr]
+    keywords: list[keyword]
+    body: list[stmt]
+    decorator_list: list[expr]
 
 class Return(stmt):
     value: expr | None
 
 class Delete(stmt):
-    targets: typing.List[expr]
+    targets: list[expr]
 
 class Assign(stmt):
-    targets: typing.List[expr]
+    targets: list[expr]
     value: expr
 
 class AugAssign(stmt):
@@ -90,60 +90,60 @@ class AnnAssign(stmt):
 class For(stmt):
     target: expr
     iter: expr
-    body: typing.List[stmt]
-    orelse: typing.List[stmt]
+    body: list[stmt]
+    orelse: list[stmt]
 
 class AsyncFor(stmt):
     target: expr
     iter: expr
-    body: typing.List[stmt]
-    orelse: typing.List[stmt]
+    body: list[stmt]
+    orelse: list[stmt]
 
 class While(stmt):
     test: expr
-    body: typing.List[stmt]
-    orelse: typing.List[stmt]
+    body: list[stmt]
+    orelse: list[stmt]
 
 class If(stmt):
     test: expr
-    body: typing.List[stmt]
-    orelse: typing.List[stmt]
+    body: list[stmt]
+    orelse: list[stmt]
 
 class With(stmt):
-    items: typing.List[withitem]
-    body: typing.List[stmt]
+    items: list[withitem]
+    body: list[stmt]
 
 class AsyncWith(stmt):
-    items: typing.List[withitem]
-    body: typing.List[stmt]
+    items: list[withitem]
+    body: list[stmt]
 
 class Raise(stmt):
     exc: expr | None
     cause: expr | None
 
 class Try(stmt):
-    body: typing.List[stmt]
-    handlers: typing.List[ExceptHandler]
-    orelse: typing.List[stmt]
-    finalbody: typing.List[stmt]
+    body: list[stmt]
+    handlers: list[ExceptHandler]
+    orelse: list[stmt]
+    finalbody: list[stmt]
 
 class Assert(stmt):
     test: expr
     msg: expr | None
 
 class Import(stmt):
-    names: typing.List[alias]
+    names: list[alias]
 
 class ImportFrom(stmt):
     module: _identifier | None
-    names: typing.List[alias]
+    names: list[alias]
     level: int
 
 class Global(stmt):
-    names: typing.List[_identifier]
+    names: list[_identifier]
 
 class Nonlocal(stmt):
-    names: typing.List[_identifier]
+    names: list[_identifier]
 
 class Expr(stmt):
     value: expr
@@ -155,7 +155,7 @@ class expr(AST): ...
 
 class BoolOp(expr):
     op: boolop
-    values: typing.List[expr]
+    values: list[expr]
 
 class BinOp(expr):
     left: expr
@@ -176,28 +176,28 @@ class IfExp(expr):
     orelse: expr
 
 class Dict(expr):
-    keys: typing.List[expr | None]
-    values: typing.List[expr]
+    keys: list[expr | None]
+    values: list[expr]
 
 class Set(expr):
-    elts: typing.List[expr]
+    elts: list[expr]
 
 class ListComp(expr):
     elt: expr
-    generators: typing.List[comprehension]
+    generators: list[comprehension]
 
 class SetComp(expr):
     elt: expr
-    generators: typing.List[comprehension]
+    generators: list[comprehension]
 
 class DictComp(expr):
     key: expr
     value: expr
-    generators: typing.List[comprehension]
+    generators: list[comprehension]
 
 class GeneratorExp(expr):
     elt: expr
-    generators: typing.List[comprehension]
+    generators: list[comprehension]
 
 class Await(expr):
     value: expr
@@ -210,21 +210,21 @@ class YieldFrom(expr):
 
 class Compare(expr):
     left: expr
-    ops: typing.List[cmpop]
-    comparators: typing.List[expr]
+    ops: list[cmpop]
+    comparators: list[expr]
 
 class Call(expr):
     func: expr
-    args: typing.List[expr]
-    keywords: typing.List[keyword]
+    args: list[expr]
+    keywords: list[keyword]
 
 class FormattedValue(expr):
     value: expr
     conversion: int | None
     format_spec: expr | None
 
 class JoinedStr(expr):
-    values: typing.List[expr]
+    values: list[expr]
 
 if sys.version_info < (3, 8):
     class Num(expr):  # Deprecated in 3.8; use Constant
@@ -267,7 +267,7 @@ class Slice(_SliceT):
 
 if sys.version_info < (3, 9):
     class ExtSlice(slice):
-        dims: typing.List[slice]
+        dims: list[slice]
     class Index(slice):
         value: expr
 
@@ -285,11 +285,11 @@ class Name(expr):
     ctx: expr_context
 
 class List(expr):
-    elts: typing.List[expr]
+    elts: list[expr]
     ctx: expr_context
 
 class Tuple(expr):
-    elts: typing.List[expr]
+    elts: list[expr]
     ctx: expr_context
 
 class expr_context(AST): ...
@@ -299,7 +299,7 @@ if sys.version_info < (3, 9):
     class AugStore(expr_context): ...
     class Param(expr_context): ...
     class Suite(mod):
-        body: typing.List[stmt]
+        body: list[stmt]
 
 class Del(expr_context): ...
 class Load(expr_context): ...
@@ -341,25 +341,25 @@ class NotIn(cmpop): ...
 class comprehension(AST):
     target: expr
     iter: expr
-    ifs: typing.List[expr]
+    ifs: list[expr]
     is_async: int
 
 class excepthandler(AST): ...
 
 class ExceptHandler(excepthandler):
     type: expr | None
     name: _identifier | None
-    body: typing.List[stmt]
+    body: list[stmt]
 
 class arguments(AST):
     if sys.version_info >= (3, 8):
-        posonlyargs: typing.List[arg]
-    args: typing.List[arg]
+        posonlyargs: list[arg]
+    args: list[arg]
     vararg: arg | None
-    kwonlyargs: typing.List[arg]
-    kw_defaults: typing.List[expr | None]
+    kwonlyargs: list[arg]
+    kw_defaults: list[expr | None]
     kwarg: arg | None
-    defaults: typing.List[expr]
+    defaults: list[expr]
 
 class arg(AST):
     arg: _identifier
@@ -380,33 +380,33 @@ class withitem(AST):
 if sys.version_info >= (3, 10):
     class Match(stmt):
         subject: expr
-        cases: typing.List[match_case]
+        cases: list[match_case]
     class pattern(AST): ...
     # Without the alias, Pyright complains variables named pattern are recursively defined
     _pattern = pattern
     class match_case(AST):
         pattern: _pattern
         guard: expr | None
-        body: typing.List[stmt]
+        body: list[stmt]
     class MatchValue(pattern):
         value: expr
     class MatchSingleton(pattern):
         value: Literal[True, False, None]
     class MatchSequence(pattern):
-        patterns: typing.List[pattern]
+        patterns: list[pattern]
     class MatchStar(pattern):
         name: _identifier | None
     class MatchMapping(pattern):
-        keys: typing.List[expr]
-        patterns: typing.List[pattern]
+        keys: list[expr]
+        patterns: list[pattern]
         rest: _identifier | None
     class MatchClass(pattern):
         cls: expr
-        patterns: typing.List[pattern]
-        kwd_attrs: typing.List[_identifier]
-        kwd_patterns: typing.List[pattern]
+        patterns: list[pattern]
+        kwd_attrs: list[_identifier]
+        kwd_patterns: list[pattern]
     class MatchAs(pattern):
         pattern: _pattern | None
         name: _identifier | None
     class MatchOr(pattern):
-        patterns: typing.List[pattern]
+        patterns: list[pattern]

stdlib/_compat_pickle.pyi

@@ -1,10 +1,10 @@
-from typing import Dict, Tuple
+from typing import Tuple
 
-IMPORT_MAPPING: Dict[str, str]
-NAME_MAPPING: Dict[Tuple[str, str], Tuple[str, str]]
+IMPORT_MAPPING: dict[str, str]
+NAME_MAPPING: dict[Tuple[str, str], Tuple[str, str]]
 PYTHON2_EXCEPTIONS: Tuple[str, ...]
 MULTIPROCESSING_EXCEPTIONS: Tuple[str, ...]
-REVERSE_IMPORT_MAPPING: Dict[str, str]
-REVERSE_NAME_MAPPING: Dict[Tuple[str, str], Tuple[str, str]]
+REVERSE_IMPORT_MAPPING: dict[str, str]
+REVERSE_NAME_MAPPING: dict[Tuple[str, str], Tuple[str, str]]
 PYTHON3_OSERROR_EXCEPTIONS: Tuple[str, ...]
 PYTHON3_IMPORTERROR_EXCEPTIONS: Tuple[str, ...]

stdlib/_csv.pyi

@@ -23,7 +23,7 @@ _DialectLike = Union[str, Dialect, Type[Dialect]]
 class _reader(Iterator[List[str]]):
     dialect: Dialect
     line_num: int
-    def __next__(self) -> List[str]: ...
+    def __next__(self) -> list[str]: ...
 
 class _writer:
     dialect: Dialect
@@ -38,5 +38,5 @@ def reader(csvfile: Iterable[str], dialect: _DialectLike = ..., **fmtparams: Any
 def register_dialect(name: str, dialect: Any = ..., **fmtparams: Any) -> None: ...
 def unregister_dialect(name: str) -> None: ...
 def get_dialect(name: str) -> Dialect: ...
-def list_dialects() -> List[str]: ...
+def list_dialects() -> list[str]: ...
 def field_size_limit(new_limit: int = ...) -> int: ...

stdlib/_dummy_thread.pyi

@@ -1,9 +1,9 @@
-from typing import Any, Callable, Dict, NoReturn, Tuple
+from typing import Any, Callable, NoReturn, Tuple
 
 TIMEOUT_MAX: int
 error = RuntimeError
 
-def start_new_thread(function: Callable[..., Any], args: Tuple[Any, ...], kwargs: Dict[str, Any] = ...) -> None: ...
+def start_new_thread(function: Callable[..., Any], args: Tuple[Any, ...], kwargs: dict[str, Any] = ...) -> None: ...
 def exit() -> NoReturn: ...
 def get_ident() -> int: ...
 def allocate_lock() -> LockType: ...