jaclang 0.7.19__py3-none-any.whl → 0.7.20__py3-none-any.whl

jaclang/compiler/absyntree.py

@@ -4212,7 +4212,7 @@ class Literal(Token, AtomExpr):
         raise NotImplementedError
 
 
-class BuiltinType(Name, Literal, NameAtom):
+class BuiltinType(Name, Literal):
     """Type node type for Jac Ast."""
 
     SYMBOL_TYPE = SymbolType.VAR

jaclang/compiler/parser.py

@@ -3587,7 +3587,7 @@ class JacParser(Pass):
             match_case_block: KW_CASE pattern_seq (KW_IF expression)? COLON statement_list
             """
             pattern = kid[1]
-            guard = kid[3] if len(kid) > 4 else None
+            guard = kid[3] if isinstance(kid[3], ast.Expr) else None
             stmts = [i for i in kid if isinstance(i, ast.CodeBlockStmt)]
             if isinstance(pattern, ast.MatchPattern) and isinstance(
                 guard, (ast.Expr, type(None))

jaclang/compiler/passes/main/__init__.py

@@ -13,7 +13,7 @@ from .type_check_pass import JacTypeCheckPass  # noqa: I100
 from .registry_pass import RegistryPass  # noqa: I100
 
 
-pass_schedule = py_code_gen
+pass_schedule = py_code_gen  # type: ignore[has-type]
 
 __all__ = [
     "SubNodeTabPass",

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -6,6 +6,7 @@ mypy apis into Jac and use jac py ast in it.
 
 from __future__ import annotations
 
+import re
 from typing import Callable, Optional, TypeVar
 
 import jaclang.compiler.absyntree as ast
@@ -46,24 +47,24 @@ class FuseTypeInfoPass(Pass):
             )
 
     def __set_sym_table_link(self, node: ast.AstSymbolNode) -> None:
-        typ = node.sym_type.split(".")
         typ_sym_table = self.ir.sym_tab
+        assert isinstance(self.ir, ast.Module)
 
-        if typ[0] == "builtins":
-            return
+        sym_type = node.sym_type
+        if re.match(r"builtins.(list|dict|tuple)", sym_type):
+            sym_type = re.sub(r"\[.*\]", "", sym_type)
+
+        typ = sym_type.split(".")
 
         if node.sym_type == "types.ModuleType" and node.sym:
             node.name_spec.type_sym_tab = node.sym.parent_tab.find_scope(node.sym_name)
 
-        assert isinstance(self.ir, ast.Module)
-
-        if typ_sym_table:
-            for i in typ:
-                if i == self.ir.name:
-                    continue
-                f = typ_sym_table.find_scope(i)
-                if f:
-                    typ_sym_table = f
+        for i in typ:
+            if i == self.ir.name:
+                continue
+            f = typ_sym_table.find_scope(i)
+            if f:
+                typ_sym_table = f
 
         if typ_sym_table != self.ir.sym_tab:
             node.name_spec.type_sym_tab = typ_sym_table
@@ -144,6 +145,11 @@ class FuseTypeInfoPass(Pass):
                         self.__set_sym_table_link(node)
                         self.__collect_python_dependencies(node)
 
+                # Special handing for BuiltinType
+                elif isinstance(node, ast.BuiltinType):
+                    func(self, node)  # type: ignore
+                    self.__set_sym_table_link(node)
+
                 # Jac node doesn't have mypy nodes linked to it
                 else:
                     self.__debug_print(
@@ -209,10 +215,21 @@ class FuseTypeInfoPass(Pass):
                     f"{type(mypy_node)}"
                 )
 
+    def __check_builltin_symbol(self, node: ast.NameAtom) -> None:
+        if isinstance(node.parent, ast.AtomTrailer) and node is node.parent.right:
+            return
+        builtins_sym_tab = self.ir.sym_tab.find_scope("builtins")
+        assert builtins_sym_tab is not None
+        builtins_sym = builtins_sym_tab.lookup(node.sym_name)
+        if builtins_sym:
+            node.name_spec._sym = builtins_sym
+
     @__handle_node
     def enter_name(self, node: ast.NameAtom) -> None:
         """Pass handler for name nodes."""
         self.__collect_type_from_symbol(node)
+        if node.sym is None:
+            self.__check_builltin_symbol(node)
 
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
@@ -423,7 +440,8 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_builtin_type(self, node: ast.BuiltinType) -> None:
         """Pass handler for BuiltinType nodes."""
-        self.__collect_type_from_symbol(node)
+        self.__check_builltin_symbol(node)
+        node.name_spec.sym_type = f"builtins.{node.sym_name}"
 
     def get_type_from_instance(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Instance
@@ -483,6 +501,21 @@ class FuseTypeInfoPass(Pass):
                 if self_obj.type_sym_tab and isinstance(right_obj, ast.AstSymbolNode):
                     self_obj.type_sym_tab.def_insert(right_obj)
 
+        # Support adding the correct type symbol table in case of ModuleType
+        # This will only work for target=Val & target1=target2=val and
+        #   target is a moduleType
+        # it won't work in case of
+        #   - target1, target2 = Val1, Val2  <-- tuples need more attention
+        #   - target = a.b.c                 <-- will be fixed after thakee's PR
+        #   - a.b.c = val                    <-- will be fixed after thakee's PR
+        for target in node.target.items:
+            if (
+                isinstance(target, ast.Name)
+                and target.sym_type == "types.ModuleType"
+                and isinstance(node.value, ast.Name)
+            ):
+                target.type_sym_tab = node.value.type_sym_tab
+
     def expand_atom_trailer(self, node_list: list[ast.AstNode]) -> list[ast.AstNode]:
         """Expand the atom trailer object in a list of AstNode."""
         out: list[ast.AstNode] = []
@@ -552,6 +585,10 @@ class FuseTypeInfoPass(Pass):
                 type_symtab: Optional[SymbolTable] = self.ir.sym_tab
                 assert isinstance(self.ir, ast.Module)
                 assert isinstance(type_symtab, SymbolTable)
+
+                if re.match(r"builtins.(list|dict|tuple)", node_type):
+                    node_type = re.sub(r"\[.*\]", "", node_type)
+
                 for j in node_type.split("."):
                     if j == self.ir.name:
                         continue

jaclang/compiler/passes/main/import_pass.py

@@ -7,6 +7,7 @@ symbols are available for matching.
 
 import ast as py_ast
 import os
+import pathlib
 from typing import Optional
 
 
@@ -200,6 +201,7 @@ class PyImportPass(JacImportPass):
     def before_pass(self) -> None:
         """Only run pass if settings are set to raise python."""
         super().before_pass()
+        self.__load_builtins()
 
     def __get_current_module(self, node: ast.AstNode) -> str:
         parent = node.find_parent_of_type(ast.Module)
@@ -296,6 +298,31 @@ class PyImportPass(JacImportPass):
             raise e
         return None
 
+    def __load_builtins(self) -> None:
+        """Pyraise builtins to help with builtins auto complete."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+
+        assert isinstance(self.ir, ast.Module)
+
+        file_to_raise = str(
+            pathlib.Path(os.path.dirname(__file__)).parent.parent.parent
+            / "vendor"
+            / "mypy"
+            / "typeshed"
+            / "stdlib"
+            / "builtins.pyi"
+        )
+        with open(file_to_raise, "r", encoding="utf-8") as f:
+            mod = PyastBuildPass(
+                input_ir=ast.PythonModuleAst(
+                    py_ast.parse(f.read()), mod_path=file_to_raise
+                ),
+            ).ir
+            mod.parent = self.ir
+            SubNodeTabPass(input_ir=mod, prior=self)
+            SymTabBuildPass(input_ir=mod, prior=self)
+            mod.parent = None
+
     def annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
         return None

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -4,10 +4,7 @@ This pass builds the symbol table tree for the Jaseci Ast. It also adds symbols
 for globals, imports, architypes, and abilities declarations and definitions.
 """
 
-import builtins
-
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.symtable import SymbolTable
 
@@ -54,21 +51,6 @@ class SymTabBuildPass(Pass):
         """
         self.push_scope(node.name, node)
         self.sync_node_to_scope(node)
