jaclang 0.6.1__py3-none-any.whl → 0.6.5__py3-none-any.whl

jaclang/vendor/mypy/stubutil.py

@@ -17,19 +17,31 @@ import mypy.options
 from mypy.modulefinder import ModuleNotFoundReason
 from mypy.moduleinspect import InspectError, ModuleInspect
 from mypy.stubdoc import ArgSig, FunctionSig
-from mypy.types import (
-    AnyType,
-    NoneType,
-    Type,
-    TypeList,
-    TypeStrVisitor,
-    UnboundType,
-    UnionType,
-)
+from mypy.types import AnyType, NoneType, Type, TypeList, TypeStrVisitor, UnboundType, UnionType
 
 # Modules that may fail when imported, or that may have side effects (fully qualified).
 NOT_IMPORTABLE_MODULES = ()
 
+# Typing constructs to be replaced by their builtin equivalents.
+TYPING_BUILTIN_REPLACEMENTS: Final = {
+    # From typing
+    "typing.Text": "builtins.str",
+    "typing.Tuple": "builtins.tuple",
+    "typing.List": "builtins.list",
+    "typing.Dict": "builtins.dict",
+    "typing.Set": "builtins.set",
+    "typing.FrozenSet": "builtins.frozenset",
+    "typing.Type": "builtins.type",
+    # From typing_extensions
+    "typing_extensions.Text": "builtins.str",
+    "typing_extensions.Tuple": "builtins.tuple",
+    "typing_extensions.List": "builtins.list",
+    "typing_extensions.Dict": "builtins.dict",
+    "typing_extensions.Set": "builtins.set",
+    "typing_extensions.FrozenSet": "builtins.frozenset",
+    "typing_extensions.Type": "builtins.type",
+}
+
 
 class CantImport(Exception):
     def __init__(self, module: str, message: str) -> None:
@@ -177,9 +189,7 @@ def remove_misplaced_type_comments(source: str | bytes) -> str | bytes:
     text = re.sub(r"''' *\n[ \t\n]*# +type: +\(.*$", "'''\n", text, flags=re.MULTILINE)
 
     # Remove something that looks like a badly formed function type comment.
-    text = re.sub(
-        r"^[ \t]*# +type: +\([^()]+(\)[ \t]*)?$", "", text, flags=re.MULTILINE
-    )
+    text = re.sub(r"^[ \t]*# +type: +\([^()]+(\)[ \t]*)?$", "", text, flags=re.MULTILINE)
 
     if isinstance(source, bytes):
         return text.encode("latin1")
@@ -239,12 +249,12 @@ class AnnotationPrinter(TypeStrVisitor):
             return " | ".join([item.accept(self) for item in t.args])
         if fullname == "typing.Optional":
             return f"{t.args[0].accept(self)} | None"
+        if fullname in TYPING_BUILTIN_REPLACEMENTS:
+            s = self.stubgen.add_name(TYPING_BUILTIN_REPLACEMENTS[fullname], require=True)
         if self.known_modules is not None and "." in s:
             # see if this object is from any of the modules that we're currently processing.
             # reverse sort so that subpackages come before parents: e.g. "foo.bar" before "foo".
-            for module_name in self.local_modules + sorted(
-                self.known_modules, reverse=True
-            ):
+            for module_name in self.local_modules + sorted(self.known_modules, reverse=True):
                 if s.startswith(module_name + "."):
                     if module_name in self.local_modules:
                         s = s[len(module_name) + 1 :]
@@ -262,6 +272,8 @@ class AnnotationPrinter(TypeStrVisitor):
             self.stubgen.import_tracker.require_name(s)
         if t.args:
             s += f"[{self.args_str(t.args)}]"
+        elif t.empty_tuple_index:
+            s += "[()]"
         return s
 
     def visit_none_type(self, t: NoneType) -> str:
@@ -292,11 +304,7 @@ class AnnotationPrinter(TypeStrVisitor):
 
 class ClassInfo:
     def __init__(
-        self,
-        name: str,
-        self_var: str,
-        docstring: str | None = None,
-        cls: type | None = None,
+        self, name: str, self_var: str, docstring: str | None = None, cls: type | None = None
     ) -> None:
         self.name = name
         self.self_var = self_var
