Run pyupgrade on the source code

Author: sobolevn

mypy/binder.py

@@ -1,8 +1,8 @@
 from collections import defaultdict
 from contextlib import contextmanager
-from typing import Dict, Iterator, List, Optional, Set, Tuple, Union, cast
+from typing import DefaultDict, Dict, Iterator, List, Optional, Set, Tuple, Union, cast
 
-from typing_extensions import DefaultDict, TypeAlias as _TypeAlias
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.erasetype import remove_instance_last_known_values
 from mypy.join import join_simple

mypy/build.py

@@ -22,9 +22,11 @@
 import time
 import types
 from typing import (
+    TYPE_CHECKING,
     AbstractSet,
     Any,
     Callable,
+    ClassVar,
     Dict,
     Iterable,
     Iterator,
@@ -41,7 +43,7 @@
 )
 
 from mypy_extensions import TypedDict
-from typing_extensions import TYPE_CHECKING, ClassVar, Final, NoReturn, TypeAlias as _TypeAlias
+from typing_extensions import Final, NoReturn, TypeAlias as _TypeAlias
 
 import mypy.semanal_main
 from mypy.checker import TypeChecker
@@ -1068,9 +1070,7 @@ def read_plugins_snapshot(manager: BuildManager) -> Optional[Dict[str, str]]:
     if snapshot is None:
         return None
     if not isinstance(snapshot, dict):
-        manager.log(
-            "Could not load plugins snapshot: cache is not a dict: {}".format(type(snapshot))
-        )
+        manager.log(f"Could not load plugins snapshot: cache is not a dict: {type(snapshot)}")
         return None
     return snapshot
 