-        for obj in dir(builtins):
-            builtin = ast.Name(
-                file_path=node.loc.mod_path,
-                name=Tok.NAME,
-                value=str(obj),
-                line=0,
-                end_line=0,
-                col_start=0,
-                col_end=0,
-                pos_start=0,
-                pos_end=0,
-            )
-            self.sync_node_to_scope(builtin)
-            builtin.sym_tab.def_insert(builtin)
-        # self.def_insert(ast.Name.gen_stub_from_node(node.name, "root"))
 
     def exit_module(self, node: ast.Module) -> None:
         """Sub objects.

jaclang/compiler/passes/main/tests/fixtures/mod_type_assign.jac

@@ -0,0 +1,7 @@
+import:jac blip;
+
+
+with entry{
+    kl = blip;
+    l1 = l2 = blip;
+}

jaclang/compiler/passes/main/tests/test_type_check_pass.py

@@ -59,6 +59,6 @@ class MypyTypeCheckPassTests(TestCase):
         self.assertIn("HasVar - species - Type: builtins.str", out)
         self.assertIn("myDog - Type: type_info.Dog", out)
         self.assertIn("Body - Type: type_info.Dog.Body", out)
-        self.assertEqual(out.count("Type: builtins.str"), 28)
+        self.assertEqual(out.count("Type: builtins.str"), 34)
         for i in lis:
             self.assertNotIn(i, out)

jaclang/compiler/passes/main/tests/test_typeinfo_pass.py

@@ -1,7 +1,29 @@
 """Test pass module."""
 
+from jaclang.compiler.compile import jac_file_to_pass
+from jaclang.compiler.passes.main.fuse_typeinfo_pass import FuseTypeInfoPass
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.utils.test import TestCase
 
 
 class TestFuseTypeInfo(TestCase):
-    """Test pass module."""
+    """Test FuseTypeInfoPass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_mod_type_assign(self) -> None:
+        """Test module type assignment."""
+        gen_ast = jac_file_to_pass(
+            self.fixture_abs_path("mod_type_assign.jac"),
+            FuseTypeInfoPass,
+            schedule=py_code_gen_typed,
+        ).ir.pp()
+        type_info_list = [
+            "kl - Type: types.ModuleType,  SymbolTable: blip",
+            "l1 - Type: types.ModuleType,  SymbolTable: blip",
+            "l2 - Type: types.ModuleType,  SymbolTable: blip",
+        ]
+        for type_info in type_info_list:
+            self.assertIn(type_info, str(gen_ast))

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -282,6 +282,16 @@ class JacFormatPass(Pass):
                         if prev_token and isinstance(prev_token, ast.Ability):
                             self.emit(node, f"{stmt.gen.jac}")
                         else:
