jaclang 0.7.1__py3-none-any.whl → 0.7.7__py3-none-any.whl

jaclang/langserve/utils.py

@@ -1,12 +1,19 @@
 """Utility functions for the language server."""
 
 import asyncio
+import builtins
+import importlib.util
+import os
+import sys
 from functools import wraps
 from typing import Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar
 
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.symtable import SymbolTable
+from jaclang.compiler.codeloc import CodeLocInfo
+from jaclang.compiler.symtable import Symbol, SymbolTable
+from jaclang.utils.helpers import import_target_to_relative_path
 
+import lsprotocol.types as lspt
 
 T = TypeVar("T", bound=Callable[..., Coroutine[Any, Any, Any]])
 P = ParamSpec("P")
@@ -55,17 +62,23 @@ def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> list[SymbolTable]:
     return sym_tabs
 
 
-def find_deepest_node_at_pos(
+def find_deepest_symbol_node_at_pos(
     node: ast.AstNode, line: int, character: int
-) -> Optional[ast.AstNode]:
-    """Return the deepest node that contains the given position."""
+) -> Optional[ast.AstSymbolNode]:
+    """Return the deepest symbol node that contains the given position."""
+    last_symbol_node = None
+
     if position_within_node(node, line, character):
-        for i in node.kid:
-            if position_within_node(i, line, character):
-                return find_deepest_node_at_pos(i, line, character)
-        return node
-    else:
-        return None
+        if isinstance(node, ast.AstSymbolNode):
+            last_symbol_node = node
+
+        for child in [i for i in node.kid if i.loc.mod_path == node.loc.mod_path]:
+            if position_within_node(child, line, character):
+                deeper_node = find_deepest_symbol_node_at_pos(child, line, character)
+                if deeper_node is not None:
+                    last_symbol_node = deeper_node
+
+    return last_symbol_node
 
 
 def position_within_node(node: ast.AstNode, line: int, character: int) -> bool:
@@ -88,3 +101,194 @@ def position_within_node(node: ast.AstNode, line: int, character: int) -> bool:
     ):
         return True
     return False
