jaclang 0.7.25__py3-none-any.whl → 0.7.26__py3-none-any.whl

jaclang/plugin/default.py

@@ -11,7 +11,7 @@ from collections import OrderedDict
 from dataclasses import field
 from functools import wraps
 from logging import getLogger
-from typing import Any, Callable, Mapping, Optional, Sequence, Type, Union
+from typing import Any, Callable, Mapping, Optional, Sequence, Type, Union, cast
 from uuid import UUID
 
 from jaclang.compiler.constant import colors
@@ -41,6 +41,7 @@ from jaclang.runtimelib.constructs import (
 )
 from jaclang.runtimelib.importer import ImportPathSpec, JacImporter, PythonImporter
 from jaclang.runtimelib.machine import JacMachine, JacProgram
+from jaclang.runtimelib.memory import Shelf, ShelfStorage
 from jaclang.runtimelib.utils import collect_node_connections, traverse_graph
 
 
@@ -53,6 +54,13 @@ logger = getLogger(__name__)
 class JacAccessValidationImpl:
     """Jac Access Validation Implementations."""
 
+    @staticmethod
+    @hookimpl
+    def elevate_root() -> None:
+        """Elevate context root to system_root."""
+        jctx = Jac.get_context()
+        jctx.root = jctx.system_root
+
     @staticmethod
     @hookimpl
     def allow_root(
@@ -379,7 +387,8 @@ class JacWalkerImpl:
         if walker.next:
             current_node = walker.next[-1].architype
             for i in warch._jac_entry_funcs_:
-                if not i.trigger:
+                trigger = i.get_funcparam_annotations(i.func)
+                if not trigger:
                     if i.func:
                         i.func(warch, current_node)
                     else:
@@ -387,7 +396,8 @@ class JacWalkerImpl:
         while len(walker.next):
             if current_node := walker.next.pop(0).architype:
                 for i in current_node._jac_entry_funcs_:
-                    if not i.trigger or isinstance(warch, i.trigger):
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(warch, trigger):
                         if i.func:
                             i.func(current_node, warch)
                         else:
@@ -395,27 +405,30 @@ class JacWalkerImpl:
                     if walker.disengaged:
                         return warch
                 for i in warch._jac_entry_funcs_:
-                    if not i.trigger or isinstance(current_node, i.trigger):
-                        if i.func and i.trigger:
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(current_node, trigger):
+                        if i.func and trigger:
                             i.func(warch, current_node)
-                        elif not i.trigger:
+                        elif not trigger:
                             continue
                         else:
                             raise ValueError(f"No function {i.name} to call.")
                     if walker.disengaged:
                         return warch
                 for i in warch._jac_exit_funcs_:
-                    if not i.trigger or isinstance(current_node, i.trigger):
-                        if i.func and i.trigger:
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(current_node, trigger):
+                        if i.func and trigger:
                             i.func(warch, current_node)
-                        elif not i.trigger:
+                        elif not trigger:
                             continue
                         else:
                             raise ValueError(f"No function {i.name} to call.")
                     if walker.disengaged:
                         return warch
                 for i in current_node._jac_exit_funcs_:
-                    if not i.trigger or isinstance(warch, i.trigger):
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(warch, trigger):
                         if i.func:
                             i.func(current_node, warch)
                         else:
@@ -423,7 +436,8 @@ class JacWalkerImpl:
                     if walker.disengaged:
                         return warch
         for i in warch._jac_exit_funcs_:
-            if not i.trigger:
+            trigger = i.get_funcparam_annotations(i.func)
+            if not trigger:
                 if i.func:
                     i.func(warch, current_node)
                 else:
@@ -560,6 +574,29 @@ class JacFeatureImpl(
         """Get current execution context."""
         return ExecutionContext.get()
 
+    @staticmethod
+    @hookimpl
+    def reset_graph(root: Optional[Root] = None) -> int:
+        """Purge current or target graph."""
+        ctx = Jac.get_context()
+        mem = cast(ShelfStorage, ctx.mem)
+        ranchor = root.__jac__ if root else ctx.root
+
+        deleted_count = 0
+        for anchor in (
+            anchors.values()
+            if isinstance(anchors := mem.__shelf__, Shelf)
+            else mem.__mem__.values()
+        ):
+            if anchor == ranchor or anchor.root != ranchor.id:
+                continue
+
+            if loaded_anchor := mem.find_by_id(anchor.id):
+                deleted_count += 1
+                Jac.destroy(loaded_anchor)
+
+        return deleted_count
+
     @staticmethod
     @hookimpl
     def get_object(id: str) -> Architype | None:

jaclang/plugin/feature.py

@@ -41,6 +41,11 @@ from jaclang.plugin.spec import (
 class JacAccessValidation:
     """Jac Access Validation Specs."""
 
+    @staticmethod
+    def elevate_root() -> None:
+        """Elevate context root to system_root."""
+        plugin_manager.hook.elevate_root()
+
     @staticmethod
     def allow_root(
         architype: Architype,
@@ -254,6 +259,11 @@ class JacFeature(
         """Get current execution context."""
         return plugin_manager.hook.get_context()
 
+    @staticmethod
+    def reset_graph(root: Optional[Root] = None) -> int:
+        """Purge current or target graph."""
+        return plugin_manager.hook.reset_graph(root=root)
+
     @staticmethod
     def get_object(id: str) -> Architype | None:
         """Get object given id."""

jaclang/plugin/spec.py

@@ -46,6 +46,12 @@ P = ParamSpec("P")
 class JacAccessValidationSpec:
     """Jac Access Validation Specs."""
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def elevate_root() -> None:
+        """Elevate context root to system_root."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def allow_root(
@@ -244,6 +250,12 @@ class JacFeatureSpec(
         """Get current execution context."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def reset_graph(root: Optional[Root]) -> int:
+        """Purge current or target graph."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def get_object(id: str) -> Architype | None:

jaclang/plugin/tests/fixtures/graph_purger.jac

@@ -0,0 +1,101 @@
+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;
+}
+
+
+walker populate {
+    can setup1 with `root entry {
+        for i in range(2) {
+            here ++> A(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup2 with A entry {
+        for i in range(2) {
+            here ++> B(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup3 with B entry {
+        for i in range(2) {
+            here ++> C(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup4 with C entry {
+        for i in range(2) {
+            here ++> D(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup5 with D entry {
+        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/plugin/tests/fixtures/other_root_access.jac

@@ -23,6 +23,15 @@ walker update_node {
     }
 }
 
+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;
 

jaclang/plugin/tests/test_jaseci.py

@@ -269,6 +269,75 @@ class TestJaseciPlugin(TestCase):
         )
         self._del_session(session)
 
+    def test_walker_purger(self) -> None:
+        """Test simple persistent object."""
+        session = self.fixture_abs_path("test_walker_purger.session")
+        self._output2buffer()
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="populate",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="traverse",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="check",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="purge",
+            args=[],
+        )
+        output = self.capturedOutput.getvalue().strip()
+        self.assertEqual(
+            output,
+            (
+                "Root()\n"
+                "A(id=0)\nA(id=1)\n"
+                "B(id=0)\nB(id=1)\nB(id=0)\nB(id=1)\n"
+                "C(id=0)\nC(id=1)\nC(id=0)\nC(id=1)\nC(id=0)\nC(id=1)\nC(id=0)\nC(id=1)\n"
+                "D(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\n"
+                "D(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\n"
+                "E(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\n"
+                "E(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\n"
+                "E(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\n"
+                "E(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\n"
+                "125\n124"
+            ),
+        )
+        self._output2buffer()
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="traverse",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="check",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="purge",
+            args=[],
+        )
+        output = self.capturedOutput.getvalue().strip()
+        self.assertEqual(output, "Root()\n1\n0")
+
+        self._del_session(session)
+
     def trigger_access_validation_test(
         self, give_access_to_full_graph: bool, via_all: bool = False
     ) -> None:
@@ -340,6 +409,55 @@ class TestJaseciPlugin(TestCase):
         self.assertEqual(archs[0], "A(val=2)")
         self.assertEqual(archs[1], "A(val=1)")
 
+        ##############################################
+        #        WITH READ ACCESS BUT ELEVATED       #
+        ##############################################
+
+        self._output2buffer()
+
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node_forced",
+            args=[20],
+            session=session,
+            root=self.roots[0],
+            node=self.nodes[1],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node_forced",
+            args=[10],
+            session=session,
+            root=self.roots[1],
+            node=self.nodes[0],
+        )
+
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="check_node",
+            args=[],
+            session=session,
+            root=self.roots[0],
+            node=self.nodes[1],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="check_node",
+            args=[],
+            session=session,
+            root=self.roots[1],
+            node=self.nodes[0],
+        )
+        archs = self.capturedOutput.getvalue().strip().split("\n")
+        self.assertTrue(len(archs) == 2)
+
+        # ---------- UPDATE SHOULD HAPPEN ---------- #
+
+        self.assertEqual(archs[0], "A(val=20)")
+        self.assertEqual(archs[1], "A(val=10)")
+
+        # ---------- DISALLOW READ ACCESS ---------- #
+
         self._output2buffer()
         cli.enter(
             filename=self.fixture_abs_path("other_root_access.jac"),
@@ -400,7 +518,7 @@ class TestJaseciPlugin(TestCase):
         cli.enter(
             filename=self.fixture_abs_path("other_root_access.jac"),
             entrypoint="update_node",
-            args=[20],
+            args=[200],
             root=self.roots[0],
             node=self.nodes[1],
             session=session,
@@ -408,7 +526,7 @@ class TestJaseciPlugin(TestCase):
         cli.enter(
             filename=self.fixture_abs_path("other_root_access.jac"),
             entrypoint="update_node",
-            args=[10],
+            args=[100],
             session=session,
             root=self.roots[1],
             node=self.nodes[0],
@@ -433,10 +551,12 @@ class TestJaseciPlugin(TestCase):
         archs = self.capturedOutput.getvalue().strip().split("\n")
         self.assertTrue(len(archs) == 2)
 
-        # --------- UPDATE SHOULD HAPPEN -------- #
+        # ---------- UPDATE SHOULD HAPPEN ---------- #
 
-        self.assertEqual(archs[0], "A(val=20)")
-        self.assertEqual(archs[1], "A(val=10)")
+        self.assertEqual(archs[0], "A(val=200)")
+        self.assertEqual(archs[1], "A(val=100)")
+
+        # ---------- DISALLOW WRITE ACCESS --------- #
 
         self._output2buffer()
         cli.enter(
@@ -474,7 +594,7 @@ class TestJaseciPlugin(TestCase):
         )
         self.assertFalse(self.capturedOutput.getvalue().strip())
 
-        # --------- ROOTS RESET OWN NODE -------- #
+        # ---------- ROOTS RESET OWN NODE ---------- #
 
         cli.enter(
             filename=self.fixture_abs_path("other_root_access.jac"),

jaclang/runtimelib/architype.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import inspect
 from dataclasses import asdict, dataclass, field, fields, is_dataclass
 from enum import IntEnum
 from logging import getLogger
@@ -291,9 +292,19 @@ class DSFunc:
     """Data Spatial Function."""
 
     name: str
-    trigger: type | UnionType | tuple[type | UnionType, ...] | None
     func: Callable[[Any, Any], Any] | None = None
 
     def resolve(self, cls: type) -> None:
         """Resolve the function."""
         self.func = getattr(cls, self.name)
+
+    def get_funcparam_annotations(
+        self, func: Callable[[Any, Any], Any] | None
+    ) -> type | UnionType | tuple[type | UnionType, ...] | None:
+        """Get function parameter annotations."""
+        if not func:
+            return None
+        annotation = (
+            inspect.signature(func, eval_str=True).parameters["_jac_here_"].annotation
+        )
+        return annotation if annotation != inspect._empty else None

jaclang/runtimelib/memory.py

@@ -25,6 +25,10 @@ class Memory(Generic[ID, TANCH]):
         self.__mem__.clear()
         self.__gc__.clear()
 
+    def is_cached(self, id: ID) -> bool:
+        """Check if id if already cached."""
+        return id in self.__mem__
+
     def find(
         self,
         ids: ID | Iterable[ID],
@@ -96,7 +100,7 @@ class ShelfStorage(Memory[UUID, Anchor]):
                             and p_d.edges != d.edges
                             and Jac.check_connect_access(d)
                         ):
-                            if not d.edges:
+                            if not d.edges and not isinstance(d.architype, Root):
                                 self.__shelf__.pop(_id, None)
                                 continue
                             p_d.edges = d.edges

jaclang/tests/fixtures/architype_def_bug.jac

@@ -0,0 +1,17 @@
+# fix test type 2
+walker MyWalker {
+    can travel with `root | MyNode entry {
+        print("MyWalker");
+    }
+}
+
+node MyNode {
+    can work with MyWalker entry {
+        print("MyNode");
+    }
+}
+
+with entry {
+    Node_1 = MyNode();
+    Node_1 spawn MyWalker();
+}

jaclang/tests/fixtures/decl_defn_param_name.jac

@@ -0,0 +1,19 @@
+
+obj SomeClass {
+    can method1(some_long_paramenter_name: int) -> None;
+    can method2(param1:int, param2:str) -> None;
+}
+
+:o:SomeClass:c:method1(short_name:int) -> None {
+  print("short_name =", short_name);
+}
+
+:o:SomeClass:c:method2(p1:int, p2: str) -> None {
+  print("p1 =", p1, ", p2 =", p2);
+}
+
+with entry {
+  sc = SomeClass();
+  sc.method1(42);
+  sc.method2(64, "foobar");
+}

jaclang/tests/fixtures/multi_dim_array_split.jac

@@ -0,0 +1,19 @@
+import:py numpy as np;
+
+with entry {
+    arr = np.array(
+        [[1,   2,  3,  4,  5],
+         [6,   7,  8,  9, 10],
+         [11, 12, 13, 14, 15],
+         [16, 17, 18, 19, 20],
+         [21, 22, 23, 24, 25]]
+    );
+
+    print('Original Array:');
+    print(arr);
+
+    print();
+
+    print('Sliced Array:');
+    print(arr[1:3, 1::2]);
+}

jaclang/tests/test_cli.py

@@ -94,6 +94,24 @@ class JacCliTests(TestCase):
         path_to_file = self.fixture_abs_path("err.impl.jac")
         self.assertIn(f'"{path_to_file}", line 2', stdout_value)
 
+    def test_param_name_diff(self) -> None:
+        """Test when parameter name from definitinon and declaration are mismatched."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+        with contextlib.suppress(Exception):
+            cli.run(self.fixture_abs_path("decl_defn_param_name.jac"))
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+
+        expected_stdout_values = (
+            "short_name = 42",
+            "p1 = 64 , p2 = foobar",
+        )
+        output = captured_output.getvalue()
+        for exp in expected_stdout_values:
+            self.assertIn(exp, output)
+
     def test_jac_test_err(self) -> None:
         """Basic test for pass."""
         captured_output = io.StringIO()

jaclang/tests/test_language.py

@@ -103,6 +103,40 @@ class JacLanguageTests(TestCase):
             "Too high!\nToo low!\nToo high!\nCongratulations! You guessed correctly.\n",
         )
 
+    def test_multi_dim_arr_slice(self) -> None:
+        """Parse micro jac file."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.tool(
+            "ir",
+            [
+                "ast",
+                self.fixture_abs_path("multi_dim_array_split.jac"),
+            ],
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        # print(arr[1:3, 1::2]);
+        expected_outputs = [
+            "+-- AtomTrailer - Type: Any",
+            "    +-- Name - arr - Type: Any,  SymbolTable: None",
+            "    +-- IndexSlice - [IndexSlice] - Type: builtins.slice,  SymbolTable: None",
+            "        +-- Token - [,",
+            "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
+            "        +-- Token - :,",
+            "        +-- Int - 3 - Type: Literal[3]?,  SymbolTable: None",
+            "        +-- Token - ,,",
+            "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
+            "        +-- Token - :,",
+            "        +-- Token - :,",
+            "        +-- Int - 2 - Type: Literal[2]?,  SymbolTable: None",
+            "        +-- Token - ],",
+        ]
+
+        for expected in expected_outputs:
+            self.assertIn(expected, stdout_value)
+
     def test_chandra_bugs(self) -> None:
         """Parse micro jac file."""
         captured_output = io.StringIO()
@@ -1189,3 +1223,13 @@ class JacLanguageTests(TestCase):
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Hello World !", stdout_value[0])
         self.assertIn("Welcome to Jaseci!", stdout_value[1])
+
+    def test_architype_def(self) -> None:
+        """Test architype definition bug."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("architype_def_bug", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("MyNode", stdout_value[0])
+        self.assertIn("MyWalker", stdout_value[1])

{jaclang-0.7.25.dist-info → jaclang-0.7.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.25
+Version: 0.7.26
 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