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

jaclang/vendor/mypy/semanal_typeargs.py

@@ -88,9 +88,7 @@ class TypeArgumentAnalyzer(MixedTraverserVisitor):
             return
         self.seen_aliases.add(t)
         assert t.alias is not None, f"Unfixed type alias {t.type_ref}"
-        is_error = self.validate_args(
-            t.alias.name, tuple(t.args), t.alias.alias_tvars, t
-        )
+        is_error = self.validate_args(t.alias.name, tuple(t.args), t.alias.alias_tvars, t)
         if not is_error:
             # If there was already an error for the alias itself, there is no point in checking
             # the expansion, most likely it will result in the same kind of error.
@@ -133,16 +131,10 @@ class TypeArgumentAnalyzer(MixedTraverserVisitor):
                     t.args = unpacked.args
 
     def validate_args(
-        self,
-        name: str,
-        args: tuple[Type, ...],
-        type_vars: list[TypeVarLikeType],
-        ctx: Context,
+        self, name: str, args: tuple[Type, ...], type_vars: list[TypeVarLikeType], ctx: Context
     ) -> bool:
         if any(isinstance(v, TypeVarTupleType) for v in type_vars):
-            prefix = next(
-                i for (i, v) in enumerate(type_vars) if isinstance(v, TypeVarTupleType)
-            )
+            prefix = next(i for (i, v) in enumerate(type_vars) if isinstance(v, TypeVarTupleType))
             tvt = type_vars[prefix]
             assert isinstance(tvt, TypeVarTupleType)
             start, middle, end = split_with_prefix_and_suffix(
@@ -173,18 +165,14 @@ class TypeArgumentAnalyzer(MixedTraverserVisitor):
                         if not arg_values:
                             is_error = True
                             self.fail(
-                                message_registry.INVALID_TYPEVAR_AS_TYPEARG.format(
-                                    arg.name, name
-                                ),
+                                message_registry.INVALID_TYPEVAR_AS_TYPEARG.format(arg.name, name),
                                 ctx,
                                 code=codes.TYPE_VAR,
                             )
                             continue
                     else:
                         arg_values = [arg]
-                    if self.check_type_var_values(
-                        name, arg_values, tvar.name, tvar.values, ctx
-                    ):
+                    if self.check_type_var_values(name, arg_values, tvar.name, tvar.values, ctx):
                         is_error = True
                 # Check against upper bound. Since it's object the vast majority of the time,
                 # add fast path to avoid a potentially slow subtype check.
@@ -210,8 +198,7 @@ class TypeArgumentAnalyzer(MixedTraverserVisitor):
                     )
             elif isinstance(tvar, ParamSpecType):
                 if not isinstance(
-                    get_proper_type(arg),
-                    (ParamSpecType, Parameters, AnyType, UnboundType),
+                    get_proper_type(arg), (ParamSpecType, Parameters, AnyType, UnboundType)
                 ):
                     self.fail(
                         "Can only replace ParamSpec with a parameter types list or"
@@ -229,30 +216,20 @@ class TypeArgumentAnalyzer(MixedTraverserVisitor):
             return
         # TODO: this should probably be .has_base("builtins.tuple"), also elsewhere. This is
         # tricky however, since this needs map_instance_to_supertype() available in many places.
-        if (
-            isinstance(proper_type, Instance)
-            and proper_type.type.fullname == "builtins.tuple"
-        ):
+        if isinstance(proper_type, Instance) and proper_type.type.fullname == "builtins.tuple":
             return
         if not isinstance(proper_type, (UnboundType, AnyType)):
             # Avoid extra errors if there were some errors already. Also interpret plain Any
             # as tuple[Any, ...] (this is better for the code in type checker).
             self.fail(
-                message_registry.INVALID_UNPACK.format(
-                    format_type(proper_type, self.options)
-                ),
+                message_registry.INVALID_UNPACK.format(format_type(proper_type, self.options)),
                 typ.type,
                 code=codes.VALID_TYPE,
             )
         typ.type = self.named_type("builtins.tuple", [AnyType(TypeOfAny.from_error)])
 
     def check_type_var_values(
-        self,
-        name: str,
-        actuals: list[Type],
-        arg_name: str,
-        valids: list[Type],
-        context: Context,
+        self, name: str, actuals: list[Type], arg_name: str, valids: list[Type], context: Context
     ) -> bool:
         is_error = False
         for actual in get_proper_types(actuals):
@@ -281,14 +258,8 @@ class TypeArgumentAnalyzer(MixedTraverserVisitor):
                     )
         return is_error
 
-    def fail(
-        self, msg: str, context: Context, *, code: ErrorCode | None = None
-    ) -> None:
+    def fail(self, msg: str, context: Context, *, code: ErrorCode | None = None) -> None:
         self.errors.report(context.line, context.column, msg, code=code)
 
-    def note(
-        self, msg: str, context: Context, *, code: ErrorCode | None = None
-    ) -> None:
-        self.errors.report(
-            context.line, context.column, msg, severity="note", code=code
-        )
+    def note(self, msg: str, context: Context, *, code: ErrorCode | None = None) -> None:
+        self.errors.report(context.line, context.column, msg, severity="note", code=code)

jaclang/vendor/mypy/semanal_typeddict.py

@@ -62,9 +62,7 @@ class TypedDictAnalyzer:
         self.api = api
         self.msg = msg
 
-    def analyze_typeddict_classdef(
-        self, defn: ClassDef
-    ) -> tuple[bool, TypeInfo | None]:
+    def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | None]:
         """Analyze a class that may define a TypedDict.
 
         Assume that base classes have been analyzed already.
@@ -91,9 +89,7 @@ class TypedDictAnalyzer:
                     possible = True
                     if isinstance(base_expr.node, TypeInfo) and base_expr.node.is_final:
                         err = message_registry.CANNOT_INHERIT_FROM_FINAL
-                        self.fail(
-                            err.format(base_expr.node.name).value, defn, code=err.code
-                        )
+                        self.fail(err.format(base_expr.node.name).value, defn, code=err.code)
         if not possible:
             return False, None
         existing_info = None
@@ -105,12 +101,7 @@ class TypedDictAnalyzer:
             and defn.base_type_exprs[0].fullname in TPDICT_NAMES
         ):
             # Building a new TypedDict
-            (
-                fields,
-                types,
-                statements,
-                required_keys,
-            ) = self.analyze_typeddict_classdef_fields(defn)
+            fields, types, statements, required_keys = self.analyze_typeddict_classdef_fields(defn)
             if fields is None:
                 return True, None  # Defer
             if self.api.is_func_scope() and "@" not in defn.name:
@@ -165,12 +156,9 @@ class TypedDictAnalyzer:
         # Iterate over bases in reverse order so that leftmost base class' keys take precedence
         for base in reversed(typeddict_bases):
             self.add_keys_and_types_from_base(base, keys, types, required_keys, defn)
-        (
-            new_keys,
-            new_types,
-            new_statements,
-            new_required_keys,
-        ) = self.analyze_typeddict_classdef_fields(defn, keys)
+        (new_keys, new_types, new_statements, new_required_keys) = (
+            self.analyze_typeddict_classdef_fields(defn, keys)
+        )
         if new_keys is None:
             return True, None  # Defer
         keys.extend(new_keys)
@@ -247,16 +235,12 @@ class TypedDictAnalyzer:
 
         for arg_expr in args:
             try:
-                type = expr_to_unanalyzed_type(
-                    arg_expr, self.options, self.api.is_stub_file
-                )
+                type = expr_to_unanalyzed_type(arg_expr, self.options, self.api.is_stub_file)
             except TypeTranslationError:
                 self.fail("Invalid TypedDict type argument", ctx)
                 return None
             analyzed = self.api.anal_type(
-                type,
-                allow_required=True,
-                allow_placeholder=not self.api.is_func_scope(),
+                type, allow_required=True, allow_placeholder=not self.api.is_func_scope()
             )
             if analyzed is None:
                 return None
@@ -264,10 +248,7 @@ class TypedDictAnalyzer:
         return base_args
 
     def map_items_to_base(
-        self,
-        valid_items: dict[str, Type],
-        tvars: list[TypeVarLikeType],
-        base_args: list[Type],
+        self, valid_items: dict[str, Type], tvars: list[TypeVarLikeType], base_args: list[Type]
     ) -> dict[str, Type]:
         """Map item types to how they would look in their base with type arguments applied.
 
@@ -322,9 +303,7 @@ class TypedDictAnalyzer:
             else:
                 name = stmt.lvalues[0].name
                 if name in (oldfields or []):
-                    self.fail(
-                        f'Overwriting TypedDict field "{name}" while extending', stmt
-                    )
+                    self.fail(f'Overwriting TypedDict field "{name}" while extending', stmt)
                 if name in fields:
                     self.fail(f'Duplicate TypedDict key "{name}"', stmt)
                     continue
@@ -344,30 +323,20 @@ class TypedDictAnalyzer:
                         return None, [], [], set()  # Need to defer
                     types.append(analyzed)
                 # ...despite possible minor failures that allow further analysis.
-                if (
-                    stmt.type is None
-                    or hasattr(stmt, "new_syntax")
-                    and not stmt.new_syntax
-                ):
+                if stmt.type is None or hasattr(stmt, "new_syntax") and not stmt.new_syntax:
                     self.fail(TPDICT_CLASS_ERROR, stmt)
                 elif not isinstance(stmt.rvalue, TempNode):
                     # x: int assigns rvalue to TempNode(AnyType())
-                    self.fail(
-                        "Right hand side values are not supported in TypedDict", stmt
-                    )
+                    self.fail("Right hand side values are not supported in TypedDict", stmt)
         total: bool | None = True
         if "total" in defn.keywords:
-            total = require_bool_literal_argument(
-                self.api, defn.keywords["total"], "total", True
-            )
+            total = require_bool_literal_argument(self.api, defn.keywords["total"], "total", True)
         if defn.keywords and defn.keywords.keys() != {"total"}:
             for_function = ' for "__init_subclass__" of "TypedDict"'
             for key in defn.keywords:
                 if key == "total":
                     continue
