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

jaclang/runtimelib/constructs.py

@@ -4,26 +4,24 @@ from __future__ import annotations
 
 
 from .architype import (
+    Anchor,
     Architype,
     DSFunc,
     EdgeAnchor,
     EdgeArchitype,
-    ElementAnchor,
     GenericEdge,
     NodeAnchor,
     NodeArchitype,
-    ObjectAnchor,
     Root,
     WalkerAnchor,
     WalkerArchitype,
 )
-from .context import ExecutionContext, exec_context
-from .memory import Memory, ShelveStorage
+from .context import ExecutionContext
+from .memory import Memory, ShelfStorage
 from .test import JacTestCheck, JacTestResult, JacTextTestRunner
 
 __all__ = [
-    "ElementAnchor",
-    "ObjectAnchor",
+    "Anchor",
     "NodeAnchor",
     "EdgeAnchor",
     "WalkerAnchor",
@@ -35,9 +33,8 @@ __all__ = [
     "Root",
     "DSFunc",
     "Memory",
-    "ShelveStorage",
+    "ShelfStorage",
     "ExecutionContext",
-    "exec_context",
     "JacTestResult",
     "JacTextTestRunner",
     "JacTestCheck",

jaclang/runtimelib/context.py

@@ -4,80 +4,100 @@ from __future__ import annotations
 
 import unittest
 from contextvars import ContextVar
-from typing import Callable, Optional
+from typing import Any, Callable, Optional, cast
 from uuid import UUID
 
-from .architype import Architype, Root
-from .machine import JacMachine, JacProgram
-from .memory import Memory, ShelveStorage
+from .architype import NodeAnchor, Root
+from .memory import Memory, ShelfStorage
 
 
-class ExecutionContext:
-    """Default Execution Context implementation."""
-
-    mem: Optional[Memory]
-    root: Optional[Root]
-
-    def __init__(self) -> None:
-        """Create execution context."""
-        super().__init__()
-        self.mem = ShelveStorage()
-        self.root = None
-        self.jac_machine = JacMachine()
-        jac_program = JacProgram(mod_bundle=None, bytecode=None)
-        self.jac_machine.attach_program(jac_program)
-
-    def init_memory(self, base_path: str = "", session: str = "") -> None:
-        """Initialize memory."""
-        if session:
-            self.mem = ShelveStorage(session)
-        else:
-            self.mem = Memory()
-        self.jac_machine = JacMachine(base_path)
-        jac_program = JacProgram(mod_bundle=None, bytecode=None)
-        self.jac_machine.attach_program(jac_program)
-
-    def get_root(self) -> Root:
-        """Get the root object."""
-        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
-
-
-exec_context: ContextVar[ExecutionContext | None] = ContextVar(
-    "ExecutionContext", default=None
+EXECUTION_CONTEXT = ContextVar[Optional["ExecutionContext"]]("ExecutionContext")
+
+SUPER_ROOT_UUID = UUID("00000000-0000-0000-0000-000000000000")
+SUPER_ROOT_ARCHITYPE = object.__new__(Root)
+SUPER_ROOT_ANCHOR = NodeAnchor(
+    id=SUPER_ROOT_UUID, architype=SUPER_ROOT_ARCHITYPE, persistent=False, edges=[]
 )
+SUPER_ROOT_ARCHITYPE.__jac__ = SUPER_ROOT_ANCHOR
+
+
+class ExecutionContext:
+    """Execution Context."""
+
+    mem: Memory
+    reports: list[Any]
+    system_root: NodeAnchor
+    root: NodeAnchor
+    entry_node: NodeAnchor
+
+    def init_anchor(
+        self,
+        anchor_id: str | None,
+        default: NodeAnchor,
+    ) -> NodeAnchor:
+        """Load initial anchors."""
+        if anchor_id:
+            if isinstance(anchor := self.mem.find_by_id(UUID(anchor_id)), NodeAnchor):
+                return anchor
+            raise ValueError(f"Invalid anchor id {anchor_id} !")
+        return default
+
+    def validate_access(self) -> bool:
+        """Validate access."""
+        return self.root.has_read_access(self.entry_node)
+
+    def set_entry_node(self, entry_node: str | None) -> None:
+        """Override entry."""
+        self.entry_node = self.init_anchor(entry_node, self.root)
+
+    def close(self) -> None:
+        """Close current ExecutionContext."""
+        self.mem.close()
+        EXECUTION_CONTEXT.set(None)
+
+    @staticmethod
+    def create(
+        session: Optional[str] = None,
+        root: Optional[str] = None,
+        auto_close: bool = True,
+    ) -> ExecutionContext:
+        """Create ExecutionContext."""
+        ctx = ExecutionContext()
+        ctx.mem = ShelfStorage(session)
+        ctx.reports = []
+
+        if not isinstance(
+            system_root := ctx.mem.find_by_id(SUPER_ROOT_UUID), NodeAnchor
+        ):
+            system_root = Root().__jac__
+            system_root.id = SUPER_ROOT_UUID
+            ctx.mem.set(system_root.id, system_root)
+
+        ctx.system_root = system_root
+
+        ctx.entry_node = ctx.root = ctx.init_anchor(root, ctx.system_root)
+
+        if auto_close and (old_ctx := EXECUTION_CONTEXT.get(None)):
+            old_ctx.close()
+
+        EXECUTION_CONTEXT.set(ctx)
+
+        return ctx
+
+    @staticmethod
+    def get() -> ExecutionContext:
+        """Get current ExecutionContext."""
+        if ctx := EXECUTION_CONTEXT.get(None):
+            return ctx
+        raise Exception("ExecutionContext is not yet available!")
+
+    @staticmethod
+    def get_root() -> Root:
+        """Get current root."""
+        if ctx := EXECUTION_CONTEXT.get(None):
+            return cast(Root, ctx.root.architype)
+
+        return SUPER_ROOT_ARCHITYPE
 
 
 class JacTestResult(unittest.TextTestResult):

jaclang/runtimelib/importer.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import importlib
+import importlib.util
 import os
 import sys
 import types
@@ -139,7 +140,7 @@ class ImportReturn:
                 else module.__name__
             )
             if isinstance(self.importer, JacImporter):
-                new_module = sys.modules.get(
+                new_module = self.importer.jac_machine.loaded_modules.get(
                     package_name,
                     self.importer.create_jac_py_module(
                         self.importer.get_sys_mod_name(jac_file_path),
@@ -177,8 +178,8 @@ class Importer:
 
     def update_sys(self, module: types.ModuleType, spec: ImportPathSpec) -> None:
         """Update sys.modules with the newly imported module."""
-        if spec.module_name not in sys.modules:
-            sys.modules[spec.module_name] = module
+        if spec.module_name not in self.jac_machine.loaded_modules:
+            self.jac_machine.load_module(spec.module_name, module)
 
 
 class PythonImporter(Importer):
@@ -280,8 +281,8 @@ class JacImporter(Importer):
         module.__path__ = [full_mod_path]
         module.__file__ = None
 
-        if module_name not in sys.modules:
-            sys.modules[module_name] = module
+        if module_name not in self.jac_machine.loaded_modules:
+            self.jac_machine.load_module(module_name, module)
         return module
 
     def create_jac_py_module(
@@ -299,7 +300,7 @@ class JacImporter(Importer):
             parts = package_path.split(".")
             for i in range(len(parts)):
                 package_name = ".".join(parts[: i + 1])
-                if package_name not in sys.modules:
+                if package_name not in self.jac_machine.loaded_modules:
                     full_mod_path = path.join(
                         base_path, package_name.replace(".", path.sep)
                     )
@@ -307,7 +308,7 @@ class JacImporter(Importer):
                         module_name=package_name,
                         full_mod_path=full_mod_path,
                     )
-        sys.modules[module_name] = module
+        self.jac_machine.load_module(module_name, module)
         return module
 
     def run_import(
@@ -322,7 +323,7 @@ class JacImporter(Importer):
         else:
             module_name = self.get_sys_mod_name(spec.full_target)
 
-        module = sys.modules.get(module_name)
+        module = self.jac_machine.loaded_modules.get(module_name)
 
         if not module or module.__name__ == "__main__" or reload:
             if os.path.isdir(spec.full_target):
@@ -340,14 +341,14 @@ class JacImporter(Importer):
                     caller_dir=spec.caller_dir,
                     cachable=spec.cachable,
                 )
-                if not codeobj:
-                    raise ImportError(f"No bytecode found for {spec.full_target}")
-                with sys_path_context(spec.caller_dir):
-                    try:
+                try:
+                    if not codeobj:
+                        raise ImportError(f"No bytecode found for {spec.full_target}")
+                    with sys_path_context(spec.caller_dir):
                         exec(codeobj, module.__dict__)
-                    except Exception as e:
-                        logger.error(dump_traceback(e))
-                        raise e
+                except Exception as e:
+                    logger.error(dump_traceback(e))
+                    raise e
         import_return = ImportReturn(module, unique_loaded_items, self)
         if spec.items:
             import_return.process_items(

jaclang/runtimelib/machine.py

@@ -1,25 +1,33 @@
 """Jac Machine module."""
 
+import inspect
 import marshal
 import os
+import sys
 import types
+from contextvars import ContextVar
 from typing import Optional
 
 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.utils.log import logging
 
+
 logger = logging.getLogger(__name__)
 
 
+JACMACHINE_CONTEXT = ContextVar["JacMachine | None"]("JacMachine")
+
+
 class JacMachine:
     """JacMachine to handle the VM-related functionalities and loaded programs."""
 
     def __init__(self, base_path: str = "") -> None:
         """Initialize the JacMachine object."""
-        # self.loaded_modules: Dict[str, types.ModuleType] = {}
-        if not len(base_path):
+        self.loaded_modules: dict[str, types.ModuleType] = {}
+        if not base_path:
             base_path = os.getcwd()
         self.base_path = base_path
         self.base_path_dir = (
@@ -29,6 +37,8 @@ class JacMachine:
         )
         self.jac_program: Optional[JacProgram] = None
 
+        JACMACHINE_CONTEXT.set(self)
+
     def attach_program(self, jac_program: "JacProgram") -> None:
         """Attach a JacProgram to the machine."""
         self.jac_program = jac_program
@@ -53,6 +63,60 @@ class JacMachine:
             )
         return None
 
+    def load_module(self, module_name: str, module: types.ModuleType) -> None:
+        """Load a module into the machine."""
+        self.loaded_modules[module_name] = module
+        sys.modules[module_name] = module
+
+    def list_modules(self) -> list[str]:
+        """List all loaded modules."""
+        return list(self.loaded_modules.keys())
+
+    def list_walkers(self, module_name: str) -> list[str]:
+        """List all walkers in a specific module."""
+        module = self.loaded_modules.get(module_name)
+        if module:
+            walkers = []
+            for name, obj in inspect.getmembers(module):
+                if isinstance(obj, type) and issubclass(obj, WalkerArchitype):
+                    walkers.append(name)
+            return walkers
+        return []
+
+    def list_nodes(self, module_name: str) -> list[str]:
+        """List all nodes in a specific module."""
+        module = self.loaded_modules.get(module_name)
+        if module:
+            nodes = []
+            for name, obj in inspect.getmembers(module):
+                if isinstance(obj, type) and issubclass(obj, NodeArchitype):
+                    nodes.append(name)
+            return nodes
+        return []
+
+    def list_edges(self, module_name: str) -> list[str]:
+        """List all edges in a specific module."""
+        module = self.loaded_modules.get(module_name)
+        if module:
+            nodes = []
+            for name, obj in inspect.getmembers(module):
+                if isinstance(obj, type) and issubclass(obj, EdgeArchitype):
+                    nodes.append(name)
+            return nodes
+        return []
+
+    @staticmethod
+    def get(base_path: str = "") -> "JacMachine":
+        """Get current jac machine."""
+        if (jac_machine := JACMACHINE_CONTEXT.get(None)) is None:
+            jac_machine = JacMachine(base_path)
+        return jac_machine
+
+    @staticmethod
+    def detach() -> None:
+        """Detach current jac machine."""
+        JACMACHINE_CONTEXT.set(None)
+
 
 class JacProgram:
     """Class to hold the mod_bundle and bytecode for Jac modules."""

jaclang/runtimelib/memory.py

@@ -2,98 +2,157 @@
 
 from __future__ import annotations
 
-import shelve
+from dataclasses import dataclass, field
+from pickle import dumps
+from shelve import Shelf, open
+from typing import Callable, Generator, Generic, Iterable, TypeVar
 from uuid import UUID
 
-from .architype import Architype
+from .architype import Anchor, NodeAnchor, Root, TANCH
 
+ID = TypeVar("ID")
 
-class Memory:
-    """Memory module interface."""
 
-    mem: dict[UUID, Architype] = {}
-    save_obj_list: dict[UUID, Architype] = {}
+@dataclass
+class Memory(Generic[ID, TANCH]):
+    """Generic Memory Handler."""
 
-    def __init__(self) -> None:
-        """init."""
-        pass
+    __mem__: dict[ID, TANCH] = field(default_factory=dict)
+    __gc__: set[TANCH] = field(default_factory=set)
 
-    def get_obj(self, obj_id: UUID) -> Architype | None:
-        """Get object from memory."""
-        return self.get_obj_from_store(obj_id)
-
-    def get_obj_from_store(self, obj_id: UUID) -> Architype | None:
-        """Get object from the underlying store."""
-        ret = self.mem.get(obj_id)
-        return ret
+    def close(self) -> None:
+        """Close memory handler."""
+        self.__mem__.clear()
+        self.__gc__.clear()
+
+    def find(
+        self,
+        ids: ID | Iterable[ID],
+        filter: Callable[[TANCH], TANCH] | None = None,
+    ) -> Generator[TANCH, None, None]:
+        """Find anchors from memory by ids with filter."""
+        if not isinstance(ids, Iterable):
+            ids = [ids]
+
+        return (
+            anchor
+            for id in ids
+            if (anchor := self.__mem__.get(id)) and (not filter or filter(anchor))
+        )
 
-    def has_obj(self, obj_id: UUID) -> bool:
-        """Check if the object exists."""
-        return self.has_obj_in_store(obj_id)
+    def find_one(
+        self,
+        ids: ID | Iterable[ID],
+        filter: Callable[[TANCH], TANCH] | None = None,
+    ) -> TANCH | None:
+        """Find one anchor from memory by ids with filter."""
+        return next(self.find(ids, filter), None)
 
-    def has_obj_in_store(self, obj_id: UUID) -> bool:
-        """Check if the object exists in the underlying store."""
-        return obj_id in self.mem
+    def find_by_id(self, id: ID) -> TANCH | None:
+        """Find one by id."""
+        return self.__mem__.get(id)
 
-    def save_obj(self, item: Architype, persistent: bool) -> None:
-        """Save object."""
-        self.mem[item._jac_.id] = item
-        if persistent:
-            # TODO: check if it needs to be saved, i.e. dirty or not
-            self.save_obj_list[item._jac_.id] = item
+    def set(self, id: ID, data: TANCH) -> None:
+        """Save anchor to memory."""
+        self.__mem__[id] = data
 
-    def commit(self) -> None:
-        """Commit changes to persistent storage, if applicable."""
-        pass
+    def remove(self, ids: ID | Iterable[ID]) -> None:
+        """Remove anchor/s from memory."""
+        if not isinstance(ids, Iterable):
+            ids = [ids]
 
-    def close(self) -> None:
-        """Close any connection, if applicable."""
-        self.mem.clear()
+        for id in ids:
+            if anchor := self.__mem__.pop(id, None):
+                self.__gc__.add(anchor)
 
 
-class ShelveStorage(Memory):
-    """Shelve storage for jaclang runtime object."""
+@dataclass
+class ShelfStorage(Memory[UUID, Anchor]):
+    """Shelf Handler."""
 
-    storage: shelve.Shelf | None = None
+    __shelf__: Shelf[Anchor] | None = None
 
-    def __init__(self, session: str = "") -> None:
-        """Init shelve storage."""
+    def __init__(self, session: str | None = None) -> None:
+        """Initialize memory handler."""
         super().__init__()
-        if session:
-            self.connect(session)
-
-    def get_obj_from_store(self, obj_id: UUID) -> Architype | None:
-        """Get object from the underlying store."""
-        obj = super().get_obj_from_store(obj_id)
-        if obj is None and self.storage:
-            obj = self.storage.get(str(obj_id))
-            if obj is not None:
-                self.mem[obj_id] = obj
-
-        return obj
-
-    def has_obj_in_store(self, obj_id: UUID | str) -> bool:
-        """Check if the object exists in the underlying store."""
-        return obj_id in self.mem or (
-            str(obj_id) in self.storage if self.storage else False
-        )
-
-    def commit(self) -> None:
-        """Commit changes to persistent storage."""
-        if self.storage is not None:
-            for obj_id, obj in self.save_obj_list.items():
-                self.storage[str(obj_id)] = obj
-        self.save_obj_list.clear()
-
-    def connect(self, session: str) -> None:
-        """Connect to storage."""
-        self.session = session
-        self.storage = shelve.open(session)
+        self.__shelf__ = open(session) if session else None  # noqa: SIM115
 
     def close(self) -> None:
-        """Close the storage."""
+        """Close memory handler."""
+        if isinstance(self.__shelf__, Shelf):
+            from jaclang.plugin.feature import JacFeature as Jac
+
+            root = Jac.get_root().__jac__
+
+            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)):
+                    _id = str(d.id)
+                    if p_d := self.__shelf__.get(_id):
+                        if (
+                            isinstance(p_d, NodeAnchor)
+                            and isinstance(d, NodeAnchor)
+                            and p_d.edges != d.edges
+                            and root.has_connect_access(d)
+                        ):
+                            if not d.edges:
+                                self.__shelf__.pop(_id, None)
+                                continue
+                            p_d.edges = d.edges
+
+                        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)):
+                                p_d.architype = d.architype
+
+                        self.__shelf__[_id] = p_d
+                    elif not (
+                        isinstance(d, NodeAnchor)
+                        and not isinstance(d.architype, Root)
+                        and not d.edges
+                    ):
+                        self.__shelf__[_id] = d
+
+            self.__shelf__.close()
         super().close()
-        self.commit()
-        if self.storage:
-            self.storage.close()
-        self.storage = None
+
+    def find(
+        self,
+        ids: UUID | Iterable[UUID],
+        filter: Callable[[Anchor], Anchor] | None = None,
+    ) -> Generator[Anchor, None, None]:
+        """Find anchors from datasource by ids with filter."""
+        if not isinstance(ids, Iterable):
+            ids = [ids]
+
+        if isinstance(self.__shelf__, Shelf):
+            for id in ids:
+                anchor = self.__mem__.get(id)
+
+                if (
+                    not anchor
+                    and id not in self.__gc__
+                    and (_anchor := self.__shelf__.get(str(id)))
+                ):
+                    self.__mem__[id] = anchor = _anchor
+                if anchor and (not filter or filter(anchor)):
+                    yield anchor
+        else:
+            yield from super().find(ids, filter)
+
+    def find_by_id(self, id: UUID) -> Anchor | None:
+        """Find one by id."""
+        data = super().find_by_id(id)
+
+        if (
+            not data
+            and isinstance(self.__shelf__, Shelf)
+            and (data := self.__shelf__.get(str(id)))
+        ):
+            self.__mem__[id] = data
+
+        return data

jaclang/runtimelib/utils.py

@@ -37,12 +37,16 @@ def collect_node_connections(
         visited_nodes.add(current_node)
         edges = current_node.edges
         for edge_ in edges:
-            target = edge_._jac_.target
+            target = edge_.target
             if target:
                 connections.add(
-                    (current_node.obj, target._jac_.obj, edge_.__class__.__name__)
+                    (
+                        current_node.architype,
+                        target.architype,
+                        edge_.__class__.__name__,
+                    )
                 )
-                collect_node_connections(target._jac_, visited_nodes, connections)
+                collect_node_connections(target, visited_nodes, connections)
 
 
 def traverse_graph(
@@ -61,17 +65,20 @@ def traverse_graph(
     edge_limit: int,
 ) -> None:
     """Traverse the graph using Breadth-First Search (BFS) or Depth-First Search (DFS)."""
-    for edge in node._jac_.edges:
-        is_self_loop = id(edge._jac_.source) == id(edge._jac_.target)
-        is_in_edge = edge._jac_.target == node
-        if (traverse and is_in_edge) or edge._jac_.obj.__class__.__name__ in edge_type:
+    for edge in node.__jac__.edges:
+        is_self_loop = id(edge.source) == id(edge.target)
+        is_in_edge = edge.target == node.__jac__
+        if (traverse and is_in_edge) or edge.architype.__class__.__name__ in edge_type:
             continue
         if is_self_loop:
             continue  # lets skip self loop for a while, need to handle it later
-        else:
-            other_nd = edge._jac_.target if not is_in_edge else edge._jac_.source
+        elif (other_nda := edge.target if not is_in_edge else edge.source) and (
+            other_nd := other_nda.architype
+        ):
             new_con = (
-                (node, other_nd, edge) if not is_in_edge else (other_nd, node, edge)
+                (node, other_nd, edge.architype)
+                if not is_in_edge
+                else (other_nd, node, edge.architype)
             )
             if node in node_depths and node_depths[node] is not None:
                 if other_nd in node_depths: