jaclang 0.7.22__py3-none-any.whl → 0.7.23__py3-none-any.whl

jaclang/plugin/feature.py

@@ -4,57 +4,265 @@ from __future__ import annotations
 
 import ast as ast3
 import types
-from typing import Any, Callable, Mapping, Optional, Sequence, Type, TypeAlias, Union
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Mapping,
+    Optional,
+    Sequence,
+    Type,
+    TypeAlias,
+    Union,
+)
+from uuid import UUID
 
-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 (
+from jaclang.plugin.spec import (
+    AccessLevel,
+    Anchor,
     Architype,
+    DSFunc,
+    EdgeAnchor,
     EdgeArchitype,
+    EdgeDir,
+    ExecutionContext,
     NodeAnchor,
     NodeArchitype,
+    P,
+    PyastGenPass,
     Root,
+    T,
     WalkerArchitype,
+    ast,
+    plugin_manager,
 )
-from jaclang.runtimelib.context import ExecutionContext
 
-import pluggy
 
-pm = pluggy.PluginManager("jac")
-pm.add_hookspecs(JacFeatureSpec)
-pm.add_hookspecs(JacCmdSpec)
-pm.add_hookspecs(JacBuiltin)
+class JacAccessValidation:
+    """Jac Access Validation Specs."""
 
+    @staticmethod
+    def allow_root(
+        architype: Architype,
+        root_id: UUID,
+        level: AccessLevel | int | str = AccessLevel.READ,
+    ) -> None:
+        """Allow all access from target root graph to current Architype."""
+        plugin_manager.hook.allow_root(
+            architype=architype, root_id=root_id, level=level
+        )
 
-class JacFeature:
-    """Jac Feature."""
+    @staticmethod
+    def disallow_root(
+        architype: Architype,
+        root_id: UUID,
+        level: AccessLevel | int | str = AccessLevel.READ,
+    ) -> None:
+        """Disallow all access from target root graph to current Architype."""
+        plugin_manager.hook.disallow_root(
+            architype=architype, root_id=root_id, level=level
+        )
+
+    @staticmethod
+    def unrestrict(
+        architype: Architype, level: AccessLevel | int | str = AccessLevel.READ
+    ) -> None:
+        """Allow everyone to access current Architype."""
+        plugin_manager.hook.unrestrict(architype=architype, level=level)
+
+    @staticmethod
+    def restrict(architype: Architype) -> None:
+        """Disallow others to access current Architype."""
+        plugin_manager.hook.restrict(architype=architype)
+
+    @staticmethod
+    def check_read_access(to: Anchor) -> bool:
+        """Read Access Validation."""
+        return plugin_manager.hook.check_read_access(to=to)
+
+    @staticmethod
+    def check_connect_access(to: Anchor) -> bool:
+        """Write Access Validation."""
+        return plugin_manager.hook.check_connect_access(to=to)
+
+    @staticmethod
+    def check_write_access(to: Anchor) -> bool:
+        """Write Access Validation."""
+        return plugin_manager.hook.check_write_access(to=to)
+
+    @staticmethod
+    def check_access_level(to: Anchor) -> AccessLevel:
+        """Access validation."""
+        return plugin_manager.hook.check_access_level(to=to)
+
+
+class JacNode:
+    """Jac Node Operations."""
+
+    @staticmethod
+    def node_dot(node: NodeArchitype, dot_file: Optional[str] = None) -> str:
+        """Generate Dot file for visualizing nodes and edges."""
+        return plugin_manager.hook.node_dot(node=node, dot_file=dot_file)
+
+    @staticmethod
+    def get_edges(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+        target_obj: Optional[list[NodeArchitype]],
+    ) -> list[EdgeArchitype]:
+        """Get edges connected to this node."""
+        return plugin_manager.hook.get_edges(
+            node=node, dir=dir, filter_func=filter_func, target_obj=target_obj
+        )
+
+    @staticmethod
+    def edges_to_nodes(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+        target_obj: Optional[list[NodeArchitype]],
+    ) -> list[NodeArchitype]:
+        """Get set of nodes connected to this node."""
+        return plugin_manager.hook.edges_to_nodes(
+            node=node, dir=dir, filter_func=filter_func, target_obj=target_obj
+        )
+
+    @staticmethod
+    def remove_edge(node: NodeAnchor, edge: EdgeAnchor) -> None:
+        """Remove reference without checking sync status."""
+        return plugin_manager.hook.remove_edge(node=node, edge=edge)
+
+
+class JacEdge:
+    """Jac Edge Operations."""
+
+    @staticmethod
+    def detach(edge: EdgeAnchor) -> None:
+        """Detach edge from nodes."""
+        return plugin_manager.hook.detach(edge=edge)
+
+
+class JacWalker:
+    """Jac Edge Operations."""
+
+    @staticmethod
+    def visit_node(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool:  # noqa: ANN401
+        """Jac's visit stmt feature."""
+        return plugin_manager.hook.visit_node(walker=walker, expr=expr)
+
+    @staticmethod
+    def ignore(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool:  # noqa: ANN401
+        """Jac's ignore stmt feature."""
+        return plugin_manager.hook.ignore(walker=walker, expr=expr)
+
+    @staticmethod
+    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
+        """Jac's spawn operator feature."""
+        return plugin_manager.hook.spawn_call(op1=op1, op2=op2)
+
+    @staticmethod
+    def disengage(walker: WalkerArchitype) -> bool:
+        """Jac's disengage stmt feature."""
+        return plugin_manager.hook.disengage(walker=walker)
+
+
+class JacClassReferences:
+    """Default Classes References."""
+
+    EdgeDir: ClassVar[TypeAlias] = EdgeDir
+    DSFunc: ClassVar[TypeAlias] = DSFunc
+    RootType: ClassVar[TypeAlias] = Root
+    Obj: ClassVar[TypeAlias] = Architype
+    Node: ClassVar[TypeAlias] = NodeArchitype
+    Edge: ClassVar[TypeAlias] = EdgeArchitype
+    Walker: ClassVar[TypeAlias] = WalkerArchitype
+
+
+class JacBuiltin:
+    """Jac Builtins."""
+
+    @staticmethod
+    def dotgen(
+        node: NodeArchitype,
+        depth: int,
+        traverse: bool,
+        edge_type: Optional[list[str]],
+        bfs: bool,
+        edge_limit: int,
+        node_limit: int,
+        dot_file: Optional[str],
+    ) -> str:
+        """Generate Dot file for visualizing nodes and edges."""
+        return plugin_manager.hook.dotgen(
+            node=node,
+            depth=depth,
+            traverse=traverse,
+            edge_type=edge_type,
+            bfs=bfs,
+            edge_limit=edge_limit,
+            node_limit=node_limit,
+            dot_file=dot_file,
+        )
+
+
+class JacCmd:
+    """Jac CLI command."""
 
-    from jaclang.compiler.constant import EdgeDir as EdgeDirType
-    from jaclang.runtimelib.constructs import DSFunc as DSFuncType
+    @staticmethod
+    def create_cmd() -> None:
+        """Create Jac CLI cmds."""
+        return plugin_manager.hook.create_cmd()
+
+
+class JacFeature(
+    JacClassReferences,
+    JacAccessValidation,
+    JacNode,
+    JacEdge,
+    JacWalker,
+    JacBuiltin,
+    JacCmd,
+):
+    """Jac Feature."""
 
-    EdgeDir: TypeAlias = EdgeDirType
-    DSFunc: TypeAlias = DSFuncType
-    RootType: TypeAlias = Root
-    Obj: TypeAlias = Architype
-    Node: TypeAlias = NodeArchitype
-    Edge: TypeAlias = EdgeArchitype
-    Walker: TypeAlias = WalkerArchitype
+    @staticmethod
+    def setup() -> None:
+        """Set Class References."""
+        plugin_manager.hook.setup()
 
     @staticmethod
     def get_context() -> ExecutionContext:
         """Get current execution context."""
-        return pm.hook.get_context()
+        return plugin_manager.hook.get_context()
 
     @staticmethod
     def get_object(id: str) -> Architype | None:
         """Get object given id."""
-        return pm.hook.get_object(id=id)
+        return plugin_manager.hook.get_object(id=id)
 
     @staticmethod
     def object_ref(obj: Architype) -> str:
         """Get object reference id."""
-        return pm.hook.object_ref(obj=obj)
+        return plugin_manager.hook.object_ref(obj=obj)
 
     @staticmethod
     def make_architype(
@@ -64,7 +272,7 @@ class JacFeature:
         on_exit: list[DSFunc],
     ) -> Type[Architype]:
         """Create a obj architype."""
-        return pm.hook.make_architype(
+        return plugin_manager.hook.make_architype(
             cls=cls, on_entry=on_entry, on_exit=on_exit, arch_base=arch_base
         )
 
@@ -73,35 +281,35 @@ class JacFeature:
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a obj architype."""
-        return pm.hook.make_obj(on_entry=on_entry, on_exit=on_exit)
+        return plugin_manager.hook.make_obj(on_entry=on_entry, on_exit=on_exit)
 
     @staticmethod
     def make_node(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a node architype."""
-        return pm.hook.make_node(on_entry=on_entry, on_exit=on_exit)
+        return plugin_manager.hook.make_node(on_entry=on_entry, on_exit=on_exit)
 
     @staticmethod
     def make_edge(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a edge architype."""
-        return pm.hook.make_edge(on_entry=on_entry, on_exit=on_exit)
+        return plugin_manager.hook.make_edge(on_entry=on_entry, on_exit=on_exit)
 
     @staticmethod
     def make_walker(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a walker architype."""
-        return pm.hook.make_walker(on_entry=on_entry, on_exit=on_exit)
+        return plugin_manager.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)
+        return plugin_manager.hook.impl_patch_filename(file_loc=file_loc)
 
     @staticmethod
     def jac_import(
@@ -116,7 +324,7 @@ class JacFeature:
         reload_module: Optional[bool] = False,
     ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
-        return pm.hook.jac_import(
+        return plugin_manager.hook.jac_import(
             target=target,
             base_path=base_path,
             absorb=absorb,
@@ -131,7 +339,7 @@ class JacFeature:
     @staticmethod
     def create_test(test_fun: Callable) -> Callable:
         """Create a test."""
-        return pm.hook.create_test(test_fun=test_fun)
+        return plugin_manager.hook.create_test(test_fun=test_fun)
 
     @staticmethod
     def run_test(
@@ -143,7 +351,7 @@ class JacFeature:
         verbose: bool = False,
     ) -> int:
         """Run the test suite in the specified .jac file."""
-        return pm.hook.run_test(
+        return plugin_manager.hook.run_test(
             filepath=filepath,
             filter=filter,
             xit=xit,
@@ -155,55 +363,17 @@ class JacFeature:
     @staticmethod
     def elvis(op1: Optional[T], op2: T) -> T:
         """Jac's elvis operator feature."""
-        return pm.hook.elvis(op1=op1, op2=op2)
+        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."""
-        return pm.hook.has_instance_default(gen_func=gen_func)
-
-    @staticmethod
-    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
-        """Jac's spawn operator feature."""
-        return pm.hook.spawn_call(op1=op1, op2=op2)
+        return plugin_manager.hook.has_instance_default(gen_func=gen_func)
 
     @staticmethod
     def report(expr: Any) -> Any:  # noqa: ANN401
         """Jac's report stmt feature."""
-        return pm.hook.report(expr=expr)
-
-    @staticmethod
-    def ignore(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:  # noqa: ANN401
-        """Jac's ignore stmt feature."""
-        return pm.hook.ignore(walker=walker, expr=expr)
-
-    @staticmethod
-    def visit_node(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:  # noqa: ANN401
-        """Jac's visit stmt feature."""
-        return pm.hook.visit_node(walker=walker, expr=expr)
-
-    @staticmethod
-    def disengage(walker: WalkerArchitype) -> bool:  # noqa: ANN401
-        """Jac's disengage stmt feature."""
-        return pm.hook.disengage(walker=walker)
+        return plugin_manager.hook.report(expr=expr)
 
     @staticmethod
     def edge_ref(
@@ -214,7 +384,7 @@ class JacFeature:
         edges_only: bool = False,
     ) -> list[NodeArchitype] | list[EdgeArchitype]:
         """Jac's apply_dir stmt feature."""
-        return pm.hook.edge_ref(
+        return plugin_manager.hook.edge_ref(
             node_obj=node_obj,
             target_obj=target_obj,
             dir=dir,
@@ -233,7 +403,7 @@ class JacFeature:
 
         Note: connect needs to call assign compr with tuple in op
         """
-        return pm.hook.connect(
+        return plugin_manager.hook.connect(
             left=left, right=right, edge_spec=edge_spec, edges_only=edges_only
         )
 
@@ -245,7 +415,7 @@ class JacFeature:
         filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
     ) -> bool:
         """Jac's disconnect operator feature."""
-        return pm.hook.disconnect(
+        return plugin_manager.hook.disconnect(
             left=left,
             right=right,
             dir=dir,
@@ -257,17 +427,17 @@ class JacFeature:
         target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
     ) -> list[T]:
         """Jac's assign comprehension feature."""
-        return pm.hook.assign_compr(target=target, attr_val=attr_val)
+        return plugin_manager.hook.assign_compr(target=target, attr_val=attr_val)
 
     @staticmethod
     def get_root() -> Root:
         """Jac's root getter."""
-        return pm.hook.get_root()
+        return plugin_manager.hook.get_root()
 
     @staticmethod
     def get_root_type() -> Type[Root]:
         """Jac's root type getter."""
-        return pm.hook.get_root_type()
+        return plugin_manager.hook.get_root_type()
 
     @staticmethod
     def build_edge(
@@ -276,28 +446,42 @@ class JacFeature:
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
         """Jac's root getter."""
-        return pm.hook.build_edge(
+        return plugin_manager.hook.build_edge(
             is_undirected=is_undirected, conn_type=conn_type, conn_assign=conn_assign
         )
 
+    @staticmethod
+    def save(
+        obj: Architype | Anchor,
+    ) -> None:
+        """Destroy object."""
+        plugin_manager.hook.save(obj=obj)
+
+    @staticmethod
+    def destroy(
+        obj: Architype | Anchor,
+    ) -> None:
+        """Destroy object."""
+        plugin_manager.hook.destroy(obj=obj)
+
     @staticmethod
     def get_semstr_type(
         file_loc: str, scope: str, attr: str, return_semstr: bool
     ) -> Optional[str]:
         """Jac's get_semstr_type feature."""
-        return pm.hook.get_semstr_type(
+        return plugin_manager.hook.get_semstr_type(
             file_loc=file_loc, scope=scope, attr=attr, return_semstr=return_semstr
         )
 
     @staticmethod
     def obj_scope(file_loc: str, attr: str) -> str:
         """Jac's get_semstr_type feature."""
-        return pm.hook.obj_scope(file_loc=file_loc, attr=attr)
+        return plugin_manager.hook.obj_scope(file_loc=file_loc, attr=attr)
 
     @staticmethod
     def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
         """Jac's get_semstr_type feature."""
-        return pm.hook.get_sem_type(file_loc=file_loc, attr=attr)
+        return plugin_manager.hook.get_sem_type(file_loc=file_loc, attr=attr)
 
     @staticmethod
     def with_llm(
@@ -314,7 +498,7 @@ class JacFeature:
         _locals: Mapping,
     ) -> Any:  # noqa: ANN401
         """Jac's with_llm feature."""
-        return pm.hook.with_llm(
+        return plugin_manager.hook.with_llm(
             file_loc=file_loc,
             model=model,
             model_params=model_params,
@@ -331,7 +515,7 @@ class JacFeature:
     @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)
+        return plugin_manager.hook.gen_llm_body(_pass=_pass, node=node)
 
     @staticmethod
     def by_llm_call(
@@ -346,7 +530,7 @@ class JacFeature:
         exclude_info: list[tuple[str, ast3.AST]],
     ) -> ast3.Call:
         """Return the LLM Call, e.g. _Jac.with_llm()."""
-        return pm.hook.by_llm_call(
+        return plugin_manager.hook.by_llm_call(
             _pass=_pass,
             model=model,
             model_params=model_params,
@@ -361,13 +545,4 @@ class JacFeature:
     @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."""
-
-    @staticmethod
-    def create_cmd() -> None:
-        """Create Jac CLI cmds."""
-        return pm.hook.create_cmd()
+        return plugin_manager.hook.get_by_llm_call_args(_pass=_pass, node=node)