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

jaclang/runtimelib/machine.py

@@ -329,23 +329,27 @@ class JacWalker:
             | NodeArchetype
             | EdgeArchetype
         ),
+        insert_loc: int = -1,
     ) -> bool:  # noqa: ANN401
         """Jac's visit stmt feature."""
         if isinstance(walker, WalkerArchetype):
             """Walker visits node."""
             wanch = walker.__jac__
             before_len = len(wanch.next)
+            next = []
             for anchor in (
                 (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
             ):
                 if anchor not in wanch.ignores:
-                    if isinstance(anchor, NodeAnchor):
-                        wanch.next.append(anchor)
-                    elif isinstance(anchor, EdgeAnchor):
-                        if target := anchor.target:
-                            wanch.next.append(target)
-                        else:
-                            raise ValueError("Edge has no target.")
+                    if isinstance(anchor, (NodeAnchor, EdgeAnchor)):
+                        next.append(anchor)
+                    else:
+                        raise ValueError("Anchor should be NodeAnchor or EdgeAnchor.")
+            if insert_loc < -len(wanch.next):  # for out of index selection
+                insert_loc = 0
+            elif insert_loc < 0:
+                insert_loc += len(wanch.next) + 1
+            wanch.next = wanch.next[:insert_loc] + next + wanch.next[insert_loc:]
             return len(wanch.next) > before_len
         else:
             raise TypeError("Invalid walker object")
@@ -381,83 +385,91 @@ class JacWalker:
             raise TypeError("Invalid walker object")
 
     @staticmethod
-    def spawn_call(walker: WalkerAnchor, node: NodeAnchor) -> WalkerArchetype:
+    def spawn_call(
+        walker: WalkerAnchor,
+        node: NodeAnchor | EdgeAnchor,
+    ) -> WalkerArchetype:
         """Jac's spawn operator feature."""
         warch = walker.archetype
         walker.path = []
-        walker.next = [node]
-        current_node = node.archetype
+        current_loc = node.archetype
 
-        # walker entry
+        # walker ability on any entry
         for i in warch._jac_entry_funcs_:
             if not i.trigger:
-                i.func(warch, current_node)
+                i.func(warch, current_loc)
             if walker.disengaged:
                 return warch
 
         while len(walker.next):
-            if current_node := walker.next.pop(0).archetype:
-                # walker entry with
+            if current_loc := walker.next.pop(0).archetype:
+                # walker ability with loc entry
                 for i in warch._jac_entry_funcs_:
                     if (
                         i.trigger
-                        and all_issubclass(i.trigger, NodeArchetype)
-                        and isinstance(current_node, i.trigger)
+                        and (
+                            all_issubclass(i.trigger, NodeArchetype)
+                            or all_issubclass(i.trigger, EdgeArchetype)
+                        )
+                        and isinstance(current_loc, i.trigger)
                     ):
-                        i.func(warch, current_node)
+                        i.func(warch, current_loc)
                     if walker.disengaged:
                         return warch
 
-                # node entry
-                for i in current_node._jac_entry_funcs_:
+                # loc ability with any entry
+                for i in current_loc._jac_entry_funcs_:
                     if not i.trigger:
-                        i.func(current_node, warch)
+                        i.func(current_loc, warch)
                     if walker.disengaged:
                         return warch
 
-                # node entry with
-                for i in current_node._jac_entry_funcs_:
+                # loc ability with walker entry
+                for i in current_loc._jac_entry_funcs_:
                     if (
                         i.trigger
                         and all_issubclass(i.trigger, WalkerArchetype)
                         and isinstance(warch, i.trigger)
                     ):
-                        i.func(current_node, warch)
+                        i.func(current_loc, warch)
                     if walker.disengaged:
                         return warch
 
-                # node exit with
-                for i in current_node._jac_exit_funcs_:
+                # loc ability with walker exit
+                for i in current_loc._jac_exit_funcs_:
                     if (
                         i.trigger
                         and all_issubclass(i.trigger, WalkerArchetype)
                         and isinstance(warch, i.trigger)
                     ):
-                        i.func(current_node, warch)
+                        i.func(current_loc, warch)
                     if walker.disengaged:
                         return warch
 
-                # node exit
-                for i in current_node._jac_exit_funcs_:
+                # loc ability with any exit
+                for i in current_loc._jac_exit_funcs_:
                     if not i.trigger:
-                        i.func(current_node, warch)
+                        i.func(current_loc, warch)
                     if walker.disengaged:
                         return warch
 
-                # walker exit with
+                # walker ability with loc exit
                 for i in warch._jac_exit_funcs_:
                     if (
                         i.trigger
-                        and all_issubclass(i.trigger, NodeArchetype)
-                        and isinstance(current_node, i.trigger)
+                        and (
+                            all_issubclass(i.trigger, NodeArchetype)
+                            or all_issubclass(i.trigger, EdgeArchetype)
+                        )
+                        and isinstance(current_loc, i.trigger)
                     ):
-                        i.func(warch, current_node)
+                        i.func(warch, current_loc)
                     if walker.disengaged:
                         return warch
-        # walker exit
+        # walker ability with any exit
         for i in warch._jac_exit_funcs_:
             if not i.trigger:
-                i.func(warch, current_node)
+                i.func(warch, current_loc)
             if walker.disengaged:
                 return warch
 
@@ -467,12 +479,14 @@ class JacWalker:
     @staticmethod
     def spawn(op1: Archetype, op2: Archetype) -> WalkerArchetype | asyncio.Future:
         """Jac's spawn operator feature."""
+        edge: EdgeAnchor | None = None
         if isinstance(op1, WalkerArchetype):
             warch = op1
             walker = op1.__jac__
             if isinstance(op2, NodeArchetype):
                 node = op2.__jac__
             elif isinstance(op2, EdgeArchetype):
+                edge = op2.__jac__
                 node = op2.__jac__.target
             else:
                 raise TypeError("Invalid target object")
@@ -482,21 +496,29 @@ class JacWalker:
             if isinstance(op1, NodeArchetype):
                 node = op1.__jac__
             elif isinstance(op1, EdgeArchetype):
+                edge = op1.__jac__
                 node = op1.__jac__.target
             else:
                 raise TypeError("Invalid target object")
         else:
             raise TypeError("Invalid walker object")
 
+        if edge is not None:
+            loc: EdgeAnchor | NodeAnchor = edge
+            walker.next = [edge, node]
+        else:
+            loc = node
+            walker.next = [node]
+
         if warch.__jac_async__:
             machine = JacMachineInterface.py_get_jac_machine()
             _event_loop = machine._event_loop
-            func = partial(JacMachineInterface.spawn_call, *(walker, node))
+            func = partial(JacMachineInterface.spawn_call, *(walker, loc))
             return asyncio.ensure_future(
                 _event_loop.run_in_executor(None, func), loop=_event_loop
             )
         else:
-            return JacMachineInterface.spawn_call(walker=walker, node=node)
+            return JacMachineInterface.spawn_call(walker=walker, node=loc)
 
     @staticmethod
     def disengage(walker: WalkerArchetype) -> bool:
@@ -525,7 +547,7 @@ class JacBuiltin:
     """Jac Builtins."""
 
     @staticmethod
-    def dotgen(
+    def printgraph(
         node: NodeArchetype,
         depth: int,
         traverse: bool,
@@ -533,9 +555,10 @@ class JacBuiltin:
         bfs: bool,
         edge_limit: int,
         node_limit: int,
-        dot_file: Optional[str],
+        file: Optional[str],
+        format: str,
     ) -> str:
-        """Generate Dot file for visualizing nodes and edges."""
+        """Generate graph for visualizing nodes and edges."""
         edge_type = edge_type if edge_type else []
         visited_nodes: list[NodeArchetype] = []
         node_depths: dict[NodeArchetype, int] = {node: 0}
@@ -589,24 +612,32 @@ class JacBuiltin:
             'digraph {\nnode [style="filled", shape="ellipse", '
             'fillcolor="invis", fontcolor="black"];\n'
         )
+        mermaid_content = "flowchart LR\n"
         for source, target, edge in connections:
             edge_label = html.escape(str(edge.__jac__.archetype))
             dot_content += (
                 f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
                 f' [label="{edge_label if "GenericEdge" not in edge_label else ""}"];\n'
             )
+            mermaid_content += (
+                f"{visited_nodes.index(source)} -->"
+                f"|{edge_label if 'GenericEdge' not in edge_label else ''}| {visited_nodes.index(target)}\n"
+            )
         for node_ in visited_nodes:
             color = (
                 colors[node_depths[node_]] if node_depths[node_] < 25 else colors[24]
             )
+            label = html.escape(str(node_.__jac__.archetype))
             dot_content += (
-                f'{visited_nodes.index(node_)} [label="{html.escape(str(node_.__jac__.archetype))}"'
+                f'{visited_nodes.index(node_)} [label="{label}"'
                 f'fillcolor="{color}"];\n'
             )
-        if dot_file:
-            with open(dot_file, "w") as f:
-                f.write(dot_content + "}")
-        return dot_content + "}"
+            mermaid_content += f'{visited_nodes.index(node_)}["{label}"]\n'
+        output = dot_content + "}" if format == "dot" else mermaid_content
+        if file:
+            with open(file, "w") as f:
+                f.write(output)
+        return output
 
 
 class JacCmd:
@@ -803,7 +834,7 @@ class JacBasics:
             items,
         )
 
-        if not mach.jac_program:
+        if not mach.program:
             JacMachineInterface.attach_program(mach, JacProgram())
 
         if lng == "py":
@@ -924,7 +955,10 @@ class JacBasics:
         dir: EdgeDir = EdgeDir.OUT,
         filter: Callable[[EdgeArchetype], bool] | None = None,
         edges_only: bool = False,
-    ) -> list[NodeArchetype] | list[EdgeArchetype]:
+        from_visit: bool = False,
+    ) -> (
+        list[NodeArchetype] | list[EdgeArchetype] | list[NodeArchetype | EdgeArchetype]
+    ):
         """Jac's apply_dir stmt feature."""
         if isinstance(sources, NodeArchetype):
             sources = [sources]
@@ -934,14 +968,23 @@ class JacBasics:
             else targets if targets else None
         )
         if edges_only:
-            connected_edges: list[EdgeArchetype] = []
+            connected_edges: list[EdgeArchetype | NodeArchetype] = []
             for node in sources:
                 edges = JacMachineInterface.get_edges(
                     node.__jac__, dir, filter, target_obj=targ_obj_set
                 )
-                connected_edges.extend(
-                    edge for edge in edges if edge not in connected_edges
-                )
+                for edge in edges:
+                    assert isinstance(edge, EdgeArchetype)
+                    if edge in connected_edges:
+                        continue
+                    if from_visit:
+                        connected_edges.append(edge)
+                        if dir == EdgeDir.IN:
+                            connected_edges.append(edge.__jac__.source.archetype)
+                        else:
+                            connected_edges.append(edge.__jac__.target.archetype)
+                    else:
+                        connected_edges.append(edge)
             return connected_edges
         else:
             connected_nodes: list[NodeArchetype] = []