+                            token_before = self.token_before(stmt)
+                            if (
+                                token_before is not None
+                                and isinstance(token_before, ast.Token)
+                                and token_before.name == Tok.LBRACE
+                                and stmt.loc.first_line - token_before.loc.last_line > 1
+                            ):
+                                self.indent_level -= 1
+                                self.emit_ln(node, "")
+                                self.indent_level += 1
                             self.emit(node, stmt.gen.jac)
                             self.indent_level -= 1
                             self.emit_ln(stmt, "")

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/line_spacing.jac

@@ -1,9 +1,11 @@
 import:py math;
 
 glob RAD = 5;
+
 glob DIA = 10;
 
 # this comment is for walker
+
 walker decorator_walk {
     can hash(func: Any) {
         can inner(a: Any) {
@@ -39,6 +41,7 @@ walker decorator_walk {
     # Entry point for the walker
 
     can start with entry {
+
         # Apply decorators to greeter
         decorated_greeter = hash(exclaim(tilde(greeter)));
 
@@ -46,7 +49,6 @@ walker decorator_walk {
         decorated_greeter("World");
 
         # this is another comment
-
     }
 }
 

jaclang/compiler/semtable.py

@@ -19,13 +19,13 @@ class SemInfo:
         self,
         node: ast.AstNode,
         name: str,
-        type: Optional[str] = None,
+        type_str: Optional[str] = None,
         semstr: str = "",
     ) -> None:
         """Initialize the class."""
-        self.node = node
+        self.node_type = type(node)
         self.name = name
-        self.type = type
+        self.type = type_str
         self.semstr = semstr
 
     def __repr__(self) -> str:
@@ -40,7 +40,7 @@ class SemInfo:
         self_scope = str(scope) + f".{self.name}({self.type})"
         _, children = sem_registry.lookup(scope=SemScope.get_scope_from_str(self_scope))
         if filter and children and isinstance(children, list):
-            return [i for i in children if isinstance(i.node, filter)]
+            return [i for i in children if i.node_type == filter]
         return children if children and isinstance(children, list) else []
 
 

jaclang/compiler/symtable.py

@@ -54,6 +54,11 @@ class Symbol:
         out.reverse()
         return ".".join(out)
 
+    @property
+    def fetch_sym_tab(self) -> Optional[SymbolTable]:
+        """Get symbol table."""
+        return self.parent_tab.find_scope(self.sym_name)
+
     def add_defn(self, node: ast.NameAtom) -> None:
         """Add defn."""
         self.defn.append(node)

jaclang/langserve/engine.py

@@ -25,7 +25,6 @@ from jaclang.langserve.utils import (
     get_location_range,
     get_symbols_for_outline,
     parse_symbol_path,
-    resolve_completion_symbol_table,
 )
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.server import LanguageServer
@@ -188,14 +187,73 @@ class JacLangServer(LanguageServer):
             if not node_selected
             else node_selected.sym_tab
         )
-        current_tab = self.modules[file_path].ir._sym_tab
         current_symbol_table = mod_tab
 
         if completion_trigger == ".":
             if current_symbol_path:
-                completion_items = resolve_completion_symbol_table(
-                    mod_tab, current_symbol_path, current_tab
-                )
+                temp_tab = mod_tab
+                for symbol in current_symbol_path:
+                    if symbol == "self":
+                        is_ability_def = (
+                            temp_tab.owner
+                            if isinstance(temp_tab.owner, ast.AbilityDef)
+                            else temp_tab.owner.find_parent_of_type(ast.AbilityDef)
+                        )
+                        if not is_ability_def:
+                            archi_owner = mod_tab.owner.find_parent_of_type(
+                                ast.Architype
+                            )
+                            temp_tab = (
+                                archi_owner._sym_tab
+                                if archi_owner and archi_owner._sym_tab
+                                else mod_tab
+                            )
+                            continue
+                        else:
+                            archi_owner = (
+                                (
+                                    is_ability_def.decl_link.find_parent_of_type(
+                                        ast.Architype
+                                    )
+                                )
+                                if is_ability_def.decl_link
+                                else None
+                            )
+                            temp_tab = (
+                                archi_owner.sym_tab
+                                if archi_owner and archi_owner.sym_tab
+                                else temp_tab
+                            )
+                            continue
+                    symb = temp_tab.lookup(symbol)
+                    if symb:
+                        fetc_tab = symb.fetch_sym_tab
+                        if fetc_tab:
+                            temp_tab = fetc_tab
+                        else:
+                            temp_tab = (
+                                symb.defn[0].type_sym_tab
+                                if symb.defn[0].type_sym_tab
+                                else temp_tab
+                            )
+                    else:
+                        break
+                completion_items = collect_all_symbols_in_scope(temp_tab, up_tree=False)
+                if (
+                    isinstance(temp_tab.owner, ast.Architype)
+                    and temp_tab.owner.base_classes
+                ):
+                    base = []
+                    for base_name in temp_tab.owner.base_classes.items:
+                        if isinstance(base_name, ast.Name) and base_name.sym:
+                            base.append(base_name.sym)
+                    for base_class_symbol in base:
+                        if base_class_symbol.fetch_sym_tab:
+                            completion_items += collect_all_symbols_in_scope(
+                                base_class_symbol.fetch_sym_tab,
+                                up_tree=False,
+                            )
+
             else:
                 completion_items = []
         else:
@@ -374,7 +432,7 @@ class JacLangServer(LanguageServer):
                             ),
                         ),
                     )
