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

jaclang/plugin/default.py

@@ -11,59 +11,549 @@ 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
 from uuid import UUID
 
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.constant import EdgeDir, colors
-from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
+from jaclang.compiler.constant import colors
 from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
-from jaclang.runtimelib.constructs import (
+from jaclang.plugin.feature import (
+    AccessLevel,
+    Anchor,
     Architype,
     DSFunc,
     EdgeAnchor,
     EdgeArchitype,
+    EdgeDir,
     ExecutionContext,
-    GenericEdge,
-    JacTestCheck,
+    JacFeature as Jac,
     NodeAnchor,
     NodeArchitype,
+    P,
+    PyastGenPass,
     Root,
-    WalkerAnchor,
+    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.utils import traverse_graph
-from jaclang.plugin.feature import JacFeature as Jac  # noqa: I100
-from jaclang.plugin.spec import P, T
+from jaclang.runtimelib.utils import collect_node_connections, traverse_graph
 
 
 import pluggy
 
 hookimpl = pluggy.HookimplMarker("jac")
+logger = getLogger(__name__)
+
+
+class JacAccessValidationImpl:
+    """Jac Access Validation Implementations."""
+
+    @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
 
-__all__ = [
-    "EdgeAnchor",
-    "GenericEdge",
-    "hookimpl",
-    "JacTestCheck",
-    "NodeAnchor",
-    "WalkerAnchor",
-    "NodeArchitype",
-    "EdgeArchitype",
-    "Root",
-    "WalkerArchitype",
-    "Architype",
-    "DSFunc",
-    "T",
-]
-
-
-class JacFeatureDefaults:
+    @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
+
+            level = to_root.access.roots.check(str(jroot.id))
+            if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+                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:
+            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]
+        if walker.next:
+            current_node = walker.next[-1].architype
+            for i in warch._jac_entry_funcs_:
+                if not i.trigger:
+                    if i.func:
+                        i.func(warch, current_node)
+                    else:
+                        raise ValueError(f"No function {i.name} to call.")
+        while len(walker.next):
+            if current_node := walker.next.pop(0).architype:
+                for i in current_node._jac_entry_funcs_:
+                    if not i.trigger or isinstance(warch, i.trigger):
+                        if i.func:
+                            i.func(current_node, warch)
+                        else:
+                            raise ValueError(f"No function {i.name} to call.")
+                    if walker.disengaged:
+                        return warch
+                for i in warch._jac_entry_funcs_:
+                    if not i.trigger or isinstance(current_node, i.trigger):
+                        if i.func and i.trigger:
+                            i.func(warch, current_node)
+                        elif not i.trigger:
+                            continue
+                        else:
+                            raise ValueError(f"No function {i.name} to call.")
+                    if walker.disengaged:
+                        return warch
+                for i in warch._jac_exit_funcs_:
+                    if not i.trigger or isinstance(current_node, i.trigger):
+                        if i.func and i.trigger:
+                            i.func(warch, current_node)
+                        elif not i.trigger:
+                            continue
+                        else:
+                            raise ValueError(f"No function {i.name} to call.")
+                    if walker.disengaged:
+                        return warch
+                for i in current_node._jac_exit_funcs_:
+                    if not i.trigger or isinstance(warch, i.trigger):
+                        if i.func:
+                            i.func(current_node, warch)
+                        else:
+                            raise ValueError(f"No function {i.name} to call.")
+                    if walker.disengaged:
+                        return warch
+        for i in warch._jac_exit_funcs_:
+            if not i.trigger:
+                if i.func:
+                    i.func(warch, current_node)
+                else:
+                    raise ValueError(f"No function {i.name} to call.")
+        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."""
 
-    pm = pluggy.PluginManager("jac")
+    @staticmethod
+    @hookimpl
+    def setup() -> None:
+        """Set Class References."""
+        pass
 
     @staticmethod
     @hookimpl
@@ -74,6 +564,7 @@ class JacFeatureDefaults:
     @staticmethod
     @hookimpl
     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)):
@@ -84,6 +575,7 @@ class JacFeatureDefaults:
     @staticmethod
     @hookimpl
     def object_ref(obj: Architype) -> str:
+        """Get object's id."""
         return obj.__jac__.id.hex
 
     @staticmethod
@@ -363,66 +855,13 @@ class JacFeatureDefaults:
 
     @staticmethod
     @hookimpl
-    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
-        """Jac's spawn operator feature."""
-        if isinstance(op1, WalkerArchitype):
-            return op1.__jac__.spawn_call(op2.__jac__)
-        elif isinstance(op2, WalkerArchitype):
-            return op2.__jac__.spawn_call(op1.__jac__)
-        else:
-            raise TypeError("Invalid walker object")
-
-    @staticmethod
-    @hookimpl
-    def report(expr: Any) -> Any:  # noqa: ANN401
+    def report(expr: Any, custom: bool) -> None:  # noqa: ANN401
         """Jac's report stmt feature."""
-
-    @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):
-            return walker.__jac__.ignore_node(
-                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
-            )
-        else:
-            raise TypeError("Invalid walker object")
-
-    @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):
-            return walker.__jac__.visit_node(
-                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
-            )
+        ctx = Jac.get_context()
+        if custom:
+            ctx.custom = expr
         else:
