jaclang 0.7.29__py3-none-any.whl → 0.7.31__py3-none-any.whl

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

@@ -83,7 +83,10 @@ class ImportPassPassTests(TestCase):
         for i in p:
             self.assertIn(i, build.ir.py_info.py_raise_map)
             self.assertRegex(
-                re.sub(r".*fixtures/", "", build.ir.py_info.py_raise_map[i]), p[i]
+                re.sub(r".*fixtures/", "", build.ir.py_info.py_raise_map[i]).replace(
+                    "\\", "/"
+                ),
+                p[i],
             )
 
     def test_py_raised_mods(self) -> None:

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/passes/tool/jac_formatter_pass.py

@@ -973,7 +973,6 @@ class JacFormatPass(Pass):
                     Tok.PIPE_FWD,
                     Tok.KW_SPAWN,
                     Tok.A_PIPE_FWD,
-                    Tok.ELVIS_OP,
                 ]
                 or (
                     node.op.name == Tok.PIPE_FWD

jaclang/compiler/tests/test_importer.py

@@ -33,7 +33,7 @@ class TestLoader(TestCase):
         )
         self.assertIn(
             "/tests/fixtures/hello_world.jac",
-            str(JacMachine.get().loaded_modules),
+            str(JacMachine.get().loaded_modules).replace("\\\\", "/"),
         )
         JacMachine.detach()
 
@@ -62,3 +62,47 @@ class TestLoader(TestCase):
             "{SomeObj(a=10): 'check'} [MyObj(apple=5, banana=7), MyObj(apple=5, banana=7)]",
             stdout_value,
         )
+
+    def test_import_with_jacpath(self) -> None:
+        """Test module import using JACPATH."""
+        # Set up a temporary JACPATH environment variable
+        import os
+        import tempfile
+
+        jacpath_dir = tempfile.TemporaryDirectory()
+        os.environ["JACPATH"] = jacpath_dir.name
+
+        # Create a mock Jac file in the JACPATH directory
+        module_name = "test_module"
+        jac_file_path = os.path.join(jacpath_dir.name, f"{module_name}.jac")
+        with open(jac_file_path, "w") as f:
+            f.write(
+                """
+                with entry {
+                    "Hello from JACPATH!" :> print;
+                }
+                """
+            )
+
+        # Capture the output
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        try:
+            JacMachine(self.fixture_abs_path(__file__)).attach_program(
+                JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+            )
+            jac_import(module_name, base_path=__file__)
+            cli.run(jac_file_path)
+
+            # Reset stdout and get the output
+            sys.stdout = sys.__stdout__
+            stdout_value = captured_output.getvalue()
+
+            self.assertIn("Hello from JACPATH!", stdout_value)
+
+        finally:
+            captured_output.close()
+            JacMachine.detach()
+            os.environ.pop("JACPATH", None)
+            jacpath_dir.cleanup()

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

@@ -179,14 +179,12 @@ class JacAccessValidationImpl:
             if to_root.access.all > access_level:
                 access_level = to_root.access.all
 
-            level = to_root.access.roots.check(str(jroot.id))
-            if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+            if (level := to_root.access.roots.check(str(jroot.id))) is not None:
                 access_level = level
 
         # if target anchor have set allowed roots
         # if current root is allowed to target anchor
-        level = to_access.roots.check(str(jroot.id))
-        if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+        if (level := to_access.roots.check(str(jroot.id))) is not None:
             access_level = level
 
         return access_level
