jaclang 0.7.16__py3-none-any.whl → 0.7.18__py3-none-any.whl

jaclang/langserve/utils.py

@@ -2,10 +2,7 @@
 
 import asyncio
 import builtins
-import importlib.util
-import os
 import re
-import sys
 from functools import wraps
 from typing import Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar
 
@@ -209,6 +206,17 @@ def create_range(loc: CodeLocInfo) -> lspt.Range:
     )
 
 
+def get_location_range(mod_item: ast.ModuleItem) -> tuple[int, int, int, int]:
+    """Get location range."""
+    if not mod_item.from_mod_path.sub_module:
+        raise ValueError("Module items should have module path. Not Possible.")
+    lookup = mod_item.from_mod_path.sub_module.sym_tab.lookup(mod_item.name.value)
+    if not lookup:
+        raise ValueError("Module items should have a symbol table entry. Not Possible.")
+    loc = lookup.decl.loc
+    return loc.first_line, loc.col_start, loc.last_line, loc.col_end
+
+
 def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind:
     """Map the symbol node to an lspt.SymbolKind."""
     return (
@@ -273,101 +281,6 @@ def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind:
     )
 
 
-def get_mod_path(mod_path: ast.ModulePath, name_node: ast.Name) -> str | None:
-    """Get path for a module import name."""
-    ret_target = None
-    if mod_path.parent and (
-        (
-            isinstance(mod_path.parent.parent, ast.Import)
-            and mod_path.parent.parent.is_py
-        )
-        or (
-            isinstance(mod_path.parent, ast.Import)
-            and mod_path.parent.from_loc
-            and mod_path.parent.is_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(mod_path.loc.mod_path))
-        spec = importlib.util.find_spec(temporary_path_str)
-        sys.path.remove(os.path.dirname(mod_path.loc.mod_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.is_jac
-        )
-        or (
-            isinstance(mod_path.parent, ast.Import)
-            and mod_path.parent.from_loc
-            and mod_path.parent.is_jac
-        )
-    ):
-        ret_target = mod_path.resolve_relative_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.is_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.is_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
-
-
 def collect_all_symbols_in_scope(
     sym_tab: SymbolTable, up_tree: bool = True
 ) -> list[lspt.CompletionItem]:
@@ -625,3 +538,20 @@ def get_line_of_code(line_number: int, lines: list[str]) -> Optional[tuple[str,
             else first_non_space
         )
     return None
+
+
+def add_unique_text_edit(
+    changes: dict[str, list[lspt.TextEdit]], key: str, new_edit: lspt.TextEdit
+) -> None:
+    """Add a new text edit to the changes dictionary if it is unique."""
+    if key not in changes:
+        changes[key] = [new_edit]
+    else:
+        for existing_edit in changes[key]:
+            if (
+                existing_edit.range.start == new_edit.range.start
+                and existing_edit.range.end == new_edit.range.end
+                and existing_edit.new_text == new_edit.new_text
+            ):
+                return
+        changes[key].append(new_edit)

jaclang/plugin/builtin.py

@@ -2,11 +2,10 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import Optional
 
-if TYPE_CHECKING:
-    from typing import Optional
-    from jaclang.runtimelib.constructs import NodeArchitype
+from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.runtimelib.constructs import Architype, NodeArchitype
 
 
 def dotgen(
@@ -40,3 +39,8 @@ def dotgen(
         node_limit=node_limit,
         dot_file=dot_file,
     )
+
+
+def jid(obj: Architype) -> str:
+    """Get the id of the object."""
+    return Jac.object_ref(obj)

jaclang/plugin/default.py

@@ -12,6 +12,7 @@ from collections import OrderedDict
 from dataclasses import field
 from functools import wraps
 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
@@ -25,16 +26,14 @@ from jaclang.runtimelib.constructs import (
     ExecutionContext,
     GenericEdge,
     JacTestCheck,
-    Memory,
     NodeAnchor,
     NodeArchitype,
-    ObjectAnchor,
     Root,
     WalkerAnchor,
     WalkerArchitype,
-    exec_context,
 )
 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
@@ -50,7 +49,6 @@ __all__ = [
     "hookimpl",
     "JacTestCheck",
     "NodeAnchor",
-    "ObjectAnchor",
     "WalkerAnchor",
     "NodeArchitype",
     "EdgeArchitype",
@@ -69,28 +67,24 @@ class JacFeatureDefaults:
 
     @staticmethod
     @hookimpl
-    def context(session: str = "") -> ExecutionContext:
-        """Get the execution context."""
-        ctx = exec_context.get()
-        if ctx is None:
-            ctx = ExecutionContext()
-            exec_context.set(ctx)
-        return ctx
+    def get_context() -> ExecutionContext:
+        """Get current execution context."""
+        return ExecutionContext.get()
 
     @staticmethod
     @hookimpl
-    def reset_context() -> None:
-        """Reset the execution context."""
-        ctx = exec_context.get()
-        if ctx:
-            ctx.reset()
-        exec_context.set(None)
+    def get_object(id: str) -> Architype | None:
+        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
 
     @staticmethod
     @hookimpl
-    def memory_hook() -> Memory | None:
-        """Return the memory hook."""
-        return Jac.context().mem
+    def object_ref(obj: Architype) -> str:
+        return obj.__jac__.id.hex
 
     @staticmethod
     @hookimpl
@@ -263,12 +257,18 @@ class JacFeatureDefaults:
             lng,
             items,
         )
+
+        jac_machine = JacMachine.get(base_path)
+        if not jac_machine.jac_program:
+            jac_machine.attach_program(JacProgram(mod_bundle=None, bytecode=None))
+
         if lng == "py":
-            import_result = PythonImporter(Jac.context().jac_machine).run_import(spec)
+            import_result = PythonImporter(JacMachine.get()).run_import(spec)
         else:
-            import_result = JacImporter(Jac.context().jac_machine).run_import(
+            import_result = JacImporter(JacMachine.get()).run_import(
                 spec, reload_module
             )
+
         return (
             (import_result.ret_mod,)
             if absorb or not items
@@ -366,9 +366,9 @@ class JacFeatureDefaults:
     def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
         """Jac's spawn operator feature."""
         if isinstance(op1, WalkerArchitype):
-            return op1._jac_.spawn_call(op2)
+            return op1.__jac__.spawn_call(op2.__jac__)
         elif isinstance(op2, WalkerArchitype):
-            return op2._jac_.spawn_call(op1)
+            return op2.__jac__.spawn_call(op1.__jac__)
         else:
             raise TypeError("Invalid walker object")
 
@@ -390,7 +390,12 @@ class JacFeatureDefaults:
         ),
     ) -> bool:
         """Jac's ignore stmt feature."""
-        return walker._jac_.ignore_node(expr)
+        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
@@ -406,7 +411,9 @@ class JacFeatureDefaults:
     ) -> bool:
         """Jac's visit stmt feature."""
         if isinstance(walker, WalkerArchitype):
-            return walker._jac_.visit_node(expr)
+            return walker.__jac__.visit_node(
+                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
+            )
         else:
             raise TypeError("Invalid walker object")
 
@@ -414,7 +421,7 @@ class JacFeatureDefaults:
     @hookimpl
     def disengage(walker: WalkerArchitype) -> bool:  # noqa: ANN401
         """Jac's disengage stmt feature."""
-        walker._jac_.disengage_now()
+        walker.__jac__.disengage_now()
         return True
 
     @staticmethod
@@ -437,7 +444,7 @@ class JacFeatureDefaults:
         if edges_only:
             connected_edges: list[EdgeArchitype] = []
             for node in node_obj:
-                connected_edges += node._jac_.get_edges(
+                connected_edges += node.__jac__.get_edges(
                     dir, filter_func, target_obj=targ_obj_set
                 )
             return list(set(connected_edges))
@@ -445,7 +452,9 @@ class JacFeatureDefaults:
             connected_nodes: list[NodeArchitype] = []
             for node in node_obj:
                 connected_nodes.extend(
-                    node._jac_.edges_to_nodes(dir, filter_func, target_obj=targ_obj_set)
+                    node.__jac__.edges_to_nodes(
+                        dir, filter_func, target_obj=targ_obj_set
+                    )
                 )
             return list(set(connected_nodes))
 
@@ -454,7 +463,7 @@ class JacFeatureDefaults:
     def connect(
         left: NodeArchitype | list[NodeArchitype],
         right: NodeArchitype | list[NodeArchitype],
-        edge_spec: Callable[[], EdgeArchitype],
+        edge_spec: Callable[[NodeAnchor, NodeAnchor], EdgeArchitype],
         edges_only: bool,
     ) -> list[NodeArchitype] | list[EdgeArchitype]:
         """Jac's connect operator feature.
@@ -464,17 +473,16 @@ class JacFeatureDefaults:
         left = [left] if isinstance(left, NodeArchitype) else left
         right = [right] if isinstance(right, NodeArchitype) else right
         edges = []
-        for i in left:
-            for j in right:
-                conn_edge = edge_spec()
-                edges.append(conn_edge)
-                i._jac_.connect_node(j, conn_edge)
 
-                if i._jac_.persistent or j._jac_.persistent:
-                    conn_edge.save()
-                    j.save()
-                    i.save()
+        root = Jac.get_root().__jac__
 
+        for i in left:
+            _left = i.__jac__
+            if root.has_connect_access(_left):
+                for j in right:
+                    _right = j.__jac__
+                    if root.has_connect_access(_right):
+                        edges.append(edge_spec(_left, _right))
         return right if not edges_only else edges
 
     @staticmethod
@@ -489,26 +497,36 @@ class JacFeatureDefaults:
         disconnect_occurred = False
         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:
-            for j in right:
-                edge_list: list[EdgeArchitype] = [*i._jac_.edges]
-                edge_list = filter_func(edge_list) if filter_func else edge_list
-                for e in edge_list:
-                    if e._jac_.target and e._jac_.source:
-                        if (
-                            dir in ["OUT", "ANY"]  # TODO: Not ideal
-                            and i._jac_.obj == e._jac_.source
-                            and e._jac_.target == j._jac_.obj
-                        ):
-                            e._jac_.detach(i._jac_.obj, e._jac_.target)
-                            disconnect_occurred = True
-                        if (
-                            dir in ["IN", "ANY"]
-                            and i._jac_.obj == e._jac_.target
-                            and e._jac_.source == j._jac_.obj
-                        ):
-                            e._jac_.detach(i._jac_.obj, e._jac_.source)
-                            disconnect_occurred = True
+            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 root.has_write_access(target)
+                    ):
+                        anchor.destroy() if anchor.persistent else anchor.detach()
+                        disconnect_occurred = True
+                    if (
+                        dir in [EdgeDir.IN, EdgeDir.ANY]
+                        and node == target
+                        and source.architype in right
+                        and root.has_write_access(source)
+                    ):
+                        anchor.destroy() if anchor.persistent else anchor.detach()
+                        disconnect_occurred = True
+
         return disconnect_occurred
 
     @staticmethod
@@ -527,7 +545,7 @@ class JacFeatureDefaults:
     @hookimpl
     def get_root() -> Root:
         """Jac's assign comprehension feature."""
-        return Jac.context().get_root()
+        return ExecutionContext.get_root()
 
     @staticmethod
     @hookimpl
@@ -541,19 +559,23 @@ class JacFeatureDefaults:
         is_undirected: bool,
         conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
-    ) -> Callable[[], EdgeArchitype]:
+    ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
         """Jac's root getter."""
         conn_type = conn_type if conn_type else GenericEdge
 
-        def builder() -> EdgeArchitype:
+        def builder(source: NodeAnchor, target: NodeAnchor) -> EdgeArchitype:
             edge = conn_type() if isinstance(conn_type, type) else conn_type
-            edge._jac_.is_undirected = is_undirected
+            edge.__attach__(source, target, is_undirected)
             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:
+                edge.__jac__.save()
+                target.save()
+                source.save()
             return edge
 
         return builder
@@ -895,14 +917,14 @@ class JacBuiltin:
         for source, target, edge in connections:
             dot_content += (
                 f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
-                f' [label="{html.escape(str(edge._jac_.obj.__class__.__name__))} "];\n'
+                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_.obj))}"'
+                f'{visited_nodes.index(node_)} [label="{html.escape(str(node_.__jac__.architype))}"'
                 f'fillcolor="{color}"];\n'
             )
         if dot_file:

jaclang/plugin/feature.py

@@ -8,16 +8,16 @@ from typing import Any, Callable, Mapping, Optional, Sequence, Type, TypeAlias,
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
-from jaclang.plugin.default import ExecutionContext
 from jaclang.plugin.spec import JacBuiltin, JacCmdSpec, JacFeatureSpec, P, T
 from jaclang.runtimelib.constructs import (
     Architype,
     EdgeArchitype,
-    Memory,
+    NodeAnchor,
     NodeArchitype,
     Root,
     WalkerArchitype,
 )
+from jaclang.runtimelib.context import ExecutionContext
 
 import pluggy
 
@@ -42,19 +42,19 @@ class JacFeature:
     Walker: TypeAlias = WalkerArchitype
 
     @staticmethod
-    def context(session: str = "") -> ExecutionContext:
-        """Create execution context."""
-        return pm.hook.context(session=session)
+    def get_context() -> ExecutionContext:
+        """Get current execution context."""
+        return pm.hook.get_context()
 
     @staticmethod
-    def reset_context() -> None:
-        """Reset execution context."""
-        return pm.hook.reset_context()
+    def get_object(id: str) -> Architype | None:
+        """Get object given id."""
+        return pm.hook.get_object(id=id)
 
     @staticmethod
-    def memory_hook() -> Memory | None:
-        """Create memory abstraction."""
-        return pm.hook.memory_hook()
+    def object_ref(obj: Architype) -> str:
+        """Get object reference id."""
+        return pm.hook.object_ref(obj=obj)
 
     @staticmethod
     def make_architype(
@@ -226,7 +226,7 @@ class JacFeature:
     def connect(
         left: NodeArchitype | list[NodeArchitype],
         right: NodeArchitype | list[NodeArchitype],
-        edge_spec: Callable[[], EdgeArchitype],
+        edge_spec: Callable[[NodeAnchor, NodeAnchor], EdgeArchitype],
         edges_only: bool = False,
     ) -> list[NodeArchitype] | list[EdgeArchitype]:
         """Jac's connect operator feature.
@@ -274,7 +274,7 @@ class JacFeature:
         is_undirected: bool,
         conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
-    ) -> Callable[[], EdgeArchitype]:
+    ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
         """Jac's root getter."""
         return pm.hook.build_edge(
             is_undirected=is_undirected, conn_type=conn_type, conn_assign=conn_assign

jaclang/plugin/spec.py

@@ -21,16 +21,15 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
 
 if TYPE_CHECKING:
-    from jaclang.runtimelib.constructs import EdgeArchitype, NodeArchitype
     from jaclang.plugin.default import (
         Architype,
         EdgeDir,
-        ExecutionContext,
         WalkerArchitype,
         Root,
         DSFunc,
     )
-    from jaclang.runtimelib.memory import Memory
+    from jaclang.runtimelib.constructs import EdgeArchitype, NodeAnchor, NodeArchitype
+    from jaclang.runtimelib.context import ExecutionContext
 
 import pluggy
 
@@ -45,20 +44,20 @@ class JacFeatureSpec:
 
     @staticmethod
     @hookspec(firstresult=True)
-    def context(session: str = "") -> ExecutionContext:
-        """Get the execution context."""
+    def get_context() -> ExecutionContext:
+        """Get current execution context."""
         raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
-    def reset_context() -> None:
-        """Reset the execution context."""
+    def get_object(id: str) -> Architype | None:
+        """Get object given id.."""
         raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
-    def memory_hook() -> Memory | None:
-        """Create memory abstraction."""
+    def object_ref(obj: Architype) -> str:
+        """Get object given id.."""
         raise NotImplementedError
 
     @staticmethod
@@ -224,7 +223,7 @@ class JacFeatureSpec:
     def connect(
         left: NodeArchitype | list[NodeArchitype],
         right: NodeArchitype | list[NodeArchitype],
-        edge_spec: Callable[[], EdgeArchitype],
+        edge_spec: Callable[[NodeAnchor, NodeAnchor], EdgeArchitype],
         edges_only: bool,
     ) -> list[NodeArchitype] | list[EdgeArchitype]:
         """Jac's connect operator feature.
@@ -270,7 +269,7 @@ class JacFeatureSpec:
         is_undirected: bool,
         conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
-    ) -> Callable[[], EdgeArchitype]:
+    ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
         """Jac's root getter."""
         raise NotImplementedError
 

jaclang/plugin/tests/fixtures/other_root_access.jac

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