jaclang 0.7.30__py3-none-any.whl → 0.7.31__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,

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/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()
 

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/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_language.py

@@ -11,7 +11,7 @@ from jaclang import jac_import
 from jaclang.cli import cli
 from jaclang.compiler.compile import jac_file_to_pass, jac_pass_to_pass, jac_str_to_pass
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-from jaclang.runtimelib.context import SUPER_ROOT_ANCHOR
+from jaclang.runtimelib.context import ExecutionContext
 from jaclang.runtimelib.machine import JacMachine, JacProgram
 from jaclang.utils.test import TestCase
 
@@ -21,7 +21,7 @@ class JacLanguageTests(TestCase):
 
     def setUp(self) -> None:
         """Set up test."""
-        SUPER_ROOT_ANCHOR.edges.clear()
+        ExecutionContext.global_system_root().edges.clear()
         JacMachine(self.fixture_abs_path("./")).attach_program(
             JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
         )
@@ -118,19 +118,19 @@ class JacLanguageTests(TestCase):
         stdout_value = captured_output.getvalue()
 
         expected_outputs = [
-            "+-- AtomTrailer - Type: builtins.list[builtins.int]",
-            "    +-- Name - arr - Type: builtins.list[builtins.list[builtins.int]],  SymbolTable: list",
-            "    +-- IndexSlice - [IndexSlice] - Type: builtins.list[builtins.list[builtins.int]],  SymbolTable: None",
-            "        +-- Token - [,",
+            "+-- AtomTrailer - Type: jaclang.JacList[builtins.int]",
+            "    +-- Name - arr - Type: jaclang.JacList[jaclang.JacList[builtins.int]],  SymbolTable: None",
+            "+-- IndexSlice - [IndexSlice] - Type: jaclang.JacList[jaclang.JacList[builtins.int]],  SymbolTable: None",
+            "        +-- Token - [, ",
             "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
-            "        +-- Token - :,",
+            "        +-- Token - :, ",
             "        +-- Int - 3 - Type: Literal[3]?,  SymbolTable: None",
-            "        +-- Token - ,,",
+            "        +-- Token - ,, ",
             "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
-            "        +-- Token - :,",
-            "        +-- Token - :,",
+            "        +-- Token - :, ",
+            "        +-- Token - :, ",
             "        +-- Int - 2 - Type: Literal[2]?,  SymbolTable: None",
-            "        +-- Token - ],",
+            "        +-- Token - ], ",
         ]
 
         for expected in expected_outputs:
@@ -1033,11 +1033,11 @@ class JacLanguageTests(TestCase):
             stdout_value,
         )
         self.assertIn(
-            "Walkers in bar:\n  - Walker: bar_walk",
+            "Walkers in bar:\n  - Walker: Walker\n  - Walker: bar_walk",
             stdout_value,
         )
         self.assertIn("Nodes in bar:\n  - Node: Item", stdout_value)
-        self.assertIn("Edges in bar:\n  - Edge: Link", stdout_value)
+        self.assertIn("Edges in bar:\n  - Edge: Edge\n  - Edge: Link", stdout_value)
         self.assertIn("Item value: 0", stdout_value)
         self.assertIn("Created 5 items.", stdout_value)
 
@@ -1247,3 +1247,17 @@ class JacLanguageTests(TestCase):
             "walker exit\n",
             captured_output.getvalue(),
         )
+
+    def test_nested_impls(self) -> None:
+        """Test complex nested impls."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("nested_impls", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Hello,from bar in kk", stdout_value[0])
+        self.assertIn("Greeting: Hello, World!", stdout_value[1])
+        self.assertIn("Repeated: Hello", stdout_value[2])
+        self.assertIn("Hello, World!", stdout_value[3])
+        self.assertIn("Last message:!", stdout_value[4])
+        self.assertIn("Final message:!", stdout_value[5])

jaclang/tests/test_reference.py

@@ -7,7 +7,7 @@ from typing import Callable, Optional
 
 import jaclang
 from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.runtimelib.context import SUPER_ROOT_ANCHOR
+from jaclang.runtimelib.context import ExecutionContext
 from jaclang.utils.test import TestCase
 
 
@@ -52,7 +52,7 @@ class JacReferenceTests(TestCase):
         """Test file."""
 
         def execute_and_capture_output(code: str | bytes, filename: str = "") -> str:
-            SUPER_ROOT_ANCHOR.edges.clear()
+            ExecutionContext.global_system_root().edges.clear()
             f = io.StringIO()
             with redirect_stdout(f):
                 exec(

jaclang/utils/helpers.py

@@ -73,13 +73,14 @@ def extract_headings(file_path: str) -> dict[str, tuple[int, int]]:
     current_heading = None
     start_line = 0
     for idx, line in enumerate(lines, start=1):
-        if line.strip().startswith("//"):
+        line = line.strip().removesuffix(".")
+        if line.startswith("// [Heading]:"):
             if current_heading is not None:
                 headings[current_heading] = (
                     start_line,
                     idx - 2,
                 )  # Subtract 1 to get the correct end line
-            current_heading = line.strip()[2:]
+            current_heading = line.removeprefix("// [Heading]:")
             start_line = idx + 1
     # Add the last heading
     if current_heading is not None:
@@ -95,7 +96,7 @@ def auto_generate_refs() -> None:
     result = extract_headings(file_path)
     created_file_path = os.path.join(
         os.path.split(os.path.dirname(__file__))[0],
-        "../support/jac-lang.org/docs/learn/jac_ref.md",
+        "../support/jac-lang.org/docs/lang_ref/jac_ref.md",
     )
     destination_folder = os.path.join(
         os.path.split(os.path.dirname(__file__))[0], "../examples/reference/"

{jaclang-0.7.30.dist-info → jaclang-0.7.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jaclang
-Version: 0.7.30
+Version: 0.7.31
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 License: MIT
 Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence