jaclang 0.8.1__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/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/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/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();
 }