@@ -324,9 +332,7 @@ class FunctionContext:
     def fullname(self) -> str:
         if self._fullname is None:
             if self.class_info:
-                self._fullname = (
-                    f"{self.module_name}.{self.class_info.name}.{self.name}"
-                )
+                self._fullname = f"{self.module_name}.{self.class_info.name}.{self.name}"
             else:
                 self._fullname = f"{self.module_name}.{self.name}"
         return self._fullname
@@ -341,16 +347,7 @@ def infer_method_ret_type(name: str) -> str | None:
         # Note: __eq__ and co may return arbitrary types, but bool is good enough for stubgen.
         elif name in ("eq", "ne", "lt", "le", "gt", "ge", "contains"):
             return "bool"
-        elif name in (
-            "len",
-            "length_hint",
-            "index",
-            "hash",
-            "sizeof",
-            "trunc",
-            "floor",
-            "ceil",
-        ):
+        elif name in ("len", "length_hint", "index", "hash", "sizeof", "trunc", "floor", "ceil"):
             return "int"
         elif name in ("format", "repr"):
             return "str"
@@ -414,9 +411,7 @@ class SignatureGenerator:
         pass
 
     @abstractmethod
-    def get_property_type(
-        self, default_type: str | None, ctx: FunctionContext
-    ) -> str | None:
+    def get_property_type(self, default_type: str | None, ctx: FunctionContext) -> str | None:
         """Return the type of the given property"""
         pass
 
@@ -466,9 +461,7 @@ class ImportTracker:
                 self.require_name(alias or name)
             self.direct_imports.pop(alias or name, None)
 
-    def add_import(
-        self, module: str, alias: str | None = None, require: bool = False
-    ) -> None:
+    def add_import(self, module: str, alias: str | None = None, require: bool = False) -> None:
         if alias:
             # 'import {module} as {alias}'
             assert "." not in alias  # invalid syntax
@@ -505,7 +498,7 @@ class ImportTracker:
     def import_lines(self) -> list[str]:
         """The list of required import lines (as strings with python code).
 
-        In order for a module be included in this output, an indentifier must be both
+        In order for a module be included in this output, an identifier must be both
         'required' via require_name() and 'imported' via add_import_from()
         or add_import()
         """
@@ -518,9 +511,7 @@ class ImportTracker:
 
         for name in sorted(
             self.required_names,
-            key=lambda n: (
-                (self.reverse_alias[n], n) if n in self.reverse_alias else (n, "")
-            ),
+            key=lambda n: (self.reverse_alias[n], n) if n in self.reverse_alias else (n, ""),
         ):
             # If we haven't seen this name in an import statement, ignore it
             if name not in self.module_for:
@@ -542,9 +533,7 @@ class ImportTracker:
                     source = self.reverse_alias[name]
                     result.append(f"import {source} as {name}\n")
                 elif name in self.reexports:
-                    assert (
-                        "." not in name
-                    )  # Because reexports only has nonqualified names
+                    assert "." not in name  # Because reexports only has nonqualified names
                     result.append(f"import {name} as {name}\n")
                 else:
                     result.append(f"import {name}\n")
@@ -618,9 +607,9 @@ class BaseStubGenerator:
         # a corresponding import statement.
         self.known_imports = {
             "_typeshed": ["Incomplete"],
-            "typing": ["Any", "TypeVar", "NamedTuple"],
+            "typing": ["Any", "TypeVar", "NamedTuple", "TypedDict"],
             "collections.abc": ["Generator"],
-            "typing_extensions": ["TypedDict", "ParamSpec", "TypeVarTuple"],
+            "typing_extensions": ["ParamSpec", "TypeVarTuple"],
         }
 
     def get_sig_generators(self) -> list[SignatureGenerator]:
@@ -632,17 +621,11 @@ class BaseStubGenerator:
             real_module = self.import_tracker.module_for.get(name)
             real_short = self.import_tracker.reverse_alias.get(name, name)
             if real_module is None and real_short not in self.defined_names:
-                real_module = (
-                    "builtins"  # not imported and not defined, must be a builtin
-                )
+                real_module = "builtins"  # not imported and not defined, must be a builtin
         else:
             name_module, real_short = name.split(".", 1)
-            real_module = self.import_tracker.reverse_alias.get(
-                name_module, name_module
-            )
-        resolved_name = (
-            real_short if real_module is None else f"{real_module}.{real_short}"
-        )
+            real_module = self.import_tracker.reverse_alias.get(name_module, name_module)
+        resolved_name = real_short if real_module is None else f"{real_module}.{real_short}"
         return resolved_name
 
     def add_name(self, fullname: str, require: bool = True) -> str:
@@ -652,7 +635,10 @@ class BaseStubGenerator:
         """
         module, name = fullname.rsplit(".", 1)
         alias = "_" + name if name in self.defined_names else None
-        self.import_tracker.add_import_from(module, [(name, alias)], require=require)
+        while alias in self.defined_names:
+            alias = "_" + alias
+        if module != "builtins" or alias:  # don't import from builtins unless needed
+            self.import_tracker.add_import_from(module, [(name, alias)], require=require)
         return alias or name
 
     def add_import_line(self, line: str) -> None:
@@ -730,9 +716,7 @@ class BaseStubGenerator:
                 self.add_name(f"{pkg}.{t}", require=False)
 
     def check_undefined_names(self) -> None:
-        undefined_names = [
-            name for name in self._all_ or [] if name not in self._toplevel_names
-        ]
+        undefined_names = [name for name in self._all_ or [] if name not in self._toplevel_names]
         if undefined_names:
             if self._output:
                 self.add("\n")

jaclang/vendor/mypy/subtypes.py

@@ -74,9 +74,7 @@ IS_CLASSVAR: Final = 2
 IS_CLASS_OR_STATIC: Final = 3
 IS_VAR: Final = 4
 
-TypeParameterChecker: _TypeAlias = Callable[
-    [Type, Type, int, bool, "SubtypeContext"], bool
-]
+TypeParameterChecker: _TypeAlias = Callable[[Type, Type, int, bool, "SubtypeContext"], bool]
 
 
 class SubtypeContext:
@@ -253,10 +251,7 @@ def is_equivalent(
 
 
 def is_same_type(
-    a: Type,
-    b: Type,
-    ignore_promotions: bool = True,
-    subtype_context: SubtypeContext | None = None,
+    a: Type, b: Type, ignore_promotions: bool = True, subtype_context: SubtypeContext | None = None
 ) -> bool:
     """Are these types proper subtypes of each other?
 
@@ -332,9 +327,7 @@ def _is_subtype(
             and isinstance(left, Instance)
             and (left.type.is_enum or left.type.fullname == "builtins.bool")
         ):
-            right = UnionType(
-                mypy.typeops.try_contracting_literals_in_union(right.items)
-            )
+            right = UnionType(mypy.typeops.try_contracting_literals_in_union(right.items))
             if proper_subtype:
                 is_subtype_of_item = any(
                     is_proper_subtype(orig_left, item, subtype_context=subtype_context)
@@ -360,11 +353,7 @@ def _is_subtype(
 
 
 def check_type_parameter(
-    left: Type,
-    right: Type,
-    variance: int,
-    proper_subtype: bool,
-    subtype_context: SubtypeContext,
+    left: Type, right: Type, variance: int, proper_subtype: bool, subtype_context: SubtypeContext
 ) -> bool:
     # It is safe to consider empty collection literals and similar as covariant, since
     # such type can't be stored in a variable, see checker.is_valid_inferred_type().
@@ -395,22 +384,16 @@ def check_type_parameter(
 
 
 class SubtypeVisitor(TypeVisitor[bool]):
-    def __init__(
-        self, right: Type, subtype_context: SubtypeContext, proper_subtype: bool
-    ) -> None:
+    def __init__(self, right: Type, subtype_context: SubtypeContext, proper_subtype: bool) -> None:
         self.right = get_proper_type(right)
         self.orig_right = right
         self.proper_subtype = proper_subtype
         self.subtype_context = subtype_context
         self.options = subtype_context.options
-        self._subtype_kind = SubtypeVisitor.build_subtype_kind(
-            subtype_context, proper_subtype
-        )
+        self._subtype_kind = SubtypeVisitor.build_subtype_kind(subtype_context, proper_subtype)
 
     @staticmethod
-    def build_subtype_kind(
-        subtype_context: SubtypeContext, proper_subtype: bool
-    ) -> SubtypeKind:
+    def build_subtype_kind(subtype_context: SubtypeContext, proper_subtype: bool) -> SubtypeKind:
         return (
             state.strict_optional,
             proper_subtype,
@@ -449,9 +432,7 @@ class SubtypeVisitor(TypeVisitor[bool]):
                 # None is compatible with Hashable (and other similar protocols). This is
                 # slightly sloppy since we don't check the signature of "__hash__".
                 # None is also compatible with `SupportsStr` protocol.
-                return not members or all(
-                    member in ("__hash__", "__str__") for member in members
-                )
+                return not members or all(member in ("__hash__", "__str__") for member in members)
             return False
         else:
             return True
@@ -495,18 +476,14 @@ class SubtypeVisitor(TypeVisitor[bool]):
                 if not self.proper_subtype:
                     # Special case to consider Foo[*tuple[Any, ...]] (i.e. bare Foo) a
                     # subtype of Foo[<whatever>], when Foo is user defined variadic tuple type.
-                    mapped = map_instance_to_supertype(
-                        left, right.partial_fallback.type
-                    )
+                    mapped = map_instance_to_supertype(left, right.partial_fallback.type)
                     for arg in map(get_proper_type, mapped.args):
                         if isinstance(arg, UnpackType):
                             unpacked = get_proper_type(arg.type)
                             if not isinstance(unpacked, Instance):
                                 break
                             assert unpacked.type.fullname == "builtins.tuple"
-                            if not isinstance(
-                                get_proper_type(unpacked.args[0]), AnyType
-                            ):
+                            if not isinstance(get_proper_type(unpacked.args[0]), AnyType):
                                 break
                         elif not isinstance(arg, AnyType):
                             break
@@ -522,18 +499,14 @@ class SubtypeVisitor(TypeVisitor[bool]):
         if isinstance(right, Instance):
             if type_state.is_cached_subtype_check(self._subtype_kind, left, right):
                 return True
-            if type_state.is_cached_negative_subtype_check(
-                self._subtype_kind, left, right
-            ):
+            if type_state.is_cached_negative_subtype_check(self._subtype_kind, left, right):
                 return False
             if not self.subtype_context.ignore_promotions:
                 for base in left.type.mro:
                     if base._promote and any(
                         self._is_subtype(p, self.right) for p in base._promote
                     ):
-                        type_state.record_subtype_cache_entry(
-                            self._subtype_kind, left, right
-                        )
+                        type_state.record_subtype_cache_entry(self._subtype_kind, left, right)
                         return True
                 # Special case: Low-level integer types are compatible with 'int'. We can't
                 # use promotions, since 'int' is already promoted to low-level integer types,
@@ -571,25 +544,17 @@ class SubtypeVisitor(TypeVisitor[bool]):
                     tvt = right.type.defn.type_vars[prefix]
                     assert isinstance(tvt, TypeVarTupleType)
                     fallback = tvt.tuple_fallback
-                    (
-                        left_prefix,
-                        left_middle,
-                        left_suffix,
-                    ) = split_with_prefix_and_suffix(t.args, prefix, suffix)
-                    (
-                        right_prefix,
-                        right_middle,
-                        right_suffix,
-                    ) = split_with_prefix_and_suffix(right.args, prefix, suffix)
+                    left_prefix, left_middle, left_suffix = split_with_prefix_and_suffix(
+                        t.args, prefix, suffix
+                    )
+                    right_prefix, right_middle, right_suffix = split_with_prefix_and_suffix(
+                        right.args, prefix, suffix
+                    )
                     left_args = (
-                        left_prefix
-                        + (TupleType(list(left_middle), fallback),)
-                        + left_suffix
+                        left_prefix + (TupleType(list(left_middle), fallback),) + left_suffix
                     )
                     right_args = (
-                        right_prefix
-                        + (TupleType(list(right_middle), fallback),)
-                        + right_suffix
+                        right_prefix + (TupleType(list(right_middle), fallback),) + right_suffix
                     )
                     if not self.proper_subtype and t.args:
                         for arg in map(get_proper_type, t.args):
@@ -598,9 +563,7 @@ class SubtypeVisitor(TypeVisitor[bool]):
                                 if not isinstance(unpacked, Instance):
                                     break
                                 assert unpacked.type.fullname == "builtins.tuple"
-                                if not isinstance(
-                                    get_proper_type(unpacked.args[0]), AnyType
-                                ):
+                                if not isinstance(get_proper_type(unpacked.args[0]), AnyType):
                                     break
                             elif not isinstance(arg, AnyType):
                                 break
@@ -625,21 +588,13 @@ class SubtypeVisitor(TypeVisitor[bool]):
                         else:
                             # TODO: everywhere else ParamSpecs are handled as invariant.
                             if not check_type_parameter(
-                                lefta,
-                                righta,
-                                COVARIANT,
-                                self.proper_subtype,
-                                self.subtype_context,
+                                lefta, righta, COVARIANT, self.proper_subtype, self.subtype_context
                             ):
                                 nominal = False
                 if nominal:
-                    type_state.record_subtype_cache_entry(
-                        self._subtype_kind, left, right
-                    )
+                    type_state.record_subtype_cache_entry(self._subtype_kind, left, right)
                 else:
-                    type_state.record_negative_subtype_cache_entry(
-                        self._subtype_kind, left, right
-                    )
+                    type_state.record_negative_subtype_cache_entry(self._subtype_kind, left, right)
                 return nominal
             if right.type.is_protocol and is_protocol_implementation(
                 left, right, proper_subtype=self.proper_subtype, options=self.options
@@ -648,9 +603,7 @@ class SubtypeVisitor(TypeVisitor[bool]):
             # We record negative cache entry here, and not in the protocol check like we do for
             # positive cache, to avoid accidentally adding a type that is not a structural
             # subtype, but is a nominal subtype (involving type: ignore override).
-            type_state.record_negative_subtype_cache_entry(
-                self._subtype_kind, left, right
-            )
+            type_state.record_negative_subtype_cache_entry(self._subtype_kind, left, right)
             return False
         if isinstance(right, TypeType):
             item = right.item
@@ -659,9 +612,7 @@ class SubtypeVisitor(TypeVisitor[bool]):
             # TODO: this is a bit arbitrary, we should only skip Any-related cases.
             if not self.proper_subtype:
                 if is_named_instance(left, "builtins.type"):
-                    return self._is_subtype(
-                        TypeType(AnyType(TypeOfAny.special_form)), right
-                    )
+                    return self._is_subtype(TypeType(AnyType(TypeOfAny.special_form)), right)
                 if left.type.is_metaclass():
                     if isinstance(item, AnyType):
                         return True
@@ -709,10 +660,7 @@ class SubtypeVisitor(TypeVisitor[bool]):
         # Instead callers (upper level types) should handle it when it appears in type list.
         if isinstance(self.right, UnpackType):
             return self._is_subtype(left.type, self.right.type)
-        if (
-            isinstance(self.right, Instance)
-            and self.right.type.fullname == "builtins.object"
-        ):
+        if isinstance(self.right, Instance) and self.right.type.fullname == "builtins.object":
             return True
         return False
 
@@ -735,10 +683,23 @@ class SubtypeVisitor(TypeVisitor[bool]):
             if left.type_guard is not None and right.type_guard is not None:
                 if not self._is_subtype(left.type_guard, right.type_guard):
                     return False
+            elif left.type_is is not None and right.type_is is not None:
+                # For TypeIs we have to check both ways; it is unsafe to pass
+                # a TypeIs[Child] when a TypeIs[Parent] is expected, because
+                # if the narrower returns False, we assume that the narrowed value is
+                # *not* a Parent.
+                if not self._is_subtype(left.type_is, right.type_is) or not self._is_subtype(
+                    right.type_is, left.type_is
+                ):
+                    return False
             elif right.type_guard is not None and left.type_guard is None:
                 # This means that one function has `TypeGuard` and other does not.
                 # They are not compatible. See https://github.com/python/mypy/issues/11307
                 return False
+            elif right.type_is is not None and left.type_is is None:
+                # Similarly, if one function has `TypeIs` and the other does not,
+                # they are not compatible.
+                return False
             return is_callable_compatible(
                 left,
                 right,
@@ -762,9 +723,7 @@ class SubtypeVisitor(TypeVisitor[bool]):
                 if self._is_subtype(left, call):
                     if len(right.type.protocol_members) == 1:
                         return True
-                    if is_protocol_implementation(
-                        left.fallback, right, skip=["__call__"]
-                    ):
+                    if is_protocol_implementation(left.fallback, right, skip=["__call__"]):
                         return True
             if right.type.is_protocol and left.is_type_obj():
                 ret_type = get_proper_type(left.ret_type)
@@ -872,13 +831,11 @@ class SubtypeVisitor(TypeVisitor[bool]):
                 tuple(left.items), right_prefix, right_suffix
             )
             if not all(
-                self._is_subtype(li, ri)
-                for li, ri in zip(prefix, right.items[:right_prefix])
+                self._is_subtype(li, ri) for li, ri in zip(prefix, right.items[:right_prefix])
             ):
                 return False
             if right_suffix and not all(
-                self._is_subtype(li, ri)
-                for li, ri in zip(suffix, right.items[-right_suffix:])
+                self._is_subtype(li, ri) for li, ri in zip(suffix, right.items[-right_suffix:])
             ):
                 return False
             return all(self._is_subtype(li, right_item) for li in middle)
@@ -966,9 +923,7 @@ class SubtypeVisitor(TypeVisitor[bool]):
                 if self._is_subtype(left, call):
                     if len(right.type.protocol_members) == 1:
                         return True
-                    if is_protocol_implementation(
-                        left.fallback, right, skip=["__call__"]
-                    ):
+                    if is_protocol_implementation(left.fallback, right, skip=["__call__"]):
                         return True
             return self._is_subtype(left.fallback, right)
         elif isinstance(right, CallableType):
@@ -1002,10 +957,7 @@ class SubtypeVisitor(TypeVisitor[bool]):
                         # If this one overlaps with the supertype in any way, but it wasn't
                         # an exact match, then it's a potential error.
                         strict_concat = (
-                            (
-                                self.options.extra_checks
-                                or self.options.strict_concatenate
-                            )
+                            (self.options.extra_checks or self.options.strict_concatenate)
                             if self.options
                             else False
                         )
@@ -1097,9 +1049,7 @@ class SubtypeVisitor(TypeVisitor[bool]):
             # We can still recover from this.
             # https://github.com/python/mypy/issues/11105
             return self.visit_none_type(NoneType())
-        raise RuntimeError(
-            f'Partial type "{left}" cannot be checked with "issubtype()"'
-        )
+        raise RuntimeError(f'Partial type "{left}" cannot be checked with "issubtype()"')
 
     def visit_type_type(self, left: TypeType) -> bool:
         right = self.right
@@ -1218,10 +1168,7 @@ def is_protocol_implementation(
                 # NOTE: If we ever change this, be sure to also change the call to
                 # SubtypeVisitor.build_subtype_kind(...) down below.
                 is_compat = is_subtype(
-                    subtype,
-                    supertype,
-                    ignore_pos_arg_names=ignore_names,
-                    options=options,
+                    subtype, supertype, ignore_pos_arg_names=ignore_names, options=options
                 )
             else:
                 is_compat = is_proper_subtype(subtype, supertype)
@@ -1269,11 +1216,7 @@ def is_protocol_implementation(
 
 
 def find_member(
-    name: str,
-    itype: Instance,
-    subtype: Type,
-    is_operator: bool = False,
-    class_obj: bool = False,
+    name: str, itype: Instance, subtype: Type, is_operator: bool = False, class_obj: bool = False
 ) -> Type | None:
     """Find the type of member by 'name' in 'itype's TypeInfo.
 
@@ -1314,13 +1257,9 @@ def find_member(
                 method = info.get_method(method_name)
                 if method and method.info.fullname != "builtins.object":
                     if isinstance(method, Decorator):
-                        getattr_type = get_proper_type(
-                            find_node_type(method.var, itype, subtype)
-                        )
+                        getattr_type = get_proper_type(find_node_type(method.var, itype, subtype))
                     else:
-                        getattr_type = get_proper_type(
-                            find_node_type(method, itype, subtype)
-                        )
+                        getattr_type = get_proper_type(find_node_type(method, itype, subtype))
                     if isinstance(getattr_type, CallableType):
                         return getattr_type.ret_type
                     return getattr_type
@@ -1423,9 +1362,7 @@ def find_node_type(
             signature = p_typ
         else:
             signature = bind_self(
-                p_typ,
-                subtype,
-                is_classmethod=isinstance(node, Var) and node.is_classmethod,
+                p_typ, subtype, is_classmethod=isinstance(node, Var) and node.is_classmethod
             )
         if node.is_property and not class_obj:
             assert isinstance(signature, CallableType)
@@ -1709,9 +1646,7 @@ def are_parameters_compatible(
     #           Furthermore, if we're checking for compatibility in all cases,
     #           we confirm that if R accepts an infinite number of arguments,
     #           L must accept the same.
-    def _incompatible(
-        left_arg: FormalArgument | None, right_arg: FormalArgument | None
-    ) -> bool:
+    def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | None) -> bool:
         if right_arg is None:
             return False
         if left_arg is None:
@@ -1813,9 +1748,7 @@ def are_parameters_compatible(
         )
 
         right_by_pos = (
-            right.argument_by_position(left_arg.pos)
-            if left_arg.pos is not None
-            else None
+            right.argument_by_position(left_arg.pos) if left_arg.pos is not None else None
         )
 
         # If the left hand argument corresponds to two right-hand arguments,
@@ -1891,9 +1824,7 @@ def are_args_compatible(
     return is_compat(right.typ, left.typ)
 
 
-def flip_compat_check(
-    is_compat: Callable[[Type, Type], bool]
-) -> Callable[[Type, Type], bool]:
+def flip_compat_check(is_compat: Callable[[Type, Type], bool]) -> Callable[[Type, Type], bool]:
     def new_is_compat(left: Type, right: Type) -> bool:
         return is_compat(right, left)
 
@@ -1934,9 +1865,7 @@ def unify_generic_callable(
         constraints.extend(c)
     if no_unify_none:
         constraints = [
-            c
-            for c in constraints
-            if not isinstance(get_proper_type(c.target), NoneType)
+            c for c in constraints if not isinstance(get_proper_type(c.target), NoneType)
         ]
     inferred_vars, _ = mypy.solve.solve_constraints(type.variables, constraints)
     if None in inferred_vars:
@@ -1997,10 +1926,7 @@ def restrict_subtype_away(t: Type, s: Type) -> Type:
             new_items = [
                 restrict_subtype_away(item, s)
                 for item in p_t.relevant_items()
-                if (
-                    isinstance(get_proper_type(item), AnyType)
-                    or not covers_at_runtime(item, s)
-                )
+                if (isinstance(get_proper_type(item), AnyType) or not covers_at_runtime(item, s))
             ]
         return UnionType.make_union(new_items)
     elif covers_at_runtime(t, s):
@@ -2040,9 +1966,7 @@ def covers_at_runtime(item: Type, supertype: Type) -> bool:
     return False
 
 
-def is_more_precise(
-    left: Type, right: Type, *, ignore_promotions: bool = False
-) -> bool:
+def is_more_precise(left: Type, right: Type, *, ignore_promotions: bool = False) -> bool:
     """Check if left is a more precise type than right.
 
     A left is a proper subtype of right, left is also more precise than