+
+
+def collect_symbols(node: SymbolTable) -> list[lspt.DocumentSymbol]:
+    """Recursively collect symbols from the AST."""
+    symbols = []
+    if node is None:
+        return symbols
+
+    for key, item in node.tab.items():
+        if (
+            key in dir(builtins)
+            or item in [owner_sym(tab) for tab in node.kid]
+            or item.decl.loc.mod_path != node.owner.loc.mod_path
+        ):
+            continue
+        else:
+
+            pos = create_range(item.decl.loc)
+            symbol = lspt.DocumentSymbol(
+                name=key,
+                kind=kind_map(item.decl),
+                range=pos,
+                selection_range=pos,
+                children=[],
+            )
+            symbols.append(symbol)
+
+    for sub_tab in [
+        i for i in node.kid if i.owner.loc.mod_path == node.owner.loc.mod_path
+    ]:
+        sub_symbols = collect_symbols(sub_tab)
+
+        if isinstance(
+            sub_tab.owner,
+            (ast.IfStmt, ast.ElseStmt, ast.WhileStmt, ast.IterForStmt, ast.InForStmt),
+        ):
+            symbols.extend(sub_symbols)
+        else:
+            sub_pos = create_range(sub_tab.owner.loc)
+            symbol = lspt.DocumentSymbol(
+                name=sub_tab.name,
+                kind=kind_map(sub_tab.owner),
+                range=sub_pos,
+                selection_range=sub_pos,
+                children=sub_symbols,
+            )
+            symbols.append(symbol)
+
+    return symbols
+
+
+def owner_sym(table: SymbolTable) -> Optional[Symbol]:
+    """Get owner sym."""
+    if table.parent and isinstance(table.owner, ast.AstSymbolNode):
+        return table.parent.lookup(table.owner.sym_name)
+    return None
+
+
+def create_range(loc: CodeLocInfo) -> lspt.Range:
+    """Create an lspt.Range from a location object."""
+    return lspt.Range(
+        start=lspt.Position(
+            line=loc.first_line - 1 if loc.first_line > 0 else 0,
+            character=loc.col_start - 1 if loc.col_start > 0 else 0,
+        ),
+        end=lspt.Position(
+            line=loc.last_line - 1 if loc.last_line > 0 else 0,
+            character=loc.col_end - 1 if loc.col_end > 0 else 0,
+        ),
+    )
+
+
+def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind:
+    """Map the symbol node to an lspt.SymbolKind."""
+    return (
+        lspt.SymbolKind.Function
+        if isinstance(sub_tab, (ast.Ability, ast.AbilityDef))
+        else (
+            lspt.SymbolKind.Class
+            if isinstance(sub_tab, (ast.Architype, ast.ArchDef))
+            else (
+                lspt.SymbolKind.Module
+                if isinstance(sub_tab, ast.Module)
+                else (
+                    lspt.SymbolKind.Enum
+                    if isinstance(sub_tab, (ast.Enum, ast.EnumDef))
+                    else lspt.SymbolKind.Variable
+                )
+            )
+        )
+    )
+
+
+def get_mod_path(mod_path: ast.ModulePath, name_node: ast.Name) -> str | None:
+    """Get path for a module import name."""
+    ret_target = None
+    module_location_path = mod_path.loc.mod_path
+    if mod_path.parent and (
+        (
+            isinstance(mod_path.parent.parent, ast.Import)
+            and mod_path.parent.parent.hint.tag.value == "py"
+        )
+        or (
+            isinstance(mod_path.parent, ast.Import)
+            and mod_path.parent.from_loc
+            and mod_path.parent.hint.tag.value == "py"
+        )
+    ):
+        if mod_path.path and name_node in mod_path.path:
+            temporary_path_str = ("." * mod_path.level) + ".".join(
+                [p.value for p in mod_path.path[: mod_path.path.index(name_node) + 1]]
+                if mod_path.path
+                else ""
+            )
+        else:
+            temporary_path_str = mod_path.path_str
+        sys.path.append(os.path.dirname(module_location_path))
+        spec = importlib.util.find_spec(temporary_path_str)
+        sys.path.remove(os.path.dirname(module_location_path))
+        if spec and spec.origin and spec.origin.endswith(".py"):
+            ret_target = spec.origin
+    elif mod_path.parent and (
+        (
+            isinstance(mod_path.parent.parent, ast.Import)
+            and mod_path.parent.parent.hint.tag.value == "jac"
+        )
+        or (
+            isinstance(mod_path.parent, ast.Import)
+            and mod_path.parent.from_loc
+            and mod_path.parent.hint.tag.value == "jac"
+        )
+    ):
+        ret_target = import_target_to_relative_path(
+            level=mod_path.level,
+            target=mod_path.path_str,
+            base_path=os.path.dirname(module_location_path),
+        )
+    return ret_target
+
+
+def get_item_path(mod_item: ast.ModuleItem) -> tuple[str, tuple[int, int]] | None:
+    """Get path."""
+    item_name = mod_item.name.value
+    if mod_item.from_parent.hint.tag.value == "py" and mod_item.from_parent.from_loc:
+        path = get_mod_path(mod_item.from_parent.from_loc, mod_item.name)
+        if path:
+            return get_definition_range(path, item_name)
+    elif mod_item.from_parent.hint.tag.value == "jac":
+        mod_node = mod_item.from_mod_path
+        if mod_node.sub_module and mod_node.sub_module._sym_tab:
+            for symbol_name, symbol in mod_node.sub_module._sym_tab.tab.items():
+                if symbol_name == item_name:
+                    return symbol.decl.loc.mod_path, (
+                        symbol.decl.loc.first_line - 1,
+                        symbol.decl.loc.last_line - 1,
+                    )
+    return None
+
+
+def get_definition_range(
+    filename: str, name: str
+) -> tuple[str, tuple[int, int]] | None:
+    """Get the start and end line of a function or class definition in a file."""
+    import ast
+
+    with open(filename, "r") as file:
+        source = file.read()
+
+    tree = ast.parse(source)
+
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.ClassDef)) and node.name == name:
+            start_line = node.lineno
+            end_line = (
+                node.body[-1].end_lineno
+                if hasattr(node.body[-1], "end_lineno")
+                else node.body[-1].lineno
+            )
+            if start_line and end_line:
+                return filename, (start_line - 1, end_line - 1)
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id == name:
+                    start_line = node.lineno
+                    end_line = (
+                        node.end_lineno if hasattr(node, "end_lineno") else node.lineno
+                    )
+                    if start_line and end_line:
+                        return filename, (start_line - 1, end_line - 1)
+
+    return None

