jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/plugin/feature.py

@@ -2,21 +2,22 @@
 
 from __future__ import annotations
 
+import ast as ast3
 import types
-from typing import Any, Callable, Optional, Type, TypeAlias, Union
+from typing import Any, Callable, Mapping, Optional, Sequence, Type, TypeAlias, Union
 
-from jaclang.compiler.absyntree import Module
-from jaclang.core.constructs import (
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
+from jaclang.plugin.spec import JacBuiltin, JacCmdSpec, JacFeatureSpec, P, T
+from jaclang.runtimelib.constructs import (
     Architype,
     EdgeArchitype,
-    Memory,
+    NodeAnchor,
     NodeArchitype,
     Root,
     WalkerArchitype,
 )
-from jaclang.plugin.default import ExecutionContext
-from jaclang.plugin.spec import JacBuiltin, JacCmdSpec, JacFeatureSpec, T
-
+from jaclang.runtimelib.context import ExecutionContext
 
 import pluggy
 
@@ -29,10 +30,11 @@ pm.add_hookspecs(JacBuiltin)
 class JacFeature:
     """Jac Feature."""
 
-    import abc
-    from jaclang.compiler.constant import EdgeDir
-    from jaclang.core.constructs import DSFunc
+    from jaclang.compiler.constant import EdgeDir as EdgeDirType
+    from jaclang.runtimelib.constructs import DSFunc as DSFuncType
 
+    EdgeDir: TypeAlias = EdgeDirType
+    DSFunc: TypeAlias = DSFuncType
     RootType: TypeAlias = Root
     Obj: TypeAlias = Architype
     Node: TypeAlias = NodeArchitype
@@ -40,19 +42,9 @@ class JacFeature:
     Walker: TypeAlias = WalkerArchitype
 
     @staticmethod
-    def context(session: str = "") -> ExecutionContext:
-        """Create execution context."""
-        return pm.hook.context(session=session)
-
-    @staticmethod
-    def reset_context() -> None:
-        """Reset execution context."""
-        return pm.hook.reset_context()
-
-    @staticmethod
-    def memory_hook() -> Memory | None:
-        """Create memory abstraction."""
-        return pm.hook.memory_hook()
+    def get_context() -> ExecutionContext:
+        """Get current execution context."""
+        return pm.hook.get_context()
 
     @staticmethod
     def make_architype(
@@ -94,6 +86,13 @@ class JacFeature:
         """Create a walker architype."""
         return pm.hook.make_walker(on_entry=on_entry, on_exit=on_exit)
 
+    @staticmethod
+    def impl_patch_filename(
+        file_loc: str,
+    ) -> Callable[[Callable[P, T]], Callable[P, T]]:
+        """Update impl file location."""
+        return pm.hook.impl_patch_filename(file_loc=file_loc)
+
     @staticmethod
     def jac_import(
         target: str,
@@ -102,9 +101,9 @@ class JacFeature:
         cachable: bool = True,
         mdl_alias: Optional[str] = None,
         override_name: Optional[str] = None,
-        mod_bundle: Optional[Module | str] = None,
         lng: Optional[str] = "jac",
         items: Optional[dict[str, Union[str, Optional[str]]]] = None,
+        reload_module: Optional[bool] = False,
     ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
         return pm.hook.jac_import(
@@ -114,9 +113,9 @@ class JacFeature:
             cachable=cachable,
             mdl_alias=mdl_alias,
             override_name=override_name,
-            mod_bundle=mod_bundle,
             lng=lng,
             items=items,
+            reload_module=reload_module,
         )
 
     @staticmethod
@@ -217,7 +216,7 @@ class JacFeature:
     def connect(
         left: NodeArchitype | list[NodeArchitype],
         right: NodeArchitype | list[NodeArchitype],
-        edge_spec: Callable[[], EdgeArchitype],
+        edge_spec: Callable[[NodeAnchor, NodeAnchor], EdgeArchitype],
         edges_only: bool = False,
     ) -> list[NodeArchitype] | list[EdgeArchitype]:
         """Jac's connect operator feature.
@@ -265,7 +264,7 @@ class JacFeature:
         is_undirected: bool,
         conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
-    ) -> Callable[[], EdgeArchitype]:
+    ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
         """Jac's root getter."""
         return pm.hook.build_edge(
             is_undirected=is_undirected, conn_type=conn_type, conn_assign=conn_assign
@@ -301,6 +300,8 @@ class JacFeature:
         inputs: list[tuple[str, str, str, Any]],
         outputs: tuple,
         action: str,
+        _globals: dict,
+        _locals: Mapping,
     ) -> Any:  # noqa: ANN401
         """Jac's with_llm feature."""
         return pm.hook.with_llm(
@@ -313,8 +314,45 @@ class JacFeature:
             inputs=inputs,
             outputs=outputs,
             action=action,
+            _globals=_globals,
+            _locals=_locals,
         )
 
+    @staticmethod
+    def gen_llm_body(_pass: PyastGenPass, node: ast.Ability) -> list[ast3.AST]:
+        """Generate the by LLM body."""
+        return pm.hook.gen_llm_body(_pass=_pass, node=node)
+
+    @staticmethod
+    def by_llm_call(
+        _pass: PyastGenPass,
+        model: ast3.AST,
+        model_params: dict[str, ast.Expr],
+        scope: ast3.AST,
+        inputs: Sequence[Optional[ast3.AST]],
+        outputs: Sequence[Optional[ast3.AST]] | ast3.Call,
+        action: Optional[ast3.AST],
+        include_info: list[tuple[str, ast3.AST]],
+        exclude_info: list[tuple[str, ast3.AST]],
+    ) -> ast3.Call:
+        """Return the LLM Call, e.g. _Jac.with_llm()."""
+        return pm.hook.by_llm_call(
+            _pass=_pass,
+            model=model,
+            model_params=model_params,
+            scope=scope,
+            inputs=inputs,
+            outputs=outputs,
+            action=action,
+            include_info=include_info,
+            exclude_info=exclude_info,
+        )
+
+    @staticmethod
+    def get_by_llm_call_args(_pass: PyastGenPass, node: ast.FuncCall) -> dict:
+        """Get the by LLM call args."""
+        return pm.hook.get_by_llm_call_args(_pass=_pass, node=node)
+
 
 class JacCmd:
     """Jac CLI command."""

jaclang/plugin/spec.py

@@ -2,28 +2,41 @@
 
 from __future__ import annotations
 
+import ast as ast3
 import types
-from typing import Any, Callable, Optional, TYPE_CHECKING, Type, TypeVar, Union
-
-from jaclang.compiler.absyntree import Module
+from typing import (
+    Any,
+    Callable,
+    Mapping,
+    Optional,
+    ParamSpec,
+    Sequence,
+    TYPE_CHECKING,
+    Type,
+    TypeVar,
+    Union,
+)
+
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
 
 if TYPE_CHECKING:
-    from jaclang.core.constructs import EdgeArchitype, NodeArchitype
     from jaclang.plugin.default import (
         Architype,
         EdgeDir,
-        ExecutionContext,
         WalkerArchitype,
         Root,
         DSFunc,
     )
-    from jaclang.core.memory import Memory
+    from jaclang.runtimelib.constructs import EdgeArchitype, NodeAnchor, NodeArchitype
+    from jaclang.runtimelib.context import ExecutionContext
 
 import pluggy
 
 hookspec = pluggy.HookspecMarker("jac")
 
 T = TypeVar("T")
+P = ParamSpec("P")
 
 
 class JacFeatureSpec:
@@ -31,20 +44,8 @@ class JacFeatureSpec:
 
     @staticmethod
     @hookspec(firstresult=True)
-    def context(session: str = "") -> ExecutionContext:
-        """Get the execution context."""
-        raise NotImplementedError
-
-    @staticmethod
-    @hookspec(firstresult=True)
-    def reset_context() -> None:
-        """Reset the execution context."""
-        raise NotImplementedError
-
-    @staticmethod
-    @hookspec(firstresult=True)
-    def memory_hook() -> Memory | None:
-        """Create memory abstraction."""
+    def get_context() -> ExecutionContext:
+        """Get current execution context."""
         raise NotImplementedError
 
     @staticmethod
@@ -90,6 +91,14 @@ class JacFeatureSpec:
         """Create a walker architype."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def impl_patch_filename(
+        file_loc: str,
+    ) -> Callable[[Callable[P, T]], Callable[P, T]]:
+        """Update impl file location."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def jac_import(
@@ -99,9 +108,9 @@ class JacFeatureSpec:
         cachable: bool,
         mdl_alias: Optional[str],
         override_name: Optional[str],
-        mod_bundle: Optional[Module | str],
         lng: Optional[str],
         items: Optional[dict[str, Union[str, Optional[str]]]],
+        reload_module: Optional[bool],
     ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
         raise NotImplementedError
@@ -202,7 +211,7 @@ class JacFeatureSpec:
     def connect(
         left: NodeArchitype | list[NodeArchitype],
         right: NodeArchitype | list[NodeArchitype],
-        edge_spec: Callable[[], EdgeArchitype],
+        edge_spec: Callable[[NodeAnchor, NodeAnchor], EdgeArchitype],
         edges_only: bool,
     ) -> list[NodeArchitype] | list[EdgeArchitype]:
         """Jac's connect operator feature.
@@ -248,7 +257,7 @@ class JacFeatureSpec:
         is_undirected: bool,
         conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
-    ) -> Callable[[], EdgeArchitype]:
+    ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
         """Jac's root getter."""
         raise NotImplementedError
 
@@ -283,10 +292,40 @@ class JacFeatureSpec:
         inputs: list[tuple[str, str, str, Any]],
         outputs: tuple,
         action: str,
+        _globals: dict,
+        _locals: Mapping,
     ) -> Any:  # noqa: ANN401
         """Jac's with_llm stmt feature."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def gen_llm_body(_pass: PyastGenPass, node: ast.Ability) -> list[ast3.AST]:
+        """Generate the by LLM body."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def by_llm_call(
+        _pass: PyastGenPass,
+        model: ast3.AST,
+        model_params: dict[str, ast.Expr],
+        scope: ast3.AST,
+        inputs: Sequence[Optional[ast3.AST]],
+        outputs: Sequence[Optional[ast3.AST]] | ast3.Call,
+        action: Optional[ast3.AST],
+        include_info: list[tuple[str, ast3.AST]],
+        exclude_info: list[tuple[str, ast3.AST]],
+    ) -> ast3.Call:
+        """Return the LLM Call, e.g. _Jac.with_llm()."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def get_by_llm_call_args(_pass: PyastGenPass, node: ast.FuncCall) -> dict:
+        """Get the by LLM call args."""
+        raise NotImplementedError
+
 
 class JacBuiltin:
     """Jac Builtins."""

jaclang/plugin/tests/fixtures/other_root_access.jac

@@ -0,0 +1,82 @@
+import:py from jaclang.runtimelib.architype {Anchor}
+import:py 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 create_node {
+    has val: int;
+
+    can enter with `root entry {
+        a = A(val=self.val);
+        here ++> a;
+        print(a.__jac__.id);
+    }
+}
+
+walker create_other_root {
+    can enter with `root entry {
+        other_root = `root().__jac__;
+        other_root.save();
+        print(other_root.id);
+    }
+}
+
+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 {
+            here.__jac__.unrestrict(self.level);
+        } else {
+            here.__jac__.allow_root(UUID(self.root_id), self.level);
+        }
+    }
+
+    can enter_nested with A entry {
+        if self.via_all {
+            here.__jac__.unrestrict(self.level);
+        } else {
+            here.__jac__.allow_root(UUID(self.root_id), self.level);
+        }
+    }
+}
+
+walker disallow_other_root_access {
+    has root_id: str, via_all: bool = False;
+
+    can enter_root with `root entry {
+        if self.via_all {
+            here.__jac__.restrict();
+        } else {
+            here.__jac__.disallow_root(UUID(self.root_id));
+        }
+    }
+
+    can enter_nested with A entry {
+        if self.via_all {
+            here.__jac__.restrict();
+        } else {
+            here.__jac__.disallow_root(UUID(self.root_id));
+        }
+    }
+}