jaclang 0.7.18__py3-none-any.whl → 0.7.22__py3-none-any.whl

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/architype.py

@@ -526,6 +526,14 @@ class WalkerAnchor(Anchor):
         if walker := self.architype:
             self.path = []
             self.next = [node]
+            if self.next:
+                current_node = self.next[-1].architype
+                for i in walker._jac_entry_funcs_:
+                    if not i.trigger:
+                        if i.func:
+                            i.func(walker, current_node)
+                        else:
+                            raise ValueError(f"No function {i.name} to call.")
             while len(self.next):
                 if current_node := self.next.pop(0).architype:
                     for i in current_node._jac_entry_funcs_:
@@ -538,16 +546,20 @@ class WalkerAnchor(Anchor):
                             return walker
                     for i in walker._jac_entry_funcs_:
                         if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func:
+                            if i.func and i.trigger:
                                 i.func(walker, current_node)
+                            elif not i.trigger:
+                                continue
                             else:
                                 raise ValueError(f"No function {i.name} to call.")
                         if self.disengaged:
                             return walker
                     for i in walker._jac_exit_funcs_:
                         if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func:
+                            if i.func and i.trigger:
                                 i.func(walker, current_node)
+                            elif not i.trigger:
+                                continue
                             else:
                                 raise ValueError(f"No function {i.name} to call.")
                         if self.disengaged:
@@ -560,6 +572,12 @@ class WalkerAnchor(Anchor):
                                 raise ValueError(f"No function {i.name} to call.")
                         if self.disengaged:
                             return walker
+            for i in walker._jac_exit_funcs_:
+                if not i.trigger:
+                    if i.func:
+                        i.func(walker, current_node)
+                    else:
+                        raise ValueError(f"No function {i.name} to call.")
             self.ignores = []
             return walker
         raise Exception(f"Invalid Reference {self.id}")

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"
@@ -340,6 +342,7 @@ class JacImporter(Importer):
                     spec.full_target,
                     caller_dir=spec.caller_dir,
                     cachable=spec.cachable,
+                    reload=reload if reload else False,
                 )
                 try:
                     if not codeobj:

jaclang/runtimelib/machine.py

@@ -6,12 +6,17 @@ import os
 import sys
 import types
 from contextvars import ContextVar
-from typing import Optional
+from typing import Optional, Union
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
 from jaclang.compiler.constant import Constants as Con
-from jaclang.runtimelib.architype import EdgeArchitype, NodeArchitype, WalkerArchitype
+from jaclang.runtimelib.architype import (
+    Architype,
+    EdgeArchitype,
+    NodeArchitype,
+    WalkerArchitype,
+)
 from jaclang.utils.log import logging
 
 
@@ -55,11 +60,12 @@ class JacMachine:
         full_target: str,
         caller_dir: str,
         cachable: bool = True,
+        reload: bool = False,
     ) -> Optional[types.CodeType]:
         """Retrieve bytecode from the attached JacProgram."""
         if self.jac_program:
             return self.jac_program.get_bytecode(
-                module_name, full_target, caller_dir, cachable
+                module_name, full_target, caller_dir, cachable, reload=reload
             )
         return None
 
@@ -105,6 +111,87 @@ class JacMachine:
             return nodes
         return []
 
