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

jaclang/runtimelib/meta_importer.py

@@ -0,0 +1,86 @@
+"""Jac meta path importer."""
+
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import os
+from types import ModuleType
+from typing import Optional, Sequence
+
+from jaclang.runtimelib.machine import JacMachine as Jac
+from jaclang.runtimelib.machine import JacMachineInterface
+from jaclang.utils.module_resolver import get_jac_search_paths
+
+
+class JacMetaImporter(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+    """Meta path importer to load .jac modules via Python's import system."""
+
+    def find_spec(
+        self,
+        fullname: str,
+        path: Optional[Sequence[str]] = None,
+        target: Optional[ModuleType] = None,
+    ) -> Optional[importlib.machinery.ModuleSpec]:
+        """Find the spec for the module."""
+        if path is None:
+            # Top-level import
+            paths_to_search = get_jac_search_paths()
+            module_path_parts = fullname.split(".")
+        else:
+            # Submodule import
+            paths_to_search = [*path]
+            module_path_parts = fullname.split(".")[-1:]
+
+        for search_path in paths_to_search:
+            candidate_path = os.path.join(search_path, *module_path_parts)
+            # Check for directory package
+            if os.path.isdir(candidate_path):
+                init_file = os.path.join(candidate_path, "__init__.jac")
+                if os.path.isfile(init_file):
+                    return importlib.util.spec_from_file_location(
+                        fullname,
+                        init_file,
+                        loader=self,
+                        submodule_search_locations=[candidate_path],
+                    )
+            # Check for .jac file
+            if os.path.isfile(candidate_path + ".jac"):
+                return importlib.util.spec_from_file_location(
+                    fullname, candidate_path + ".jac", loader=self
+                )
+        return None
+
+    def create_module(
+        self, spec: importlib.machinery.ModuleSpec
+    ) -> Optional[ModuleType]:
+        """Create the module."""
+        return None  # use default machinery
+
+    def exec_module(self, module: ModuleType) -> None:
+        """Execute the module."""
+        if not module.__spec__ or not module.__spec__.origin:
+            raise ImportError(
+                f"Cannot find spec or origin for module {module.__name__}"
+            )
+        file_path = module.__spec__.origin
+        is_pkg = module.__spec__.submodule_search_locations is not None
+
+        if is_pkg:
+            codeobj = Jac.program.get_bytecode(full_target=file_path)
+            if codeobj:
+                exec(codeobj, module.__dict__)
+            JacMachineInterface.load_module(module.__name__, module)
+            return
+
+        base_path = os.path.dirname(file_path)
+        target = os.path.splitext(os.path.basename(file_path))[0]
+        ret = JacMachineInterface.jac_import(
+            target=target,
+            base_path=base_path,
+            override_name=module.__name__,
+        )
+        if ret:
+            loaded_module = ret[0]
+            module.__dict__.update(loaded_module.__dict__)
+        else:
+            raise ImportError(f"Unable to import {module.__name__}")

jaclang/runtimelib/tests/fixtures/graph_purger.jac

@@ -1,21 +1,26 @@
-import from jaclang.runtimelib.machine {JacMachineInterface as Jac}
+import from jaclang.runtimelib.machine { JacMachine as Jac } 
+
 
 node A {
     has id: int;
 }
 
+
 node B {
     has id: int;
 }
 
+
 node C {
     has id: int;
 }
 
+
 node D {
     has id: int;
 }
 
+
 node E {
     has id: int;
 }
@@ -23,81 +28,74 @@ node E {
 
 walker populate {
     can setup1 with `root entry {
-        for i in range(2) {
-            here ++> A(id=i);
-        }
+        for i in range(2) { here ++> A(id=i); }
         visit [-->];
     }
-
+    
     can setup2 with A entry {
-        for i in range(2) {
-            here ++> B(id=i);
-        }
+        for i in range(2) { here ++> B(id=i); }
         visit [-->];
     }
-
+    
     can setup3 with B entry {
-        for i in range(2) {
-            here ++> C(id=i);
-        }
+        for i in range(2) { here ++> C(id=i); }
         visit [-->];
     }
-
+    
     can setup4 with C entry {
-        for i in range(2) {
-            here ++> D(id=i);
-        }
+        for i in range(2) { here ++> D(id=i); }
         visit [-->];
     }
-
+    
     can setup5 with D entry {
-        for i in range(2) {
-            here ++> E(id=i);
-        }
+        for i in range(2) { here ++> E(id=i); }
         visit [-->];
     }
 }
 
+
 walker traverse {
     can enter1 with `root entry {
         print(here);
         visit [-->];
     }
-
+    
     can enter2 with A entry {
         print(here);
         visit [-->];
     }
-
+    
     can enter3 with B entry {
         print(here);
         visit [-->];
     }
-
+    
     can enter4 with C entry {
         print(here);
         visit [-->];
     }
-
+    
     can enter5 with D entry {
         print(here);
         visit [-->];
     }
-
+    
     can enter6 with E entry {
         print(here);
         visit [-->];
     }
 }
 
+
 walker purge {
     can purge with `root entry {
         print(Jac.reset_graph());
     }
 }
 
+
 walker check {
     can enter with `root entry {
         print(len(Jac.get_context().mem.__shelf__.values()));
     }
-}
+}

jaclang/runtimelib/tests/fixtures/other_root_access.jac

@@ -1,51 +1,57 @@
-import from jaclang.runtimelib.machine {JacMachineInterface as Jac}
-import from jaclang.runtimelib.archetype {Anchor}
-import from uuid {UUID}
+import from jaclang.runtimelib.machine { JacMachine as Jac } 
+import from jaclang.runtimelib.archetype { Anchor } 
+import from uuid { UUID } 
+
 
 node A {
     has val: int;
 }
 
+
 walker check_node {
     can enter with `root entry {
         visit [-->];
     }
-
+    
     can enter2 with A entry {
         print(here);
     }
 }
 
+
 walker update_node {
     has val: int;
-
+    
     can enter2 with A entry {
         here.val = self.val;
     }
 }
 
+
 walker update_target_node {
     has val: int;
     has node_id: str;
-
+    
     can enter with `root entry {
-        target_node = &(self.node_id);
+        target_node = & (self.node_id);
         target_node.val = self.val;
     }
 }
 
+
 walker update_node_forced {
     has val: int;
-
+    
     can enter2 with A entry {
         Jac.elevate_root();
         here.val = self.val;
     }
 }
 
+
 walker create_node {
     has val: int;
-
+    
     can enter with `root entry {
         a = A(val=self.val);
         here ++> a;
@@ -53,6 +59,7 @@ walker create_node {
     }
 }
 
+
 walker create_other_root {
     can enter with `root entry {
         other_root = `root().__jac__;
@@ -61,9 +68,10 @@ walker create_other_root {
     }
 }
 
-walker allow_other_root_access {
-    has root_id: str, level: int | str = 1, via_all: bool = False;
 
+walker allow_other_root_access {
+    has root_id: str , level: int | str = 1 , via_all: bool = False;
+    
     can enter_root with `root entry {
         if self.via_all {
             Jac.perm_grant(here, self.level);
@@ -71,7 +79,7 @@ walker allow_other_root_access {
             Jac.allow_root(here, UUID(self.root_id), self.level);
         }
     }
-
+    
     can enter_nested with A entry {
         if self.via_all {
             Jac.perm_grant(here, self.level);
@@ -81,9 +89,10 @@ walker allow_other_root_access {
     }
 }
 
-walker disallow_other_root_access {
-    has root_id: str, via_all: bool = False;
 
+walker disallow_other_root_access {
+    has root_id: str , via_all: bool = False;
+    
     can enter_root with `root entry {
         if self.via_all {
             Jac.perm_revoke(here);
@@ -91,7 +100,7 @@ walker disallow_other_root_access {
             Jac.disallow_root(here, UUID(self.root_id));
         }
     }
-
+    
     can enter_nested with A entry {
         if self.via_all {
             Jac.perm_revoke(here);
@@ -99,4 +108,4 @@ walker disallow_other_root_access {
             Jac.disallow_root(here, UUID(self.root_id));
         }
     }
-}
+}

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/tests/test_jaseci.py

@@ -117,8 +117,8 @@ class TestJaseciPlugin(TestCase):
             args=[],
         )
         output = self.capturedOutput.getvalue().strip()
-        self.assertEqual(output, "node a\nnode b")
         self._del_session(session)
+        self.assertEqual(output, "node a\nnode b")
 
     def test_get_edge(self) -> None:
         """Test get an edge object."""
@@ -818,6 +818,8 @@ class TestJaseciPlugin(TestCase):
         )
         self.assertEqual("None", self.capturedOutput.getvalue().strip())
 
+        self._del_session(session)
+
     def test_traversing_save(self) -> None:
         """Test traversing save."""
         global session

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

@@ -1,30 +1,30 @@
-import from jaclang.runtimelib.machine { JacMachineInterface, JacMachine }
+import from jaclang.runtimelib.machine { JacMachine }
 
-glob dynamic_module_source = """
-import from .arch_create_util {UtilityNode}
 
-walker DynamicWalker {
-can start with entry {
-print("DynamicWalker Started");
-here ++> UtilityNode(data=42);
-visit [-->](`?UtilityNode);
-}
+glob dynamic_module_source =
+    """
+    import from arch_create_util {UtilityNode}
 
-def UtilityNode {
-here.display_data();
-}
-}
-""";
+    walker DynamicWalker {
+    can start with entry {
+    print("DynamicWalker Started");
+    here ++> UtilityNode(data=42);
+    visit [-->](`?UtilityNode);
+    }
+
+    def UtilityNode {
+    here.display_data();
+    }
+    }
+    """;
 
-with entry {
-    node_arch = JacMachineInterface.create_archetype_from_source(JacMachineInterface.py_get_jac_machine(),
-        dynamic_module_source,
-        module_name="dynamic_module"
-    );
-    walker_obj = JacMachineInterface.spawn_walker(JacMachineInterface.py_get_jac_machine(),
-        'DynamicWalker',
-        module_name="dynamic_module",
 
-    );
+with entry {
+    node_arch =
+        JacMachine.create_archetype_from_source(
+            dynamic_module_source, module_name="dynamic_module"
+        );
+    walker_obj =
+        JacMachine.spawn_walker('DynamicWalker', module_name="dynamic_module", );
     root spawn walker_obj;
 }

jaclang/tests/fixtures/async_ability.jac

@@ -1,18 +1,51 @@
 import asyncio;
+import from typing {Coroutine}
 
-async def say_hello(){
-    print("Hello");
-    await asyncio.sleep(1);
-    print("World!");
+node MyNode {
+    has val:int;
+
+    can foo1 with MyWalker entry {
+        print("foo1");
+    }
+
+    async can foo2 with MyWalker entry {
+        print("foo2");
+    }
+}
+
+edge MyEdge  {
+    has value:int;
 }
 
-async def main(){
-    await asyncio.gather(
-        say_hello(),
-        say_hello()
-    );
+async def fun{
+    print("Async function");
+}
+
+async walker MyWalker {
+    has name:str;
+
+    async can do_print with MyNode entry {
+        print("I am here man", here);
+        visit [-->];
+        await fun();
+    }
+
+    can foo3 with MyNode entry {
+        print("foo3");
+    }
 }
 
 with entry {
-    asyncio.run(main());
+    root ++> (node1:= MyNode(5));
+    node1 +>:MyEdge(100):+> MyNode(10);
+    node1 +>:MyEdge(200):+> MyNode(15);
+    walker1 = MyWalker("Mylife");
+    async def foo(w:W, a:A)-> None {
+        print("Let's start the task");
+        x = w spawn a;
+        print("It is Coroutine task", isinstance(x, Coroutine));
+        await x;
+        print("Coroutine task is completed");
+    }
+    asyncio.run(foo(walker1,node1));
 }

jaclang/tests/fixtures/async_function.jac

@@ -0,0 +1,18 @@
+import asyncio;
+
+async def say_hello(){
+    print("Hello");
+    await asyncio.sleep(1);
+    print("World!");
+}
+
+async def main(){
+    await asyncio.gather(
+        say_hello(),
+        say_hello()
+    );
+}
+
+with entry {
+    asyncio.run(main());
+}

jaclang/tests/fixtures/async_walker.jac

@@ -1,23 +1,28 @@
 import time;
+import asyncio;
+import from typing {Coroutine}
 node A {
     has val: int;
-
-    can do1 with W entry {
-        print("A Entry action ", self.val);
-        visit [self-->];
-        time.sleep(1);
-    }
 }
 
 async walker W {
     has num: int;
+
+    async can do1 with A entry {
+        print("A Entry action ", here.val);
+        visit [here-->];
+    }
 }
 
 with entry {
     root ++> (a1 := A(1)) ++> [a2 := A(2), a3 := A(3), a4 := A(4)];
-    w1 := W(8);
-    task = w1 spawn a1;
-    print("It is non blocking");
-    result = await task ;
-    print(result);
-}
+    w1 = W(8);
+    async def foo(w:W, a:A)-> None {
+        print("Let's start the task");
+        x = w spawn a;
+        print("It is Coroutine task", isinstance(x, Coroutine));
+        await x;
+        print("Coroutine task is completed");
+    }
+    asyncio.run(foo(w1,a1));
+}

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