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

jaclang/vendor/mypy/server/update.py

@@ -166,10 +166,7 @@ from mypy.util import module_prefix, split_target
 
 MAX_ITER: Final = 1000
 
-SENSITIVE_INTERNAL_MODULES = tuple(core_modules) + (
-    "mypy_extensions",
-    "typing_extensions",
-)
+SENSITIVE_INTERNAL_MODULES = tuple(core_modules) + ("mypy_extensions", "typing_extensions")
 
 
 class FineGrainedBuildManager:
@@ -254,8 +251,7 @@ class FineGrainedBuildManager:
         )
         if self.previous_targets_with_errors and is_verbose(self.manager):
             self.manager.log_fine_grained(
-                "previous targets with errors: %s"
-                % sorted(self.previous_targets_with_errors)
+                "previous targets with errors: %s" % sorted(self.previous_targets_with_errors)
             )
 
         blocking_error = None
@@ -370,9 +366,7 @@ class FineGrainedBuildManager:
             )
             return changed_modules, (next_id, next_path), None
 
-        result = self.update_module(
-            next_id, next_path, next_id in removed_set, followed
-        )
+        result = self.update_module(next_id, next_path, next_id in removed_set, followed)
         remaining, (next_id, next_path), blocker_messages = result
         changed_modules = [(id, path) for id, path in changed_modules if id != next_id]
         changed_modules = dedupe_modules(remaining + changed_modules)
@@ -502,9 +496,7 @@ def find_unloaded_deps(
     return unloaded
 
 
-def ensure_deps_loaded(
-    module: str, deps: dict[str, set[str]], graph: dict[str, State]
-) -> None:
+def ensure_deps_loaded(module: str, deps: dict[str, set[str]], graph: dict[str, State]) -> None:
     """Ensure that the dependencies on a module are loaded.
 
     Dependencies are loaded into the 'deps' dictionary.
@@ -667,9 +659,7 @@ def update_module_isolated(
 
     # Merge old and new ASTs.
     new_modules_dict: dict[str, MypyFile | None] = {module: state.tree}
-    replace_modules_with_new_variants(
-        manager, graph, {orig_module: orig_tree}, new_modules_dict
-    )
+    replace_modules_with_new_variants(manager, graph, {orig_module: orig_tree}, new_modules_dict)
 
     t1 = time.time()
     # Perform type checking.
@@ -680,18 +670,14 @@ def update_module_isolated(
     t2 = time.time()
     state.finish_passes()
     t3 = time.time()
-    manager.add_stats(
-        semanal_time=t1 - t0, typecheck_time=t2 - t1, finish_passes_time=t3 - t2
-    )
+    manager.add_stats(semanal_time=t1 - t0, typecheck_time=t2 - t1, finish_passes_time=t3 - t2)
 
     graph[module] = state
 
     return NormalUpdate(module, path, remaining_modules, state.tree)
 
 
-def find_relative_leaf_module(
-    modules: list[tuple[str, str]], graph: Graph
-) -> tuple[str, str]:
+def find_relative_leaf_module(modules: list[tuple[str, str]], graph: Graph) -> tuple[str, str]:
     """Find a module in a list that directly imports no other module in the list.
 
     If no such module exists, return the lexicographically first module from the list.
@@ -718,9 +704,7 @@ def find_relative_leaf_module(
     return modules[0]
 
 
-def delete_module(
-    module_id: str, path: str, graph: Graph, manager: BuildManager
-) -> None:
+def delete_module(module_id: str, path: str, graph: Graph, manager: BuildManager) -> None:
     manager.log_fine_grained(f"delete module {module_id!r}")
     # TODO: Remove deps for the module (this only affects memory use, not correctness)
     if module_id in graph:
@@ -794,9 +778,7 @@ def calculate_active_triggers(
         diff = compare_symbol_table_snapshots(id, snapshot1, snapshot2)
         package_nesting_level = id.count(".")
         for item in diff.copy():
-            if item.count(".") <= package_nesting_level + 1 and item.split(".")[
-                -1
-            ] not in (
+            if item.count(".") <= package_nesting_level + 1 and item.split(".")[-1] not in (
                 "__builtins__",
                 "__file__",
                 "__name__",
@@ -838,9 +820,7 @@ def replace_modules_with_new_variants(
         preserved_module = old_modules.get(id)
         new_module = new_modules[id]
         if preserved_module and new_module is not None:
-            merge_asts(
-                preserved_module, preserved_module.names, new_module, new_module.names
-            )
+            merge_asts(preserved_module, preserved_module.names, new_module, new_module.names)
             manager.modules[id] = preserved_module
             graph[id].tree = preserved_module
 
@@ -871,9 +851,7 @@ def propagate_changes_using_dependencies(
     while triggered or targets_with_errors:
         num_iter += 1
         if num_iter > MAX_ITER:
-            raise RuntimeError(
-                "Max number of iterations (%d) reached (endless loop?)" % MAX_ITER
-            )
+            raise RuntimeError("Max number of iterations (%d) reached (endless loop?)" % MAX_ITER)
 
         todo, unloaded, stale_protos = find_targets_recursive(
             manager, graph, triggered, deps, up_to_date_modules
@@ -900,9 +878,7 @@ def propagate_changes_using_dependencies(
         # TODO: Preserve order (set is not optimal)
         for id, nodes in sorted(todo.items(), key=lambda x: x[0]):
             assert id not in up_to_date_modules
-            triggered |= reprocess_nodes(
-                manager, graph, id, nodes, deps, processed_targets
-            )
+            triggered |= reprocess_nodes(manager, graph, id, nodes, deps, processed_targets)
         # Changes elsewhere may require us to reprocess modules that were
         # previously considered up to date. For example, there may be a
         # dependency loop that loops back to an originally processed module.
@@ -989,9 +965,7 @@ def reprocess_nodes(
     Return fired triggers.
     """
     if module_id not in graph:
-        manager.log_fine_grained(
-            "%s not in graph (blocking errors or deleted?)" % module_id
-        )
+        manager.log_fine_grained("%s not in graph (blocking errors or deleted?)" % module_id)
         return set()
 
     file_node = manager.modules[module_id]
@@ -1010,9 +984,7 @@ def reprocess_nodes(
     state = graph[module_id]
     options = state.options
     manager.errors.set_file_ignored_lines(
-        file_node.path,
-        file_node.ignored_lines,
-        options.ignore_errors or state.ignore_all,
+        file_node.path, file_node.ignored_lines, options.ignore_errors or state.ignore_all
     )
     manager.errors.set_skipped_lines(file_node.path, file_node.skipped_lines)
 
@@ -1077,9 +1049,7 @@ def reprocess_nodes(
     return new_triggered
 
 
-def find_symbol_tables_recursive(
-    prefix: str, symbols: SymbolTable
-) -> dict[str, SymbolTable]:
+def find_symbol_tables_recursive(prefix: str, symbols: SymbolTable) -> dict[str, SymbolTable]:
     """Find all nested symbol tables.
 
     Args:
@@ -1092,9 +1062,7 @@ def find_symbol_tables_recursive(
     result = {}
     result[prefix] = symbols
     for name, node in symbols.items():
-        if isinstance(node.node, TypeInfo) and node.node.fullname.startswith(
-            prefix + "."
-        ):
+        if isinstance(node.node, TypeInfo) and node.node.fullname.startswith(prefix + "."):
             more = find_symbol_tables_recursive(prefix + "." + name, node.node.names)
             result.update(more)
     return result
@@ -1132,9 +1100,7 @@ def lookup_target(
     """
 
     def not_found() -> None:
-        manager.log_fine_grained(
-            f"Can't find matching target for {target} (stale dependency?)"
-        )
+        manager.log_fine_grained(f"Can't find matching target for {target} (stale dependency?)")
 
     modules = manager.modules
     items = split_target(modules, target)
@@ -1205,9 +1171,7 @@ def is_verbose(manager: BuildManager) -> bool:
     return manager.options.verbosity >= 1 or DEBUG_FINE_GRAINED
 
 
-def target_from_node(
-    module: str, node: FuncDef | MypyFile | OverloadedFuncDef
-) -> str | None:
+def target_from_node(module: str, node: FuncDef | MypyFile | OverloadedFuncDef) -> str | None:
     """Return the target name corresponding to a deferred node.
 
     Args:

jaclang/vendor/mypy/solve.py

@@ -6,13 +6,7 @@ from collections import defaultdict
 from typing import Iterable, Sequence
 from typing_extensions import TypeAlias as _TypeAlias
 
-from mypy.constraints import (
-    SUBTYPE_OF,
-    SUPERTYPE_OF,
-    Constraint,
-    infer_constraints,
-    neg_op,
-)
+from mypy.constraints import SUBTYPE_OF, SUPERTYPE_OF, Constraint, infer_constraints, neg_op
 from mypy.expandtype import expand_type
 from mypy.graph_utils import prepare_sccs, strongly_connected_components, topsort
 from mypy.join import join_types
@@ -72,9 +66,7 @@ def solve_constraints(
     extra_vars: list[TypeVarId] = []
     # Get additional type variables from generic actuals.
     for c in constraints:
-        extra_vars.extend(
-            [v.id for v in c.extra_tvars if v.id not in vars + extra_vars]
-        )
+        extra_vars.extend([v.id for v in c.extra_tvars if v.id not in vars + extra_vars])
         originals.update({v.id: v for v in c.extra_tvars if v.id not in originals})
 
     if allow_polymorphic:
@@ -433,10 +425,7 @@ def transitive_closure(
             if (lower, upper) in graph:
                 continue
             graph |= {
-                (l, u)
-                for l in tvars
-                for u in tvars
-                if (l, lower) in graph and (upper, u) in graph
+                (l, u) for l in tvars for u in tvars if (l, lower) in graph and (upper, u) in graph
             }
             for u in tvars:
                 if (upper, u) in graph:
@@ -536,9 +525,7 @@ def skip_reverse_union_constraints(cs: list[Constraint]) -> list[Constraint]:
         if isinstance(p_target, UnionType):
             for item in p_target.items:
                 if isinstance(item, TypeVarType):
-                    reverse_union_cs.add(
-                        Constraint(item, neg_op(c.op), c.origin_type_var)
-                    )
+                    reverse_union_cs.add(Constraint(item, neg_op(c.op), c.origin_type_var))
     return [c for c in cs if c not in reverse_union_cs]
 
 

jaclang/vendor/mypy/split_namespace.py

@@ -14,9 +14,7 @@ from typing import Any
 
 
 class SplitNamespace(argparse.Namespace):
-    def __init__(
-        self, standard_namespace: object, alt_namespace: object, alt_prefix: str
-    ) -> None:
+    def __init__(self, standard_namespace: object, alt_namespace: object, alt_prefix: str) -> None:
         self.__dict__["_standard_namespace"] = standard_namespace
         self.__dict__["_alt_namespace"] = alt_namespace
         self.__dict__["_alt_prefix"] = alt_prefix

jaclang/vendor/mypy/stats.py

@@ -126,10 +126,7 @@ class StatisticsVisitor(TraverserVisitor):
 
     def process_import(self, imp: ImportFrom | ImportAll) -> None:
         import_id, ok = correct_relative_import(
-            self.cur_mod_id,
-            imp.relative,
-            imp.id,
-            self.cur_mod_node.is_package_init_file(),
+            self.cur_mod_id, imp.relative, imp.id, self.cur_mod_node.is_package_init_file()
         )
         if ok and import_id in self.modules:
             kind = TYPE_PRECISE
@@ -163,11 +160,7 @@ class StatisticsVisitor(TraverserVisitor):
                     assert isinstance(o.type, CallableType)
                     sig = o.type
                     arg_types = sig.arg_types
-                    if (
-                        sig.arg_names
-                        and sig.arg_names[0] == "self"
-                        and not self.inferred
-                    ):
+                    if sig.arg_names and sig.arg_names[0] == "self" and not self.inferred:
                         arg_types = arg_types[1:]
                     for arg in arg_types:
                         self.type(arg)
@@ -241,12 +234,7 @@ class StatisticsVisitor(TraverserVisitor):
         self.record_precise_if_checked_scope(o)
 
     def visit_name_expr(self, o: NameExpr) -> None:
-        if o.fullname in (
-            "builtins.None",
-            "builtins.True",
-            "builtins.False",
-            "builtins.Ellipsis",
-        ):
+        if o.fullname in ("builtins.None", "builtins.True", "builtins.False", "builtins.Ellipsis"):
             self.record_precise_if_checked_scope(o)
         else:
             self.process_node(o)
@@ -277,9 +265,7 @@ class StatisticsVisitor(TraverserVisitor):
         else:
             pass  # TODO: Handle overloaded functions, etc.
 
-    def record_callable_target_precision(
-        self, o: CallExpr, callee: CallableType
-    ) -> None:
+    def record_callable_target_precision(self, o: CallExpr, callee: CallableType) -> None:
         """Record imprecision caused by callee argument types.
 
         This only considers arguments passed in a call expression. Arguments
@@ -382,9 +368,7 @@ class StatisticsVisitor(TraverserVisitor):
             self.log("  !! Any type around line %d" % self.line)
             self.num_any_exprs += 1
             self.record_line(self.line, TYPE_ANY)
-        elif (not self.all_nodes and is_imprecise(t)) or (
-            self.all_nodes and is_imprecise2(t)
-        ):
+        elif (not self.all_nodes and is_imprecise(t)) or (self.all_nodes and is_imprecise2(t)):
             self.log("  !! Imprecise type around line %d" % self.line)
             self.num_imprecise_exprs += 1
             self.record_line(self.line, TYPE_IMPRECISE)
@@ -438,9 +422,7 @@ def dump_type_stats(
     if is_special_module(path):
         return
     print(path)
-    visitor = StatisticsVisitor(
-        inferred, filename=tree.fullname, modules=modules, typemap=typemap
-    )
+    visitor = StatisticsVisitor(inferred, filename=tree.fullname, modules=modules, typemap=typemap)
     tree.accept(visitor)
     for line in visitor.output:
         print(line)

jaclang/vendor/mypy/strconv.py

@@ -40,9 +40,7 @@ class StrConv(NodeVisitor[str]):
     def stringify_type(self, t: mypy.types.Type) -> str:
         import mypy.types
 
-        return t.accept(
-            mypy.types.TypeStrVisitor(id_mapper=self.id_mapper, options=self.options)
-        )
+        return t.accept(mypy.types.TypeStrVisitor(id_mapper=self.id_mapper, options=self.options))
 
     def get_id(self, o: object) -> int | None:
         if self.id_mapper:
@@ -113,10 +111,7 @@ class StrConv(NodeVisitor[str]):
             # case# output in all platforms.
             a.insert(0, o.path.replace(os.sep, "/"))
         if o.ignored_lines:
-            a.append(
-                "IgnoredLines(%s)"
-                % ", ".join(str(line) for line in sorted(o.ignored_lines))
-            )
+            a.append("IgnoredLines(%s)" % ", ".join(str(line) for line in sorted(o.ignored_lines)))
         return self.dump(a, o)
 
     def visit_import(self, o: mypy.nodes.Import) -> str:
@@ -148,10 +143,7 @@ class StrConv(NodeVisitor[str]):
         arg_kinds = {arg.kind for arg in o.arguments}
         if len(arg_kinds & {mypy.nodes.ARG_NAMED, mypy.nodes.ARG_NAMED_OPT}) > 0:
             a.insert(1, f"MaxPos({o.max_pos})")
-        if o.abstract_status in (
-            mypy.nodes.IS_ABSTRACT,
-            mypy.nodes.IMPLICITLY_ABSTRACT,
-        ):
+        if o.abstract_status in (mypy.nodes.IS_ABSTRACT, mypy.nodes.IMPLICITLY_ABSTRACT):
             a.insert(-1, "Abstract")
         if o.is_static:
             a.insert(-1, "Static")
@@ -179,10 +171,7 @@ class StrConv(NodeVisitor[str]):
         # (in this case base_type_exprs is empty).
         if o.base_type_exprs:
             if o.info and o.info.bases:
-                if (
-                    len(o.info.bases) != 1
-                    or o.info.bases[0].type.fullname != "builtins.object"
-                ):
+                if len(o.info.bases) != 1 or o.info.bases[0].type.fullname != "builtins.object":
                     a.insert(1, ("BaseType", o.info.bases))
             else:
                 a.insert(1, ("BaseTypeExpr", o.base_type_exprs))
@@ -193,10 +182,7 @@ class StrConv(NodeVisitor[str]):
         if o.decorators:
             a.insert(1, ("Decorators", o.decorators))
         if o.info and o.info._promote:
-            a.insert(
-                1,
-                f"Promote([{','.join(self.stringify_type(p) for p in o.info._promote)}])",
-            )
+            a.insert(1, f"Promote([{','.join(self.stringify_type(p) for p in o.info._promote)}])")
         if o.info and o.info.tuple_type:
             a.insert(1, ("TupleType", [o.info.tuple_type]))
         if o.info and o.info.fallback_to_any:
@@ -239,9 +225,7 @@ class StrConv(NodeVisitor[str]):
             a.append(o.type)
         return self.dump(a, o)
 
-    def visit_operator_assignment_stmt(
-        self, o: mypy.nodes.OperatorAssignmentStmt
-    ) -> str:
+    def visit_operator_assignment_stmt(self, o: mypy.nodes.OperatorAssignmentStmt) -> str:
         return self.dump([o.op, o.lvalue, o.rvalue], o)
 
     def visit_while_stmt(self, o: mypy.nodes.WhileStmt) -> str:
@@ -558,9 +542,7 @@ class StrConv(NodeVisitor[str]):
     def visit_set_comprehension(self, o: mypy.nodes.SetComprehension) -> str:
         return self.dump([o.generator], o)
 
-    def visit_dictionary_comprehension(
-        self, o: mypy.nodes.DictionaryComprehension
-    ) -> str:
+    def visit_dictionary_comprehension(self, o: mypy.nodes.DictionaryComprehension) -> str:
         condlists = o.condlists if any(o.condlists) else None
         return self.dump([o.key, o.value, o.indices, o.sequences, condlists], o)
 
@@ -643,12 +625,7 @@ def dump_tagged(nodes: Sequence[object], tag: str | None, str_conv: StrConv) ->
             a.append(indent(n.accept(str_conv), 2))
         elif isinstance(n, Type):
             a.append(
-                indent(
-                    n.accept(
-                        TypeStrVisitor(str_conv.id_mapper, options=str_conv.options)
-                    ),
-                    2,
-                )
+                indent(n.accept(TypeStrVisitor(str_conv.id_mapper, options=str_conv.options)), 2)
             )
         elif n is not None:
             a.append(indent(str(n), 2))

jaclang/vendor/mypy/stubdoc.py

@@ -11,15 +11,7 @@ import io
 import keyword
 import re
 import tokenize
-from typing import (
-    Any,
-    Final,
-    MutableMapping,
-    MutableSequence,
-    NamedTuple,
-    Sequence,
-    Tuple,
-)
+from typing import Any, Final, MutableMapping, MutableSequence, NamedTuple, Sequence, Tuple
 from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.util
@@ -150,11 +142,7 @@ class FunctionSig(NamedTuple):
 
         prefix = "async " if is_async else ""
         sig = "{indent}{prefix}def {name}({args}){ret}:".format(
-            indent=indent,
-            prefix=prefix,
-            name=self.name,
-            args=", ".join(args),
-            ret=retfield,
+            indent=indent, prefix=prefix, name=self.name, args=", ".join(args), ret=retfield
         )
         if docstring:
             suffix = f"\n{indent}    {mypy.util.quote_docstring(docstring)}"
@@ -280,18 +268,12 @@ class DocStringParser:
                 if self.arg_type and not is_valid_type(self.arg_type):
                     # wrong type, use Any
                     self.args.append(
-                        ArgSig(
-                            name=self.arg_name,
-                            type=None,
-                            default=bool(self.arg_default),
-                        )
+                        ArgSig(name=self.arg_name, type=None, default=bool(self.arg_default))
                     )
                 else:
                     self.args.append(
                         ArgSig(
-                            name=self.arg_name,
-                            type=self.arg_type,
-                            default=bool(self.arg_default),
+                            name=self.arg_name, type=self.arg_type, default=bool(self.arg_default)
                         )
                     )
             self.arg_name = ""
@@ -299,18 +281,12 @@ class DocStringParser:
             self.arg_default = None
             self.accumulator = ""
 
-        elif (
-            token.type == tokenize.OP
-            and token.string == "->"
-            and self.state[-1] == STATE_INIT
-        ):
+        elif token.type == tokenize.OP and token.string == "->" and self.state[-1] == STATE_INIT:
             self.accumulator = ""
             self.state.append(STATE_RETURN_VALUE)
 
         # ENDMAKER is necessary for python 3.4 and 3.5.
-        elif token.type in (tokenize.NEWLINE, tokenize.ENDMARKER) and self.state[
-            -1
-        ] in (
+        elif token.type in (tokenize.NEWLINE, tokenize.ENDMARKER) and self.state[-1] in (
             STATE_INIT,
             STATE_RETURN_VALUE,
         ):
@@ -324,9 +300,7 @@ class DocStringParser:
 
             if self.found:
                 self.signatures.append(
-                    FunctionSig(
-                        name=self.function_name, args=self.args, ret_type=self.ret_type
-                    )
+                    FunctionSig(name=self.function_name, args=self.args, ret_type=self.ret_type)
                 )
                 self.found = False
             self.args = []
@@ -409,11 +383,7 @@ def infer_ret_type_sig_from_docstring(docstr: str, name: str) -> str | None:
 
 def infer_ret_type_sig_from_anon_docstring(docstr: str) -> str | None:
     """Convert signature in form of "(self: TestClass, arg0) -> int" to their return type."""
-    lines = [
-        "stub" + line.strip()
-        for line in docstr.splitlines()
-        if line.strip().startswith("(")
-    ]
+    lines = ["stub" + line.strip() for line in docstr.splitlines() if line.strip().startswith("(")]
     return infer_ret_type_sig_from_docstring("".join(lines), "stub")