+    def update_walker(
+        self, module_name: str, items: Optional[dict[str, Union[str, Optional[str]]]]
+    ) -> tuple[types.ModuleType, ...]:
+        """Reimport the module."""
+        from .importer import JacImporter, ImportPathSpec
+
+        if module_name in self.loaded_modules:
+            try:
+                old_module = self.loaded_modules[module_name]
+                importer = JacImporter(self)
+                spec = ImportPathSpec(
+                    target=module_name,
+                    base_path=self.base_path,
+                    absorb=False,
+                    cachable=True,
+                    mdl_alias=None,
+                    override_name=None,
+                    lng="jac",
+                    items=items,
+                )
+                import_result = importer.run_import(spec, reload=True)
+                ret_items = []
+                if items:
+                    for item_name in items:
+                        if hasattr(old_module, item_name):
+                            new_attr = getattr(import_result.ret_mod, item_name, None)
+                            if new_attr:
+                                ret_items.append(new_attr)
+                                setattr(
+                                    old_module,
+                                    item_name,
+                                    new_attr,
+                                )
+                return (old_module,) if not items else tuple(ret_items)
+            except Exception as e:
+                logger.error(f"Failed to update module {module_name}: {e}")
+        else:
+            logger.warning(f"Module {module_name} not found in loaded modules.")
+        return ()
+
+    def spawn_node(
+        self,
+        node_name: str,
+        attributes: Optional[dict] = None,
+        module_name: str = "__main__",
+    ) -> NodeArchitype:
+        """Spawn a node instance of the given node_name with attributes."""
+        node_class = self.get_architype(module_name, node_name)
+        if isinstance(node_class, type) and issubclass(node_class, NodeArchitype):
+            if attributes is None:
+                attributes = {}
+            node_instance = node_class(**attributes)
+            return node_instance
+        else:
+            raise ValueError(f"Node {node_name} not found.")
+
+    def spawn_walker(
+        self,
+        walker_name: str,
+        attributes: Optional[dict] = None,
+        module_name: str = "__main__",
+    ) -> WalkerArchitype:
+        """Spawn a walker instance of the given walker_name."""
+        walker_class = self.get_architype(module_name, walker_name)
+        if isinstance(walker_class, type) and issubclass(walker_class, WalkerArchitype):
+            if attributes is None:
+                attributes = {}
+            walker_instance = walker_class(**attributes)
+            return walker_instance
+        else:
+            raise ValueError(f"Walker {walker_name} not found.")
+
+    def get_architype(
+        self, module_name: str, architype_name: str
+    ) -> Optional[Architype]:
+        """Retrieve an architype class from a module."""
+        module = self.loaded_modules.get(module_name)
+        if module:
+            return getattr(module, architype_name, None)
+        return None
+
     @staticmethod
     def get(base_path: str = "") -> "JacMachine":
         """Get current jac machine."""
@@ -134,6 +221,7 @@ class JacProgram:
         full_target: str,
         caller_dir: str,
         cachable: bool = True,
+        reload: bool = False,
     ) -> Optional[types.CodeType]:
         """Get the bytecode for a specific module."""
         if self.mod_bundle and isinstance(self.mod_bundle, Module):
@@ -141,7 +229,7 @@ class JacProgram:
             return marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
         gen_dir = os.path.join(caller_dir, Con.JAC_GEN_DIR)
         pyc_file_path = os.path.join(gen_dir, module_name + ".jbc")
-        if cachable and os.path.exists(pyc_file_path):
+        if cachable and os.path.exists(pyc_file_path) and not reload:
             with open(pyc_file_path, "rb") as f:
                 return marshal.load(f)
 

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/settings.py

@@ -17,6 +17,10 @@ class Settings:
     collect_py_dep_debug: bool = False
     print_py_raised_ast: bool = False
 
+    # Compiler configuration
+    disable_mtllm: bool = False
+    ignore_test_annex: bool = False
+
     # Formatter configuration
     max_line_length: int = 88
 

jaclang/tests/fixtures/bar.jac

@@ -31,4 +31,4 @@ walker bar_walk {
             disengage;
         }
     }
-}
+}

jaclang/tests/fixtures/builtins_test.jac

@@ -0,0 +1,16 @@
+with entry {
+    a: list[str] = [];
+    a.append("str1");
+    a.append("str2");
+    a.pop();
+    a.pop();
+
+    str(6).count("6");
+    int("5");
+
+    b: dict[str, list[int]] = {"a": [2, 3, 4]};
+    b.keys();
+    b["a"].append(9);
+
+    dir(a);
+}

jaclang/tests/fixtures/dynamic_architype.jac

