jaclang 0.7.17__py3-none-any.whl → 0.7.21__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,103 +281,6 @@ def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind:
     )
 
 
-def get_mod_path(
-    mod_path: ast.ModulePath, name_node: ast.Name
-) -> str | None:  # TODO: This should go away
-    """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.dot_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]:
@@ -421,119 +332,6 @@ def parse_symbol_path(text: str, dot_position: int) -> list[str]:
     return all_words
 
 
-def resolve_symbol_path(sym_name: str, node_tab: SymbolTable) -> str:
-    """Resolve symbol path."""
-    visited = set()
-    current_tab: Optional[SymbolTable] = node_tab
-
-    while current_tab is not None and current_tab not in visited:
-        visited.add(current_tab)
-        for name, symbol in current_tab.tab.items():
-            if name not in dir(builtins) and name == sym_name:
-                path = symbol.defn[0]._sym_type
-                if symbol.sym_type == SymbolType.ENUM_ARCH:
-                    if isinstance(current_tab.owner, ast.Module):
-                        return current_tab.owner.name + "." + sym_name
-                    elif isinstance(current_tab.owner, ast.AstSymbolNode):
-                        return current_tab.owner.name_spec._sym_type + "." + sym_name
-                return path
-        current_tab = current_tab.parent if current_tab.parent != current_tab else None
-    return ""
-
-
-def find_symbol_table(path: str, current_tab: Optional[SymbolTable]) -> SymbolTable:
-    """Find symbol table."""
-    path = path.lstrip(".")
-    current_table = current_tab
-    if current_table:
-        for segment in path.split("."):
-            current_table = next(
-                (
-                    child_table
-                    for child_table in current_table.kid
-                    if child_table.name == segment
-                ),
-                current_table,
-            )
-    if current_table:
-        return current_table
-    raise ValueError(f"Symbol table not found for path {path}")
-
-
-def resolve_completion_symbol_table(
-    mod_tab: SymbolTable,
-    current_symbol_path: list[str],
-    current_tab: Optional[SymbolTable],
-) -> list[lspt.CompletionItem]:
-    """Resolve symbol table for completion items."""
-    current_symbol_table = mod_tab
-    for obj in current_symbol_path:
-        if obj == "self":
-            try:
-                try:
-                    is_abilitydef = (
-                        mod_tab.owner
-                        if isinstance(mod_tab.owner, ast.AbilityDef)
-                        else mod_tab.owner.parent_of_type(ast.AbilityDef)
-                    )
-                    archi_owner = (
-                        (is_abilitydef.decl_link.parent_of_type(ast.Architype))
-                        if is_abilitydef.decl_link
-                        else None
-                    )
-                    current_symbol_table = (
-                        archi_owner._sym_tab
-                        if archi_owner and archi_owner._sym_tab
-                        else mod_tab
-                    )
-                    continue
-
-                except ValueError:
-                    pass
-                archi_owner = mod_tab.owner.parent_of_type(ast.Architype)
-                current_symbol_table = (
-                    archi_owner._sym_tab
-                    if archi_owner and archi_owner._sym_tab
-                    else mod_tab
-                )
-            except ValueError:
-                pass
-        else:
-            path: str = resolve_symbol_path(obj, current_symbol_table)
-            if path:
-                current_symbol_table = find_symbol_table(path, current_tab)
-            else:
-                if (
-                    isinstance(current_symbol_table.owner, ast.Architype)
-                    and current_symbol_table.owner.base_classes
-                ):
-                    for base_name in current_symbol_table.owner.base_classes.items:
-                        if isinstance(base_name, ast.Name) and base_name.sym:
-                            path = base_name.sym.sym_dotted_name + "." + obj
-                            current_symbol_table = find_symbol_table(path, current_tab)
-    if (
-        isinstance(current_symbol_table.owner, ast.Architype)
-        and current_symbol_table.owner.base_classes
-    ):
-        base = []
-        for base_name in current_symbol_table.owner.base_classes.items:
-            if isinstance(base_name, ast.Name) and base_name.sym:
-                base.append(base_name.sym.sym_dotted_name)
-        for base_ in base:
-            completion_items = collect_all_symbols_in_scope(
-                find_symbol_table(base_, current_tab),
-                up_tree=False,
-            )
-    else:
-        completion_items = []
-    if isinstance(current_symbol_table.owner, (ast.Ability, ast.AbilityDef)):
-        return completion_items
-    completion_items.extend(
-        collect_all_symbols_in_scope(current_symbol_table, up_tree=False)
-    )
-    return completion_items
-
-
 def get_token_start(
     token_index: int | None, sem_tokens: list[int]
 ) -> tuple[int, int, int]:

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,13 +12,13 @@ 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
 from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
 from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
 from jaclang.runtimelib.constructs import (
-    Anchor,
     Architype,
     DSFunc,
     EdgeAnchor,
@@ -44,7 +44,6 @@ import pluggy
 hookimpl = pluggy.HookimplMarker("jac")
 
 __all__ = [
-    "Anchor",
     "EdgeAnchor",
     "GenericEdge",
     "hookimpl",
@@ -72,6 +71,21 @@ class JacFeatureDefaults:
         """Get current execution context."""
         return ExecutionContext.get()
 
+    @staticmethod
+    @hookimpl
+    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 object_ref(obj: Architype) -> str:
+        return obj.__jac__.id.hex
+
     @staticmethod
     @hookimpl
     def make_architype(
@@ -903,7 +917,7 @@ 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__.architype.__class__.__name__))} "];\n'
+                f' [label="{html.escape(str(edge.__jac__.architype))} "];\n'
             )
         for node_ in visited_nodes:
             color = (

jaclang/plugin/feature.py

@@ -46,6 +46,16 @@ class JacFeature:
         """Get current execution context."""
         return pm.hook.get_context()
 
+    @staticmethod
+    def get_object(id: str) -> Architype | None:
+        """Get object given id."""
+        return pm.hook.get_object(id=id)
+
+    @staticmethod
+    def object_ref(obj: Architype) -> str:
+        """Get object reference id."""
+        return pm.hook.object_ref(obj=obj)
+
     @staticmethod
     def make_architype(
         cls: type,

jaclang/plugin/spec.py

@@ -48,6 +48,18 @@ class JacFeatureSpec:
         """Get current execution context."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def get_object(id: str) -> Architype | None:
