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

jaclang/tests/fixtures/builtin_printgraph_json.jac

@@ -0,0 +1,21 @@
+import json;
+
+
+node N {
+    has val: int;
+}
+
+
+edge E {
+    has val: int = 0;
+}
+
+
+with entry {
+    end = root;
+    for i in range(0, 2) {
+        end +>: E : val=i :+> (end := [ N(val=i) for i in range(0, 2) ]);
+    }
+    data = printgraph(node=root, format="json");
+    print(data);
+}

jaclang/tests/fixtures/builtin_printgraph_mermaid.jac

@@ -0,0 +1,16 @@
+node N {
+    has val: int;
+}
+
+edge E {
+    has val: int = 0;
+}
+
+with entry {
+    end = root;
+    for i in range(0, 2) {
+        end +>: E : val=i :+> (end := [ N(val=i) for i in range(0, 2) ]);
+    }
+    data = printgraph(node=root, format="mermaid");
+    print(data);
+}

jaclang/tests/fixtures/chandra_bugs2.jac

@@ -1,27 +1,34 @@
 import re;
 
-glob a: int = 5;
+
+glob a : int = 5;
+
 
 with entry {
-    arguments = {x: None  for x in re.findall(
-        r'\{([A-Za-z0-9_]+)\}',
-        "Apple {apple} pineapple {pineapple}"
-    )};
-    a: int = 5;
+    arguments = { x : None for x in re.findall(r'\{([A-Za-z0-9_]+)\}', "Apple {apple} pineapple {pineapple}") };
+    a : int = 5;
     if False {
-        with open(f"Apple{apple}.txt") as f { # Fix syntax highlighting
-
-        print(f.read());
+        with open(f"Apple{apple}.txt") as f {
+            # Fix syntax highlighting
+            print(
+                f.read()
+            );
         }
     }
     print(arguments);
-    print("""This is a long
-    line of code.""");
+    print(
+        """This is a long
+        line of code."""
+    );
 }
 
+
 with entry {
-    a = {"a": "apple", "b": "ball", "c": "cat"};
-    y = {**a, "d": "dog", "e": "elephant"};
+    a = {"a" : "apple" , "b" : "ball" , "c" : "cat" };
+    y = {** a , "d" : "dog" , "e" : "elephant" };
     print(y);
 }
+
+
 # Use before def error would be nice
+

jaclang/tests/fixtures/concurrency.jac

@@ -6,7 +6,7 @@ node A {
     can do with entry {
         print("Started");
         sleep(2);
-        print(here);
+        print(visitor);
 
     }
 }

jaclang/tests/fixtures/create_dynamic_archetype.jac

@@ -1,35 +1,32 @@
-import from jaclang.runtimelib.machine { JacMachineInterface, JacMachine }
+import from jaclang.runtimelib.machine { JacMachine }
 # Dynamically create a node archetype
-glob source_code = """
-node dynamic_node {
-has value:int;
-can print_value with entry {
-print("Dynamic Node Value:", f'{self.value}');
-}
-}
-""";
+ glob source_code =
+    """
+    node dynamic_node {
+    has value:int;
+    can print_value with entry {
+    print("Dynamic Node Value:", f'{self.value}');
+    }
+    }
+    """;
 
 # Create a new walker archetype dynamically
-glob walker_code = """
-walker dynamic_walker {
-can visit_nodes with entry {
-visit [-->];
-}
-}
-""";
+ glob walker_code =
+    """
+    walker dynamic_walker {
+    can visit_nodes with entry {
+    visit [-->];
+    }
+    }
+    """;
 
-with entry {
-    node_arch = JacMachineInterface.create_archetype_from_source(JacMachineInterface.py_get_jac_machine(), source_code);
-    walker_arch = JacMachineInterface.create_archetype_from_source(JacMachineInterface.py_get_jac_machine(), walker_code);
 
-    node_obj = JacMachineInterface.spawn_node(JacMachineInterface.py_get_jac_machine(),
-        'dynamic_node',
-        {'value': 99},
-        node_arch.__name__
-    );
-    walker_obj = JacMachineInterface.spawn_walker(JacMachineInterface.py_get_jac_machine(),
-        'dynamic_walker',
-        module_name=walker_arch.__name__
-    );
+with entry {
+    node_arch = JacMachine.create_archetype_from_source(source_code);
+    walker_arch = JacMachine.create_archetype_from_source(walker_code);
+    node_obj =
+        JacMachine.spawn_node('dynamic_node', {'value' : 99  } , node_arch.__name__);
+    walker_obj =
+        JacMachine.spawn_walker('dynamic_walker', module_name=walker_arch.__name__);
     node_obj spawn walker_obj;
 }

jaclang/tests/fixtures/deep/deeper/deep_outer_import.jac

@@ -1,8 +1,11 @@
-import from ..one_lev_dup { olprint }
-import from ...needs_import_dup { my_print, pyfunc }
+import from jaclang.tests.fixtures.deep.one_lev_dup { olprint }
+import from jaclang.tests.fixtures.needs_import_dup { my_print , pyfunc }
+
 
 with entry {
     # print(olpyprint());
-    print(olprint());
+    print(
+        olprint()
+    );
     print(my_print(pyfunc));
-}
+}

jaclang/tests/fixtures/deep/deeper/snd_lev.jac

@@ -1,6 +1,6 @@
 import from ..mycode { code }
 
-def slprint ->str {
+
+def slprint-> str {
     return "sl" + code();
 }
-

jaclang/tests/fixtures/deep/deeper/snd_lev_dup.jac

@@ -0,0 +1,6 @@
+import from jaclang.tests.fixtures.deep.mycode { code }
+
+
+def slprint-> str {
+    return "sl" + code();
+}

jaclang/tests/fixtures/deep/one_lev.jac

@@ -1,7 +1,7 @@
 import from .deeper { snd_lev }
 
 
-def olprint -> str {
+def olprint-> str {
     # deeper.snd_lev.slprint(); FIXME:
-    return "one level deeper" + snd_lev.slprint();
+     return "one level deeper" + snd_lev.slprint();
 }

jaclang/tests/fixtures/deep/one_lev_dup.jac

@@ -1,5 +1,6 @@
-import from .deeper { snd_lev }
+import from .deeper { snd_lev_dup }
 
-def olprint -> str {
-    return "one level deeper" + snd_lev.slprint();
+
+def olprint-> str {
+    return "one level deeper" + snd_lev_dup.slprint();
 }

jaclang/tests/fixtures/dynamic_archetype.jac

@@ -1,30 +1,37 @@
-import from jaclang.runtimelib.machine {JacMachineInterface, JacMachine}
-import from bar {Item}
+import from jaclang.runtimelib.machine { JacMachine } 
+import from bar { Item } 
+
 
 node test_node {
-    has value:int;
+    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) {}
+
+walker child_walker ( test_walker ) {}
+
 
 with entry {
-    for value in range(1, 4) {
-        root ++> test_node(value=value);
-        root ++> Item(value=value);
-    }
-    node_obj = JacMachineInterface.spawn_node(JacMachineInterface.py_get_jac_machine(), node_name='test_node', attributes={'value': 0}, module_name='__main__');
-    walker_obj = JacMachineInterface.spawn_walker(JacMachineInterface.py_get_jac_machine(), walker_name='child_walker', module_name='__main__');
-    external_node = JacMachineInterface.spawn_node(JacMachineInterface.py_get_jac_machine(), node_name='Item', attributes={'value': 0}, module_name='bar');
+    for value in range(1, 4) { root ++> test_node(value=value); root ++> Item(value=value); }
+    node_obj = JacMachine.spawn_node(
+        node_name='test_node', attributes={'value' : 0 }, module_name='__main__'
+    );
+    walker_obj = JacMachine.spawn_walker(
+        walker_name='child_walker', module_name='__main__'
+    );
+    external_node = JacMachine.spawn_node(
+        node_name='Item', attributes={'value' : 0 }, module_name='bar'
+    );
     root ++> external_node;
     root ++> node_obj;
     print("Spawned Node:", node_obj);

jaclang/tests/fixtures/edge_ability.jac

@@ -0,0 +1,49 @@
+node MyNode {
+    has val:int;
+
+    can ability1 with MyWalker entry {
+        print("MyWalker from node",visitor);
+    }
+
+    can ability2 with MyWalker exit {
+        print("MyWalker from node",visitor);
+    }
+}
+
+edge MyEdge {
+    has path:int;
+
+    can ability3 with MyWalker entry {
+        print("MyWalker from edge",visitor);
+    }
+
+    can ability4 with MyWalker exit {
+        print("MyWalker from edge",visitor);
+    }
+}
+
+walker MyWalker {
+    can ability5 with MyEdge entry {
+        print("MyEdge from walker",here);
+    }
+
+    can ability6 with MyEdge exit {
+        print("MyEdge from walker",here);
+    }
+
+    can ability7 with MyNode entry {
+        print("MyNode from walker",here);
+        visit [edge -->];
+    }
+
+    can ability8 with MyNode exit {
+        print("MyNode from walker",here);
+        visit [edge -->];
+    }
+}
+
+with entry {
+    e1 = MyEdge(1);
+    root +>:e1:+> MyNode(10) +>:MyEdge(2):+> MyNode(20);
+    MyWalker() spawn e1;
+}

jaclang/tests/fixtures/foo.jac

@@ -1,42 +1,34 @@
-import from jaclang.runtimelib.machine { JacMachineInterface, JacMachine }
-import from bar { bar_walk }
+import from jaclang.runtimelib.machine { JacMachine } 
+import from bar { bar_walk } 
 # Test runner to initialize the walker
-
-def test_run {
+ def test_run {
     # Print the loaded modules
-    modules = JacMachineInterface.list_modules(JacMachineInterface.py_get_jac_machine());
+     modules = JacMachine.list_modules();
     "Loaded Modules:" |> print;
-    for mod_name in modules {
-        f"Module: {mod_name}" |> print;
-    }
+    for mod_name in modules { f"Module: {mod_name}" |> print; }
     # Print walkers
-    walkers = JacMachineInterface.list_walkers(JacMachineInterface.py_get_jac_machine(), mod_name);
+     walkers = JacMachine.list_walkers(mod_name);
     if walkers {
         f"Walkers in {mod_name}:" |> print;
-        for walker in walkers {
-            f"  - Walker: {walker}" |> print;
-        }
+        for walker in walkers { f"  - Walker: {walker}" |> print; }
     }
     # Print nodes
-    nodes = JacMachineInterface.list_nodes(JacMachineInterface.py_get_jac_machine(), mod_name);
+     nodes = JacMachine.list_nodes(mod_name);
     if nodes {
         f"Nodes in {mod_name}:" |> print;
-        for node in nodes {
-            f"  - Node: {node}" |> print;
-        }
+        for node in nodes { f"  - Node: {node}" |> print; }
     }
     # Print edges
-    edges = JacMachineInterface.list_edges(JacMachineInterface.py_get_jac_machine(), mod_name);
+     edges = JacMachine.list_edges(mod_name);
     if edges {
         f"Edges in {mod_name}:" |> print;
-        for edge in edges {
-            f"  - Edge: {edge}" |> print;
-        }
+        for edge in edges { f"  - Edge: {edge}" |> print; }
     }
     root spawn bar_walk();
 }
-# Define the entry point to run the test
 
-with entry {
+
+# Define the entry point to run the test
+ with entry {
     test_run();
 }

jaclang/tests/fixtures/guess_game.jac

@@ -17,7 +17,7 @@ node turn {
 
 impl turn.check {
     guess = guesses.pop(0);
-    guess |> here.process_guess;
+    guess |> visitor.process_guess;
     visit [-->];
 }
 

jaclang/tests/fixtures/here_usage_error.jac

@@ -0,0 +1,21 @@
+node MyNode{
+    has val:int;
+
+    can ability1 with MyWalker entry {
+        print("Visitor name is ",here.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/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/jac_from_py.py

@@ -1,4 +1,4 @@
 from jaclang import JacMachine as Jac
 
-(mod,) = Jac.py_jac_import(target=".simple_walk", base_path=__file__)
+(mod,) = Jac.jac_import(target=".simple_walk", base_path=__file__)
 mod.test_run()

jaclang/tests/fixtures/jp_importer.jac

@@ -1,16 +1,16 @@
-import from math { sin as s, cos, sqrt as sq }
+import from math { sin as s , cos , sqrt as sq }
 include random;
-import from ..test_cli { JacCliTests as Jac }
+import from jaclang.tests.test_cli { JacCliTests as Jac }
 import from deep.mycode { code as c }
-import hashcheck as h, assign_compr as a;
+import hashcheck as h , assign_compr as a;
 import ignore;
 import from jacsamp { my_print as m }
 
 
-with entry{
-    print(sq(4), s(30),cos(30));
+with entry {
+    print(sq(4), s(30), cos(30));
     print(randint(1, 10));
     print(m("--->my_print<---"));
     print(h.a, a.mvar);
     print(c());
-    }
+}

jaclang/tests/fixtures/jp_importer_auto.jac

@@ -1,14 +1,16 @@
-import from math { sin as s, cos, sqrt as sq }
+import from math { sin as s , cos , sqrt as sq }
 include random;
-import from ..test_cli { JacCliTests as Jac }
+import from jaclang.tests.test_cli { JacCliTests as Jac }
 import from deep.mycode { code as c }
-import hashcheck as h, assign_compr as a;
+import hashcheck as h , assign_compr as a;
 import from jacsamp { my_print as m }
 
+
 with entry {
     print(sq(4), s(30), cos(30));
     print(randint(1, 10));
     print(m("--->my_print<---"));
     print(h.a, a.mvar);
     print(c());
+    print(Jac);
 }

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

@@ -0,0 +1,24 @@
+with entry {
+    # unicode characters
+    items = [{"title":"1st", "due":True, "completed":True}, {"title":"2nd", "due":False, "completed":False}];
+    for (i, item) in enumerate(items) {
+        status = "✓" if item["completed"] else "○";
+        due = f" (due: {item['due']})" if item["due"] else "";
+        print(f"{i+1}. {status} {item['title']}{due}");
+    }
+    
+    # unicode emojis and symbols
+    print("🌟 Star");    
+    
+    # unicode in triple quoted strings
+    multiline = """Multi-line with ✓ unicode and ○ symbols""";
+    print(multiline);
+    
+    # unicode in raw strings
+    raw_unicode = r"Raw string with ✓ and ○";
+    print(raw_unicode);
+    
+    # mixed unicode and escape sequences
+    mixed = "Tab ✓\nNewline ○";
+    print(mixed);
+}

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/fixtures/walker_update.jac

@@ -1,13 +1,11 @@
-import from bar { bar_walk }
-import from jaclang.runtimelib.machine { JacMachineInterface, JacMachine }
+import from bar { bar_walk } 
+import from jaclang.runtimelib.machine { JacMachine } 
 import os;
 
+
 def update_bar_walker {
     "Updating bar.jac with new behavior." |> print;
-    (bar_walk_new, ) = JacMachineInterface.update_walker(JacMachineInterface.py_get_jac_machine(),
-        "bar",
-        items={'bar_walk': None}
-    );
+    (bar_walk_new,) = JacMachine.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__}");
@@ -16,4 +14,4 @@ def update_bar_walker {
 
 with entry {
     update_bar_walker();
-}
+}