@@ -1284,9 +1284,7 @@ def find_cache_meta(id: str, path: str, manager: BuildManager) -> Optional[Cache
     if meta is None:
         return None
     if not isinstance(meta, dict):
-        manager.log(
-            "Could not load cache for {}: meta cache is not a dict: {}".format(id, repr(meta))
-        )
+        manager.log(f"Could not load cache for {id}: meta cache is not a dict: {repr(meta)}")
         return None
     m = cache_meta_from_dict(meta, data_json)
     t2 = time.time()
@@ -1459,9 +1457,7 @@ def validate_meta(
                 manager.log(f"Using stale metadata for {id}: file {path}")
                 return meta
             else:
-                manager.log(
-                    "Metadata abandoned for {}: file {} has different hash".format(id, path)
-                )
+                manager.log(f"Metadata abandoned for {id}: file {path} has different hash")
                 return None
         else:
             t0 = time.time()

mypy/checkexpr.py

@@ -2,9 +2,21 @@
 
 import itertools
 from contextlib import contextmanager
-from typing import Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Union, cast
+from typing import (
+    Callable,
+    ClassVar,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Union,
+    cast,
+)
 
-from typing_extensions import ClassVar, Final, TypeAlias as _TypeAlias, overload
+from typing_extensions import Final, TypeAlias as _TypeAlias, overload
 
 import mypy.checker
 import mypy.errorcodes as codes

mypy/checkmember.py

@@ -1,8 +1,6 @@
 """Type checking of attribute access"""
 
-from typing import Callable, Optional, Sequence, Union, cast
-
-from typing_extensions import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, Optional, Sequence, Union, cast
 
 from mypy import meet, message_registry, subtypes
 from mypy.erasetype import erase_typevars
@@ -836,7 +834,7 @@ def analyze_class_attribute_access(
     if override_info:
         info = override_info
 
-    fullname = "{}.{}".format(info.fullname, name)
+    fullname = f"{info.fullname}.{name}"
     hook = mx.chk.plugin.get_class_attribute_hook(fullname)
 
     node = info.get(name)

mypy/checkstrformat.py

@@ -11,9 +11,21 @@
 """
 
 import re
-from typing import Callable, Dict, List, Match, Optional, Pattern, Set, Tuple, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Dict,
+    List,
+    Match,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+    Union,
+    cast,
+)
 
-from typing_extensions import TYPE_CHECKING, Final, TypeAlias as _TypeAlias
+from typing_extensions import Final, TypeAlias as _TypeAlias
 
 import mypy.errorcodes as codes
 from mypy.errors import Errors

mypy/config_parser.py

@@ -46,7 +46,7 @@ def parse_version(v: Union[str, float]) -> Tuple[int, int]:
         pass  # Error raised elsewhere
     elif major == 3:
         if minor < defaults.PYTHON3_VERSION_MIN[1]:
-            msg = "Python 3.{0} is not supported (must be {1}.{2} or higher)".format(
+            msg = "Python 3.{} is not supported (must be {}.{} or higher)".format(
                 minor, *defaults.PYTHON3_VERSION_MIN
             )
 

mypy/errors.py

@@ -884,7 +884,7 @@ def render_messages(self, errors: List[ErrorInfo]) -> List[ErrorTuple]:
                                 -1,
                                 -1,
                                 "note",
-                                'In class "{}":'.format(e.type),
+                                f'In class "{e.type}":',
                                 e.allow_dups,
                                 None,
                             )
@@ -899,7 +899,7 @@ def render_messages(self, errors: List[ErrorInfo]) -> List[ErrorTuple]:
                                 -1,
                                 -1,
                                 "note",
-                                'In function "{}":'.format(e.function_or_member),
+                                f'In function "{e.function_or_member}":',
                                 e.allow_dups,
                                 None,
                             )

mypy/fastparse.py

@@ -1855,9 +1855,7 @@ def _extract_argument_name(self, n: ast3.expr) -> Optional[str]:
         elif isinstance(n, NameConstant) and str(n.value) == "None":
             return None
         self.fail(
-            "Expected string literal for argument name, got {}".format(type(n).__name__),
-            self.line,
-            0,
+            f"Expected string literal for argument name, got {type(n).__name__}", self.line, 0
         )
         return None
 

mypy/ipc.py

@@ -10,9 +10,9 @@
 import sys
 import tempfile
 from types import TracebackType
-from typing import Callable, Optional
+from typing import Callable, Optional, Type
 
-from typing_extensions import Final, Type
+from typing_extensions import Final
 
 if sys.platform == "win32":
     # This may be private, but it is needed for IPC on Windows, and is basically stable

mypy/messages.py

@@ -337,7 +337,7 @@ def has_no_attr(
             self.fail(f'Member "{member}" is not assignable', context)
         elif member == "__contains__":
             self.fail(
-                "Unsupported right operand type for in ({})".format(format_type(original_type)),
+                f"Unsupported right operand type for in ({format_type(original_type)})",
                 context,
                 code=codes.OPERATOR,
             )
@@ -350,19 +350,19 @@ def has_no_attr(
                     break
         elif member == "__neg__":
             self.fail(
-                "Unsupported operand type for unary - ({})".format(format_type(original_type)),
+                f"Unsupported operand type for unary - ({format_type(original_type)})",
                 context,
                 code=codes.OPERATOR,
             )
         elif member == "__pos__":
             self.fail(
-                "Unsupported operand type for unary + ({})".format(format_type(original_type)),
+                f"Unsupported operand type for unary + ({format_type(original_type)})",
                 context,
                 code=codes.OPERATOR,
             )
         elif member == "__invert__":
             self.fail(
-                "Unsupported operand type for ~ ({})".format(format_type(original_type)),
+                f"Unsupported operand type for ~ ({format_type(original_type)})",
                 context,
                 code=codes.OPERATOR,
             )
@@ -378,7 +378,7 @@ def has_no_attr(
                 )
             else:
                 self.fail(
-                    "Value of type {} is not indexable".format(format_type(original_type)),
+                    f"Value of type {format_type(original_type)} is not indexable",
                     context,
                     code=codes.INDEX,
                 )
@@ -986,13 +986,13 @@ def no_variant_matches_arguments(
             )
         elif num_args == 1:
             self.fail(
-                "No overload variant{} matches argument type {}".format(name_str, arg_types_str),
+                f"No overload variant{name_str} matches argument type {arg_types_str}",
                 context,
                 code=code,
             )
         else:
             self.fail(
-                "No overload variant{} matches argument types {}".format(name_str, arg_types_str),
+                f"No overload variant{name_str} matches argument types {arg_types_str}",
                 context,
                 code=code,
             )
@@ -1009,13 +1009,11 @@ def wrong_number_values_to_unpack(
                 self.fail(f"Need more than 1 value to unpack ({expected} expected)", context)
             else:
                 self.fail(
-                    "Need more than {} values to unpack ({} expected)".format(provided, expected),
-                    context,
+                    f"Need more than {provided} values to unpack ({expected} expected)", context
                 )
         elif provided > expected:
             self.fail(
-                "Too many values to unpack ({} expected, {} provided)".format(expected, provided),
-                context,
+                f"Too many values to unpack ({expected} expected, {provided} provided)", context
             )
 
     def unpacking_strings_disallowed(self, context: Context) -> None:
@@ -1035,9 +1033,7 @@ def overload_signature_incompatible_with_supertype(
     ) -> None:
         target = self.override_target(name, name_in_super, supertype)
         self.fail(
-            'Signature of "{}" incompatible with {}'.format(name, target),
-            context,
-            code=codes.OVERRIDE,
+            f'Signature of "{name}" incompatible with {target}', context, code=codes.OVERRIDE
         )
 
         note_template = 'Overload variants must be defined in the same order as they are in "{}"'
@@ -1054,9 +1050,7 @@ def signature_incompatible_with_supertype(
     ) -> None:
         code = codes.OVERRIDE
         target = self.override_target(name, name_in_super, supertype)
-        self.fail(
-            'Signature of "{}" incompatible with {}'.format(name, target), context, code=code
-        )
+        self.fail(f'Signature of "{name}" incompatible with {target}', context, code=code)
 
         INCLUDE_DECORATOR = True  # Include @classmethod and @staticmethod decorators, if any
         ALLOW_DUPS = True  # Allow duplicate notes, needed when signatures are duplicates
@@ -1197,13 +1191,11 @@ def incompatible_type_application(
             self.fail("Type application targets a non-generic function or class", context)
         elif actual_arg_count > expected_arg_count:
             self.fail(
-                "Type application has too many types ({} expected)".format(expected_arg_count),
-                context,
+                f"Type application has too many types ({expected_arg_count} expected)", context
             )
         else:
             self.fail(
-                "Type application has too few types ({} expected)".format(expected_arg_count),
-                context,
+                f"Type application has too few types ({expected_arg_count} expected)", context
             )
 
     def could_not_infer_type_arguments(
@@ -1487,9 +1479,7 @@ def forward_operator_not_callable(self, forward_method: str, context: Context) -
         self.fail(f'Forward operator "{forward_method}" is not callable', context)
 
     def signatures_incompatible(self, method: str, other_method: str, context: Context) -> None:
-        self.fail(
-            'Signatures of "{}" and "{}" are incompatible'.format(method, other_method), context
-        )
+        self.fail(f'Signatures of "{method}" and "{other_method}" are incompatible', context)
 
     def yield_from_invalid_operand_type(self, expr: Type, context: Context) -> Type:
         text = format_type(expr) if format_type(expr) != "object" else expr
@@ -1641,7 +1631,7 @@ def typeddict_key_not_found(
             )
         else:
             self.fail(
-                'TypedDict {} has no key "{}"'.format(format_type(typ), item_name),
+                f'TypedDict {format_type(typ)} has no key "{item_name}"',
                 context,
                 code=codes.TYPEDDICT_ITEM,
             )
@@ -1655,9 +1645,7 @@ def typeddict_key_not_found(
 
     def typeddict_context_ambiguous(self, types: List[TypedDictType], context: Context) -> None:
         formatted_types = ", ".join(list(format_type_distinctly(*types)))
-        self.fail(
-            "Type of TypedDict is ambiguous, could be any of ({})".format(formatted_types), context
-        )
+        self.fail(f"Type of TypedDict is ambiguous, could be any of ({formatted_types})", context)
 
     def typeddict_key_cannot_be_deleted(
         self, typ: TypedDictType, item_name: str, context: Context
@@ -1666,8 +1654,7 @@ def typeddict_key_cannot_be_deleted(
             self.fail(f'TypedDict key "{item_name}" cannot be deleted', context)
         else:
             self.fail(
-                'Key "{}" of TypedDict {} cannot be deleted'.format(item_name, format_type(typ)),
-                context,
+                f'Key "{item_name}" of TypedDict {format_type(typ)} cannot be deleted', context
             )
 
     def typeddict_setdefault_arguments_inconsistent(
@@ -1719,8 +1706,7 @@ def untyped_decorated_function(self, typ: Type, context: Context) -> None:
             self.fail("Function is untyped after decorator transformation", context)
         else:
             self.fail(
-                'Type of decorated function contains type "Any" ({})'.format(format_type(typ)),
-                context,
+                f'Type of decorated function contains type "Any" ({format_type(typ)})', context
             )
 
     def typed_function_untyped_decorator(self, func_name: str, context: Context) -> None:
@@ -1739,14 +1725,12 @@ def bad_proto_variance(
 
     def concrete_only_assign(self, typ: Type, context: Context) -> None:
         self.fail(
-            "Can only assign concrete classes to a variable of type {}".format(format_type(typ)),
-            context,
+            f"Can only assign concrete classes to a variable of type {format_type(typ)}", context
         )
 
     def concrete_only_call(self, typ: Type, context: Context) -> None:
         self.fail(
-            "Only concrete class can be given where {} is expected".format(format_type(typ)),
-            context,
+            f"Only concrete class can be given where {format_type(typ)} is expected", context
         )
 
     def cannot_use_function_with_type(
@@ -1763,7 +1747,7 @@ def report_non_method_protocol(
         )
         if len(members) < 3:
             attrs = ", ".join(members)
-            self.note('Protocol "{}" has non-method member(s): {}'.format(tp.name, attrs), context)
+            self.note(f'Protocol "{tp.name}" has non-method member(s): {attrs}', context)
 
     def note_call(
         self, subtype: Type, call: Type, context: Context, *, code: Optional[ErrorCode]
@@ -2117,9 +2101,7 @@ def format_callable_args(
             if arg_kind.is_star() or arg_name is None:
                 arg_strings.append(f"{constructor}({format(arg_type)})")
             else:
-                arg_strings.append(
-                    "{}({}, {})".format(constructor, format(arg_type), repr(arg_name))
-                )
+                arg_strings.append(f"{constructor}({format(arg_type)}, {repr(arg_name)})")
 
     return ", ".join(arg_strings)
 

mypy/metastore.py

@@ -12,9 +12,7 @@
 import os
 import time
 from abc import abstractmethod
-from typing import Any, Iterable, List, Optional
-
-from typing_extensions import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Iterable, List, Optional
 
 if TYPE_CHECKING:
     # We avoid importing sqlite3 unless we are using it so we can mostly work