[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

mypy/checker.py

@@ -1203,7 +1203,9 @@ def visit_func_def(self, defn: FuncDef) -> None:
                         # been typechecked, and decorated methods will be
                         # checked when the decorator is.
                         found_method_base_classes = self.pure_check_method_override(defn)
-                        self.pure_check_explicit_override_decorator(defn, found_method_base_classes)
+                        self.pure_check_explicit_override_decorator(
+                            defn, found_method_base_classes
+                        )
                     self.pure_check_inplace_operator_method(defn)
             if defn.original_def:
                 # Override previous definition.
@@ -1313,7 +1315,9 @@ def check_func_def(
                 # function. In the first case, set up another reference with the
                 # precise type.
                 if not self.can_skip_diagnostics:
-                    self.pure_check_func_item(item, typ, name, defn=defn, original_typ=original_typ)
+                    self.pure_check_func_item(
+                        item, typ, name, defn=defn, original_typ=original_typ
+                    )
 
                 # Fix the type if decorated with `@types.coroutine` or `@asyncio.coroutine`.
                 if defn.is_awaitable_coroutine:
@@ -1495,9 +1499,8 @@ def check_func_def(
 
                 if show_error:
                     if self.options.warn_no_return:
-                        if (
-                            not self.current_node_deferred
-                            and not isinstance(return_type, (NoneType, AnyType))
+                        if not self.current_node_deferred and not isinstance(
+                            return_type, (NoneType, AnyType)
                         ):
                             # Control flow fell off the end of a function that was
                             # declared to return a non-None type.
@@ -1533,21 +1536,25 @@ def check_func_def(
 
             self.binder = old_binder
 
-    def pure_check_func_item(self, item: FuncItem, typ: CallableType, name: str | None, *, defn: FuncItem, original_typ: CallableType) -> None:
+    def pure_check_func_item(
+        self,
+        item: FuncItem,
+        typ: CallableType,
+        name: str | None,
+        *,
+        defn: FuncItem,
+        original_typ: CallableType,
+    ) -> None:
         if isinstance(item, FuncDef):
             fdef = item
             # Check if __init__ has an invalid return type.
             if (
                 fdef.info
                 and fdef.name in ("__init__", "__init_subclass__")
-                and not isinstance(
-                    get_proper_type(typ.ret_type), (NoneType, UninhabitedType)
-                )
+                and not isinstance(get_proper_type(typ.ret_type), (NoneType, UninhabitedType))
                 and not self.dynamic_funcs[-1]
             ):
-                self.fail(
-                    message_registry.MUST_HAVE_NONE_RETURN_TYPE.format(fdef.name), item
-                )
+                self.fail(message_registry.MUST_HAVE_NONE_RETURN_TYPE.format(fdef.name), item)
 
             # Check validity of __new__ signature
             if fdef.info and fdef.name == "__new__":
@@ -1582,13 +1589,9 @@ def pure_check_func_item(self, item: FuncItem, typ: CallableType, name: str | No
         # Refuse contravariant return type variable
         if isinstance(typ.ret_type, TypeVarType):
             if typ.ret_type.variance == CONTRAVARIANT:
-                self.fail(
-                    message_registry.RETURN_TYPE_CANNOT_BE_CONTRAVARIANT, typ.ret_type
-                )
+                self.fail(message_registry.RETURN_TYPE_CANNOT_BE_CONTRAVARIANT, typ.ret_type)
             self.pure_check_unbound_return_typevar(typ)
-        elif (
-            isinstance(original_typ.ret_type, TypeVarType) and original_typ.ret_type.values
-        ):
+        elif isinstance(original_typ.ret_type, TypeVarType) and original_typ.ret_type.values:
             # Since type vars with values are expanded, the return type is changed
             # to a raw value. This is a hack to get it back.
             self.pure_check_unbound_return_typevar(original_typ)
@@ -1597,9 +1600,7 @@ def pure_check_func_item(self, item: FuncItem, typ: CallableType, name: str | No
         if defn.is_generator:
             if defn.is_async_generator:
                 if not self.is_async_generator_return_type(typ.ret_type):
-                    self.fail(
-                        message_registry.INVALID_RETURN_TYPE_FOR_ASYNC_GENERATOR, typ
-                    )
+                    self.fail(message_registry.INVALID_RETURN_TYPE_FOR_ASYNC_GENERATOR, typ)
             else:
                 if not self.is_generator_return_type(typ.ret_type, defn.is_coroutine):
                     self.fail(message_registry.INVALID_RETURN_TYPE_FOR_GENERATOR, typ)
@@ -3451,9 +3452,11 @@ def check_assignment(
                     rvalue_type = remove_instance_last_known_values(rvalue_type)
                 self.infer_variable_type(inferred, lvalue, rvalue_type, rvalue)
             self.check_assignment_to_slots(lvalue)
-            if isinstance(lvalue, RefExpr) and not (
-                isinstance(lvalue, NameExpr) and lvalue.name == "__match_args__"
-            ) and not self.can_skip_diagnostics:
+            if (
+                isinstance(lvalue, RefExpr)
+                and not (isinstance(lvalue, NameExpr) and lvalue.name == "__match_args__")
+                and not self.can_skip_diagnostics
+            ):
                 # We check override here at the end after storing the inferred type, since
                 # override check will try to access the current attribute via symbol tables
                 # (like a regular attribute access).
@@ -3570,11 +3573,15 @@ def pure_check_compatibility_all_supers(self, lvalue: RefExpr, rvalue: Expressio
             for base in lvalue_node.info.mro[1:]:
                 tnode = base.names.get(lvalue_node.name)
                 if tnode is not None:
-                    if not self.pure_check_compatibility_classvar_super(lvalue_node, base, tnode.node):
+                    if not self.pure_check_compatibility_classvar_super(
+                        lvalue_node, base, tnode.node
+                    ):
                         # Show only one error per variable
                         break
 
-                    if not self.pure_check_compatibility_final_super(lvalue_node, base, tnode.node):
+                    if not self.pure_check_compatibility_final_super(
+                        lvalue_node, base, tnode.node
+                    ):
                         # Show only one error per variable
                         break