+        """Get object given id.."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def object_ref(obj: Architype) -> str:
+        """Get object given id.."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def make_architype(

jaclang/plugin/tests/test_jaseci.py

@@ -337,8 +337,8 @@ class TestJaseciPlugin(TestCase):
 
         # --------- NO UPDATE SHOULD HAPPEN -------- #
 
-        self.assertTrue(archs[0], "A(val=2)")
-        self.assertTrue(archs[1], "A(val=1)")
+        self.assertEqual(archs[0], "A(val=2)")
+        self.assertEqual(archs[1], "A(val=1)")
 
         self._output2buffer()
         cli.enter(
@@ -435,8 +435,8 @@ class TestJaseciPlugin(TestCase):
 
         # --------- UPDATE SHOULD HAPPEN -------- #
 
-        self.assertTrue(archs[0], "A(val=20)")
-        self.assertTrue(archs[1], "A(val=10)")
+        self.assertEqual(archs[0], "A(val=20)")
+        self.assertEqual(archs[1], "A(val=10)")
 
         self._output2buffer()
         cli.enter(
@@ -474,6 +474,25 @@ class TestJaseciPlugin(TestCase):
         )
         self.assertFalse(self.capturedOutput.getvalue().strip())
 
+        # --------- ROOTS RESET OWN NODE -------- #
+
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node",
+            args=[1],
+            session=session,
+            root=self.roots[0],
+            node=self.nodes[0],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node",
+            args=[2],
+            session=session,
+            root=self.roots[1],
+            node=self.nodes[1],
+        )
+
     def test_other_root_access(self) -> None:
         """Test filtering on node, then visit."""
         global session

jaclang/runtimelib/architype.py

@@ -526,6 +526,14 @@ class WalkerAnchor(Anchor):
         if walker := self.architype:
             self.path = []
             self.next = [node]
+            if self.next:
+                current_node = self.next[-1].architype
+                for i in walker._jac_entry_funcs_:
+                    if not i.trigger:
+                        if i.func:
+                            i.func(walker, current_node)
+                        else:
+                            raise ValueError(f"No function {i.name} to call.")
             while len(self.next):
                 if current_node := self.next.pop(0).architype:
                     for i in current_node._jac_entry_funcs_:
@@ -538,16 +546,20 @@ class WalkerAnchor(Anchor):
                             return walker
                     for i in walker._jac_entry_funcs_:
                         if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func:
+                            if i.func and i.trigger:
                                 i.func(walker, current_node)
