jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/plugin/default.py

@@ -1,1443 +0,0 @@
-"""Jac Language Features."""
-
-from __future__ import annotations
-
-import ast as ast3
-import fnmatch
-import html
-import inspect
-import os
-import types
-from collections import OrderedDict
-from dataclasses import field
-from functools import wraps
-from logging import getLogger
-from typing import Any, Callable, Mapping, Optional, Sequence, Type, Union, cast
-from uuid import UUID
-
-from jaclang.compiler.constant import colors
-from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
-from jaclang.plugin.feature import (
-    AccessLevel,
-    Anchor,
-    Architype,
-    DSFunc,
-    EdgeAnchor,
-    EdgeArchitype,
-    EdgeDir,
-    ExecutionContext,
-    JacFeature as Jac,
-    NodeAnchor,
-    NodeArchitype,
-    P,
-    PyastGenPass,
-    Root,
-    T,
-    WalkerArchitype,
-    ast,
-)
-from jaclang.runtimelib.constructs import (
-    GenericEdge,
-    JacTestCheck,
-)
-from jaclang.runtimelib.importer import ImportPathSpec, JacImporter, PythonImporter
-from jaclang.runtimelib.machine import JacMachine, JacProgram
-from jaclang.runtimelib.memory import Shelf, ShelfStorage
-from jaclang.runtimelib.utils import (
-    all_issubclass,
-    collect_node_connections,
-    traverse_graph,
-)
-
-import pluggy
-
-hookimpl = pluggy.HookimplMarker("jac")
-logger = getLogger(__name__)
-
-
-class JacCallableImplementation:
-    """Callable Implementations."""
-
-    @staticmethod
-    def get_object(id: str) -> Architype | None:
-        """Get object by id."""
-        if id == "root":
-            return Jac.get_context().root.architype
-        elif obj := Jac.get_context().mem.find_by_id(UUID(id)):
-            return obj.architype
-
-        return None
-
-
-class JacAccessValidationImpl:
-    """Jac Access Validation Implementations."""
-
-    @staticmethod
-    @hookimpl
-    def elevate_root() -> None:
-        """Elevate context root to system_root."""
-        jctx = Jac.get_context()
-        jctx.root = jctx.system_root
-
-    @staticmethod
-    @hookimpl
-    def allow_root(
-        architype: Architype, root_id: UUID, level: AccessLevel | int | str
-    ) -> None:
-        """Allow all access from target root graph to current Architype."""
-        level = AccessLevel.cast(level)
-        access = architype.__jac__.access.roots
-
-        _root_id = str(root_id)
-        if level != access.anchors.get(_root_id, AccessLevel.NO_ACCESS):
-            access.anchors[_root_id] = level
-
-    @staticmethod
-    @hookimpl
-    def disallow_root(
-        architype: Architype, root_id: UUID, level: AccessLevel | int | str
-    ) -> None:
-        """Disallow all access from target root graph to current Architype."""
-        level = AccessLevel.cast(level)
-        access = architype.__jac__.access.roots
-
-        access.anchors.pop(str(root_id), None)
-
-    @staticmethod
-    @hookimpl
-    def unrestrict(architype: Architype, level: AccessLevel | int | str) -> None:
-        """Allow everyone to access current Architype."""
-        anchor = architype.__jac__
-        level = AccessLevel.cast(level)
-        if level != anchor.access.all:
-            anchor.access.all = level
-
-    @staticmethod
-    @hookimpl
-    def restrict(architype: Architype) -> None:
-        """Disallow others to access current Architype."""
-        anchor = architype.__jac__
-        if anchor.access.all > AccessLevel.NO_ACCESS:
-            anchor.access.all = AccessLevel.NO_ACCESS
-
-    @staticmethod
-    @hookimpl
-    def check_read_access(to: Anchor) -> bool:
-        """Read Access Validation."""
-        if not (access_level := Jac.check_access_level(to) > AccessLevel.NO_ACCESS):
-            logger.info(
-                f"Current root doesn't have read access to {to.__class__.__name__}[{to.id}]"
-            )
-        return access_level
-
-    @staticmethod
-    @hookimpl
-    def check_connect_access(to: Anchor) -> bool:
-        """Write Access Validation."""
-        if not (access_level := Jac.check_access_level(to) > AccessLevel.READ):
-            logger.info(
-                f"Current root doesn't have connect access to {to.__class__.__name__}[{to.id}]"
-            )
-        return access_level
-
-    @staticmethod
-    @hookimpl
-    def check_write_access(to: Anchor) -> bool:
-        """Write Access Validation."""
-        if not (access_level := Jac.check_access_level(to) > AccessLevel.CONNECT):
-            logger.info(
-                f"Current root doesn't have write access to {to.__class__.__name__}[{to.id}]"
-            )
-        return access_level
-
-    @staticmethod
-    @hookimpl
-    def check_access_level(to: Anchor) -> AccessLevel:
-        """Access validation."""
-        if not to.persistent:
-            return AccessLevel.WRITE
-
-        jctx = Jac.get_context()
-
-        jroot = jctx.root
-
-        # if current root is system_root
-        # if current root id is equal to target anchor's root id
-        # if current root is the target anchor
-        if jroot == jctx.system_root or jroot.id == to.root or jroot == to:
-            return AccessLevel.WRITE
-
-        access_level = AccessLevel.NO_ACCESS
-
-        # if target anchor have set access.all
-        if (to_access := to.access).all > AccessLevel.NO_ACCESS:
-            access_level = to_access.all
-
-        # if target anchor's root have set allowed roots
-        # if current root is allowed to the whole graph of target anchor's root
-        if to.root and isinstance(to_root := jctx.mem.find_one(to.root), Anchor):
-            if to_root.access.all > access_level:
-                access_level = to_root.access.all
-
-            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
-        if (level := to_access.roots.check(str(jroot.id))) is not None:
-            access_level = level
-
-        return access_level
-
-
-class JacNodeImpl:
-    """Jac Node Operations."""
-
-    @staticmethod
-    @hookimpl
-    def node_dot(node: NodeArchitype, dot_file: Optional[str]) -> str:
-        """Generate Dot file for visualizing nodes and edges."""
-        visited_nodes: set[NodeAnchor] = set()
-        connections: set[tuple[NodeArchitype, NodeArchitype, str]] = set()
-        unique_node_id_dict = {}
-
-        collect_node_connections(node.__jac__, visited_nodes, connections)
-        dot_content = 'digraph {\nnode [style="filled", shape="ellipse", fillcolor="invis", fontcolor="black"];\n'
-        for idx, i in enumerate([nodes_.architype for nodes_ in visited_nodes]):
-            unique_node_id_dict[i] = (i.__class__.__name__, str(idx))
-            dot_content += f'{idx} [label="{i}"];\n'
-        dot_content += 'edge [color="gray", style="solid"];\n'
-
-        for pair in list(set(connections)):
-            dot_content += (
-                f"{unique_node_id_dict[pair[0]][1]} -> {unique_node_id_dict[pair[1]][1]}"
-                f' [label="{pair[2]}"];\n'
-            )
-        if dot_file:
-            with open(dot_file, "w") as f:
-                f.write(dot_content + "}")
-        return dot_content + "}"
-
-    @staticmethod
-    @hookimpl
-    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."""
-        ret_edges: list[EdgeArchitype] = []
-        for anchor in node.edges:
-            if (
-                (source := anchor.source)
-                and (target := anchor.target)
-                and (not filter_func or filter_func([anchor.architype]))
-                and source.architype
-                and target.architype
-            ):
-                if (
-                    dir in [EdgeDir.OUT, EdgeDir.ANY]
-                    and node == source
-                    and (not target_obj or target.architype in target_obj)
-                    and Jac.check_read_access(target)
-                ):
-                    ret_edges.append(anchor.architype)
-                if (
-                    dir in [EdgeDir.IN, EdgeDir.ANY]
-                    and node == target
-                    and (not target_obj or source.architype in target_obj)
-                    and Jac.check_read_access(source)
-                ):
-                    ret_edges.append(anchor.architype)
-        return ret_edges
-
-    @staticmethod
-    @hookimpl
-    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."""
-        ret_edges: list[NodeArchitype] = []
-        for anchor in node.edges:
-            if (
-                (source := anchor.source)
-                and (target := anchor.target)
-                and (not filter_func or filter_func([anchor.architype]))
-                and source.architype
-                and target.architype
-            ):
-                if (
-                    dir in [EdgeDir.OUT, EdgeDir.ANY]
-                    and node == source
-                    and (not target_obj or target.architype in target_obj)
-                    and Jac.check_read_access(target)
-                ):
-                    ret_edges.append(target.architype)
-                if (
-                    dir in [EdgeDir.IN, EdgeDir.ANY]
-                    and node == target
-                    and (not target_obj or source.architype in target_obj)
-                    and Jac.check_read_access(source)
-                ):
-                    ret_edges.append(source.architype)
-        return ret_edges
-
-    @staticmethod
-    @hookimpl
-    def remove_edge(node: NodeAnchor, edge: EdgeAnchor) -> None:
-        """Remove reference without checking sync status."""
-        for idx, ed in enumerate(node.edges):
-            if ed.id == edge.id:
-                node.edges.pop(idx)
-                break
-
-
-class JacEdgeImpl:
-    """Jac Edge Operations."""
-
-    @staticmethod
-    @hookimpl
-    def detach(edge: EdgeAnchor) -> None:
-        """Detach edge from nodes."""
-        Jac.remove_edge(node=edge.source, edge=edge)
-        Jac.remove_edge(node=edge.target, edge=edge)
-
-
-class JacWalkerImpl:
-    """Jac Edge Operations."""
-
-    @staticmethod
-    @hookimpl
-    def visit_node(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:
-        """Jac's visit stmt feature."""
-        if isinstance(walker, WalkerArchitype):
-            """Walker visits node."""
-            wanch = walker.__jac__
-            before_len = len(wanch.next)
-            for anchor in (
-                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
-            ):
-                if anchor not in wanch.ignores:
-                    if isinstance(anchor, NodeAnchor):
-                        wanch.next.append(anchor)
-                    elif isinstance(anchor, EdgeAnchor):
-                        if target := anchor.target:
-                            wanch.next.append(target)
-                        else:
-                            raise ValueError("Edge has no target.")
-            return len(wanch.next) > before_len
-        else:
-            raise TypeError("Invalid walker object")
-
-    @staticmethod
-    @hookimpl
-    def ignore(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:
-        """Jac's ignore stmt feature."""
-        if isinstance(walker, WalkerArchitype):
-            wanch = walker.__jac__
-            before_len = len(wanch.ignores)
-            for anchor in (
-                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
-            ):
-                if anchor not in wanch.ignores:
-                    if isinstance(anchor, NodeAnchor):
-                        wanch.ignores.append(anchor)
-                    elif isinstance(anchor, EdgeAnchor):
-                        if target := anchor.target:
-                            wanch.ignores.append(target)
-                        else:
-                            raise ValueError("Edge has no target.")
-            return len(wanch.ignores) > before_len
-        else:
-            raise TypeError("Invalid walker object")
-
-    @staticmethod
-    @hookimpl
-    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
-        """Invoke data spatial call."""
-        if isinstance(op1, WalkerArchitype):
-            warch = op1
-            walker = op1.__jac__
-            if isinstance(op2, NodeArchitype):
-                node = op2.__jac__
-            elif isinstance(op2, EdgeArchitype):
-                node = op2.__jac__.target
-            else:
-                raise TypeError("Invalid target object")
-        elif isinstance(op2, WalkerArchitype):
-            warch = op2
-            walker = op2.__jac__
-            if isinstance(op1, NodeArchitype):
-                node = op1.__jac__
-            elif isinstance(op1, EdgeArchitype):
-                node = op1.__jac__.target
-            else:
-                raise TypeError("Invalid target object")
-        else:
-            raise TypeError("Invalid walker object")
-
-        walker.path = []
-        walker.next = [node]
-        current_node = node.architype
-
-        # walker entry
-        for i in warch._jac_entry_funcs_:
-            if i.func and not i.trigger:
-                i.func(warch, current_node)
-            if walker.disengaged:
-                return warch
-
-        while len(walker.next):
-            if current_node := walker.next.pop(0).architype:
-                # walker entry with
-                for i in warch._jac_entry_funcs_:
-                    if (
-                        i.func
-                        and i.trigger
-                        and all_issubclass(i.trigger, NodeArchitype)
-                        and isinstance(current_node, i.trigger)
-                    ):
-                        i.func(warch, current_node)
-                    if walker.disengaged:
-                        return warch
-
-                # node entry
-                for i in current_node._jac_entry_funcs_:
-                    if i.func and not i.trigger:
-                        i.func(current_node, warch)
-                    if walker.disengaged:
-                        return warch
-
-                # node entry with
-                for i in current_node._jac_entry_funcs_:
-                    if (
-                        i.func
-                        and i.trigger
-                        and all_issubclass(i.trigger, WalkerArchitype)
-                        and isinstance(warch, i.trigger)
-                    ):
-                        i.func(current_node, warch)
-                    if walker.disengaged:
-                        return warch
-
-                # node exit with
-                for i in current_node._jac_exit_funcs_:
-                    if (
-                        i.func
-                        and i.trigger
-                        and all_issubclass(i.trigger, WalkerArchitype)
-                        and isinstance(warch, i.trigger)
-                    ):
-                        i.func(current_node, warch)
-                    if walker.disengaged:
-                        return warch
-
-                # node exit
-                for i in current_node._jac_exit_funcs_:
-                    if i.func and not i.trigger:
-                        i.func(current_node, warch)
-                    if walker.disengaged:
-                        return warch
-
-                # walker exit with
-                for i in warch._jac_exit_funcs_:
-                    if (
-                        i.func
-                        and i.trigger
-                        and all_issubclass(i.trigger, NodeArchitype)
-                        and isinstance(current_node, i.trigger)
-                    ):
-                        i.func(warch, current_node)
-                    if walker.disengaged:
-                        return warch
-        # walker exit
-        for i in warch._jac_exit_funcs_:
-            if i.func and not i.trigger:
-                i.func(warch, current_node)
-            if walker.disengaged:
-                return warch
-
-        walker.ignores = []
-        return warch
-
-    @staticmethod
-    @hookimpl
-    def disengage(walker: WalkerArchitype) -> bool:  # noqa: ANN401
-        """Jac's disengage stmt feature."""
-        walker.__jac__.disengaged = True
-        return True
-
-
-class JacBuiltinImpl:
-    """Jac Builtins."""
-
-    @staticmethod
-    @hookimpl
-    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."""
-        edge_type = edge_type if edge_type else []
-        visited_nodes: list[NodeArchitype] = []
-        node_depths: dict[NodeArchitype, int] = {node: 0}
-        queue: list = [[node, 0]]
-        connections: list[tuple[NodeArchitype, NodeArchitype, EdgeArchitype]] = []
-
-        def dfs(node: NodeArchitype, cur_depth: int) -> None:
-            """Depth first search."""
-            if node not in visited_nodes:
-                visited_nodes.append(node)
-                traverse_graph(
-                    node,
-                    cur_depth,
-                    depth,
-                    edge_type,
-                    traverse,
-                    connections,
-                    node_depths,
-                    visited_nodes,
-                    queue,
-                    bfs,
-                    dfs,
-                    node_limit,
-                    edge_limit,
-                )
-
-        if bfs:
-            cur_depth = 0
-            while queue:
-                current_node, cur_depth = queue.pop(0)
-                if current_node not in visited_nodes:
-                    visited_nodes.append(current_node)
-                    traverse_graph(
-                        current_node,
-                        cur_depth,
-                        depth,
-                        edge_type,
-                        traverse,
-                        connections,
-                        node_depths,
-                        visited_nodes,
-                        queue,
-                        bfs,
-                        dfs,
-                        node_limit,
-                        edge_limit,
-                    )
-        else:
-            dfs(node, cur_depth=0)
-        dot_content = (
-            'digraph {\nnode [style="filled", shape="ellipse", '
-            'fillcolor="invis", fontcolor="black"];\n'
-        )
-        for source, target, edge in connections:
-            edge_label = html.escape(str(edge.__jac__.architype))
-            dot_content += (
-                f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
-                f' [label="{edge_label if "GenericEdge" not in edge_label else ""}"];\n'
-            )
-        for node_ in visited_nodes:
-            color = (
-                colors[node_depths[node_]] if node_depths[node_] < 25 else colors[24]
-            )
-            dot_content += (
-                f'{visited_nodes.index(node_)} [label="{html.escape(str(node_.__jac__.architype))}"'
-                f'fillcolor="{color}"];\n'
-            )
-        if dot_file:
-            with open(dot_file, "w") as f:
-                f.write(dot_content + "}")
-        return dot_content + "}"
-
-
-class JacCmdImpl:
-    """Jac CLI command."""
-
-    @staticmethod
-    @hookimpl
-    def create_cmd() -> None:
-        """Create Jac CLI cmds."""
-        pass
-
-
-class JacFeatureImpl(
-    JacAccessValidationImpl,
-    JacNodeImpl,
-    JacEdgeImpl,
-    JacWalkerImpl,
-    JacBuiltinImpl,
-    JacCmdImpl,
-):
-    """Jac Feature."""
-
-    @staticmethod
-    @hookimpl
-    def setup() -> None:
-        """Set Class References."""
-        pass
-
-    @staticmethod
-    @hookimpl
-    def get_context() -> ExecutionContext:
-        """Get current execution context."""
-        return ExecutionContext.get()
-
-    @staticmethod
-    @hookimpl
-    def reset_graph(root: Optional[Root] = None) -> int:
-        """Purge current or target graph."""
-        ctx = Jac.get_context()
-        mem = cast(ShelfStorage, ctx.mem)
-        ranchor = root.__jac__ if root else ctx.root
-
-        deleted_count = 0
-        for anchor in (
-            anchors.values()
-            if isinstance(anchors := mem.__shelf__, Shelf)
-            else mem.__mem__.values()
-        ):
-            if anchor == ranchor or anchor.root != ranchor.id:
-                continue
-
-            if loaded_anchor := mem.find_by_id(anchor.id):
-                deleted_count += 1
-                Jac.destroy(loaded_anchor)
-
-        return deleted_count
-
-    @staticmethod
-    @hookimpl
-    def get_object_func() -> Callable[[str], Architype | None]:
-        """Get object by id func."""
-        return JacCallableImplementation.get_object
-
-    @staticmethod
-    @hookimpl
-    def object_ref(obj: Architype) -> str:
-        """Get object's id."""
-        return obj.__jac__.id.hex
-
-    @staticmethod
-    @hookimpl
-    def make_architype(
-        cls: type,
-        arch_base: Type[Architype],
-        on_entry: list[DSFunc],
-        on_exit: list[DSFunc],
-    ) -> Type[Architype]:
-        """Create a new architype."""
-        for i in on_entry + on_exit:
-            i.resolve(cls)
-        if not hasattr(cls, "_jac_entry_funcs_") or not hasattr(
-            cls, "_jac_exit_funcs_"
-        ):
-            # 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:
-            new_entry_funcs = OrderedDict(zip([i.name for i in on_entry], on_entry))
-            entry_funcs = OrderedDict(
-                zip([i.name for i in cls._jac_entry_funcs_], cls._jac_entry_funcs_)
-            )
-            entry_funcs.update(new_entry_funcs)
-            cls._jac_entry_funcs_ = list(entry_funcs.values())
-
-            new_exit_funcs = OrderedDict(zip([i.name for i in on_exit], on_exit))
-            exit_funcs = OrderedDict(
-                zip([i.name for i in cls._jac_exit_funcs_], cls._jac_exit_funcs_)
-            )
-            exit_funcs.update(new_exit_funcs)
-            cls._jac_exit_funcs_ = list(exit_funcs.values())
-
-        inner_init = cls.__init__  # type: ignore
-
-        @wraps(inner_init)
-        def new_init(self: Architype, *args: object, **kwargs: object) -> None:
-            arch_base.__init__(self)
-            inner_init(self, *args, **kwargs)
-
-        cls.__init__ = new_init  # type: ignore
-        return cls
-
-    @staticmethod
-    @hookimpl
-    def make_obj(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]:
-        """Create a new architype."""
-
-        def decorator(cls: Type[Architype]) -> Type[Architype]:
-            """Decorate class."""
-            cls = Jac.make_architype(
-                cls=cls, arch_base=Architype, on_entry=on_entry, on_exit=on_exit
-            )
-            return cls
-
-        return decorator
-
-    @staticmethod
-    @hookimpl
-    def make_node(
-        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=NodeArchitype, on_entry=on_entry, on_exit=on_exit
-            )
-            return cls
-
-        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(
-        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=EdgeArchitype, on_entry=on_entry, on_exit=on_exit
-            )
-            return cls
-
-        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(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]:
-        """Create a walker architype."""
-
-        def decorator(cls: Type[Architype]) -> Type[Architype]:
-            """Decorate class."""
-            cls = Jac.make_architype(
-                cls=cls, arch_base=WalkerArchitype, on_entry=on_entry, on_exit=on_exit
-            )
-            return cls
-
-        return decorator
-
-    @staticmethod
-    @hookimpl
-    def impl_patch_filename(
-        file_loc: str,
-    ) -> Callable[[Callable[P, T]], Callable[P, T]]:
-        """Update impl file location."""
-
-        def decorator(func: Callable[P, T]) -> Callable[P, T]:
-            try:
-                code = func.__code__
-                new_code = types.CodeType(
-                    code.co_argcount,
-                    code.co_posonlyargcount,
-                    code.co_kwonlyargcount,
-                    code.co_nlocals,
-                    code.co_stacksize,
-                    code.co_flags,
-                    code.co_code,
-                    code.co_consts,
-                    code.co_names,
-                    code.co_varnames,
-                    file_loc,
-                    code.co_name,
-                    code.co_qualname,
-                    code.co_firstlineno,
-                    code.co_linetable,
-                    code.co_exceptiontable,
-                    code.co_freevars,
-                    code.co_cellvars,
-                )
-                func.__code__ = new_code
-            except AttributeError:
-                pass
-            return func
-
-        return decorator
-
-    @staticmethod
-    @hookimpl
-    def jac_import(
-        target: str,
-        base_path: str,
-        absorb: bool,
-        cachable: bool,
-        mdl_alias: Optional[str],
-        override_name: Optional[str],
-        lng: Optional[str],
-        items: Optional[dict[str, Union[str, Optional[str]]]],
-        reload_module: Optional[bool],
-    ) -> tuple[types.ModuleType, ...]:
-        """Core Import Process."""
-        spec = ImportPathSpec(
-            target,
-            base_path,
-            absorb,
-            cachable,
-            mdl_alias,
-            override_name,
-            lng,
-            items,
-        )
-
-        jac_machine = JacMachine.get(base_path)
-        if not jac_machine.jac_program:
-            jac_machine.attach_program(
-                JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
-            )
-
-        if lng == "py":
-            import_result = PythonImporter(JacMachine.get()).run_import(spec)
-        else:
-            import_result = JacImporter(JacMachine.get()).run_import(
-                spec, reload_module
-            )
-
-        return (
-            (import_result.ret_mod,)
-            if absorb or not items
-            else tuple(import_result.ret_items)
-        )
-
-    @staticmethod
-    @hookimpl
-    def create_test(test_fun: Callable) -> Callable:
-        """Create a new test."""
-        file_path = inspect.getfile(test_fun)
-        func_name = test_fun.__name__
-
-        def test_deco() -> None:
-            test_fun(JacTestCheck())
-
-        test_deco.__name__ = test_fun.__name__
-        JacTestCheck.add_test(file_path, func_name, test_deco)
-
-        return test_deco
-
-    @staticmethod
-    @hookimpl
-    def run_test(
-        filepath: str,
-        func_name: Optional[str],
-        filter: Optional[str],
-        xit: bool,
-        maxfail: Optional[int],
-        directory: Optional[str],
-        verbose: bool,
-    ) -> int:
-        """Run the test suite in the specified .jac file."""
-        test_file = False
-        ret_count = 0
-        if filepath:
-            if filepath.endswith(".jac"):
-                base, mod_name = os.path.split(filepath)
-                base = base if base else "./"
-                mod_name = mod_name[:-4]
-                if mod_name.endswith(".test"):
-                    mod_name = mod_name[:-5]
-                JacTestCheck.reset()
-                Jac.jac_import(target=mod_name, base_path=base, cachable=False)
-                JacTestCheck.run_test(
-                    xit, maxfail, verbose, os.path.abspath(filepath), func_name
-                )
-                ret_count = JacTestCheck.failcount
-            else:
-                print("Not a .jac file.")
-        else:
-            directory = directory if directory else os.getcwd()
-
-        if filter or directory:
-            current_dir = directory if directory else os.getcwd()
-            for root_dir, _, files in os.walk(current_dir, topdown=True):
-                files = (
-                    [file for file in files if fnmatch.fnmatch(file, filter)]
-                    if filter
-                    else files
-                )
-                files = [
-                    file
-                    for file in files
-                    if not file.endswith((".test.jac", ".impl.jac"))
-                ]
-                for file in files:
-                    if file.endswith(".jac"):
-                        test_file = True
-                        print(f"\n\n\t\t* Inside {root_dir}" + "/" + f"{file} *")
-                        JacTestCheck.reset()
-                        Jac.jac_import(target=file[:-4], base_path=root_dir)
-                        JacTestCheck.run_test(
-                            xit, maxfail, verbose, os.path.abspath(file), func_name
-                        )
-
-                    if JacTestCheck.breaker and (xit or maxfail):
-                        break
-                if JacTestCheck.breaker and (xit or maxfail):
-                    break
-            JacTestCheck.breaker = False
-            ret_count += JacTestCheck.failcount
-            JacTestCheck.failcount = 0
-            print("No test files found.") if not test_file else None
-
-        return ret_count
-
-    @staticmethod
-    @hookimpl
-    def has_instance_default(gen_func: Callable[[], T]) -> T:
-        """Jac's has container default feature."""
-        return field(default_factory=lambda: gen_func())
-
-    @staticmethod
-    @hookimpl
-    def report(expr: Any, custom: bool) -> None:  # noqa: ANN401
-        """Jac's report stmt feature."""
-        ctx = Jac.get_context()
-        if custom:
-            ctx.custom = expr
-        else:
-            ctx.reports.append(expr)
-
-    @staticmethod
-    @hookimpl
-    def edge_ref(
-        node_obj: NodeArchitype | list[NodeArchitype],
-        target_obj: Optional[NodeArchitype | list[NodeArchitype]],
-        dir: EdgeDir,
-        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
-        edges_only: bool,
-    ) -> list[NodeArchitype] | list[EdgeArchitype]:
-        """Jac's apply_dir stmt feature."""
-        if isinstance(node_obj, NodeArchitype):
-            node_obj = [node_obj]
-        targ_obj_set: Optional[list[NodeArchitype]] = (
-            [target_obj]
-            if isinstance(target_obj, NodeArchitype)
-            else target_obj if target_obj else None
-        )
-        if edges_only:
-            connected_edges: list[EdgeArchitype] = []
-            for node in node_obj:
-                edges = Jac.get_edges(
-                    node.__jac__, dir, filter_func, target_obj=targ_obj_set
-                )
-                connected_edges.extend(
-                    edge for edge in edges if edge not in connected_edges
-                )
-            return connected_edges
-        else:
-            connected_nodes: list[NodeArchitype] = []
-            for node in node_obj:
-                nodes = Jac.edges_to_nodes(
-                    node.__jac__, dir, filter_func, target_obj=targ_obj_set
-                )
-                connected_nodes.extend(
-                    node for node in nodes if node not in connected_nodes
-                )
-            return connected_nodes
-
-    @staticmethod
-    @hookimpl
-    def connect(
-        left: NodeArchitype | list[NodeArchitype],
-        right: NodeArchitype | list[NodeArchitype],
-        edge_spec: Callable[[NodeAnchor, NodeAnchor], EdgeArchitype],
-        edges_only: bool,
-    ) -> list[NodeArchitype] | list[EdgeArchitype]:
-        """Jac's connect operator feature.
-
-        Note: connect needs to call assign compr with tuple in op
-        """
-        left = [left] if isinstance(left, NodeArchitype) else left
-        right = [right] if isinstance(right, NodeArchitype) else right
-        edges = []
-
-        for i in left:
-            _left = i.__jac__
-            if Jac.check_connect_access(_left):
-                for j in right:
-                    _right = j.__jac__
-                    if Jac.check_connect_access(_right):
-                        edges.append(edge_spec(_left, _right))
-        return right if not edges_only else edges
-
-    @staticmethod
-    @hookimpl
-    def disconnect(
-        left: NodeArchitype | list[NodeArchitype],
-        right: NodeArchitype | list[NodeArchitype],
-        dir: EdgeDir,
-        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
-    ) -> bool:  # noqa: ANN401
-        """Jac's disconnect operator feature."""
-        disconnect_occurred = False
-        left = [left] if isinstance(left, NodeArchitype) else left
-        right = [right] if isinstance(right, NodeArchitype) else right
-
-        for i in left:
-            node = i.__jac__
-            for anchor in set(node.edges):
-                if (
-                    (source := anchor.source)
-                    and (target := anchor.target)
-                    and (not filter_func or filter_func([anchor.architype]))
-                    and source.architype
-                    and target.architype
-                ):
-                    if (
-                        dir in [EdgeDir.OUT, EdgeDir.ANY]
-                        and node == source
-                        and target.architype in right
-                        and Jac.check_connect_access(target)
-                    ):
-                        Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
-                        disconnect_occurred = True
-                    if (
-                        dir in [EdgeDir.IN, EdgeDir.ANY]
-                        and node == target
-                        and source.architype in right
-                        and Jac.check_connect_access(source)
-                    ):
-                        Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
-                        disconnect_occurred = True
-
-        return disconnect_occurred
-
-    @staticmethod
-    @hookimpl
-    def assign_compr(
-        target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
-    ) -> list[T]:
-        """Jac's assign comprehension feature."""
-        for obj in target:
-            attrs, values = attr_val
-            for attr, value in zip(attrs, values):
-                setattr(obj, attr, value)
-        return target
-
-    @staticmethod
-    @hookimpl
-    def get_root() -> Root:
-        """Jac's assign comprehension feature."""
-        return ExecutionContext.get_root()
-
-    @staticmethod
-    @hookimpl
-    def get_root_type() -> Type[Root]:
-        """Jac's root getter."""
-        from jaclang import Root as JRoot
-
-        return cast(Type[Root], JRoot)
-
-    @staticmethod
-    @hookimpl
-    def build_edge(
-        is_undirected: bool,
-        conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
-        conn_assign: Optional[tuple[tuple, tuple]],
-    ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
-        """Jac's root getter."""
-        from jaclang import GenericEdge
-
-        ct = conn_type if conn_type else GenericEdge
-
-        def builder(source: NodeAnchor, target: NodeAnchor) -> EdgeArchitype:
-            edge = ct() if isinstance(ct, type) else ct
-
-            eanch = edge.__jac__ = EdgeAnchor(
-                architype=edge,
-                source=source,
-                target=target,
-                is_undirected=is_undirected,
-            )
-            source.edges.append(eanch)
-            target.edges.append(eanch)
-
-            if conn_assign:
-                for fld, val in zip(conn_assign[0], conn_assign[1]):
-                    if hasattr(edge, fld):
-                        setattr(edge, fld, val)
-                    else:
-                        raise ValueError(f"Invalid attribute: {fld}")
-            if source.persistent or target.persistent:
-                Jac.save(eanch)
-            return edge
-
-        return builder
-
-    @staticmethod
-    @hookimpl
-    def save(obj: Architype | Anchor) -> None:
-        """Destroy object."""
-        anchor = obj.__jac__ if isinstance(obj, Architype) else obj
-
-        jctx = Jac.get_context()
-
-        anchor.persistent = True
-        anchor.root = jctx.root.id
-
-        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:
-        """Destroy object."""
-        anchor = obj.__jac__ if isinstance(obj, Architype) else obj
-
-        if Jac.check_write_access(anchor):
-            match anchor:
-                case NodeAnchor():
-                    for edge in anchor.edges:
-                        Jac.destroy(edge)
-                case EdgeAnchor():
-                    Jac.detach(anchor)
-                case _:
-                    pass
-
-            Jac.get_context().mem.remove(anchor.id)
-
-    @staticmethod
-    @hookimpl
-    def get_semstr_type(
-        file_loc: str, scope: str, attr: str, return_semstr: bool
-    ) -> Optional[str]:
-        """Jac's get_semstr_type feature."""
-        from jaclang.compiler.semtable import SemInfo, SemScope, SemRegistry
-        from jaclang.runtimelib.machine import JacMachine
-
-        _scope = SemScope.get_scope_from_str(scope)
-        jac_program = JacMachine.get().jac_program
-        mod_registry: SemRegistry = (
-            jac_program.sem_ir if jac_program is not None else SemRegistry()
-        )
-        _, attr_seminfo = mod_registry.lookup(_scope, attr)
-        if attr_seminfo and isinstance(attr_seminfo, SemInfo):
-            return attr_seminfo.semstr if return_semstr else attr_seminfo.type
-        return None
-
-    @staticmethod
-    @hookimpl
-    def obj_scope(file_loc: str, attr: str) -> str:
-        """Jac's gather_scope feature."""
-        from jaclang.runtimelib.machine import JacMachine
-
-        jac_program = JacMachine.get().jac_program
-        mod_registry: SemRegistry = (
-            jac_program.sem_ir if jac_program is not None else SemRegistry()
-        )
-
-        attr_scope = None
-        for x in attr.split("."):
-            attr_scope, attr_sem_info = mod_registry.lookup(attr_scope, x)
-            if isinstance(attr_sem_info, SemInfo) and attr_sem_info.type not in [
-                "class",
-                "obj",
-                "node",
-                "edge",
-            ]:
-                attr_scope, attr_sem_info = mod_registry.lookup(
-                    None, attr_sem_info.type
-                )
-                if isinstance(attr_sem_info, SemInfo) and isinstance(
-                    attr_sem_info.type, str
-                ):
-                    attr_scope = SemScope(
-                        attr_sem_info.name, attr_sem_info.type, attr_scope
-                    )
-            else:
-                if isinstance(attr_sem_info, SemInfo) and isinstance(
-                    attr_sem_info.type, str
-                ):
-                    attr_scope = SemScope(
-                        attr_sem_info.name, attr_sem_info.type, attr_scope
-                    )
-        return str(attr_scope)
-
-    @staticmethod
-    @hookimpl
-    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
-        """Jac's get_semstr_type implementation."""
-        from jaclang.runtimelib.machine import JacMachine
-        from jaclang.compiler.semtable import SemInfo, SemScope
-
-        jac_program = JacMachine.get().jac_program
-        mod_registry: SemRegistry = (
-            jac_program.sem_ir if jac_program is not None else SemRegistry()
-        )
-
-        attr_scope = None
-        for x in attr.split("."):
-            attr_scope, attr_sem_info = mod_registry.lookup(attr_scope, x)
-            if isinstance(attr_sem_info, SemInfo) and attr_sem_info.type not in [
-                "class",
-                "obj",
-                "node",
-                "edge",
-            ]:
-                attr_scope, attr_sem_info = mod_registry.lookup(
-                    None, attr_sem_info.type
-                )
-                if isinstance(attr_sem_info, SemInfo) and isinstance(
-                    attr_sem_info.type, str
-                ):
-                    attr_scope = SemScope(
-                        attr_sem_info.name, attr_sem_info.type, attr_scope
-                    )
-            else:
-                if isinstance(attr_sem_info, SemInfo) and isinstance(
-                    attr_sem_info.type, str
-                ):
-                    attr_scope = SemScope(
-                        attr_sem_info.name, attr_sem_info.type, attr_scope
-                    )
-        if isinstance(attr_sem_info, SemInfo) and isinstance(attr_scope, SemScope):
-            return attr_sem_info.semstr, attr_scope.as_type_str
-        return "", ""
-
-    @staticmethod
-    @hookimpl
-    def with_llm(
-        file_loc: str,
-        model: Any,  # noqa: ANN401
-        model_params: dict[str, Any],
-        scope: str,
-        incl_info: list[tuple[str, str]],
-        excl_info: list[tuple[str, str]],
-        inputs: list[tuple[str, str, str, Any]],
-        outputs: tuple,
-        action: str,
-        _globals: dict,
-        _locals: Mapping,
-    ) -> Any:  # noqa: ANN401
-        """Jac's with_llm feature."""
-        raise ImportError(
-            "mtllm is not installed. Please install it with `pip install mtllm` and run `jac clean`."
-        )
-
-    @staticmethod
-    @hookimpl
-    def gen_llm_body(_pass: PyastGenPass, node: ast.Ability) -> list[ast3.AST]:
-        """Generate the by LLM body."""
-        _pass.log_warning(
-            "MT-LLM is not installed. Please install it with `pip install mtllm`."
-        )
-        return [
-            _pass.sync(
-                ast3.Raise(
-                    _pass.sync(
-                        ast3.Call(
-                            func=_pass.sync(
-                                ast3.Name(id="ImportError", ctx=ast3.Load())
-                            ),
-                            args=[
-                                _pass.sync(
-                                    ast3.Constant(
-                                        value="mtllm is not installed. Please install it with `pip install mtllm` and run `jac clean`."  # noqa: E501
-                                    )
-                                )
-                            ],
-                            keywords=[],
-                        )
-                    )
-                )
-            )
-        ]
-
-    @staticmethod
-    @hookimpl
-    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()."""
-        _pass.log_warning(
-            "MT-LLM is not installed. Please install it with `pip install mtllm`."
-        )
-        return ast3.Call(
-            func=_pass.sync(
-                ast3.Attribute(
-                    value=_pass.sync(ast3.Name(id="_Jac", ctx=ast3.Load())),
-                    attr="with_llm",
-                    ctx=ast3.Load(),
-                )
-            ),
-            args=[],
-            keywords=[
-                _pass.sync(
-                    ast3.keyword(
-                        arg="file_loc",
-                        value=_pass.sync(ast3.Constant(value="None")),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="model",
-                        value=_pass.sync(ast3.Constant(value="None")),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="model_params",
-                        value=_pass.sync(ast3.Dict(keys=[], values=[])),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="scope",
-                        value=_pass.sync(ast3.Constant(value="None")),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="incl_info",
-                        value=_pass.sync(ast3.List(elts=[], ctx=ast3.Load())),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="excl_info",
-                        value=_pass.sync(ast3.List(elts=[], ctx=ast3.Load())),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="inputs",
-                        value=_pass.sync(ast3.List(elts=[], ctx=ast3.Load())),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="outputs",
-                        value=_pass.sync(ast3.List(elts=[], ctx=ast3.Load())),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="action",
-                        value=_pass.sync(ast3.Constant(value="None")),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="_globals",
-                        value=_pass.sync(ast3.Constant(value="None")),
-                    )
-                ),
-                _pass.sync(
-                    ast3.keyword(
-                        arg="_locals",
-                        value=_pass.sync(ast3.Constant(value="None")),
-                    )
-                ),
-            ],
-        )
-
-    @staticmethod
-    @hookimpl
-    def get_by_llm_call_args(_pass: PyastGenPass, node: ast.FuncCall) -> dict:
-        """Get the by LLM call args."""
-        return {
-            "model": None,
-            "model_params": {},
-            "scope": None,
-            "inputs": [],
-            "outputs": [],
-            "action": None,
-            "include_info": [],
-            "exclude_info": [],
-        }