jaclang 0.7.30__py3-none-any.whl → 0.7.32__py3-none-any.whl

jaclang/compiler/passes/main/tests/test_type_check_pass.py

@@ -70,19 +70,22 @@ class MypyTypeCheckPassTests(TestCase):
         )
         self.assertRegex(
             out,
-            r"129:24 - 129:28.*SpecialVarRef - _Jac.get_root\(\) \- Type\: jaclang.runtimelib.architype.Root",
+            r"129:24 - 129:28.*SpecialVarRef - Jac.get_root\(\) \- Type\: jaclang.Root",
         )
+
         self.assertRegex(out, r"129:11 - 129:29.*FuncCall \- Type\: builtins\.str")
         self.assertRegex(
             out,
             r"129:15 - 129:23.*Name \- node_dot \- Type\: builtins.str,  SymbolTable\: str",
         )
+
         self.assertRegex(
             out,
-            r"128:5 - 128:25.*BinaryExpr \- Type\: jaclang.runtimelib.architype.WalkerArchitype",
+            r"128:5 - 128:25.*BinaryExpr \- Type\: jaclang.Walker",
         )
         self.assertRegex(
             out,
-            r"48:11 - 48:28.*EdgeRefTrailer \- Type\: builtins.list\[data_spatial_types.A\]",
+            r"48:11 - 48:28.*EdgeRefTrailer \- Type\: jaclang.JacList\[data_spatial_types.A\]",
         )
+
         self.assertRegex(out, r"24:5 - 24:25.*BinaryExpr \- Type\: builtins.bool", out)

jaclang/compiler/tests/test_parser.py

@@ -89,12 +89,20 @@ class TestLarkParser(TestCaseMicroSuite):
                 JacParser.TreeToAST.__base__, value.__name__, False
             ):
                 parse_funcs.append(name)
-        for i in rules:
-            self.assertIn(i, parse_funcs)
-        for i in parse_funcs:
-            if i in ["binary_expr_unwind", "ice", "nu"]:
+        for rule in rules:
+            self.assertIn(rule, parse_funcs)
+        for fn in parse_funcs:
+            if fn.startswith("_") or fn in [
+                "ice",
+                "match",
+                "consume",
+                "match_token",
+                "consume_token",
+                "match_many",
+                "consume_many",
+            ]:
                 continue
-            self.assertIn(i, rules)
+            self.assertIn(fn, rules)
 
     def test_all_ast_has_normalize(self) -> None:
         """Test for enter/exit name diffs with parser."""

jaclang/plugin/builtin.py

@@ -7,6 +7,12 @@ from typing import Optional
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.runtimelib.constructs import Architype, NodeArchitype
 