jaclang/plugin/builtin.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Optional
-    from jaclang.core.construct import NodeArchitype
+    from jaclang.core.constructs import NodeArchitype
 
 
 def dotgen(

jaclang/plugin/default.py

@@ -7,40 +7,39 @@ import html
 import os
 import pickle
 import types
-from contextvars import ContextVar
+from collections import OrderedDict
 from dataclasses import field
 from functools import wraps
 from typing import Any, Callable, Optional, Type, Union
-from uuid import UUID
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.constant import EdgeDir, colors
+from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
 from jaclang.core.aott import (
     aott_raise,
     extract_non_primary_type,
     get_all_type_explanations,
     get_info_types,
-    get_object_string,
-    get_type_annotation,
+    get_input_information,
 )
-from jaclang.core.construct import (
+from jaclang.core.constructs import (
     Architype,
     DSFunc,
     EdgeAnchor,
     EdgeArchitype,
+    ExecutionContext,
     GenericEdge,
     JacTestCheck,
+    Memory,
     NodeAnchor,
     NodeArchitype,
     ObjectAnchor,
     Root,
     WalkerAnchor,
     WalkerArchitype,
+    exec_context,
 )
 from jaclang.core.importer import jac_importer
-from jaclang.core.memory import Memory
-from jaclang.core.registry import SemInfo, SemRegistry, SemScope
-from jaclang.core.shelve_storage import ShelveStorage
 from jaclang.core.utils import traverse_graph
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.plugin.spec import T
@@ -70,65 +69,6 @@ __all__ = [
 hookimpl = pluggy.HookimplMarker("jac")
 
 
-class ExecutionContext:
-    """Default Execution Context implementation."""
-
-    mem: Optional[Memory]
-    root: Optional[Root]
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.mem = ShelveStorage()
-        self.root = None
-
-    def init_memory(self, session: str = "") -> None:
-        if session:
-            self.mem = ShelveStorage(session)
-        else:
-            self.mem = Memory()
-
-    def get_root(self) -> Root:
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        if not self.root:
-            root = self.mem.get_obj(UUID(int=0))
-            if root is None:
-                self.root = Root()
-                self.mem.save_obj(self.root, persistent=self.root._jac_.persistent)
-            elif not isinstance(root, Root):
-                raise ValueError(f"Invalid root object: {root}")
-            else:
-                self.root = root
-        return self.root
-
-    def get_obj(self, obj_id: UUID) -> Architype | None:
-        """Get object from memory."""
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        return self.mem.get_obj(obj_id)
-
-    def save_obj(self, item: Architype, persistent: bool) -> None:
-        """Save object to memory."""
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        self.mem.save_obj(item, persistent)
-
-    def reset(self) -> None:
-        """Reset the execution context."""
-        if self.mem:
-            self.mem.close()
-        self.mem = None
-        self.root = None
-
-
-ExecContext: ContextVar[ExecutionContext | None] = ContextVar(
-    "ExecutionContext", default=None
-)
-
-
 class JacFeatureDefaults:
     """Jac Feature."""
 
@@ -138,20 +78,20 @@ class JacFeatureDefaults:
     @hookimpl
     def context(session: str = "") -> ExecutionContext:
         """Get the execution context."""
-        ctx = ExecContext.get()
+        ctx = exec_context.get()
         if ctx is None:
             ctx = ExecutionContext()
-            ExecContext.set(ctx)
+            exec_context.set(ctx)
         return ctx
 
     @staticmethod
     @hookimpl
     def reset_context() -> None:
         """Reset the execution context."""
-        ctx = ExecContext.get()
+        ctx = exec_context.get()
         if ctx:
             ctx.reset()
-        ExecContext.set(None)
+        exec_context.set(None)
 
     @staticmethod
     @hookimpl
@@ -170,7 +110,9 @@ class JacFeatureDefaults:
         """Create a new architype."""
         for i in on_entry + on_exit:
             i.resolve(cls)
-        if not issubclass(cls, arch_base):
+        if not hasattr(cls, "_jac_entry_funcs_") or not hasattr(
+            cls, "_jac_exit_funcs_"
+        ):
             # Saving the module path and reassign it after creating cls
             # So the jac modules are part of the correct module
             cur_module = cls.__module__
@@ -179,12 +121,20 @@ class JacFeatureDefaults:
             cls._jac_entry_funcs_ = on_entry  # type: ignore
             cls._jac_exit_funcs_ = on_exit  # type: ignore
         else:
-            cls._jac_entry_funcs_ = cls._jac_entry_funcs_ + [
-                x for x in on_entry if x not in cls._jac_entry_funcs_
-            ]
-            cls._jac_exit_funcs_ = cls._jac_exit_funcs_ + [
-                x for x in on_exit if x not in cls._jac_exit_funcs_
-            ]
+            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)
@@ -268,7 +218,7 @@ class JacFeatureDefaults:
         cachable: bool,
         mdl_alias: Optional[str],
         override_name: Optional[str],
-        mod_bundle: Optional[Module],
+        mod_bundle: Optional[Module | str],
         lng: Optional[str],
         items: Optional[dict[str, Union[str, bool]]],
     ) -> Optional[types.ModuleType]:
@@ -387,7 +337,13 @@ class JacFeatureDefaults:
     @hookimpl
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's ignore stmt feature."""
         return walker._jac_.ignore_node(expr)
@@ -396,7 +352,13 @@ class JacFeatureDefaults:
     @hookimpl
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's visit stmt feature."""
         if isinstance(walker, WalkerArchitype):
@@ -533,14 +495,14 @@ class JacFeatureDefaults:
     @hookimpl
     def build_edge(
         is_undirected: bool,
-        conn_type: Optional[Type[EdgeArchitype]],
+        conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[], EdgeArchitype]:
         """Jac's root getter."""
         conn_type = conn_type if conn_type else GenericEdge
 
         def builder() -> EdgeArchitype:
-            edge = conn_type()
+            edge = conn_type() if isinstance(conn_type, type) else conn_type
             edge._jac_.is_undirected = is_undirected
             if conn_assign:
                 for fld, val in zip(conn_assign[0], conn_assign[1]):
@@ -698,16 +660,10 @@ class JacFeatureDefaults:
         incl_info = [x for x in incl_info if not isinstance(x[1], type)]
         information, collected_types = get_info_types(_scope, mod_registry, incl_info)
         type_collector.extend(collected_types)
-        inputs_information_list = []
-        for i in inputs:
-            typ_anno = get_type_annotation(i[3])
-            type_collector.extend(extract_non_primary_type(typ_anno))
-            inputs_information_list.append(
-                f"{i[0]} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}"
-            )
-        inputs_information = "\n".join(inputs_information_list)
 
-        output_information = f"{outputs[0]} ({outputs[1]})"
+        inputs_information = get_input_information(inputs, type_collector)
+
+        output_information = f"{outputs[0]} ({outputs[1]})".strip()
         type_collector.extend(extract_non_primary_type(outputs[1]))
         output_type_explanations = "\n".join(
             list(

jaclang/plugin/feature.py

@@ -3,22 +3,20 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, TYPE_CHECKING, Type, Union
+from typing import Any, Callable, Optional, Type, TypeAlias, Union
 
 from jaclang.compiler.absyntree import Module
+from jaclang.core.constructs import (
+    Architype,
+    EdgeArchitype,
+    Memory,
+    NodeArchitype,
+    Root,
+    WalkerArchitype,
+)
+from jaclang.plugin.default import ExecutionContext
 from jaclang.plugin.spec import JacBuiltin, JacCmdSpec, JacFeatureSpec, T
 
-if TYPE_CHECKING:
-    from jaclang.core.construct import (
-        Architype,
-        EdgeArchitype,
-        NodeArchitype,
-        WalkerArchitype,
-        Root,
-    )
-    from jaclang.plugin.default import ExecutionContext
-    from jaclang.core.memory import Memory
-
 
 import pluggy
 
@@ -33,7 +31,13 @@ class JacFeature:
 
     import abc
     from jaclang.compiler.constant import EdgeDir
-    from jaclang.plugin.spec import DSFunc
+    from jaclang.core.constructs import DSFunc
+
+    RootType: TypeAlias = Root
+    Obj: TypeAlias = Architype
+    Node: TypeAlias = NodeArchitype
+    Edge: TypeAlias = EdgeArchitype
+    Walker: TypeAlias = WalkerArchitype
 
     @staticmethod
     def context(session: str = "") -> ExecutionContext:
@@ -98,7 +102,7 @@ class JacFeature:
         cachable: bool = True,
         mdl_alias: Optional[str] = None,
         override_name: Optional[str] = None,
-        mod_bundle: Optional[Module] = None,
+        mod_bundle: Optional[Module | str] = None,
         lng: Optional[str] = "jac",
         items: Optional[dict[str, Union[str, bool]]] = None,
     ) -> Optional[types.ModuleType]:
@@ -162,7 +166,13 @@ class JacFeature:
     @staticmethod
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        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)
@@ -170,7 +180,13 @@ class JacFeature:
     @staticmethod
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        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)
@@ -247,7 +263,7 @@ class JacFeature:
     @staticmethod
     def build_edge(
         is_undirected: bool,
-        conn_type: Optional[Type[EdgeArchitype]],
+        conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[], EdgeArchitype]:
         """Jac's root getter."""