-            elif isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
+            elif isinstance(node_selected, ast.ElementStmt):
                 return None
             decl_node = (
                 node_selected.parent.body.target

jaclang/langserve/tests/test_server.py

@@ -282,7 +282,7 @@ class TestJacLangServer(TestCase):
             ),
             (
                 "<JacSemTokenType.FUNCTION: 12>, <JacSemTokenModifier.DECLARATION: 1>,",
-                6,
+                8,
             ),
             ("<JacSemTokenType.METHOD: 13>, <JacSemTokenModifier.DECLARATION: 1>", 6),
             ("<JacSemTokenType.ENUM: 3>, <JacSemTokenModifier.DECLARATION: 1>,", 4),

jaclang/langserve/utils.py

@@ -332,119 +332,6 @@ def parse_symbol_path(text: str, dot_position: int) -> list[str]:
     return all_words
 
 
-def resolve_symbol_path(sym_name: str, node_tab: SymbolTable) -> str:
-    """Resolve symbol path."""
-    visited = set()
-    current_tab: Optional[SymbolTable] = node_tab
-
-    while current_tab is not None and current_tab not in visited:
-        visited.add(current_tab)
-        for name, symbol in current_tab.tab.items():
-            if name not in dir(builtins) and name == sym_name:
-                path = symbol.defn[0]._sym_type
-                if symbol.sym_type == SymbolType.ENUM_ARCH:
-                    if isinstance(current_tab.owner, ast.Module):
-                        return current_tab.owner.name + "." + sym_name
-                    elif isinstance(current_tab.owner, ast.AstSymbolNode):
-                        return current_tab.owner.name_spec._sym_type + "." + sym_name
-                return path
-        current_tab = current_tab.parent if current_tab.parent != current_tab else None
-    return ""
-
-
-def find_symbol_table(path: str, current_tab: Optional[SymbolTable]) -> SymbolTable:
-    """Find symbol table."""
-    path = path.lstrip(".")
-    current_table = current_tab
-    if current_table:
-        for segment in path.split("."):
-            current_table = next(
-                (
-                    child_table
-                    for child_table in current_table.kid
-                    if child_table.name == segment
-                ),
-                current_table,
-            )
-    if current_table:
-        return current_table
-    raise ValueError(f"Symbol table not found for path {path}")
-
-
-def resolve_completion_symbol_table(
-    mod_tab: SymbolTable,
-    current_symbol_path: list[str],
-    current_tab: Optional[SymbolTable],
-) -> list[lspt.CompletionItem]:
-    """Resolve symbol table for completion items."""
-    current_symbol_table = mod_tab
-    for obj in current_symbol_path:
-        if obj == "self":
-            try:
-                try:
-                    is_abilitydef = (
-                        mod_tab.owner
-                        if isinstance(mod_tab.owner, ast.AbilityDef)
-                        else mod_tab.owner.parent_of_type(ast.AbilityDef)
-                    )
-                    archi_owner = (
-                        (is_abilitydef.decl_link.parent_of_type(ast.Architype))
-                        if is_abilitydef.decl_link
-                        else None
-                    )
-                    current_symbol_table = (
-                        archi_owner._sym_tab
-                        if archi_owner and archi_owner._sym_tab
-                        else mod_tab
-                    )
-                    continue
-
-                except ValueError:
-                    pass
-                archi_owner = mod_tab.owner.parent_of_type(ast.Architype)
-                current_symbol_table = (
-                    archi_owner._sym_tab
-                    if archi_owner and archi_owner._sym_tab
-                    else mod_tab
-                )
-            except ValueError:
-                pass
-        else:
-            path: str = resolve_symbol_path(obj, current_symbol_table)
-            if path:
-                current_symbol_table = find_symbol_table(path, current_tab)
-            else:
-                if (
-                    isinstance(current_symbol_table.owner, ast.Architype)
-                    and current_symbol_table.owner.base_classes
-                ):
-                    for base_name in current_symbol_table.owner.base_classes.items:
-                        if isinstance(base_name, ast.Name) and base_name.sym:
-                            path = base_name.sym.sym_dotted_name + "." + obj
-                            current_symbol_table = find_symbol_table(path, current_tab)
-    if (
-        isinstance(current_symbol_table.owner, ast.Architype)
-        and current_symbol_table.owner.base_classes
-    ):
-        base = []
-        for base_name in current_symbol_table.owner.base_classes.items:
-            if isinstance(base_name, ast.Name) and base_name.sym:
-                base.append(base_name.sym.sym_dotted_name)
-        for base_ in base:
-            completion_items = collect_all_symbols_in_scope(
-                find_symbol_table(base_, current_tab),
-                up_tree=False,
-            )
-    else:
-        completion_items = []
-    if isinstance(current_symbol_table.owner, (ast.Ability, ast.AbilityDef)):
-        return completion_items
-    completion_items.extend(
-        collect_all_symbols_in_scope(current_symbol_table, up_tree=False)
-    )
-    return completion_items
-
-
 def get_token_start(
     token_index: int | None, sem_tokens: list[int]
 ) -> tuple[int, int, int]:

jaclang/plugin/tests/test_jaseci.py

@@ -337,8 +337,8 @@ class TestJaseciPlugin(TestCase):
 
         # --------- NO UPDATE SHOULD HAPPEN -------- #
 
-        self.assertTrue(archs[0], "A(val=2)")
-        self.assertTrue(archs[1], "A(val=1)")
+        self.assertEqual(archs[0], "A(val=2)")
+        self.assertEqual(archs[1], "A(val=1)")
 
         self._output2buffer()
         cli.enter(
@@ -435,8 +435,8 @@ class TestJaseciPlugin(TestCase):
 
         # --------- UPDATE SHOULD HAPPEN -------- #
 
-        self.assertTrue(archs[0], "A(val=20)")
-        self.assertTrue(archs[1], "A(val=10)")
+        self.assertEqual(archs[0], "A(val=20)")
+        self.assertEqual(archs[1], "A(val=10)")
 
         self._output2buffer()
         cli.enter(
@@ -474,6 +474,25 @@ class TestJaseciPlugin(TestCase):
         )
         self.assertFalse(self.capturedOutput.getvalue().strip())
 
+        # --------- ROOTS RESET OWN NODE -------- #
+
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node",
+            args=[1],
+            session=session,
+            root=self.roots[0],
+            node=self.nodes[0],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node",
+            args=[2],
+            session=session,
+            root=self.roots[1],
+            node=self.nodes[1],
+        )
+
     def test_other_root_access(self) -> None:
         """Test filtering on node, then visit."""
         global session

jaclang/runtimelib/importer.py

@@ -195,6 +195,8 @@ class PythonImporter(Importer):
             loaded_items: list = []
             if spec.target.startswith("."):
                 spec.target = spec.target.lstrip(".")
+                if len(spec.target.split(".")) > 1:
+                    spec.target = spec.target.split(".")[-1]
                 full_target = path.normpath(path.join(spec.caller_dir, spec.target))
                 imp_spec = importlib.util.spec_from_file_location(
                     spec.target, full_target + ".py"

jaclang/runtimelib/memory.py

@@ -106,7 +106,7 @@ class ShelfStorage(Memory[UUID, Anchor]):
                         if root.has_write_access(d):
                             if hash(dumps(p_d.access)) != hash(dumps(d.access)):
                                 p_d.access = d.access
-                            if hash(dumps(d.architype)) != hash(dumps(d.architype)):
+                            if hash(dumps(p_d.architype)) != hash(dumps(d.architype)):
                                 p_d.architype = d.architype
 
                         self.__shelf__[_id] = p_d

jaclang/stubs/jaclang/__init__.pyi

@@ -0,0 +1,5 @@
+from _typeshed import Incomplete
+
+__all__ = ["jac_import"]
+
+jac_import: Incomplete