-                self.msg.unexpected_keyword_argument_for_function(
-                    for_function, key, defn
-                )
+                self.msg.unexpected_keyword_argument_for_function(for_function, key, defn)
         required_keys = {
             field
             for (field, t) in zip(fields, types)
@@ -443,18 +412,12 @@ class TypedDictAnalyzer:
             # Perform various validations after unwrapping.
             for t in types:
                 check_for_explicit_any(
-                    t,
-                    self.options,
-                    self.api.is_typeshed_stub_file,
-                    self.msg,
-                    context=call,
+                    t, self.options, self.api.is_typeshed_stub_file, self.msg, context=call
                 )
             if self.options.disallow_any_unimported:
                 for t in types:
                     if has_any_from_unimported_type(t):
-                        self.msg.unimported_type_becomes_any(
-                            "Type of a TypedDict key", t, call
-                        )
+                        self.msg.unimported_type_becomes_any("Type of a TypedDict key", t, call)
 
             existing_info = None
             if isinstance(node.analyzed, TypedDictExpr):
@@ -491,8 +454,7 @@ class TypedDictAnalyzer:
             return self.fail_typeddict_arg("Unexpected arguments to TypedDict()", call)
         if len(args) == 3 and call.arg_names[2] != "total":
             return self.fail_typeddict_arg(
-                f'Unexpected keyword argument "{call.arg_names[2]}" for "TypedDict"',
-                call,
+                f'Unexpected keyword argument "{call.arg_names[2]}" for "TypedDict"', call
             )
         if not isinstance(args[0], StrExpr):
             return self.fail_typeddict_arg(
@@ -592,10 +554,7 @@ class TypedDictAnalyzer:
         typeddict_type = TypedDictType(dict(zip(items, types)), required_keys, fallback)
         if info.special_alias and has_placeholder(info.special_alias.target):
             self.api.process_placeholder(
-                None,
-                "TypedDict item",
-                info,
-                force_progress=typeddict_type != info.typeddict_type,
+                None, "TypedDict item", info, force_progress=typeddict_type != info.typeddict_type
             )
         info.update_typeddict_type(typeddict_type)
         return info

jaclang/vendor/mypy/server/astdiff.py

@@ -113,9 +113,7 @@ from mypy.util import get_prefix
 # For example, the snapshot of the 'int' type is ('Instance', 'builtins.int', ()).
 
 # Type snapshots are strict, they must be hashable and ordered (e.g. for Unions).
-Primitive: _TypeAlias = Union[
-    str, float, int, bool
-]  # float is for Literal[3.14] support.
+Primitive: _TypeAlias = Union[str, float, int, bool]  # float is for Literal[3.14] support.
 SnapshotItem: _TypeAlias = Tuple[Union[Primitive, "SnapshotItem"], ...]
 
 # Symbol snapshots can be more lenient.
@@ -123,9 +121,7 @@ SymbolSnapshot: _TypeAlias = Tuple[object, ...]
 
 
 def compare_symbol_table_snapshots(
-    name_prefix: str,
-    snapshot1: dict[str, SymbolSnapshot],
-    snapshot2: dict[str, SymbolSnapshot],
+    name_prefix: str, snapshot1: dict[str, SymbolSnapshot], snapshot2: dict[str, SymbolSnapshot]
 ) -> set[str]:
     """Return names that are different in two snapshots of a symbol table.
 
@@ -167,9 +163,7 @@ def compare_symbol_table_snapshots(
     return triggers
 
 
-def snapshot_symbol_table(
-    name_prefix: str, table: SymbolTable
-) -> dict[str, SymbolSnapshot]:
+def snapshot_symbol_table(name_prefix: str, table: SymbolTable) -> dict[str, SymbolSnapshot]:
     """Create a snapshot description that represents the state of a symbol table.
 
     The snapshot has a representation based on nested tuples and dicts
@@ -231,9 +225,7 @@ def snapshot_symbol_table(
     return result
 
 
-def snapshot_definition(
-    node: SymbolNode | None, common: SymbolSnapshot
-) -> SymbolSnapshot:
+def snapshot_definition(node: SymbolNode | None, common: SymbolSnapshot) -> SymbolSnapshot:
     """Create a snapshot description of a symbol table node.
 
     The representation is nested tuples and dicts. Only externally
@@ -261,11 +253,7 @@ def snapshot_definition(
             node.is_static,
             signature,
             is_trivial_body,
-            (
-                dataclass_transform_spec.serialize()
-                if dataclass_transform_spec is not None
-                else None
-            ),
+            dataclass_transform_spec.serialize() if dataclass_transform_spec is not None else None,
         )
     elif isinstance(node, Var):
         return ("Var", common, snapshot_optional_type(node.type), node.is_final)
@@ -311,19 +299,12 @@ def snapshot_definition(
             tuple(snapshot_type(tdef) for tdef in node.defn.type_vars),
             [snapshot_type(base) for base in node.bases],
             [snapshot_type(p) for p in node._promote],
-            (
-                dataclass_transform_spec.serialize()
-                if dataclass_transform_spec is not None
-                else None
-            ),
+            dataclass_transform_spec.serialize() if dataclass_transform_spec is not None else None,
         )
         prefix = node.fullname
         symbol_table = snapshot_symbol_table(prefix, node.names)
         # Special dependency for abstract attribute handling.
-        symbol_table["(abstract)"] = (
-            "Abstract",
-            tuple(sorted(node.abstract_attributes)),
-        )
+        symbol_table["(abstract)"] = ("Abstract", tuple(sorted(node.abstract_attributes)))
         return ("TypeInfo", common, attrs, symbol_table)
     else:
         # Other node types are handled elsewhere.
@@ -401,11 +382,7 @@ class SnapshotTypeVisitor(TypeVisitor[SnapshotItem]):
             "Instance",
             encode_optional_str(typ.type.fullname),
             snapshot_types(typ.args),
-            (
-                ("None",)
-                if typ.last_known_value is None
-                else snapshot_type(typ.last_known_value)
-            ),
+            ("None",) if typ.last_known_value is None else snapshot_type(typ.last_known_value),
         )
 
     def visit_type_var(self, typ: TypeVarType) -> SnapshotItem:
@@ -487,9 +464,7 @@ class SnapshotTypeVisitor(TypeVisitor[SnapshotItem]):
         return ("TupleType", snapshot_types(typ.items))
 
     def visit_typeddict_type(self, typ: TypedDictType) -> SnapshotItem:
-        items = tuple(
-            (key, snapshot_type(item_type)) for key, item_type in typ.items.items()
-        )
+        items = tuple((key, snapshot_type(item_type)) for key, item_type in typ.items.items())
         required = tuple(sorted(typ.required_keys))
         return ("TypedDictType", items, required)
 

jaclang/vendor/mypy/server/astmerge.py

@@ -167,17 +167,13 @@ def replacement_map_from_symbol_table(
                 and new_node.kind == node.kind
             ):
                 replacements[new_node.node] = node.node
-                if isinstance(node.node, TypeInfo) and isinstance(
-                    new_node.node, TypeInfo
-                ):
+                if isinstance(node.node, TypeInfo) and isinstance(new_node.node, TypeInfo):
                     type_repl = replacement_map_from_symbol_table(
                         node.node.names, new_node.node.names, prefix
                     )
                     replacements.update(type_repl)
                     if node.node.special_alias and new_node.node.special_alias:
-                        replacements[new_node.node.special_alias] = (
-                            node.node.special_alias
-                        )
+                        replacements[new_node.node.special_alias] = node.node.special_alias
     return replacements
 
 

jaclang/vendor/mypy/server/deps.py

@@ -204,9 +204,7 @@ def get_dependencies_of_target(
             # functions.
             for defn in target.defs:
                 # TODO: Recurse into top-level statements and class bodies but skip functions.
-                if not isinstance(
-                    defn, (ClassDef, Decorator, FuncDef, OverloadedFuncDef)
-                ):
+                if not isinstance(defn, (ClassDef, Decorator, FuncDef, OverloadedFuncDef)):
                     defn.accept(visitor)
         elif isinstance(target, FuncBase) and target.info:
             # It's a method.
@@ -266,10 +264,7 @@ class DependencyVisitor(TraverserVisitor):
                 for base in non_trivial_bases(o.info):
                     # Base class __init__/__new__ doesn't generate a logical
                     # dependency since the override can be incompatible.
-                    if not self.use_logical_deps() or o.name not in (
-                        "__init__",
-                        "__new__",
-                    ):
+                    if not self.use_logical_deps() or o.name not in ("__init__", "__new__"):
                         self.add_dependency(make_trigger(base.fullname + "." + o.name))
             self.add_type_alias_deps(self.scope.current_target())
             super().visit_func_def(o)
@@ -296,16 +291,10 @@ class DependencyVisitor(TraverserVisitor):
                 tname: str | None = None
                 if isinstance(d, RefExpr) and d.fullname:
                     tname = d.fullname
-                if (
-                    isinstance(d, CallExpr)
-                    and isinstance(d.callee, RefExpr)
-                    and d.callee.fullname
-                ):
+                if isinstance(d, CallExpr) and isinstance(d.callee, RefExpr) and d.callee.fullname:
                     tname = d.callee.fullname
                 if tname is not None:
-                    self.add_dependency(
-                        make_trigger(tname), make_trigger(o.func.fullname)
-                    )
+                    self.add_dependency(make_trigger(tname), make_trigger(o.func.fullname))
         super().visit_decorator(o)
 
     def visit_class_def(self, o: ClassDef) -> None:
@@ -335,9 +324,7 @@ class DependencyVisitor(TraverserVisitor):
         if info.typeddict_type:
             self.add_type_dependencies(info.typeddict_type, target=make_trigger(target))
         if info.declared_metaclass:
-            self.add_type_dependencies(
-                info.declared_metaclass, target=make_trigger(target)
-            )
+            self.add_type_dependencies(info.declared_metaclass, target=make_trigger(target))
         if info.is_protocol:
             for base_info in info.mro[:-1]:
                 # We add dependencies from whole MRO to cover explicit subprotocols.
@@ -351,8 +338,7 @@ class DependencyVisitor(TraverserVisitor):
                 # In this example we add <Super[wildcard]> -> <Sub>, to invalidate Sub if
                 # a new member is added to Super.
                 self.add_dependency(
-                    make_wildcard_trigger(base_info.fullname),
-                    target=make_trigger(target),
+                    make_wildcard_trigger(base_info.fullname), target=make_trigger(target)
                 )
                 # More protocol dependencies are collected in type_state._snapshot_protocol_deps
                 # after a full run or update is finished.
@@ -426,9 +412,7 @@ class DependencyVisitor(TraverserVisitor):
         module_id, _ = correct_relative_import(
             self.scope.current_module_id(), o.relative, o.id, self.is_package_init_file
         )
-        self.add_dependency(
-            make_trigger(module_id)
-        )  # needed if module is added/removed
+        self.add_dependency(make_trigger(module_id))  # needed if module is added/removed
         for name, as_name in o.names:
             self.add_dependency(make_trigger(module_id + "." + name))
 
@@ -455,9 +439,7 @@ class DependencyVisitor(TraverserVisitor):
                 self.add_type_dependencies(val, target=make_trigger(analyzed.fullname))
             # We need to re-analyze the definition if bound or value is deleted.
             super().visit_call_expr(rvalue)
-        elif isinstance(rvalue, CallExpr) and isinstance(
-            rvalue.analyzed, NamedTupleExpr
-        ):
+        elif isinstance(rvalue, CallExpr) and isinstance(rvalue.analyzed, NamedTupleExpr):
             # Depend on types of named tuple items.
             info = rvalue.analyzed.info
             prefix = f"{self.scope.current_full_target()}.{info.name}"
@@ -469,9 +451,7 @@ class DependencyVisitor(TraverserVisitor):
                         self.add_type_dependencies(typ, target=make_trigger(prefix))
                         attr_target = make_trigger(f"{prefix}.{name}")
                         self.add_type_dependencies(typ, target=attr_target)
-        elif isinstance(rvalue, CallExpr) and isinstance(
-            rvalue.analyzed, TypedDictExpr
-        ):
+        elif isinstance(rvalue, CallExpr) and isinstance(rvalue.analyzed, TypedDictExpr):
             # Depend on the underlying typeddict type
             info = rvalue.analyzed.info
             assert info.typeddict_type is not None
@@ -491,9 +471,7 @@ class DependencyVisitor(TraverserVisitor):
                 class_name = typ.type_object().fullname
                 self.add_dependency(make_trigger(class_name + ".__init__"))
                 self.add_dependency(make_trigger(class_name + ".__new__"))
-            if isinstance(rvalue, IndexExpr) and isinstance(
-                rvalue.analyzed, TypeAliasExpr
-            ):
+            if isinstance(rvalue, IndexExpr) and isinstance(rvalue.analyzed, TypeAliasExpr):
                 self.add_type_dependencies(rvalue.analyzed.node.target)
             elif typ:
                 self.add_type_dependencies(typ)
@@ -534,9 +512,7 @@ class DependencyVisitor(TraverserVisitor):
                     if isinstance(lv, RefExpr) and lv.fullname and lv.is_new_def:
                         if lv.kind == LDEF:
                             return  # local definitions don't generate logical deps
-                        self.add_dependency(
-                            make_trigger(fname), make_trigger(lv.fullname)
-                        )
+                        self.add_dependency(make_trigger(fname), make_trigger(lv.fullname))
 
     def process_lvalue(self, lvalue: Expression) -> None:
         """Generate additional dependencies for an lvalue."""
@@ -548,9 +524,7 @@ class DependencyVisitor(TraverserVisitor):
                 # global variable.
                 lvalue_type = self.get_non_partial_lvalue_type(lvalue)
                 type_triggers = self.get_type_triggers(lvalue_type)
-                attr_trigger = make_trigger(
-                    f"{self.scope.current_full_target()}.{lvalue.name}"
-                )
+                attr_trigger = make_trigger(f"{self.scope.current_full_target()}.{lvalue.name}")
                 for type_trigger in type_triggers:
                     self.add_dependency(type_trigger, attr_trigger)
         elif isinstance(lvalue, MemberExpr):
@@ -560,9 +534,7 @@ class DependencyVisitor(TraverserVisitor):
                     info = node.info
                     if info and has_user_bases(info):
                         # Recheck Liskov for self definitions
-                        self.add_dependency(
-                            make_trigger(info.fullname + "." + lvalue.name)
-                        )
+                        self.add_dependency(make_trigger(info.fullname + "." + lvalue.name))
             if lvalue.kind is None:
                 # Reference to a non-module attribute
                 if lvalue.expr not in self.type_map:
@@ -730,9 +702,7 @@ class DependencyVisitor(TraverserVisitor):
         # "a.b" is a known reference to an unimported module. Find the base
         # reference to an unimported module (such as "a.b") and the name suffix
         # (such as "c.d") needed to build a full name.
-        while typ.type_of_any == TypeOfAny.from_another_any and isinstance(
-            e.expr, MemberExpr
-        ):
+        while typ.type_of_any == TypeOfAny.from_another_any and isinstance(e.expr, MemberExpr):
             suffix = "." + e.name + suffix
             e = e.expr
             if e.expr not in self.type_map:
@@ -742,10 +712,7 @@ class DependencyVisitor(TraverserVisitor):
                 # Can't find the base reference to the unimported module.
                 return None
             typ = obj_type
-        if (
-            typ.type_of_any == TypeOfAny.from_unimported_type
-            and typ.missing_import_name
-        ):
+        if typ.type_of_any == TypeOfAny.from_unimported_type and typ.missing_import_name:
             # Infer the full name of the unimported definition.
             return typ.missing_import_name + "." + e.name + suffix
         return None
@@ -843,9 +810,7 @@ class DependencyVisitor(TraverserVisitor):
         if typ is not None:
             self.add_operator_method_dependency_for_type(typ, method)
 
-    def add_operator_method_dependency_for_type(
-        self, typ: ProperType, method: str
-    ) -> None:
+    def add_operator_method_dependency_for_type(self, typ: ProperType, method: str) -> None:
         # Note that operator methods can't be (non-metaclass) methods of type objects
         # (that is, TypeType objects or Callables representing a type).
         if isinstance(typ, TypeVarType):
@@ -857,19 +822,12 @@ class DependencyVisitor(TraverserVisitor):
             self.add_dependency(trigger)
         elif isinstance(typ, UnionType):
             for item in typ.items:
-                self.add_operator_method_dependency_for_type(
-                    get_proper_type(item), method
-                )
+                self.add_operator_method_dependency_for_type(get_proper_type(item), method)
         elif isinstance(typ, FunctionLike) and typ.is_type_obj():
             self.add_operator_method_dependency_for_type(typ.fallback, method)
         elif isinstance(typ, TypeType):
-            if (
-                isinstance(typ.item, Instance)
-                and typ.item.type.metaclass_type is not None
-            ):
-                self.add_operator_method_dependency_for_type(
-                    typ.item.type.metaclass_type, method
-                )
+            if isinstance(typ.item, Instance) and typ.item.type.metaclass_type is not None:
+                self.add_operator_method_dependency_for_type(typ.item.type.metaclass_type, method)
 
     def visit_generator_expr(self, e: GeneratorExpr) -> None:
         super().visit_generator_expr(e)
@@ -957,10 +915,7 @@ class DependencyVisitor(TraverserVisitor):
             return targets
         elif isinstance(typ, TypeType):
             triggers = self.attribute_triggers(typ.item, name)
-            if (
-                isinstance(typ.item, Instance)
-                and typ.item.type.metaclass_type is not None
-            ):
+            if isinstance(typ.item, Instance) and typ.item.type.metaclass_type is not None:
                 triggers.append(
                     make_trigger(f"{typ.item.type.metaclass_type.type.fullname}.{name}")
                 )
@@ -1144,9 +1099,7 @@ class TypeTriggersVisitor(TypeVisitor[List[str]]):
         return triggers
 
 
-def merge_dependencies(
-    new_deps: dict[str, set[str]], deps: dict[str, set[str]]
-) -> None:
+def merge_dependencies(new_deps: dict[str, set[str]], deps: dict[str, set[str]]) -> None:
     for trigger, targets in new_deps.items():
         deps.setdefault(trigger, set()).update(targets)
 
@@ -1156,9 +1109,7 @@ def non_trivial_bases(info: TypeInfo) -> list[TypeInfo]:
 
 
 def has_user_bases(info: TypeInfo) -> bool:
-    return any(
-        base.module_name not in ("builtins", "typing", "enum") for base in info.mro[1:]
-    )
+    return any(base.module_name not in ("builtins", "typing", "enum") for base in info.mro[1:])
 
 
 def dump_all_dependencies(

jaclang/vendor/mypy/server/mergecheck.py

@@ -51,9 +51,7 @@ def check_consistency(o: object) -> None:
         path2 = get_path(sym2, seen, parents)
 
         if fn in m:
-            print(
-                f"\nDuplicate {type(sym).__name__!r} nodes with fullname {fn!r} found:"
-            )
+            print(f"\nDuplicate {type(sym).__name__!r} nodes with fullname {fn!r} found:")
             print("[1] %d: %s" % (id(sym1), path_to_str(path1)))
             print("[2] %d: %s" % (id(sym2), path_to_str(path2)))
 

jaclang/vendor/mypy/server/objgraph.py

@@ -43,11 +43,7 @@ def get_edge_candidates(o: object) -> Iterator[tuple[object, object]]:
     if type(o) not in COLLECTION_TYPE_BLACKLIST:
         for attr in dir(o):
             try:
-                if (
-                    attr not in ATTR_BLACKLIST
-                    and hasattr(o, attr)
-                    and not isproperty(o, attr)
-                ):
+                if attr not in ATTR_BLACKLIST and hasattr(o, attr) and not isproperty(o, attr):
                     e = getattr(o, attr)
                     if type(e) not in ATOMIC_TYPE_BLACKLIST:
                         yield attr, e
@@ -77,9 +73,7 @@ def get_edges(o: object) -> Iterator[tuple[object, object]]:
                 yield s, e
 
 
-def get_reachable_graph(
-    root: object,
-) -> tuple[dict[int, object], dict[int, tuple[int, object]]]:
+def get_reachable_graph(root: object) -> tuple[dict[int, object], dict[int, tuple[int, object]]]:
     parents = {}
     seen = {id(root): root}
     worklist = [root]