jaclang/plugin/spec.py

@@ -3,19 +3,19 @@
 from __future__ import annotations
 
 import types
-from dataclasses import dataclass
 from typing import Any, Callable, Optional, TYPE_CHECKING, Type, TypeVar, Union
 
 from jaclang.compiler.absyntree import Module
 
 if TYPE_CHECKING:
-    from jaclang.core.construct import EdgeArchitype, NodeArchitype
+    from jaclang.core.constructs import EdgeArchitype, NodeArchitype
     from jaclang.plugin.default import (
         Architype,
         EdgeDir,
         ExecutionContext,
         WalkerArchitype,
         Root,
+        DSFunc,
     )
     from jaclang.core.memory import Memory
 
@@ -26,20 +26,6 @@ hookspec = pluggy.HookspecMarker("jac")
 T = TypeVar("T")
 
 
-# TODO: DSFunc should be moved into jaclang/core
-@dataclass(eq=False)
-class DSFunc:
-    """Data Spatial Function."""
-
-    name: str
-    trigger: type | types.UnionType | tuple[type | types.UnionType, ...] | None
-    func: Callable[[Any, Any], Any] | None = None
-
-    def resolve(self, cls: type) -> None:
-        """Resolve the function."""
-        self.func = getattr(cls, self.name)
-
-
 class JacFeatureSpec:
     """Jac Feature."""
 
@@ -113,7 +99,7 @@ class JacFeatureSpec:
         cachable: bool,
         mdl_alias: Optional[str],
         override_name: Optional[str],
-        mod_bundle: Optional[Module],
+        mod_bundle: Optional[Module | str],
         lng: Optional[str],
         items: Optional[dict[str, Union[str, bool]]],
     ) -> Optional[types.ModuleType]:
@@ -167,7 +153,13 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's ignore stmt feature."""
         raise NotImplementedError
@@ -176,7 +168,13 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:  # noqa: ANN401
         """Jac's visit stmt feature."""
         raise NotImplementedError
@@ -248,7 +246,7 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def build_edge(
         is_undirected: bool,
-        conn_type: Optional[Type[EdgeArchitype]],
+        conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[], EdgeArchitype]:
         """Jac's root getter."""