@@ -1310,7 +1353,7 @@ class JacUtils:
     @staticmethod
     def attach_program(mach: JacMachine, jac_program: JacProgram) -> None:
         """Attach a JacProgram to the machine."""
-        mach.jac_program = jac_program
+        mach.program = jac_program
 
     @staticmethod
     def load_module(
@@ -1545,7 +1588,6 @@ class JacMachine(JacMachineInterface):
         base_path: str = "",
         session: Optional[str] = None,
         root: Optional[str] = None,
-        interp_mode: bool = False,
     ) -> None:
         """Initialize JacMachine."""
         self.loaded_modules: dict[str, types.ModuleType] = {}
@@ -1558,8 +1600,7 @@ class JacMachine(JacMachineInterface):
             if not os.path.isdir(base_path)
             else os.path.abspath(base_path)
         )
-        self.jac_program: JacProgram = JacProgram()
-        self.interp_mode = interp_mode
+        self.program: JacProgram = JacProgram()
         self.pool = ThreadPoolExecutor()
         self._event_loop = asyncio.new_event_loop()
         self.mem: Memory = ShelfStorage(session)

jaclang/runtimelib/tests/fixtures/traversing_save.jac

@@ -1,17 +1,19 @@
 node A {}
 node B {}
 
+
 walker build {
     can run with `root entry {
         a = A();
-        a ++> B(); # connecting two non persistent nodes
-
-        here ++> a;
+        a ++> B();
+        # connecting two non persistent nodes
+         here ++> a;
     }
 }
 
+
 walker view {
     can run with `root entry {
-        print(dotgen(here));
+        print(printgraph(here));
     }
-}
+}

jaclang/runtimelib/utils.py

