reformat

Author: ilevkivskyi

mypy/checker.py

@@ -2055,9 +2055,9 @@ def check_setter_type_override(
         original_type = get_raw_setter_type(base_node)
         if isinstance(base_node, Var):
             expanded_type = map_type_from_supertype(original_type, defn.info, base)
-            original_type = get_proper_type(expand_self_type(
-                base_node, expanded_type, fill_typevars(defn.info)
-            ))
+            original_type = get_proper_type(
+                expand_self_type(base_node, expanded_type, fill_typevars(defn.info))
+            )
         else:
             assert isinstance(original_type, CallableType)
             original_type = self.bind_and_map_method(base_attr, original_type, defn.info, base)
@@ -2114,9 +2114,7 @@ def check_method_override_for_base_with_name(
         if is_settable_property(defn) and (
             is_settable_property(original_node) or isinstance(original_node, Var)
         ):
-            if is_custom_settable_property(defn) or (
-                is_custom_settable_property(original_node)
-            ):
+            if is_custom_settable_property(defn) or (is_custom_settable_property(original_node)):
                 always_allow_covariant = True
                 self.check_setter_type_override(defn, base_attr, base)
         # `original_type` can be partial if (e.g.) it is originally an
@@ -3402,8 +3400,13 @@ def check_compatibility_all_supers(
                 if base_type:
                     assert base_node is not None
                     if not self.check_compatibility_super(
-                        lvalue, lvalue_type, rvalue, base, base_type, base_node,
-                        always_allow_covariant=custom_setter
+                        lvalue,
+                        lvalue_type,
+                        rvalue,
+                        base,
+                        base_type,
+                        base_node,
+                        always_allow_covariant=custom_setter,
                     ):
                         # Only show one error per variable; even if other
                         # base classes are also incompatible
@@ -3507,7 +3510,7 @@ def check_compatibility_super(
         return True
 
     def lvalue_type_from_base(
-        self, expr_node: Var, base: TypeInfo, setter_type: bool = False,
+        self, expr_node: Var, base: TypeInfo, setter_type: bool = False
     ) -> tuple[Type | None, SymbolNode | None]:
         """For a NameExpr that is part of a class, walk all base classes and try
         to find the first class that defines a Type for the same name."""
@@ -3542,18 +3545,14 @@ def lvalue_type_from_base(
             # value, not the Callable
             if base_node.is_property:
                 base_type = get_proper_type(base_type.ret_type)
-        if isinstance(base_type, FunctionLike) and isinstance(
-            base_node, OverloadedFuncDef
-        ):
+        if isinstance(base_type, FunctionLike) and isinstance(base_node, OverloadedFuncDef):
             # Same for properties with setter
             if base_node.is_property:
                 if setter_type:
                     assert isinstance(base_node.items[0], Decorator)
                     base_type = base_node.items[0].var.setter_type
                     assert isinstance(base_type, CallableType)
-                    base_type = self.bind_and_map_method(
-                        base_var, base_type, expr_node.info, base
-                    )
+                    base_type = self.bind_and_map_method(base_var, base_type, expr_node.info, base)
                     assert isinstance(base_type, CallableType)
                     base_type = get_proper_type(base_type.arg_types[0])
                 else:
@@ -8790,9 +8789,7 @@ def is_custom_settable_property(defn: SymbolNode | None) -> bool:
     setter_type = var.setter_type.arg_types[1]
     if isinstance(get_proper_type(setter_type), AnyType):
         return False
-    return not is_same_type(
-        get_property_type(get_proper_type(var.type)), setter_type
-    )
+    return not is_same_type(get_property_type(get_proper_type(var.type)), setter_type)
 
 
 def get_raw_setter_type(defn: OverloadedFuncDef | Var) -> ProperType:

mypy/messages.py

@@ -1168,30 +1168,16 @@ def overload_signature_incompatible_with_supertype(
     def incompatible_setter_override(
         self, defn: Context, typ: Type, original_type: Type, base: TypeInfo
     ) -> None:
-        self.fail(
-            "Incompatible override of a setter type",
-            defn,
-            code=codes.OVERRIDE,
-        )
-        base_str, override_str = format_type_distinctly(
-            original_type, typ, options=self.options
-        )
+        self.fail("Incompatible override of a setter type", defn, code=codes.OVERRIDE)
+        base_str, override_str = format_type_distinctly(original_type, typ, options=self.options)
         self.note(
             f' (base class "{base.name}" defined the type as {base_str},',
             defn,
             code=codes.OVERRIDE,
         )
-        self.note(
-            f" override has type {override_str})",
-            defn,
-            code=codes.OVERRIDE,
-        )
+        self.note(f" override has type {override_str})", defn, code=codes.OVERRIDE)
         if is_subtype(typ, original_type):
-            self.note(
-                " Setter types should behave contravariantly",
-                defn,
-                code=codes.OVERRIDE,
-            )
+            self.note(" Setter types should behave contravariantly", defn, code=codes.OVERRIDE)
 
     def signature_incompatible_with_supertype(
         self,
@@ -3075,9 +3061,7 @@ def get_conflict_protocol_types(
                 different_setter = True
             supertype = set_supertype
         if IS_EXPLICIT_SETTER in get_member_flags(member, left):
-            set_subtype = mypy.typeops.get_protocol_member(
-                left, member, class_obj, is_lvalue=True
-            )
+            set_subtype = mypy.typeops.get_protocol_member(left, member, class_obj, is_lvalue=True)
             if set_subtype != subtype:
                 different_setter = True
             subtype = set_subtype

mypy/nodes.py

@@ -1090,9 +1090,17 @@ def deserialize(cls, data: JsonDict) -> Var:
         assert data[".class"] == "Var"
         name = data["name"]
         type = None if data["type"] is None else mypy.types.deserialize_type(data["type"])
-        setter_type = None if data["setter_type"] is None else mypy.types.deserialize_type(data["setter_type"])
+        setter_type = (
+            None
+            if data["setter_type"] is None
+            else mypy.types.deserialize_type(data["setter_type"])
+        )
         v = Var(name, type)
-        assert setter_type is None or isinstance(setter_type, mypy.types.ProperType) and isinstance(setter_type, mypy.types.CallableType)
+        assert (
+            setter_type is None
+            or isinstance(setter_type, mypy.types.ProperType)
+            and isinstance(setter_type, mypy.types.CallableType)
+        )
         v.setter_type = setter_type
         v.is_ready = False  # Override True default set in __init__
         v._fullname = data["fullname"]

mypy/typeops.py

@@ -1172,8 +1172,7 @@ def named_type(fullname: str) -> Instance:
             NoneType()
             if subtype.type is None
             else Instance(
-                subtype.type,
-                [AnyType(TypeOfAny.unannotated)] * len(subtype.type.type_vars),
+                subtype.type, [AnyType(TypeOfAny.unannotated)] * len(subtype.type.type_vars)
             )
         )
     return subtype