@@ -0,0 +1,34 @@
+import:py from jaclang.runtimelib.machine {JacMachine}
+import:jac from bar {Item}
+
+node test_node {
+    has value:int;
+}
+
+walker test_walker {
+    can visit_nodes with `root entry {
+        visit [-->];
+    }
+
+    can print_value with test_node | Item entry {
+        print("Value:", f'{here.value}');
+    }
+}
+
+walker child_walker :test_walker: {}
+
+with entry {
+    for value in range(1, 4) {
+        root ++> test_node(value=value);
+        root ++> Item(value=value);
+    }
+    node_obj = JacMachine.get().spawn_node(node_name='test_node', attributes={'value': 0}, module_name='__main__');
+    walker_obj = JacMachine.get().spawn_walker(walker_name='child_walker', module_name='__main__');
+    external_node = JacMachine.get().spawn_node(node_name='Item', attributes={'value': 0}, module_name='bar');
+    root ++> external_node;
+    root ++> node_obj;
+    print("Spawned Node:", node_obj);
+    print("Spawned Walker:", walker_obj);
+    print("Spawned External node:", external_node);
+    root spawn walker_obj;
+}

jaclang/tests/fixtures/entry_exit.jac

@@ -0,0 +1,36 @@
+node test_node {
+    has value: int;
+}
+
+walker test_walker {
+    has visited_nodes: list = [];
+    has entry_count: int = 0;
+    has exit_count: int = 0;
+
+    can traverse with `root entry {
+        visit [-->](`?test_node);
+    }
+
+    can log_entry with entry {
+        print("Entering at the beginning of walker: ",here);
+        self.entry_count += 1;
+    }
+
+    can log_visit with test_node exit {
+        print("Visiting node : ", here);
+        self.visited_nodes.append(here);
+    }
+
+    can log_exit with exit {
+        print("Exiting at the end of walker: ",here);
+        self.exit_count += 1;
+    }
+}
+
+with entry {
+    for i in range(10) {
+        root ++> (next:=test_node(value=i));
+    }
+    wlk_obj = root spawn test_walker();
+    print(wlk_obj);
+}

jaclang/tests/fixtures/foo.jac

@@ -1,4 +1,3 @@
-import:py from jaclang.plugin.feature, JacFeature as Jac;
 import:py from jaclang.runtimelib.machine, JacMachine;
 import:jac from bar, bar_walk;
 # Test runner to initialize the walker

jaclang/tests/fixtures/match_multi_ex.jac

@@ -0,0 +1,12 @@
+with entry{
+    Num =10;
+    match Num{
+        case 2:
+            print("Two");
+        case 10:
+            print("Ten");
+            print("ten");
+        case _:
+            print("nothing");
+    }
+}

jaclang/tests/fixtures/trailing_comma.jac

@@ -0,0 +1,88 @@
+"""
+This test file is to ensure the valid syntax of jac lang.
+Add new jac syntax here to test if it compile without any issue.
+"""
+
+
+# Import statement without trailing comma.
+import:py from time { sleep, timezone, tzname }
+# Import statement with trailing comma.
+import:py from os { path, getenv, getpid,  }
+
+enum WithoutTrailComma {
+    FOO = "FOO",
+    BAR = "BAR"
+}
+
+enum WithTrailComma {
+    FOO = "FOO",
+    BAR = "BAR",
+}
+
+can without_trail_comma(a: int, b: int) {}
+
+can with_trail_comma(a: int, b: int, c: int, ) {}
+
+with entry {
+
+    dict_without_trail_comma = {"key": "value"};
+    dict_with_trail_comma = {"key": "val",};
+
+    list_without_trail_comma = ["foo", "bar"];
+    list_with_trail_comma = ["foo", "bar",];
+
+    set_without_trail_comma = {"foo", "bar"};
+    set_with_trail_comma = {"foo", "bar"};
+    obj foo11 {
+        has val: int,
+            val2: int = 9,
+            val3: int = 8,
+            val4: int = 8,
+            val5: int = 8;
+    }
+    empty_tuple = ();
+    single_tuple = ('single', );
+
+    tuple_without_trail_comma = ("foo", "bar");
+    tuple_with_trail_comma = ("foo", "bar", );
+
+    mixed_tuple = (1, 'two', 3.0, False);
+    mixed_tuple_with_trail_comma = (1, 'two', 3.0, False, );
+
+    nested_tuple = (1, (2, 3), 'four');
+    nested_tuple_with_trail_comma = (1, (2, 3), 'four', );
+
+    deeply_nested_tuple = (1, (2, (3, (4, 5))));
+    deeply_nested_tuple_with_trail_comma = (1, (2, (3, (4, 5))), );
+
+    tuple1 = ("foo", );
+    tuple1_2 = ("foo", "bar", "baz");
+    tuple_2_2 = ("foo", "bar", "baz", );
+
+    foo_instance1 = foo11(val=90);
+    foo_instance1_2 = foo11(val=90, );
+
+    foo_instance3 = foo11(2, 34, val3=90);
+    foo_instance3_2 = foo11(2, 34, val3=90, );
+
+    foo_instance4 = foo11(2, 34, val3=90, val4=90);
+    foo_instance4_2 = foo11(2, 34, val3=90, val4=90, );
+
+    func_tuple = (foo_instance1, foo_instance3_2, len(tuple1_2));
+    func_tuple_with_trail_comma = (foo_instance1, foo_instance3_2, len(tuple1_2), );
+
+    unpack_tuple = (1, 2, 3);
+    (a, b, c, ) = unpack_tuple;
+    values = (a, b, c);
+
+    (1, 2);
+    (1, 2, );
+    (1, 2, 3, 4);
+    (1, 2, 3, 4, );
+
+    val_f = (foo_instance3_2.val, foo_instance3_2.val2, foo_instance3_2.val3);
+    expression_tuple = (1 + 2, len("abc"), foo_instance1.val * 2);
+    tuple_with_list = (1, [2, 3], 4);
+    print("Code compiled and ran successfully!");
+
+}

jaclang/tests/fixtures/walker_update.jac

@@ -0,0 +1,19 @@
+import:jac from bar { bar_walk }
+import:py from jaclang.runtimelib.machine { JacMachine }
+import:py os;
+
+can update_bar_walker {
+    "Updating bar.jac with new behavior." |> print;
+    (bar_walk_new, ) = JacMachine.get().update_walker(
+        "bar",
+        items={'bar_walk': None}
+    );
+    "Running bar_walk after update..." |> print;
+    root spawn bar_walk_new();
+    print(f"bar_walk: {bar_walk_new.__dict__}");
+}
+
+
+with entry {
+    update_bar_walker();
+}

jaclang/tests/test_cli.py

@@ -190,6 +190,33 @@ class JacCliTests(TestCase):
             r"8\:37 \- 8:44.*ModuleItem - display - abs_path\:.*fixtures/pygame_mock/display.py",
         )
 
+    def test_builtins_loading(self) -> None:
+        """Testing for print AstTool."""
+        from jaclang.settings import settings
+
+        settings.ast_symbol_info_detailed = True
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('builtins_test.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        settings.ast_symbol_info_detailed = False
+
+        self.assertRegex(
+            stdout_value,
+            r"2\:8 \- 2\:12.*BuiltinType - list - .*SymbolPath: builtins_test.builtins.list",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"15\:5 \- 15\:8.*Name - dir - .*SymbolPath: builtins_test.builtins.dir",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"13\:12 \- 13\:18.*Name - append - .*SymbolPath: builtins_test.builtins.list.append",
+        )
+
     def test_ast_dotgen(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()
@@ -218,8 +245,8 @@ class JacCliTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("type_info.ServerWrapper"), 7)
-        self.assertEqual(stdout_value.count("builtins.int"), 2)
-        self.assertEqual(stdout_value.count("builtins.str"), 7)
+        self.assertEqual(stdout_value.count("builtins.int"), 3)
+        self.assertEqual(stdout_value.count("builtins.str"), 10)
 
     def test_build_and_run(self) -> None:
         """Testing for print AstTool."""