@@ -133,7 +133,7 @@ def extract_params(
     include_info = []
     exclude_info = []
     if body.params:
-        for param in body.params.items:
+        for param in body.params:
             if isinstance(param, uni.KWPair) and isinstance(param.key, uni.Name):
                 key = param.key.value
                 value = param.value
@@ -153,7 +153,7 @@ def extract_params(
                         )
                         include_info.append((var_name, value.gen.py_ast[0]))
                     elif isinstance(value, uni.TupleVal) and value.values:
-                        for i in value.values.items:
+                        for i in value.values:
                             var_name = (
                                 i.right.value
                                 if isinstance(i, uni.AtomTrailer)
@@ -175,7 +175,7 @@ def extract_params(
                         )
                         exclude_info.append((var_name, value.gen.py_ast[0]))
                     elif isinstance(value, uni.TupleVal) and value.values:
-                        for i in value.values.items:
+                        for i in value.values:
                             var_name = (
                                 i.right.value
                                 if isinstance(i, uni.AtomTrailer)

jaclang/tests/fixtures/backward_edge_visit.jac

@@ -0,0 +1,31 @@
+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 {
+        visit [edge <--];
+    }
+}
+
+with entry {
+    n0 = MyNode(0);
+    n1 = MyNode(10);
+    root +>:MyEdge(0):+> n0 <+:MyEdge(1):<+ n1;
+    n1 <+:MyEdge(2):<+ MyNode(20);
+    n1 <+:MyEdge(3):<+ MyNode(30);
+    n1 <+:MyEdge(4):<+ MyNode(40);
+    MyWalker() spawn n0;
+}

jaclang/tests/fixtures/builtin_printgraph.jac

@@ -0,0 +1,85 @@
+node a {
+    has val: int;
+}
+
+
+edge Edge1 {
+    has val: int = 5;
+}
+
+
+with entry {
+    end = root;
+    for i in range(0, 4) {
+        end ++> (end := [ a(val=i) for i in range(0, 3) ]);
+    }
+    x = [ a(val=i) for i in range(0, 3) ];
+    end = x[1];
+    for i in range(0, 8) {
+        locals()[chr(ord('b') + i)] = (values := [ a(val=j * i + 5.2 * i + 6) for j in range(0, 3) ]);
+        end ++> (end := values);
+    }
+    p = b[1];
+    for k in range(0, 10) {
+        p +>: Edge1 : val=6 :+> (p := a(val=k));
+    }
+    # b++>c;
+     # c++>b;
+     d1 = printgraph();
+    l1 = d1 |> len;
+    #generate dot for all connected with root
+     #  d2=printgraph(b[1],Traverse=True,depth=20,bfs=False,node_limit=12);l2=d2|>len;  #generate dot for all connected with root
+     d2 = printgraph(
+        b[1],
+        edge_type=["Edge1"],
+        depth=20,
+        traverse=True,
+        bfs=False,
+        node_limit=19
+    );
+    l2 = d2 |> len;
+    #generate dot for all connected with root
+     d3 = printgraph(b[2], edge_limit=5, depth=5);
+    l3 = d3 |> len;
+    #generate dot for all connected with b[1] node
+     d4 = printgraph(
+        b[1],
+        bfs=True,
+        edge_type=["Edge1"],
+        node_limit=100,
+        edge_limit=900,
+        depth=300
+    );
+    l4 = d4 |> len;
+    #generate dot from nodes with depth 3 connected with b[1] node
+     d5 = printgraph(b[1], node_limit=10, edge_limit=90);
+    l5 := d5 |> len;
+    #generate dot from nodes with depth 3 connected with b[1] node
+    print(
+        d1.count('a(val') == 12,
+        d1.count('#FFFFE0') == 3,
+        'Root' in d1,
+        d1.count('label=""') == 30
+    );
+    print(
+        d2.count('a(val') == 19,
+        d2.count('#F5E5FF') == 2,
+        'Edge1' not in d2,
+        d2.count('label=""') == 42
+    );
+    print(d3.count('a(val') == 6, d3.count('label=""') == 5, d3.count('#F5E5FF') == 1);
+    print(d4.count("a(val") == 25, d4.count('label=""') == 66, d4.count('#FFF0F') == 3);
+    print(d5.count("Edge1(val=6)") == 2, d5.count('label=""') == 24);
+    # print(l3<l2);
+    
+    # print(d1);
+    
+    # print(d2);
+    
+    # print(d3);
+    
+    # print(d4);
+    
+    # print(printgraph(node=b[2],bfs=True,depth=3.96,edge_limit=12,node_limit=12.96));
+    
+}

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/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/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;
+}