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

jaclang/tests/fixtures/builtin_dotgen.jac

@@ -31,6 +31,7 @@ with entry{
     print(d2.count('a(val')==19,d2.count('#F5E5FF')==2 ,'Edge1' not in d2,d2.count('GenericEdge')==42);
     print(d3.count('a(val')==6,d3.count("GenericEdge")==5,d3.count('#F5E5FF')==1);
     print(d4.count("a(val")==25,d4.count("GenericEdge")==66,d4.count('#FFF0F')==3);
+    print(d5.count("Edge1(val=6)")==2, d5.count("GenericEdge()")==24);
     # print(l3<l2);
     # print(d1);
     # print(d2);

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/objref.jac

@@ -0,0 +1,12 @@
+node MyNode {
+    has value: int = 0;
+}
+
+with entry {
+    root ++> (x:=MyNode());
+    obj_id = jid(x);
+    myobj = &obj_id;
+    print(obj_id);
+    print(myobj);
+    print("valid:", myobj == x);
+}

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

@@ -39,7 +39,7 @@ class JacLanguageTests(TestCase):
         sys.stdout = captured_output
 
         # Execute the function
-        cli.run(self.fixture_abs_path("sub_abil_sep.jac"))  # type: ignore
+        cli.run(self.fixture_abs_path("sub_abil_sep.jac"))
 
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -376,7 +376,7 @@ class JacLanguageTests(TestCase):
         jac_import("builtin_dotgen", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertEqual(stdout_value.count("True"), 14)
+        self.assertEqual(stdout_value.count("True"), 16)
 
     def test_with_contexts(self) -> None:
         """Test walking through edges."""
@@ -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()
@@ -951,3 +960,134 @@ class JacLanguageTests(TestCase):
         self.assertIn("Edges in bar:\n  - Edge: Link", stdout_value)
         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()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("objref.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        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}"

{jaclang-0.7.17.dist-info → jaclang-0.7.21.dist-info}/METADATA

@@ -1,18 +1,22 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.17
+Version: 0.7.21
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT
 Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence
 Author: Jason Mars
 Author-email: jason@jaseci.org
+Maintainer: Jason Mars
+Maintainer-email: jason@jaseci.org
 Requires-Python: >=3.11.0,<4.0.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: all
 Provides-Extra: llm
+Provides-Extra: streamlit
 Project-URL: Documentation, https://jac-lang.org
 Project-URL: Repository, https://github.com/Jaseci-Labs/jaclang
 Description-Content-Type: text/markdown
@@ -40,7 +44,7 @@ This is the main source code repository for the [Jac] programming language. It c
 [Documentation]: https://www.jac-lang.org//learn/guide/
 [Contributing]: .github/CONTRIBUTING.md
 
-## What and Why Jac?
+## What and Why is Jac?
 
 - **Native Superset of Python** - Jac is a native superset of python, meaning the entire python ecosystem is directly interoperable with Jac without any trickery (no interop interface needed). Like Typescript is to Javascript, or C++ is to C, Jac is to Python. (every Jac program can be ejected to pure python, and every python program can be transpiled to a Jac program)