+                            elif not i.trigger:
+                                continue
                             else:
                                 raise ValueError(f"No function {i.name} to call.")
                         if self.disengaged:
                             return walker
                     for i in walker._jac_exit_funcs_:
                         if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func:
+                            if i.func and i.trigger:
                                 i.func(walker, current_node)
+                            elif not i.trigger:
+                                continue
                             else:
                                 raise ValueError(f"No function {i.name} to call.")
                         if self.disengaged:
@@ -560,6 +572,12 @@ class WalkerAnchor(Anchor):
                                 raise ValueError(f"No function {i.name} to call.")
                         if self.disengaged:
                             return walker
+            for i in walker._jac_exit_funcs_:
+                if not i.trigger:
+                    if i.func:
+                        i.func(walker, current_node)
+                    else:
+                        raise ValueError(f"No function {i.name} to call.")
             self.ignores = []
             return walker
         raise Exception(f"Invalid Reference {self.id}")

jaclang/runtimelib/importer.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import importlib
+import importlib.util
 import os
 import sys
 import types
@@ -194,6 +195,8 @@ class PythonImporter(Importer):
             loaded_items: list = []
             if spec.target.startswith("."):
                 spec.target = spec.target.lstrip(".")
+                if len(spec.target.split(".")) > 1:
+                    spec.target = spec.target.split(".")[-1]
                 full_target = path.normpath(path.join(spec.caller_dir, spec.target))
                 imp_spec = importlib.util.spec_from_file_location(
                     spec.target, full_target + ".py"
@@ -339,6 +342,7 @@ class JacImporter(Importer):
                     spec.full_target,
                     caller_dir=spec.caller_dir,
                     cachable=spec.cachable,
+                    reload=reload if reload else False,
                 )
                 try:
                     if not codeobj:

jaclang/runtimelib/machine.py

@@ -6,12 +6,17 @@ import os
 import sys
 import types
 from contextvars import ContextVar
-from typing import Optional
+from typing import Optional, Union
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
 from jaclang.compiler.constant import Constants as Con
-from jaclang.runtimelib.architype import EdgeArchitype, NodeArchitype, WalkerArchitype
+from jaclang.runtimelib.architype import (
+    Architype,
+    EdgeArchitype,
+    NodeArchitype,
+    WalkerArchitype,
+)
 from jaclang.utils.log import logging
 
 
@@ -55,11 +60,12 @@ class JacMachine:
         full_target: str,
         caller_dir: str,
         cachable: bool = True,
+        reload: bool = False,
     ) -> Optional[types.CodeType]:
         """Retrieve bytecode from the attached JacProgram."""
         if self.jac_program:
             return self.jac_program.get_bytecode(
-                module_name, full_target, caller_dir, cachable
+                module_name, full_target, caller_dir, cachable, reload=reload
             )
         return None
 
@@ -105,6 +111,87 @@ class JacMachine:
             return nodes
         return []
 
+    def update_walker(
+        self, module_name: str, items: Optional[dict[str, Union[str, Optional[str]]]]
+    ) -> tuple[types.ModuleType, ...]:
+        """Reimport the module."""
+        from .importer import JacImporter, ImportPathSpec
+
+        if module_name in self.loaded_modules:
+            try:
+                old_module = self.loaded_modules[module_name]
+                importer = JacImporter(self)
+                spec = ImportPathSpec(
+                    target=module_name,
+                    base_path=self.base_path,
+                    absorb=False,
+                    cachable=True,
+                    mdl_alias=None,
+                    override_name=None,
+                    lng="jac",
+                    items=items,
+                )
+                import_result = importer.run_import(spec, reload=True)
+                ret_items = []
+                if items:
+                    for item_name in items:
+                        if hasattr(old_module, item_name):
+                            new_attr = getattr(import_result.ret_mod, item_name, None)
+                            if new_attr:
+                                ret_items.append(new_attr)
+                                setattr(
+                                    old_module,
+                                    item_name,
+                                    new_attr,
+                                )
+                return (old_module,) if not items else tuple(ret_items)
+            except Exception as e:
+                logger.error(f"Failed to update module {module_name}: {e}")
+        else:
+            logger.warning(f"Module {module_name} not found in loaded modules.")
+        return ()
+
+    def spawn_node(
+        self,
+        node_name: str,
+        attributes: Optional[dict] = None,
+        module_name: str = "__main__",
+    ) -> NodeArchitype:
+        """Spawn a node instance of the given node_name with attributes."""
+        node_class = self.get_architype(module_name, node_name)
+        if isinstance(node_class, type) and issubclass(node_class, NodeArchitype):
+            if attributes is None:
+                attributes = {}
+            node_instance = node_class(**attributes)
+            return node_instance
+        else:
+            raise ValueError(f"Node {node_name} not found.")
+
+    def spawn_walker(
+        self,
+        walker_name: str,
+        attributes: Optional[dict] = None,
+        module_name: str = "__main__",
+    ) -> WalkerArchitype:
+        """Spawn a walker instance of the given walker_name."""
+        walker_class = self.get_architype(module_name, walker_name)
+        if isinstance(walker_class, type) and issubclass(walker_class, WalkerArchitype):
+            if attributes is None:
+                attributes = {}
+            walker_instance = walker_class(**attributes)
+            return walker_instance
+        else:
+            raise ValueError(f"Walker {walker_name} not found.")
+
+    def get_architype(
+        self, module_name: str, architype_name: str
+    ) -> Optional[Architype]:
+        """Retrieve an architype class from a module."""
+        module = self.loaded_modules.get(module_name)
+        if module:
+            return getattr(module, architype_name, None)
+        return None
+
     @staticmethod
     def get(base_path: str = "") -> "JacMachine":
         """Get current jac machine."""