@@ -662,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:
@@ -726,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(
@@ -742,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(
@@ -920,12 +957,6 @@ class JacFeatureImpl(
 
         return ret_count
 
-    @staticmethod
-    @hookimpl
-    def elvis(op1: Optional[T], op2: T) -> T:
-        """Jac's elvis operator feature."""
-        return ret if (ret := op1) is not None else op2
-
     @staticmethod
     @hookimpl
     def has_instance_default(gen_func: Callable[[], T]) -> T:
@@ -1032,7 +1063,7 @@ class JacFeatureImpl(
                         dir in [EdgeDir.OUT, EdgeDir.ANY]
                         and node == source
                         and target.architype in right
-                        and Jac.check_write_access(target)
+                        and Jac.check_connect_access(target)
                     ):
                         Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
                         disconnect_occurred = True
@@ -1040,7 +1071,7 @@ class JacFeatureImpl(
                         dir in [EdgeDir.IN, EdgeDir.ANY]
                         and node == target
                         and source.architype in right
-                        and Jac.check_write_access(source)
+                        and Jac.check_connect_access(source)
                     ):
                         Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
                         disconnect_occurred = True
@@ -1069,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
@@ -1079,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]
@@ -377,11 +391,6 @@ class JacFeature(
             verbose=verbose,
         )
 
-    @staticmethod
-    def elvis(op1: Optional[T], op2: T) -> T:
-        """Jac's elvis operator feature."""
-        return plugin_manager.hook.elvis(op1=op1, op2=op2)
-
     @staticmethod
     def has_instance_default(gen_func: Callable[[], T]) -> T:
         """Jac's has container default feature."""

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(
@@ -355,12 +371,6 @@ class JacFeatureSpec(
         """Run the test suite in the specified .jac file."""
         raise NotImplementedError
 
-    @staticmethod
-    @hookspec(firstresult=True)
-    def elvis(op1: Optional[T], op2: T) -> T:
-        """Jac's elvis operator feature."""
-        raise NotImplementedError
-
     @staticmethod
     @hookspec(firstresult=True)
     def has_instance_default(gen_func: Callable[[], T]) -> T:

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")
@@ -44,9 +45,9 @@ class Access:
 
     anchors: dict[str, AccessLevel] = field(default_factory=dict)
 
-    def check(self, anchor: str) -> AccessLevel:
+    def check(self, anchor: str) -> AccessLevel | None:
         """Validate access."""
-        return self.anchors.get(anchor, AccessLevel.NO_ACCESS)
+        return self.anchors.get(anchor)
 
 
 @dataclass
@@ -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/runtimelib/importer.py

@@ -158,9 +158,6 @@ class ImportReturn:
             return getattr(new_module, name, new_module)
         except ImportError as e:
             logger.error(dump_traceback(e))
-            # logger.error(
-            #     f"Failed to load {name} from {jac_file_path} in {module.__name__}: {str(e)}"
-            # )
             return None
 
 
@@ -319,6 +316,32 @@ class JacImporter(Importer):
         """Run the import process for Jac modules."""
         unique_loaded_items: list[types.ModuleType] = []
         module = None
+        # Gather all possible search paths
+        jacpaths = os.environ.get("JACPATH", "")
+        search_paths = [spec.caller_dir]
+        if jacpaths:
+            for p in jacpaths.split(os.pathsep):
+                p = p.strip()
+                if p and p not in search_paths:
+                    search_paths.append(p)
+
+            # Attempt to locate the module file or directory
+            found_path = None
+            target_path_components = spec.target.split(".")
+            for search_path in search_paths:
+                candidate = os.path.join(search_path, "/".join(target_path_components))
+                # Check if the candidate is a directory or a .jac file
+                if (os.path.isdir(candidate)) or (os.path.isfile(candidate + ".jac")):
+                    found_path = candidate
+                    break
+
+            # If a suitable path was found, update spec.full_target; otherwise, raise an error
+            if found_path:
+                spec.full_target = os.path.abspath(found_path)
+            else:
+                raise ImportError(
+                    f"Unable to locate module '{spec.target}' in {search_paths}"
+                )
         if os.path.isfile(spec.full_target + ".jac"):
             module_name = self.get_sys_mod_name(spec.full_target + ".jac")
             module_name = spec.override_name if spec.override_name else module_name

jaclang/runtimelib/machine.py

@@ -38,6 +38,7 @@ class JacMachine:
         self.loaded_modules: dict[str, types.ModuleType] = {}
         if not base_path:
             base_path = os.getcwd()
+        # Ensure the base_path is a list rather than a string
         self.base_path = base_path
         self.base_path_dir = (
             os.path.dirname(base_path)
@@ -306,12 +307,11 @@ class JacProgram:
                 return marshal.load(f)
 
         result = compile_jac(full_target, cache_result=cachable)
-        if result.errors_had or not result.ir.gen.py_bytecode:
+        if result.errors_had:
             for alrt in result.errors_had:
                 # We're not logging here, it already gets logged as the errors were added to the errors_had list.
                 # Regardless of the logging, this needs to be sent to the end user, so we'll printing it to stderr.
                 logger.error(alrt.pretty_print())
-            return None
         if result.ir.gen.py_bytecode is not None:
             return marshal.loads(result.ir.gen.py_bytecode)
         else:

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 [-->];
 }
 }
 """;