jaclang 0.8.1__py3-none-any.whl → 0.8.3__py3-none-any.whl

jaclang/tests/test_language.py

@@ -5,11 +5,12 @@ import os
 import sys
 import sysconfig
 import tempfile
+import subprocess
+from pathlib import Path
 from unittest.mock import patch
 
-from jaclang import JacMachineInterface as Jac, JacMachine
+from jaclang import JacMachine as Jac
 from jaclang.cli import cli
-from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
@@ -19,15 +20,16 @@ class JacLanguageTests(TestCase):
 
     def setUp(self) -> None:
         """Set up test."""
-        self.mach = JacMachine(self.fixture_abs_path("./"))
+        Jac.reset_machine()
+        Jac.set_base_path(self.fixture_abs_path("./"))
         Jac.attach_program(
-            self.mach,
             JacProgram(),
         )
         return super().setUp()
 
     def tearDown(self) -> None:
         """Tear down test."""
+        Jac.reset_machine()
         return super().tearDown()
 
     def test_sub_abilities(self) -> None:
@@ -69,7 +71,6 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach,
             "micro.simple_walk",
             base_path=self.examples_abs_path(""),
             override_name="__main__",
@@ -87,7 +88,7 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach, "micro.simple_walk_by_edge", base_path=self.examples_abs_path("")
+            "micro.simple_walk_by_edge", base_path=self.examples_abs_path("")
         )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -100,7 +101,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "guess_game", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("guess_game", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -114,9 +115,7 @@ class JacLanguageTests(TestCase):
 
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "builtin_printgraph_json", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("builtin_printgraph_json", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         data = json.loads(stdout_value)
@@ -135,7 +134,6 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach,
             "builtin_printgraph_mermaid",
             base_path=self.fixture_abs_path("./"),
         )
@@ -147,7 +145,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "chandra_bugs", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("chandra_bugs", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -159,9 +157,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "chandra_bugs2", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("chandra_bugs2", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -176,7 +172,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "ignore_dup", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("ignore_dup", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.split("\n")[0].count("here"), 10)
@@ -186,16 +182,16 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "hashcheck_dup", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("hashcheck_dup", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("check"), 2)
 
     def test_arith_precedence(self) -> None:
         """Basic precedence test."""
-        prog = JacProgram().compile_from_str("with entry {print(4-5-4);}", "test.jac")
+        prog = JacProgram().compile(
+            use_str="with entry {print(4-5-4);}", file_path="test.jac"
+        )
         captured_output = io.StringIO()
         sys.stdout = captured_output
         exec(compile(prog.gen.py_ast[0], "test.py", "exec"))
@@ -207,7 +203,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "needs_import", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("needs_import", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("<module 'pyfunc' from", stdout_value)
@@ -217,7 +213,6 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach,
             "reference.special_comprehensions",
             base_path=self.examples_abs_path(""),
         )
@@ -229,9 +224,7 @@ class JacLanguageTests(TestCase):
         """Test the dot gen of nodes and edges of bubblesort."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "gendot_bubble_sort", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("gendot_bubble_sort", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -243,9 +236,7 @@ class JacLanguageTests(TestCase):
         """Test assign_compr."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "assign_compr_dup", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("assign_compr_dup", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -257,9 +248,7 @@ class JacLanguageTests(TestCase):
         """Test raw string and byte string."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "raw_byte_string", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("raw_byte_string", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count(r"\\\\"), 2)
@@ -270,7 +259,6 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach,
             "compiler/passes/main/tests/fixtures/fstrings",
             base_path=self.fixture_abs_path("../../"),
         )
@@ -286,36 +274,30 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
 
-        Jac.jac_import(self.mach, "deep_import", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("deep_import", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        print(self.mach.loaded_modules.keys())
         self.assertEqual(stdout_value.split("\n")[0], "one level deeperslHello World!")
 
     def test_deep_imports_interp_mode(self) -> None:
         """Parse micro jac file."""
-        mach = JacMachine(self.fixture_abs_path("./"))
+        Jac.set_base_path(self.fixture_abs_path("./"))
         Jac.attach_program(
-            mach,
             JacProgram(),
         )
-        Jac.jac_import(
-            mach, "deep_import_interp", base_path=self.fixture_abs_path("./")
-        )
-        self.assertEqual(len(mach.program.mod.hub.keys()), 1)
-        mach = JacMachine(self.fixture_abs_path("./"))
+        Jac.jac_import("deep_import_interp", base_path=self.fixture_abs_path("./"))
+        self.assertEqual(len(Jac.program.mod.hub.keys()), 1)
+        Jac.set_base_path(self.fixture_abs_path("./"))
         Jac.attach_program(
-            mach,
             (prog := JacProgram()),
         )
-        prog.compile(self.fixture_abs_path("./deep_import_interp.jac"))
-        Jac.jac_import(
-            mach, "deep_import_interp", base_path=self.fixture_abs_path("./")
-        )
-        self.assertEqual(len(mach.program.mod.hub.keys()), 5)
+        prog.build(self.fixture_abs_path("./deep_import_interp.jac"))
+        Jac.jac_import("deep_import_interp", base_path=self.fixture_abs_path("./"))
+        self.assertEqual(len(Jac.program.mod.hub.keys()), 5)
 
     def test_deep_imports_mods(self) -> None:
         """Parse micro jac file."""
+        Jac.reset_machine()
         targets = [
             "deep",
             "deep.deeper",
@@ -326,20 +308,19 @@ class JacLanguageTests(TestCase):
         for i in targets:
             if i in sys.modules:
                 del sys.modules[i]
-        Jac.jac_import(
-            self.mach, "deep_import_mods", base_path=self.fixture_abs_path("./")
-        )
-        mods = self.mach.loaded_modules.keys()
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("deep_import_mods", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = eval(captured_output.getvalue())
         for i in targets:
-            self.assertIn(i, mods)
-        self.assertEqual(len([i for i in mods if i.startswith("deep")]), 6)
+            self.assertIn(i, stdout_value)
 
     def test_deep_outer_imports_one(self) -> None:
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach,
             "deep.deeper.deep_outer_import",
             base_path=self.fixture_abs_path("./"),
         )
@@ -363,7 +344,7 @@ class JacLanguageTests(TestCase):
         """Test has lambda_goodness."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "has_goodness", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("has_goodness", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.split("\n")[0], "mylist:  [1, 2, 3]")
@@ -373,7 +354,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "edge_ops", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("edge_ops", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("[(3, 5), (14, 1), (5, 1)]", stdout_value)
@@ -384,7 +365,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "disconn", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("disconn", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("c(cc=0)", stdout_value[0])
@@ -401,7 +382,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "simple_archs", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("simple_archs", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.split("\n")[0], "1 2 0")
@@ -411,7 +392,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "edges_walk", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("edges_walk", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("creator()\n", stdout_value)
@@ -424,7 +405,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "tuplytuples", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("tuplytuples", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -436,9 +417,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "deferred_field", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("deferred_field", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -450,9 +429,7 @@ class JacLanguageTests(TestCase):
         """Test the dot gen of nodes and edges as a builtin."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "builtin_printgraph", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("builtin_printgraph", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("True"), 16)
@@ -461,7 +438,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "with_context", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("with_context", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("im in", stdout_value)
@@ -476,9 +453,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "micro.typed_filter_compr", base_path=self.examples_abs_path("")
-        )
+        Jac.jac_import("micro.typed_filter_compr", base_path=self.examples_abs_path(""))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -492,9 +467,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges and nodes."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "edge_node_walk", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("edge_node_walk", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("creator()\n", stdout_value)
@@ -513,9 +486,7 @@ class JacLanguageTests(TestCase):
         """Test Enum as member stmt."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "enum_inside_archtype", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("enum_inside_archtype", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("2 Accessing privileged Data", stdout_value)
@@ -536,7 +507,6 @@ class JacLanguageTests(TestCase):
                 ),
                 prog=JacProgram(),
             ).ir_out.unparse()
-        print(output)
         self.assertIn("def greet2(**kwargs: Any)", output)
         self.assertEqual(output.count("with entry {"), 14)
         self.assertIn("assert (x == 5) , 'x should be equal to 5' ;", output)
@@ -607,7 +577,7 @@ class JacLanguageTests(TestCase):
                 ),
                 prog=None,
             ).ir_out.unparse()
-        self.assertIn("match Container(inner=Inner(x=a, y=b)) { \n", output)
+        self.assertIn("match Container(inner=Inner(x=a, y=b)) {\n", output)
         self.assertIn("case Container(inner = Inner(x = a, y = 0)):\n", output)
         self.assertIn("case Container(inner = Inner(x = a, y = b)):\n", output)
         self.assertIn("case _:\n", output)
@@ -616,7 +586,7 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "refs_target", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("refs_target", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("[c(val=0), c(val=1), c(val=2)]", stdout_value)
@@ -624,14 +594,14 @@ class JacLanguageTests(TestCase):
 
     def test_py_kw_as_name_disallowed(self) -> None:
         """Basic precedence test."""
-        (prog := JacProgram()).compile_from_str(
-            "with entry {print.is.not.True(4-5-4);}", "test.jac"
+        (prog := JacProgram()).compile(
+            use_str="with entry {print.is.not.True(4-5-4);}", file_path="test.jac"
         )
         self.assertIn("Python keyword is used as name", str(prog.errors_had[0].msg))
 
     def test_double_format_issue(self) -> None:
         """Basic precedence test."""
-        prog = JacProgram().compile_from_str("with entry {print(hello);}", "test.jac")
+        prog = JacProgram().compile("with entry {print(hello);}", "test.jac")
         prog.unparse()
         before = prog.format()
         prog.format()
@@ -643,9 +613,7 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "inherit_check", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("inherit_check", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual("I am in b\nI am in b\nwww is also in b\n", stdout_value)
@@ -654,7 +622,7 @@ class JacLanguageTests(TestCase):
         """Test tuple unpack."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "tupleunpack", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("tupleunpack", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("1", stdout_value[0])
@@ -664,9 +632,7 @@ class JacLanguageTests(TestCase):
         """Test trailing comma."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "trailing_comma", base_path=self.fixture_abs_path("./")
-        )
+        Jac.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)
@@ -675,7 +641,7 @@ class JacLanguageTests(TestCase):
         """Test try finally."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "try_finally", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("try_finally", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("try block", stdout_value[0])
@@ -688,9 +654,7 @@ class JacLanguageTests(TestCase):
         """Test arithmetic bug."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "arithmetic_bug", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("arithmetic_bug", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("0.0625", stdout_value[0])
@@ -703,7 +667,7 @@ class JacLanguageTests(TestCase):
         """Test lambda expr."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "lambda", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("lambda", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("9", stdout_value[0])
@@ -713,9 +677,7 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "walker_override", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("walker_override", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual("baz\nbar\n", stdout_value)
@@ -724,7 +686,7 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "nosigself", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("nosigself", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("5"), 2)
@@ -733,9 +695,7 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "hash_init_check", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("hash_init_check", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("Test Passed", stdout_value)
@@ -765,9 +725,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "edgetypeissue", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("edgetypeissue", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("[x()]", stdout_value)
@@ -776,9 +734,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "blankwithentry", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("blankwithentry", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("i work", stdout_value)
@@ -787,7 +743,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "dblhello", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("dblhello", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("Hello World!"), 1)
@@ -797,7 +753,7 @@ class JacLanguageTests(TestCase):
         """Test class method output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "cls_method", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("cls_method", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("MyClass", stdout_value[0])
@@ -806,10 +762,14 @@ class JacLanguageTests(TestCase):
 
     def test_list_methods(self) -> None:
         """Test list_modules, list_walkers, list_nodes, and list_edges."""
+        Jac.reset_machine()
+        Jac.set_base_path(self.fixture_abs_path("."))
+        sys.modules.pop("foo", None)
+        sys.modules.pop("bar", None)
         captured_output = io.StringIO()
         sys.stdout = captured_output
 
-        Jac.jac_import(self.mach, "foo", base_path=self.fixture_abs_path("."))
+        Jac.jac_import("foo", base_path=self.fixture_abs_path("."))
 
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -833,6 +793,9 @@ class JacLanguageTests(TestCase):
 
     def test_walker_dynamic_update(self) -> None:
         """Test dynamic update of a walker during runtime."""
+        Jac.reset_machine()
+        Jac.set_base_path(self.fixture_abs_path("."))
+        sys.modules.pop("bar", None)
         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")
@@ -846,6 +809,7 @@ class JacLanguageTests(TestCase):
         )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
+        os.remove(session) if os.path.exists(session) else None
         expected_output = "Created 5 items."
         self.assertIn(expected_output, stdout_value.split("\n"))
         # Define the new behavior to be added
@@ -975,9 +939,7 @@ class JacLanguageTests(TestCase):
         """Test match case with multiple expressions."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "match_multi_ex", base_path=self.fixture_abs_path("./")
-        )
+        Jac.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])
@@ -987,7 +949,7 @@ class JacLanguageTests(TestCase):
         """Test entry and exit behavior of walker."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "entry_exit", base_path=self.fixture_abs_path("./"))
+        Jac.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])
@@ -1000,7 +962,7 @@ class JacLanguageTests(TestCase):
         """Test entry and exit behavior of walker."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "visit_order", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("visit_order", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual("[MyNode(Name='End'), MyNode(Name='Middle')]\n", stdout_value)
@@ -1009,9 +971,7 @@ class JacLanguageTests(TestCase):
         """Test supporting multiple global variable in a statement."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "glob_multivar_statement", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("glob_multivar_statement", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Hello World !", stdout_value[0])
@@ -1021,9 +981,7 @@ class JacLanguageTests(TestCase):
         """Test archetype definition bug."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "archetype_def_bug", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("archetype_def_bug", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("MyWalker", stdout_value[0])
@@ -1033,9 +991,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "visit_sequence", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("visit_sequence", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         self.assertEqual(
             "walker entry\nwalker enter to root\n"
@@ -1050,9 +1006,7 @@ class JacLanguageTests(TestCase):
         """Test connect traverse syntax."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "connect_traverse_syntax", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("connect_traverse_syntax", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("A(val=5), A(val=10)", stdout_value[0])
@@ -1068,7 +1022,7 @@ class JacLanguageTests(TestCase):
         """Test complex nested impls."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "node_del", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("node_del", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("0 : [2, 3, 4, 5, 6, 7, 8, 9, 10]", stdout_value[0])
@@ -1108,7 +1062,7 @@ class JacLanguageTests(TestCase):
                 sys.stdout = captured_output
                 original_cwd = os.getcwd()
                 try:
-                    Jac.jac_import(self.mach, "importer_site", base_path=tmpdir)
+                    Jac.jac_import("importer_site", base_path=tmpdir)
                 finally:
                     os.chdir(original_cwd)
                     sys.stdout = sys.__stdout__
@@ -1197,19 +1151,18 @@ class JacLanguageTests(TestCase):
         """Test async walker."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "async_walker", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("async_walker", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
-        self.assertNotIn("It is non blocking", stdout_value[4])
-        self.assertIn("W(num=8)", stdout_value[5])
+        self.assertIn("Let's start the task", stdout_value[0])
+        self.assertIn("It is Coroutine task True", stdout_value[1])
+        self.assertIn("Coroutine task is completed", stdout_value[6])
 
-    def test_async_ability(self) -> None:
+    def test_async_function(self) -> None:
         """Test async ability."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "async_ability", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("async_function", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Hello", stdout_value[0])
@@ -1220,7 +1173,7 @@ class JacLanguageTests(TestCase):
         """Test concurrency in jaclang."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "concurrency", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("concurrency", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Started", stdout_value[0])
@@ -1286,9 +1239,7 @@ class JacLanguageTests(TestCase):
         """Test visitor, here keyword usage in jaclang."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "here_visitor_usage", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("here_visitor_usage", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Here value is  10", stdout_value[0])
@@ -1342,3 +1293,50 @@ class JacLanguageTests(TestCase):
         self.assertIn("MyWalker() from node MyNode(val=40)", stdout_value[6])
         self.assertIn("MyWalker() from node MyNode(val=90)", stdout_value[7])
         self.assertIn("MyWalker() from node MyNode(val=70)", stdout_value[9])
+
+    def test_async_ability(self) -> None:
+        """Test async ability."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("async_ability", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Let's start the task", stdout_value[0])
+        self.assertIn("It is Coroutine task True", stdout_value[1])
+        self.assertIn("I am here man MyNode(val=5)", stdout_value[2])
+        self.assertIn("Async function", stdout_value[3])
+        self.assertIn("foo3", stdout_value[4])
+        self.assertIn("foo1", stdout_value[5])
+        self.assertIn("foo2", stdout_value[6])
+        self.assertIn("Coroutine task is completed", stdout_value[17])
+
+    def test_unicode_string_literals(self) -> None:
+        """Test unicode characters in string literals are preserved correctly."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("unicode_strings", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("1. ✓ 1st (due: True)", stdout_value[0])
+        self.assertIn("🌟 Star", stdout_value[2])
+        self.assertIn("Multi-line with ✓ unicode and ○ symbols", stdout_value[3])
+        self.assertIn("Raw string with ✓ and ○", stdout_value[4])
+        self.assertIn("Tab ✓", stdout_value[5])
+        self.assertIn("Newline ○", stdout_value[6])
+
+    def test_sitecustomize_meta_importer(self) -> None:
+        """Verify Jac modules importable without importing jaclang."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            Path(tmpdir, "mymod.jac").write_text('with entry {print("via meta");}')
+            env = os.environ.copy()
+            project_root = Path(__file__).resolve().parents[2]
+            env["PYTHONPATH"] = os.pathsep.join([str(project_root), tmpdir])
+            proc = subprocess.run(
+                [sys.executable, "-c", "import mymod"],
+                capture_output=True,
+                text=True,
+                cwd=tmpdir,
+                env=env,
+            )
+            self.assertEqual(proc.returncode, 0, proc.stderr)
+            self.assertEqual(proc.stdout.strip(), "via meta")