@@ -134,6 +221,7 @@ class JacProgram:
         full_target: str,
         caller_dir: str,
         cachable: bool = True,
+        reload: bool = False,
     ) -> Optional[types.CodeType]:
         """Get the bytecode for a specific module."""
         if self.mod_bundle and isinstance(self.mod_bundle, Module):
@@ -141,7 +229,7 @@ class JacProgram:
             return marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
         gen_dir = os.path.join(caller_dir, Con.JAC_GEN_DIR)
         pyc_file_path = os.path.join(gen_dir, module_name + ".jbc")
-        if cachable and os.path.exists(pyc_file_path):
+        if cachable and os.path.exists(pyc_file_path) and not reload:
             with open(pyc_file_path, "rb") as f:
                 return marshal.load(f)
 

jaclang/runtimelib/memory.py

@@ -18,7 +18,7 @@ class Memory(Generic[ID, TANCH]):
     """Generic Memory Handler."""
 
     __mem__: dict[ID, TANCH] = field(default_factory=dict)
-    __gc__: set[ID] = field(default_factory=set)
+    __gc__: set[TANCH] = field(default_factory=set)
 
     def close(self) -> None:
         """Close memory handler."""
@@ -62,8 +62,8 @@ class Memory(Generic[ID, TANCH]):
             ids = [ids]
 
         for id in ids:
-            self.__mem__.pop(id, None)
-            self.__gc__.add(id)
+            if anchor := self.__mem__.pop(id, None):
+                self.__gc__.add(anchor)
 
 
 @dataclass
@@ -84,9 +84,9 @@ class ShelfStorage(Memory[UUID, Anchor]):
 
             root = Jac.get_root().__jac__
 
-            for id in self.__gc__:
-                self.__shelf__.pop(str(id), None)
-                self.__mem__.pop(id, None)
+            for anchor in self.__gc__:
+                self.__shelf__.pop(str(anchor.id), None)
+                self.__mem__.pop(anchor.id, None)
 
             for d in self.__mem__.values():
                 if d.persistent and d.hash != hash(dumps(d)):
@@ -106,7 +106,7 @@ class ShelfStorage(Memory[UUID, Anchor]):
                         if root.has_write_access(d):
                             if hash(dumps(p_d.access)) != hash(dumps(d.access)):
                                 p_d.access = d.access
-                            if hash(dumps(d.architype)) != hash(dumps(d.architype)):
+                            if hash(dumps(p_d.architype)) != hash(dumps(d.architype)):
                                 p_d.architype = d.architype
 
                         self.__shelf__[_id] = p_d

jaclang/settings.py

@@ -17,6 +17,10 @@ class Settings:
     collect_py_dep_debug: bool = False
     print_py_raised_ast: bool = False
 
+    # Compiler configuration
+    disable_mtllm: bool = False
+    ignore_test_annex: bool = False
+
     # Formatter configuration
     max_line_length: int = 88
 

jaclang/tests/fixtures/bar.jac

@@ -31,4 +31,4 @@ walker bar_walk {
             disengage;
         }
     }
-}
+}