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

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."""

jaclang/tests/test_language.py

@@ -522,7 +522,7 @@ class JacLanguageTests(TestCase):
         self.assertIn("can greet2(**kwargs: Any) {", output)
         self.assertIn("squares_dict = {x: (x ** 2)  for x in numbers};", output)
         self.assertIn(
-            '\n\n@ my_decorator \n can say_hello() {\n    """Say hello""" ; ', output
+            '\n\n@ my_decorator \n can say_hello() {\n\n    """Say hello""" ;', output
         )
 
     def test_needs_import_2(self) -> None:
@@ -568,7 +568,7 @@ class JacLanguageTests(TestCase):
                     py_ast.parse(f.read()), mod_path=py_out_path
                 ),
             ).ir.unparse()
-        self.assertIn("class X {\n    with entry {\n        a_b = 67;", output)
+        self.assertIn("class X {\n    with entry {\n\n        a_b = 67;", output)
         self.assertIn("br = b'Hello\\\\\\\\nWorld'", output)
         self.assertIn("class Circle {\n    can init(radius: float", output)
         self.assertIn("<>node = 90;    \n    print(<>node) ;\n}\n", output)
@@ -677,6 +677,15 @@ class JacLanguageTests(TestCase):
         self.assertIn("1", stdout_value[0])
         self.assertIn("[2, 3, 4]", stdout_value[1])
 
+    def test_trailing_comma(self) -> None:
+        """Test trailing comma."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("trailing_comma", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("Code compiled and ran successfully!", stdout_value)
+
     def test_try_finally(self) -> None:
         """Test try finally."""
         captured_output = io.StringIO()
@@ -952,6 +961,103 @@ class JacLanguageTests(TestCase):
         self.assertIn("Item value: 0", stdout_value)
         self.assertIn("Created 5 items.", stdout_value)
 
+    def test_walker_dynamic_update(self) -> None:
+        """Test dynamic update of a walker during runtime."""
+        session = self.fixture_abs_path("bar_walk.session")
+        bar_file_path = self.fixture_abs_path("bar.jac")
+        update_file_path = self.fixture_abs_path("walker_update.jac")
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.enter(
+            filename=bar_file_path,
+            session=session,
+            entrypoint="bar_walk",
+            args=[],
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        expected_output = "Created 5 items."
+        self.assertIn(expected_output, stdout_value.split("\n"))
+        # Define the new behavior to be added
+        new_behavior = """
+        # New behavior added during runtime
+        can end with `root exit {
+            "bar_walk has been updated with new behavior!" |> print;
+            disengage;
+            }
+        }
+        """
+
+        # Backup the original file content
+        with open(bar_file_path, "r") as bar_file:
+            original_content = bar_file.read()
+
+        # Update the bar.jac file with new behavior
+        with open(bar_file_path, "r+") as bar_file:
+            content = bar_file.read()
+            last_brace_index = content.rfind("}")
+            if last_brace_index != -1:
+                updated_content = content[:last_brace_index] + new_behavior
+                bar_file.seek(0)
+                bar_file.write(updated_content)
+                bar_file.truncate()
+
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        try:
+            cli.run(
+                filename=update_file_path,
+            )
+            sys.stdout = sys.__stdout__
+            stdout_value = captured_output.getvalue()
+            expected_output = "bar_walk has been updated with new behavior!"
+            self.assertIn(expected_output, stdout_value.split("\n"))
+        finally:
+            # Restore the original content of bar.jac
+            with open(bar_file_path, "w") as bar_file:
+                bar_file.write(original_content)
+
+    def test_dynamic_spawn_architype(self) -> None:
+        """Test that the walker and node can be spawned and behaves as expected."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("dynamic_architype.jac"))
+
+        output = captured_output.getvalue().strip()
+        output_lines = output.split("\n")
+
+        # Expected outputs for spawned entities
+        expected_spawned_node = "Spawned Node:"
+        expected_spawned_walker = "Spawned Walker:"
+        expected_spawned_external_node = "Spawned External node:"
+
+        # Check for the spawned messages
+        self.assertTrue(
+            any(expected_spawned_node in line for line in output_lines),
+            f"Expected '{expected_spawned_node}' in output.",
+        )
+        self.assertTrue(
+            any(expected_spawned_walker in line for line in output_lines),
+            f"Expected '{expected_spawned_walker}' in output.",
+        )
+        self.assertTrue(
+            any(expected_spawned_external_node in line for line in output_lines),
+            f"Expected '{expected_spawned_external_node}' in output.",
+        )
+
+        # Expected values from the walker traversal
+        expected_values = ["Value: 0", "Value: 1", "Value: 2", "Value: 3"]
+
+        # Each expected value should appear twice (once for test_node, once for Item)
+        for val in expected_values:
+            occurrences = [line for line in output_lines if line.strip() == val]
+            self.assertEqual(
+                len(occurrences),
+                2,
+                f"Expected '{val}' to appear 2 times, but found {len(occurrences)}.",
+            )
+
     def test_object_ref_interface(self) -> None:
         """Test class method output."""
         captured_output = io.StringIO()
@@ -962,3 +1068,26 @@ class JacLanguageTests(TestCase):
         self.assertEqual(len(stdout_value[0]), 32)
         self.assertEqual("MyNode(value=0)", stdout_value[1])
         self.assertEqual("valid: True", stdout_value[2])
+
+    def test_match_multi_ex(self) -> None:
+        """Test match case with multiple expressions."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("match_multi_ex", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertEqual("Ten", stdout_value[0])
+        self.assertEqual("ten", stdout_value[1])
+
+    def test_entry_exit(self) -> None:
+        """Test entry and exit behavior of walker."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("entry_exit", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Entering at the beginning of walker:  Root()", stdout_value[0])
+        self.assertIn("entry_count=1, exit_count=1", str(stdout_value[12]))
+        self.assertIn(
+            "Exiting at the end of walker:  test_node(value=", stdout_value[11]
+        )

jaclang/utils/treeprinter.py

@@ -113,7 +113,7 @@ def print_ast_tree(
                     if node.sym
                     else "<No Symbol is associated with this node>"
                 )
-                out += f" SymbolPath: {symbol}"
+                out += f", SymbolPath: {symbol}"
             return out
         elif isinstance(node, Token):
             return f"{node.__class__.__name__} - {node.value}, {access}"