-            raise TypeError("Invalid walker object")
-
-    @staticmethod
-    @hookimpl
-    def disengage(walker: WalkerArchitype) -> bool:  # noqa: ANN401
-        """Jac's disengage stmt feature."""
-        walker.__jac__.disengage_now()
-        return True
+            ctx.reports.append(expr)
 
     @staticmethod
     @hookimpl
@@ -444,19 +883,23 @@ class JacFeatureDefaults:
         if edges_only:
             connected_edges: list[EdgeArchitype] = []
             for node in node_obj:
-                connected_edges += node.__jac__.get_edges(
-                    dir, filter_func, target_obj=targ_obj_set
+                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 list(set(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.__jac__.edges_to_nodes(
-                        dir, filter_func, target_obj=targ_obj_set
-                    )
+                    node for node in nodes if node not in connected_nodes
                 )
-            return list(set(connected_nodes))
+            return connected_nodes
 
     @staticmethod
     @hookimpl
@@ -474,14 +917,12 @@ class JacFeatureDefaults:
         right = [right] if isinstance(right, NodeArchitype) else right
         edges = []
 
-        root = Jac.get_root().__jac__
-
         for i in left:
             _left = i.__jac__
-            if root.has_connect_access(_left):
+            if Jac.check_connect_access(_left):
                 for j in right:
                     _right = j.__jac__
-                    if root.has_connect_access(_right):
+                    if Jac.check_connect_access(_right):
                         edges.append(edge_spec(_left, _right))
         return right if not edges_only else edges
 
@@ -498,8 +939,6 @@ class JacFeatureDefaults:
         left = [left] if isinstance(left, NodeArchitype) else left
         right = [right] if isinstance(right, NodeArchitype) else right
 
-        root = Jac.get_root().__jac__
-
         for i in left:
             node = i.__jac__
             for anchor in set(node.edges):
@@ -514,17 +953,17 @@ class JacFeatureDefaults:
                         dir in [EdgeDir.OUT, EdgeDir.ANY]
                         and node == source
                         and target.architype in right
-                        and root.has_write_access(target)
+                        and Jac.check_write_access(target)
                     ):
-                        anchor.destroy() if anchor.persistent else anchor.detach()
+                        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 root.has_write_access(source)
+                        and Jac.check_write_access(source)
                     ):
-                        anchor.destroy() if anchor.persistent else anchor.detach()
+                        Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
                         disconnect_occurred = True
 
         return disconnect_occurred
@@ -565,7 +1004,16 @@ class JacFeatureDefaults:
 
         def builder(source: NodeAnchor, target: NodeAnchor) -> EdgeArchitype:
             edge = conn_type() if isinstance(conn_type, type) else conn_type
-            edge.__attach__(source, target, is_undirected)
+
+            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):
@@ -573,13 +1021,44 @@ class JacFeatureDefaults:
                     else:
                         raise ValueError(f"Invalid attribute: {fld}")
             if source.persistent or target.persistent:
-                edge.__jac__.save()
-                target.save()
-                source.save()
+                Jac.save(eanch)
+                Jac.save(target)
+                Jac.save(source)
             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)
+
+    @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(
@@ -645,6 +1124,7 @@ class JacFeatureDefaults:
     @staticmethod
     @hookimpl
     def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
+        """Jac's get_semstr_type implementation."""
         with open(
             os.path.join(
                 os.path.dirname(file_loc),
@@ -843,101 +1323,3 @@ class JacFeatureDefaults:
             "include_info": [],
             "exclude_info": [],
         }
-
-
-class JacBuiltin:
-    """Jac Builtins."""
-
-    @staticmethod
-    @hookimpl
-    def dotgen(
-        node: NodeArchitype,
-        depth: int,
-        traverse: bool,
-        edge_type: 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:
-            dot_content += (
-                f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
-                f' [label="{html.escape(str(edge.__jac__.architype))} "];\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 JacCmdDefaults:
-    """Jac CLI command."""
-
-    @staticmethod
-    @hookimpl
-    def create_cmd() -> None:
-        """Create Jac CLI cmds."""
-        pass