format

Author: jhance

mypy/applytype.py

@@ -157,7 +157,7 @@ def apply_generic_arguments(
             assert False, "mypy bug: unhandled case applying unpack"
     else:
         callable = callable.copy_modified(
-            arg_types = [expand_type(at, id_to_type) for at in callable.arg_types]
+            arg_types=[expand_type(at, id_to_type) for at in callable.arg_types]
         )
 
     # Apply arguments to TypeGuard if any.

mypy/checkexpr.py

@@ -124,7 +124,6 @@
     LITERAL_TYPE_NAMES,
     TUPLE_LIKE_INSTANCE_NAMES,
     AnyType,
-    UnpackType,
     CallableType,
     DeletedType,
     ErasedType,
@@ -150,6 +149,7 @@
     TypeVarType,
     UninhabitedType,
     UnionType,
+    UnpackType,
     flatten_nested_unions,
     get_proper_type,
     get_proper_types,
@@ -2025,13 +2025,17 @@ def check_argument_types(
                     and isinstance(get_proper_type(first_actual_arg_type.items[0]), UnpackType)
                 ):
                     # TODO: use walrus operator
-                    actual_types = [first_actual_arg_type.items[0]] + [arg_types[a] for a in actuals[1:]]
+                    actual_types = [first_actual_arg_type.items[0]] + [
+                        arg_types[a] for a in actuals[1:]
+                    ]
                     actual_kinds = [nodes.ARG_STAR] + [nodes.ARG_POS] * (len(actuals) - 1)
 
                     assert isinstance(orig_callee_arg_type, TupleType)
                     assert orig_callee_arg_type.items
                     callee_arg_types = orig_callee_arg_type.items
-                    callee_arg_kinds = [nodes.ARG_STAR] + [nodes.ARG_POS] * (len(orig_callee_arg_type.items) - 1)
+                    callee_arg_kinds = [nodes.ARG_STAR] + [nodes.ARG_POS] * (
+                        len(orig_callee_arg_type.items) - 1
+                    )
                     expanded_tuple = True
 
             if not expanded_tuple:
@@ -2059,7 +2063,9 @@ def check_argument_types(
             assert len(callee_arg_types) == len(actual_types)
             assert len(callee_arg_types) == len(actual_kinds)
             assert len(callee_arg_types) == len(callee_arg_kinds)
-            for actual, actual_type, actual_kind, callee_arg_type, callee_arg_kind in zip(actuals, actual_types, actual_kinds, callee_arg_types, callee_arg_kinds):
+            for actual, actual_type, actual_kind, callee_arg_type, callee_arg_kind in zip(
+                actuals, actual_types, actual_kinds, callee_arg_types, callee_arg_kinds
+            ):
                 if actual_type is None:
                     continue  # Some kind of error was already reported.
                 # Check that a *arg is valid as varargs.

mypy/constraints.py

@@ -135,9 +135,7 @@ def infer_constraints_for_callable(
 
             unpacked_type = get_proper_type(unpack_type.type)
             if isinstance(unpacked_type, TypeVarTupleType):
-                constraints.append(
-                    Constraint(unpacked_type, SUPERTYPE_OF, TypeList(actual_types))
-                )
+                constraints.append(Constraint(unpacked_type, SUPERTYPE_OF, TypeList(actual_types)))
             elif isinstance(unpacked_type, TupleType):
                 # Prefixes get converted to positional args, so technically the only case we
                 # should have here is like Tuple[Unpack[Ts], Y1, Y2, Y3]. If this turns out

mypy/typevartuples.py

@@ -4,8 +4,8 @@
 
 from typing import Sequence, TypeVar
 
-from mypy.types import Instance, ProperType, Type, UnpackType, get_proper_type, CallableType
-from mypy.nodes import ARG_STAR, ARG_POS
+from mypy.nodes import ARG_POS, ARG_STAR
+from mypy.types import CallableType, Instance, ProperType, Type, UnpackType, get_proper_type
 
 
 def find_unpack_in_list(items: Sequence[Type]) -> int | None:
@@ -155,24 +155,16 @@ def extract_unpack(types: Sequence[Type]) -> ProperType | None:
 
 def replace_starargs(callable: CallableType, types: list[Type]) -> CallableType:
     star_index = callable.arg_kinds.index(ARG_STAR)
-    arg_kinds = (                      
+    arg_kinds = (
         callable.arg_kinds[:star_index]
-        + [ARG_POS] * len(types)           
+        + [ARG_POS] * len(types)
         + callable.arg_kinds[star_index + 1 :]
     )
     arg_names = (
         callable.arg_names[:star_index]
         + [None] * len(types)
         + callable.arg_names[star_index + 1 :]
     )
-    arg_types = (
-        callable.arg_types[:star_index]
-        + types
-        + callable.arg_types[star_index + 1 :]
-    )
+    arg_types = callable.arg_types[:star_index] + types + callable.arg_types[star_index + 1 :]
 
-    return callable.copy_modified(
-        arg_types=arg_types,
-        arg_names=arg_names,
-        arg_kinds=arg_kinds,
-    )
+    return callable.copy_modified(arg_types=arg_types, arg_names=arg_names, arg_kinds=arg_kinds)