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

jaclang/tests/fixtures/here_visitor_usage.jac

@@ -0,0 +1,21 @@
+node MyNode{
+    has val:int;
+
+    can ability1 with MyWalker entry {
+        print("Visitor name is ",visitor.name);
+    }
+}
+
+walker MyWalker{
+    has name:str;
+
+    can ability2 with MyNode entry {
+        print("Here value is ",here.val);
+    }
+}
+
+with entry {
+    Node1 = MyNode(10);
+    Walker1 = MyWalker("Walker 1");
+    Walker1 spawn Node1;
+}

jaclang/tests/fixtures/node_del.jac

@@ -2,48 +2,44 @@ node person {
     has age: int;
 }
 
-with entry {
-    p1 = person(10); p5 = person(50);
-    p2 = person(20); p6 = person(60);
-    p3 = person(30); p7 = person(70);
-    p4 = person(40); p8 = person(80);
 
-    root ++> p1++> p2++> p3++> p4;
-    root ++> p5++> p6++> p7++> p8;
+with entry {
+    p1 = person(10);
+    p5 = person(50);
+    p2 = person(20);
+    p6 = person(60);
+    p3 = person(30);
+    p7 = person(70);
+    p4 = person(40);
+    p8 = person(80);
+    root ++> p1 ++> p2 ++> p3 ++> p4;
+    root ++> p5 ++> p6 ++> p7 ++> p8;
     p4 ++> p8;
-
     # # before deletion
-    a = dotgen(root);
-    assert a.count('label=""]') == 9;
-    assert a.count('[label="person(') == 8;
-
+     a = printgraph(root);
+    assert a.count('label=""]') == 9 ;
+    assert a.count('[label="person(') == 8 ;
     # # delete p2
-    del p2;
-    b = dotgen(root);
-    assert b.count('label="person') == 7;
-    assert 'age=20' not in b;
-
+     del p2 ;
+    b = printgraph(root);
+    assert b.count('label="person') == 7 ;
+    assert 'age=20' not in b ;
     # doublecheck p3 also doesnot attach to it
-    c = dotgen(p3);
-    assert c.count('label="person') == 7;
-    assert 'age=20' not in c;
-
-
+     c = printgraph(p3);
+    assert c.count('label="person') == 7 ;
+    assert 'age=20' not in c ;
     # # del multiple nodes
-    del [p1, p4];
-    d = dotgen(root);
-    assert d.count('label="person') == 4;
-    for i in [10, 20, 30, 40 ]{
-        assert f'age={i}' not in d;
+     del [p1, p4] ;
+    d = printgraph(root);
+    assert d.count('label="person') == 4 ;
+    for i in [10, 20, 30, 40] {
+        assert f'age={i}' not in d ;
     }
-
-
-    apple_list = [1, 2, 3, 4, 5,6,7,8,9,10];
-    del apple_list[0];
+    apple_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    del apple_list[0] ;
     print('apple list after delete 0 :', apple_list);
-    del [apple_list[6], apple_list[7]];
+    del [apple_list[6], apple_list[7]] ;
     print('apple list after delete 7, 8 :', apple_list);
-
     obj Inner {
         has c: list;
         has d: int;
@@ -52,9 +48,7 @@ with entry {
         has b: Inner;
     }
     a = Outer(b=Inner(c=[1, 2, 3], d=4));
-
     print('a.b before delete :', a.b);
-    del a.b.c[1];
+    del a.b.c[1] ;
     print('a.b after delete :', a.b);
-
 }

jaclang/tests/fixtures/visit_traversal.jac

@@ -0,0 +1,47 @@
+node MyNode {
+    has val:int;
+
+    can do with MyWalker entry {
+        print( visitor,"from node", self);
+    }
+}
+
+edge MyEdge {
+    has path:int;
+
+    can do with MyWalker entry {
+        print(visitor,"from edge",self);
+    }
+}
+
+walker MyWalker {
+    can does with MyNode entry {
+        if here.val == 20{
+            visit :0:[-->];
+        }
+        elif here.val == 30 {
+            visit :-1:[-->];
+        }
+        elif here.val == 40 {
+            visit :-8:[-->]; # test out of index
+        }
+        else {
+            visit [-->];
+        }
+        
+    }
+}
+
+with entry {
+    n0 = MyNode(0);
+    n1 = MyNode(10);
+    n2 = MyNode(20);
+    n3 = MyNode(30);
+    n4 = MyNode(40);
+    root ++> n0 ++> n1;
+    n1 ++> [n2, n3, n4, MyNode(45)];
+    n2 ++> [MyNode(50), MyNode(60)];
+    n3 ++> MyNode(70);
+    n4 ++> MyNode(90);
+    MyWalker() spawn n0;
+}

jaclang/tests/test_cli.py

@@ -11,7 +11,7 @@ import traceback
 import unittest
 from jaclang.cli import cli
 from jaclang.cli.cmdreg import cmd_registry, extract_param_descriptions
-from jaclang.runtimelib.builtin import dotgen
+from jaclang.runtimelib.builtin import printgraph
 from jaclang.utils.test import TestCase
 
 
@@ -190,7 +190,7 @@ class JacCliTests(TestCase):
             r"13\:12 \- 13\:18.*Name - append - .*SymbolPath: builtins.list.append",
         )
 
-    def test_ast_dotgen(self) -> None:
+    def test_ast_printgraph(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
@@ -293,11 +293,16 @@ class JacCliTests(TestCase):
     def test_graph_coverage(self) -> None:
         """Test for coverage of graph cmd."""
         graph_params = set(inspect.signature(cli.dot).parameters.keys())
-        dotgen_params = set(inspect.signature(dotgen).parameters.keys())
-        dotgen_params = dotgen_params - {"node", "dot_file", "edge_type", "as_json"}
-        dotgen_params.update({"initial", "saveto", "connection", "session"})
-        self.assertTrue(dotgen_params.issubset(graph_params))
-        self.assertEqual(len(dotgen_params) + 1, len(graph_params))
+        printgraph_params = set(inspect.signature(printgraph).parameters.keys())
+        printgraph_params = printgraph_params - {
+            "node",
+            "file",
+            "edge_type",
+            "format",
+        }
+        printgraph_params.update({"initial", "saveto", "connection", "session"})
+        self.assertTrue(printgraph_params.issubset(graph_params))
+        self.assertEqual(len(printgraph_params) + 1, len(graph_params))
 
     def test_graph(self) -> None:
         """Test for graph CLI cmd."""

jaclang/tests/test_language.py

@@ -108,14 +108,14 @@ class JacLanguageTests(TestCase):
             "Too high!\nToo low!\nToo high!\nCongratulations! You guessed correctly.\n",
         )
 
-    def test_dotgen(self) -> None:
+    def test_printgraph(self) -> None:
         """Test the dot gen of builtin function."""
         import json
 
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach, "builtin_dotgen_json", base_path=self.fixture_abs_path("./")
+            self.mach, "builtin_printgraph_json", base_path=self.fixture_abs_path("./")
         )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -130,6 +130,19 @@ class JacLanguageTests(TestCase):
         edges = data["edges"]
         self.assertEqual(len(edges), 6)
 
+    def test_printgraph_mermaid(self) -> None:
+        """Test the mermaid gen of builtin function."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import(
+            self.mach,
+            "builtin_printgraph_mermaid",
+            base_path=self.fixture_abs_path("./"),
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("flowchart LR", stdout_value)
+
     def test_chandra_bugs(self) -> None:
         """Parse micro jac file."""
         captured_output = io.StringIO()
@@ -155,7 +168,7 @@ class JacLanguageTests(TestCase):
             stdout_value,
             "{'apple': None, 'pineapple': None}\n"
             "This is a long\n"
-            "    line of code.\n"
+            "        line of code.\n"
             "{'a': 'apple', 'b': 'ball', 'c': 'cat', 'd': 'dog', 'e': 'elephant'}\n",
         )
 
@@ -281,7 +294,7 @@ class JacLanguageTests(TestCase):
 
     def test_deep_imports_interp_mode(self) -> None:
         """Parse micro jac file."""
-        mach = JacMachine(self.fixture_abs_path("./"), interp_mode=True)
+        mach = JacMachine(self.fixture_abs_path("./"))
         Jac.attach_program(
             mach,
             JacProgram(),
@@ -289,18 +302,17 @@ class JacLanguageTests(TestCase):
         Jac.jac_import(
             mach, "deep_import_interp", base_path=self.fixture_abs_path("./")
         )
-        print(mach.jac_program.mod.hub.keys())
-        self.assertEqual(len(mach.jac_program.mod.hub.keys()), 1)
-        mach = JacMachine(self.fixture_abs_path("./"), interp_mode=False)
+        self.assertEqual(len(mach.program.mod.hub.keys()), 1)
+        mach = JacMachine(self.fixture_abs_path("./"))
         Jac.attach_program(
             mach,
-            JacProgram(),
+            (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("./")
         )
-        print(mach.jac_program.mod.hub.keys())
-        self.assertEqual(len(mach.jac_program.mod.hub.keys()), 5)
+        self.assertEqual(len(mach.program.mod.hub.keys()), 5)
 
     def test_deep_imports_mods(self) -> None:
         """Parse micro jac file."""
@@ -439,7 +451,7 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach, "builtin_dotgen", base_path=self.fixture_abs_path("./")
+            self.mach, "builtin_printgraph", base_path=self.fixture_abs_path("./")
         )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -553,8 +565,10 @@ class JacLanguageTests(TestCase):
             ).ir_out.unparse()
         self.assertIn("class X {\n    with entry {\n        a_b = 67;", output)
         self.assertIn("br = b'Hello\\\\\\\\nWorld'", output)
-        self.assertIn("class Circle {\n    def init(radius: float", output)
-        self.assertIn("<>node = 90;\n    \n\n    print(<>node);\n", output)
+        self.assertIn(
+            "class Circle {\n    def init(self: Circle, radius: float", output
+        )
+        self.assertIn("<>node = 90;\n    print(<>node);\n", output)
 
     def test_pyfunc_3(self) -> None:
         """Test py ast to Jac ast conversion."""
@@ -574,7 +588,7 @@ class JacLanguageTests(TestCase):
             ).ir_out.unparse()
         self.assertIn("if (0 <= x <= 5) {", output)
         self.assertIn("  case _:\n", output)
-        self.assertIn(" case Point ( x = int ( a ), y = 0 ):\n", output)
+        self.assertIn(" case Point(x = int(a), y = 0):\n", output)
         self.assertIn("class Sample {\n    def init", output)
 
     def test_py2jac(self) -> None:
@@ -594,8 +608,8 @@ class JacLanguageTests(TestCase):
                 prog=None,
             ).ir_out.unparse()
         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 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)
 
     def test_refs_target(self) -> None:
@@ -1267,3 +1281,64 @@ class JacLanguageTests(TestCase):
         self.assertIn("(tok[ 0 ] > change_end_line)", output)
         self.assertIn("(tok[ 0 ] == change_end_line)", output)
         self.assertIn("(tok[ 1 ] > change_end_char)", output)
+
+    def test_here_visitor_usage(self) -> None:
+        """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("./")
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Here value is  10", stdout_value[0])
+        self.assertIn("Visitor name is  Walker 1", stdout_value[1])
+
+    def test_here_visitor_error(self) -> None:
+        """Test visitor, here keyword usage in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+        cli.run(self.fixture_abs_path("here_usage_error.jac"))
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("'here' is not defined", stdout_value)
+
+    def test_edge_ability(self) -> None:
+        """Test visitor, here keyword usage in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("edge_ability.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("MyEdge from walker MyEdge(path=1)", stdout_value[0])
+        self.assertIn("MyWalker from edge MyWalker()", stdout_value[1])
+        self.assertIn("MyWalker from node MyWalker()", stdout_value[6])
+        self.assertIn("MyEdge from walker MyEdge(path=2)", stdout_value[16])
+
+    def test_backward_edge_visit(self) -> None:
+        """Test backward edge visit in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("backward_edge_visit.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("MyWalker() from node MyNode(val=0)", stdout_value[0])
+        self.assertIn("MyWalker() from edge MyEdge(path=0)", stdout_value[1])
+        self.assertIn("MyWalker() from edge MyEdge(path=3)", stdout_value[6])
+        self.assertIn("MyWalker() from node MyNode(val=40)", stdout_value[9])
+
+    def test_visit_traversal(self) -> None:
+        """Test visit traversal semantic in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("visit_traversal.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("MyWalker() from node MyNode(val=0)", stdout_value[0])
+        self.assertIn("MyWalker() from node MyNode(val=20)", stdout_value[2])
+        self.assertIn("MyWalker() from node MyNode(val=60)", stdout_value[4])
+        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])

jaclang/utils/helpers.py

@@ -99,12 +99,20 @@ def auto_generate_refs() -> str:
         heading = heading.strip()
         heading_snakecase = heading_to_snake(heading)
         content = (
-            f'## {heading}\n**Code Example**\n=== "Jac"\n    ```jac linenums="1"\n    --8<-- "jac/examples/reference/'
-            f'{heading_snakecase}.jac"\n'
-            f'    ```\n=== "Python"\n    ```python linenums="1"\n    --8<-- "jac/examples/reference/'
-            f'{heading_snakecase}.py"\n    ```\n'
-            f'??? example "Jac Grammar Snippet"\n    ```yaml linenums="{lines[0]}"\n    --8<-- '
-            f'"jaclang/compiler/jac.lark:{lines[0]}:{lines[1]}"\n    ```\n'
+            f'## {heading}\n**Code Example**\n!!! example "Runnable Example in Jac and JacLib"\n'
+            '    === "Try it!"\n        <div class="code-block">\n'
+            "        ```jac\n"
+            f'        --8<-- "jac/examples/reference/{heading_snakecase}.jac"\n'
+            "        ```\n"
+            "        </div>\n"
+            '    === "Jac"\n        ```jac linenums="1"\n'
+            f'        --8<-- "jac/examples/reference/{heading_snakecase}.jac"\n'
+            f'        ```\n    === "Python"\n'
+            '        ```python linenums="1"\n'
+            '        --8<-- "jac/examples/reference/'
+            f'{heading_snakecase}.py"\n        ```\n'
+            f'??? info "Jac Grammar Snippet"\n    ```yaml linenums="{lines[0]}"\n    --8<-- '
+            f'"jac/jaclang/compiler/jac.lark:{lines[0]}:{lines[1]}"\n    ```\n'
             "**Description**\n\n--8<-- "
             f'"jac/examples/reference/'
             f'{heading_snakecase}.md"\n'

jaclang/utils/lang_tools.py

@@ -229,7 +229,7 @@ class AstTool:
                     return out
                 case "sym.":
                     return (
-                        ir.sym_tab.sym_dotgen()
+                        ir.sym_tab.sym_printgraph()
                         if isinstance(ir.sym_tab, UniScopeNode)
                         else "Sym_tab is None."
                     )
@@ -241,7 +241,7 @@ class AstTool:
                         out += f"##{t}##\n# {mod_name} #\n##{t}##\n{module_.pp()}\n"
                     return out
                 case "ast.":
-                    return ir.dotgen()
+                    return ir.printgraph()
                 case "unparse":
                     return ir.unparse()
                 case "pyast":
@@ -277,7 +277,6 @@ class AstTool:
                 arrow = "-.->" if "Optional" in kid.typ else "-->"
                 typ = (
                     kid.typ.replace("Optional[", "")
-                    .replace("SubNodeList[", "")
                     .replace("SubTag[", "")
                     .replace("Sequence[", "")
                     .replace("]", "")

jaclang/utils/tests/test_lang_tools.py

@@ -21,7 +21,8 @@ class JacAstToolTests(TestCase):
         out = self.tool.pass_template()
         self.assertIn("target: Expr,", out)
         self.assertIn("self, node: ast.ReturnStmt", out)
-        self.assertIn("exprs: SubNodeList[ExprAsItem],", out)
+        self.assertIn("exprs: Sequence[ExprAsItem],", out)
+        self.assertIn("path: Optional[Sequence[Name]],", out)
         self.assertIn("value: str,", out)
         self.assertIn("def exit_module(self, node: ast.Module)", out)
         self.assertGreater(out.count("def exit_"), 20)

jaclang/utils/treeprinter.py

@@ -28,7 +28,6 @@ CLASS_COLOR_MAP: dict[str, str] = {
     "ArchSpec": "#a3d3f0",
     "MatchPattern": "#a0d8b3",
     "SubTag": "#cafafa",
-    "SubNodeList": "#dbbfe5",
     "Module": "#D1FFE2  ",
     "GlobalVars": "#e1d1ff",
     "Test": "#e1d1ff",
@@ -136,7 +135,7 @@ CLASS_COLOR_MAP: dict[str, str] = {
 }
 
 
-def dotgen_ast_tree(
+def printgraph_ast_tree(
     root: UniNode,
     dot_lines: Optional[list[str]] = None,
 ) -> str:
@@ -184,7 +183,7 @@ def dotgen_ast_tree(
     dot_lines.append(f"{gen_node_id(root)} {gen_node_parameters(root)};")
     for i in root.kid:
         dot_lines.append(f"{gen_node_id(root)}  -> {gen_node_id(i)};")
-        dotgen_ast_tree(i, dot_lines)
+        printgraph_ast_tree(i, dot_lines)
     if starting_call:
         return "\ndigraph graph1 {\n" + "\n".join(list(set(dot_lines))) + "\n}"
     return " "
@@ -502,7 +501,7 @@ def get_symtab_tree_str(
     )
 
 
-def dotgen_symtab_tree(node: UniScopeNode) -> str:
+def printgraph_symtab_tree(node: UniScopeNode) -> str:
     """Generate DOT graph representation of a symbol table tree."""
     dot_lines = []
     id_map = {}

{jaclang-0.8.0.dist-info → jaclang-0.8.1.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: jaclang
-Version: 0.8.0
+Version: 0.8.1
 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
@@ -14,11 +13,13 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
 Provides-Extra: llm
 Provides-Extra: streamlit
 Requires-Dist: mypy (>=1.15.0,<2.0.0)
 Project-URL: Documentation, https://jac-lang.org
+Project-URL: Homepage, https://jaseci.org
 Project-URL: Repository, https://github.com/Jaseci-Labs/jaclang
 Description-Content-Type: text/markdown