+__all__ = [
+    "dotgen",
+    "jid",
+    "jobj",
+]
+
 
 def dotgen(
     node: Optional[NodeArchitype] = None,
@@ -44,3 +50,8 @@ def dotgen(
 def jid(obj: Architype) -> str:
     """Get the id of the object."""
     return Jac.object_ref(obj)
+
+
+def jobj(id: str) -> Architype | None:
+    """Get the object from the id."""
+    return Jac.get_object(id)

jaclang/plugin/default.py

@@ -660,11 +660,15 @@ class JacFeatureImpl(
         if not hasattr(cls, "_jac_entry_funcs_") or not hasattr(
             cls, "_jac_exit_funcs_"
         ):
-            # Saving the module path and reassign it after creating cls
-            # So the jac modules are part of the correct module
-            cur_module = cls.__module__
-            cls = type(cls.__name__, (cls, arch_base), {})
-            cls.__module__ = cur_module
+            # If a class only inherit from object (ie. Doesn't inherit from a class), we cannot modify
+            # the __bases__ property of it, so it's necessary to make sure the class is not a direct child of object.
+            assert cls.__bases__ != (object,)
+            bases = (
+                (cls.__bases__ + (arch_base,))
+                if arch_base not in cls.__bases__
+                else cls.__bases__
+            )
+            cls.__bases__ = bases
             cls._jac_entry_funcs_ = on_entry  # type: ignore
             cls._jac_exit_funcs_ = on_exit  # type: ignore
         else:
@@ -724,6 +728,22 @@ class JacFeatureImpl(
 
         return decorator
 
+    @staticmethod
+    @hookimpl
+    def make_root(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a obj architype."""
+
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
+            """Decorate class."""
+            cls = Jac.make_architype(
+                cls=cls, arch_base=Root, on_entry=on_entry, on_exit=on_exit
+            )
+            return cls
+
+        return decorator
+
     @staticmethod
     @hookimpl
     def make_edge(
@@ -740,6 +760,25 @@ class JacFeatureImpl(
 
         return decorator
 
+    @staticmethod
+    @hookimpl
+    def make_generic_edge(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a edge architype."""
+
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
+            """Decorate class."""
+            cls = Jac.make_architype(
+                cls=cls,
+                arch_base=GenericEdge,
+                on_entry=on_entry,
+                on_exit=on_exit,
+            )
+            return cls
+
+        return decorator
+
     @staticmethod
     @hookimpl
     def make_walker(
@@ -1061,7 +1100,9 @@ class JacFeatureImpl(
     @hookimpl
     def get_root_type() -> Type[Root]:
         """Jac's root getter."""
-        return Root
+        from jaclang import Root as JRoot
+
+        return cast(Type[Root], JRoot)
 
     @staticmethod
     @hookimpl
@@ -1071,10 +1112,12 @@ class JacFeatureImpl(
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
         """Jac's root getter."""
-        conn_type = conn_type if conn_type else GenericEdge
+        from jaclang import GenericEdge
+
+        ct = conn_type if conn_type else GenericEdge
 
         def builder(source: NodeAnchor, target: NodeAnchor) -> EdgeArchitype:
-            edge = conn_type() if isinstance(conn_type, type) else conn_type
+            edge = ct() if isinstance(ct, type) else ct
 
             eanch = edge.__jac__ = EdgeAnchor(
                 architype=edge,
@@ -1093,8 +1136,6 @@ class JacFeatureImpl(
                         raise ValueError(f"Invalid attribute: {fld}")
             if source.persistent or target.persistent:
                 Jac.save(eanch)
-                Jac.save(target)
-                Jac.save(source)
             return edge
 
         return builder
@@ -1112,6 +1153,19 @@ class JacFeatureImpl(
 
         jctx.mem.set(anchor.id, anchor)
 
+        match anchor:
+            case NodeAnchor():
+                for ed in anchor.edges:
+                    if ed.is_populated() and not ed.persistent:
+                        Jac.save(ed)
+            case EdgeAnchor():
+                if (src := anchor.source) and src.is_populated() and not src.persistent:
+                    Jac.save(src)
+                if (trg := anchor.target) and trg.is_populated() and not trg.persistent:
+                    Jac.save(trg)
+            case _:
+                pass
+
     @staticmethod
     @hookimpl
     def destroy(obj: Architype | Anchor) -> None:

jaclang/plugin/feature.py

@@ -305,6 +305,13 @@ class JacFeature(
         """Create a node architype."""
         return plugin_manager.hook.make_node(on_entry=on_entry, on_exit=on_exit)
 
+    @staticmethod
+    def make_root(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a root node architype."""
+        return plugin_manager.hook.make_root(on_entry=on_entry, on_exit=on_exit)
+
     @staticmethod
     def make_edge(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
@@ -312,6 +319,13 @@ class JacFeature(
         """Create a edge architype."""
         return plugin_manager.hook.make_edge(on_entry=on_entry, on_exit=on_exit)
 
+    @staticmethod
+    def make_generic_edge(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a edge architype."""
+        return plugin_manager.hook.make_generic_edge(on_entry=on_entry, on_exit=on_exit)
+
     @staticmethod
     def make_walker(
         on_entry: list[DSFunc], on_exit: list[DSFunc]

jaclang/plugin/spec.py

@@ -295,6 +295,14 @@ class JacFeatureSpec(
         """Create a node architype."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def make_root(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a root node architype."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def make_edge(
@@ -303,6 +311,14 @@ class JacFeatureSpec(
         """Create a edge architype."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def make_generic_edge(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a generic edge architype."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def make_walker(

jaclang/plugin/tests/fixtures/graph_purger.jac

@@ -1,3 +1,5 @@
+import:py from jaclang.plugin.feature {JacFeature as Jac}
+
 node A {
     has id: int;
 }

jaclang/plugin/tests/fixtures/other_root_access.jac

@@ -1,3 +1,4 @@
+import:py from jaclang.plugin.feature {JacFeature as Jac}
 import:py from jaclang.runtimelib.architype {Anchor}
 import:py from uuid {UUID}
 

jaclang/plugin/tests/fixtures/savable_object.jac

@@ -1,3 +1,5 @@
+import:py from jaclang.plugin.feature {JacFeature as Jac}
+
 enum Enum {
     A = "a",
     B = "b",

jaclang/plugin/tests/fixtures/traversing_save.jac

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

jaclang/plugin/tests/test_jaseci.py

@@ -748,7 +748,7 @@ class TestJaseciPlugin(TestCase):
     def test_savable_object(self) -> None:
         """Test ObjectAnchor save."""
         global session
-        session = self.fixture_abs_path("other_root_access.session")
+        session = self.fixture_abs_path("savable_object.session")
 
         self._output2buffer()
 
@@ -816,3 +816,36 @@ class TestJaseciPlugin(TestCase):
             session=session,
         )
         self.assertEqual("None", self.capturedOutput.getvalue().strip())
+
+    def test_traversing_save(self) -> None:
+        """Test traversing save."""
+        global session
+        session = self.fixture_abs_path("traversing_save.session")
+
+        self._output2buffer()
+        cli.enter(
+            filename=self.fixture_abs_path("traversing_save.jac"),
+            entrypoint="build",
+            args=[],
+            session=session,
+        )
+
+        cli.enter(
+            filename=self.fixture_abs_path("traversing_save.jac"),
+            entrypoint="view",
+            args=[],
+            session=session,
+        )
+
+        self.assertEqual(
+            "digraph {\n"
+            'node [style="filled", shape="ellipse", fillcolor="invis", fontcolor="black"];\n'
+            '0 -> 1  [label=""];\n'
+            '1 -> 2  [label=""];\n'
+            '0 [label="Root()"fillcolor="#FFE9E9"];\n'
+            '1 [label="A()"fillcolor="#F0FFF0"];\n'
+            '2 [label="B()"fillcolor="#F5E5FF"];\n}',
+            self.capturedOutput.getvalue().strip(),
+        )
+
+        self._del_session(session)

jaclang/runtimelib/architype.py

@@ -12,6 +12,7 @@ from types import UnionType
 from typing import Any, Callable, ClassVar, Optional, TypeVar
 from uuid import UUID, uuid4
 
+
 logger = getLogger(__name__)
 
 TARCH = TypeVar("TARCH", bound="Architype")
@@ -285,21 +286,13 @@ class ObjectArchitype(Architype):
         self.__jac__ = ObjectAnchor(architype=self)
 
 
-@dataclass(eq=False)
 class GenericEdge(EdgeArchitype):
-    """Generic Root Node."""
-
-    _jac_entry_funcs_: ClassVar[list[DSFunc]] = []
-    _jac_exit_funcs_: ClassVar[list[DSFunc]] = []
+    """Generic Edge."""
 
 
-@dataclass(eq=False)
 class Root(NodeArchitype):
     """Generic Root Node."""
 
-    _jac_entry_funcs_: ClassVar[list[DSFunc]] = []
-    _jac_exit_funcs_: ClassVar[list[DSFunc]] = []
-
     def __init__(self) -> None:
         """Create root node."""
         self.__jac__ = NodeAnchor(architype=self, persistent=True, edges=[])
@@ -315,16 +308,13 @@ class DSFunc:
     @cached_property
     def trigger(self) -> type | UnionType | tuple[type | UnionType, ...] | None:
         """Get function parameter annotations."""
-        t = (
-            (
-                inspect.signature(self.func, eval_str=True)
-                .parameters["_jac_here_"]
-                .annotation
-            )
-            if self.func
-            else None
-        )
-        return None if t is inspect._empty else t
+        if self.func:
+            parameters = inspect.signature(self.func, eval_str=True).parameters
+            if len(parameters) >= 2:
+                second_param = list(parameters.values())[1]
+                ty = second_param.annotation
+                return ty if ty != inspect._empty else None
+        return None
 
     def resolve(self, cls: type) -> None:
         """Resolve the function."""

jaclang/runtimelib/context.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import unittest
 from contextvars import ContextVar
 from dataclasses import MISSING
-from typing import Any, Callable, Optional, cast
+from typing import Any, Callable, ClassVar, Optional, cast
 from uuid import UUID
 
 from .architype import NodeAnchor, Root
@@ -13,13 +13,7 @@ from .memory import Memory, ShelfStorage
 
 
 EXECUTION_CONTEXT = ContextVar[Optional["ExecutionContext"]]("ExecutionContext")
-
 SUPER_ROOT_UUID = UUID("00000000-0000-0000-0000-000000000000")
-SUPER_ROOT_ARCHITYPE = object.__new__(Root)
-SUPER_ROOT_ANCHOR = NodeAnchor(
-    id=SUPER_ROOT_UUID, architype=SUPER_ROOT_ARCHITYPE, persistent=False, edges=[]
-)
-SUPER_ROOT_ARCHITYPE.__jac__ = SUPER_ROOT_ANCHOR
 
 
 class ExecutionContext:
@@ -32,6 +26,9 @@ class ExecutionContext:
     root: NodeAnchor
     entry_node: NodeAnchor
 
+    # A context change event subscription list, those who want to listen ctx change will register here.
+    on_ctx_change: ClassVar[list[Callable[[ExecutionContext | None], None]]] = []
+
     def init_anchor(
         self,
         anchor_id: str | None,
@@ -52,6 +49,8 @@ class ExecutionContext:
         """Close current ExecutionContext."""
         self.mem.close()
         EXECUTION_CONTEXT.set(None)
+        for func in ExecutionContext.on_ctx_change:
+            func(EXECUTION_CONTEXT.get(None))
 
     @staticmethod
     def create(
@@ -60,6 +59,8 @@ class ExecutionContext:
         auto_close: bool = True,
     ) -> ExecutionContext:
         """Create ExecutionContext."""
+        from jaclang import Root
+
         ctx = ExecutionContext()
         ctx.mem = ShelfStorage(session)
         ctx.reports = []
@@ -67,7 +68,7 @@ class ExecutionContext:
         if not isinstance(
             system_root := ctx.mem.find_by_id(SUPER_ROOT_UUID), NodeAnchor
         ):
-            system_root = Root().__jac__
+            system_root = cast(NodeAnchor, Root().__jac__)  # type: ignore[attr-defined]
             system_root.id = SUPER_ROOT_UUID
             ctx.mem.set(system_root.id, system_root)
 
@@ -79,6 +80,8 @@ class ExecutionContext:
             old_ctx.close()
 
         EXECUTION_CONTEXT.set(ctx)
+        for func in ExecutionContext.on_ctx_change:
+            func(EXECUTION_CONTEXT.get(None))
 
         return ctx
 
@@ -95,7 +98,20 @@ class ExecutionContext:
         if ctx := EXECUTION_CONTEXT.get(None):
             return cast(Root, ctx.root.architype)
 
-        return SUPER_ROOT_ARCHITYPE
+        return cast(Root, ExecutionContext.global_system_root().architype)
+
+    @staticmethod
+    def global_system_root() -> NodeAnchor:
+        """Get global system root."""
+        from jaclang import Root
+
+        if not (sr_anch := getattr(ExecutionContext, "system_root", None)):
+            sr_arch = Root()
+            sr_anch = sr_arch.__jac__  # type: ignore[attr-defined]
+            sr_anch.id = SUPER_ROOT_UUID
+            sr_anch.persistent = False
+            ExecutionContext.system_root = sr_anch
+        return sr_anch
 
 
 class JacTestResult(unittest.TextTestResult):

jaclang/settings.py

@@ -23,6 +23,8 @@ class Settings:
     disable_mtllm: bool = False
     ignore_test_annex: bool = False
     allow_import_from: bool = False
+    pyout_jaclib_import_all: bool = True
+    pyout_jaclib_alias = "jl"
 
     # Formatter configuration
     max_line_length: int = 88

jaclang/tests/fixtures/base_class_complex_expr.jac

@@ -0,0 +1,38 @@
+class Apple {
+    with entry {
+        a = 1;
+    }
+}
+
+class Orange {
+    with entry {
+        b = 2;
+    }
+}
+
+with entry {
+    mm = [Apple, Orange];
+}
+
+class Banana :mm[1]: {
+    with entry {
+        c = 3;
+    }
+}
+
+can return_class() -> `Type[Apple] {
+    print('Returning Apple');
+    return Apple;
+}
+
+class Kiwi :return_class(): {
+    with entry {
+        d = 4;
+        ;
+    }
+}
+
+with entry {
+    a = Kiwi();
+    print(Kiwi.d);
+}

jaclang/tests/fixtures/create_dynamic_architype.jac

@@ -13,7 +13,7 @@ print("Dynamic Node Value:", f'{self.value}');
 glob walker_code = """
 walker dynamic_walker {
 can visit_nodes with entry {
-visit [-->](`?dynamic_node);
+visit [-->];
 }
 }
 """;

jaclang/tests/fixtures/nested_impls.jac

@@ -0,0 +1,55 @@
+obj mainObject;
+
+:obj:mainObject{
+    can greet;
+    obj subObject;
+}
+can foo{
+     obj ObjInsideFunction;
+     return ObjInsideFunction();
+}
+:can:foo:obj:ObjInsideFunction{
+    can bar{
+        print("Hello,from bar in kk");
+    }
+}
+
+with entry{
+    foo().bar();
+}
+:obj:mainObject:can:greet{
+    print("Greeting: Hello, World!");
+}
+
+:obj:mainObject:obj:subObject{
+    can displayMessage;
+    can shortMessage{
+        print("Hello, World!");
+    }
+    obj nestedObject;
+}
+:obj:mainObject:obj:subObject:can:displayMessage{
+    print("Repeated: Hello!");
+}
+
+:obj:mainObject:obj:subObject:obj:nestedObject{
+    can lastMessage;
+    can finalMessage{
+        print("Final message:!");
+    }
+}
+
+:obj:mainObject:obj:subObject:obj:nestedObject:can:lastMessage{
+# impl mainObject.subObject.nestedObject{  # TODO
+        print("Last message:!");
+
+}
+
+
+with entry{
+    mainObject().greet();
+    mainObject().subObject().displayMessage();
+    mainObject().subObject().shortMessage();
+    mainObject().subObject().nestedObject().lastMessage();
+    mainObject().subObject().nestedObject().finalMessage();
+}

jaclang/tests/test_cli.py

@@ -294,6 +294,27 @@ class JacCliTests(TestCase):
             r"10:7 - 10:12.*Name - start - Type.*SymbolPath: base_class2.B.start",
         )
 
+    def test_base_class_complex_expr(self) -> None:
+        """Testing for print AstTool."""
+        from jaclang.settings import settings
+
+        # settings.ast_symbol_info_detailed = True
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool(
+            "ir", ["ast", f"{self.fixture_abs_path('base_class_complex_expr.jac')}"]
+        )
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        settings.ast_symbol_info_detailed = False
+
+        self.assertRegex(
+            stdout_value,
+            r"36\:9 \- 36\:13.*Name \- Kiwi \- Type\: base_class_complex_expr.Kiwi,  SymbolTable\: Kiwi",
+        )
+
     def test_expr_types(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()