jaclang 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/core/construct.py

@@ -2,15 +2,15 @@
 
 from __future__ import annotations
 
-# import shelve
-import types
 import unittest
 from dataclasses import dataclass, field
-from typing import Any, Callable, Optional, Union
-
+from typing import Callable, Optional
+from uuid import UUID, uuid4
 
 from jaclang.compiler.constant import EdgeDir
 from jaclang.core.utils import collect_node_connections
+from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.plugin.spec import DSFunc
 
 
 @dataclass(eq=False)
@@ -18,6 +18,7 @@ class ElementAnchor:
     """Element Anchor."""
 
     obj: Architype
+    id: UUID = field(default_factory=uuid4)
 
 
 @dataclass(eq=False)
@@ -35,6 +36,37 @@ class NodeAnchor(ObjectAnchor):
 
     obj: NodeArchitype
     edges: list[EdgeArchitype] = field(default_factory=lambda: [])
+    edge_ids: list[UUID] = field(default_factory=lambda: [])
+    persistent: bool = False
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        state = self.__dict__.copy()
+        state.pop("obj")
+        if self.edges and "edges" in state:
+            edges = state.pop("edges")
+            state["edge_ids"] = [e._jac_.id for e in edges]
+
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Override setstate for pickle and shelve."""
+        self.__dict__.update(state)
+        if "edge_ids" in state:
+            self.edge_ids = state.pop("edge_ids")
+
+    def populate_edges(self) -> None:
+        """Populate edges from edge ids."""
+        if len(self.edges) == 0 and len(self.edge_ids) > 0:
+            for e_id in self.edge_ids:
+                edge = Jac.context().get_obj(e_id)
+                if edge is None:
+                    raise ValueError(f"Edge with id {e_id} not found.")
+                elif not isinstance(edge, EdgeArchitype):
+                    raise ValueError(f"Object with id {e_id} is not an edge.")
+                else:
+                    self.edges.append(edge)
+            self.edge_ids.clear()
 
     def connect_node(self, nd: NodeArchitype, edg: EdgeArchitype) -> NodeArchitype:
         """Connect a node with given edge."""
@@ -48,6 +80,8 @@ class NodeAnchor(ObjectAnchor):
         target_obj: Optional[list[NodeArchitype]],
     ) -> list[EdgeArchitype]:
         """Get edges connected to this node."""
+        self.populate_edges()
+
         edge_list: list[EdgeArchitype] = [*self.edges]
         ret_edges: list[EdgeArchitype] = []
         edge_list = filter_func(edge_list) if filter_func else edge_list
@@ -76,6 +110,9 @@ class NodeAnchor(ObjectAnchor):
         target_obj: Optional[list[NodeArchitype]],
     ) -> list[NodeArchitype]:
         """Get set of nodes connected to this node."""
+        self.populate_edges()
+        for edge in self.edges:
+            edge.populate_nodes()
         edge_list: list[EdgeArchitype] = [*self.edges]
         node_list: list[NodeArchitype] = []
         edge_list = filter_func(edge_list) if filter_func else edge_list
@@ -126,7 +163,29 @@ class EdgeAnchor(ObjectAnchor):
     obj: EdgeArchitype
     source: Optional[NodeArchitype] = None
     target: Optional[NodeArchitype] = None
+    source_id: Optional[UUID] = None
+    target_id: Optional[UUID] = None
     is_undirected: bool = False
+    persistent: bool = False
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        state = self.__dict__.copy()
+        state.pop("obj")
+
+        if self.source:
+            state["source_id"] = self.source._jac_.id
+            state.pop("source")
+
+        if self.target:
+            state["target_id"] = self.target._jac_.id
+            state.pop("target")
+
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Override setstate for pickle and shelve."""
+        self.__dict__.update(state)
 
     def attach(
         self, src: NodeArchitype, trg: NodeArchitype, is_undirected: bool = False
@@ -268,26 +327,113 @@ class Architype:
         """Create default architype."""
         self._jac_: ObjectAnchor = ObjectAnchor(obj=self)
 
+    def __hash__(self) -> int:
+        """Override hash for architype."""
+        return hash(self._jac_.id)
+
+    def __eq__(self, other: object) -> bool:
+        """Override equality for architype."""
+        if not isinstance(other, Architype):
+            return False
+        else:
+            return self._jac_.id == other._jac_.id
+
+    def __repr__(self) -> str:
+        """Override repr for architype."""
+        return f"{self.__class__.__name__}"
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        raise NotImplementedError
+
 
 class NodeArchitype(Architype):
     """Node Architype Protocol."""
 
+    _jac_: NodeAnchor
+
     def __init__(self) -> None:
         """Create node architype."""
         self._jac_: NodeAnchor = NodeAnchor(obj=self)
+        Jac.context().save_obj(self, persistent=self._jac_.persistent)
+
+    def save(self) -> None:
+        """Save the node to the memory/storage hierarchy."""
+        self._jac_.persistent = True
+        Jac.context().save_obj(self, persistent=True)
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        state = self.__dict__.copy()
+        state["_jac_"] = self._jac_.__getstate__()
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Override setstate for pickle and shelve."""
+        self.__dict__.update(state)
+        self._jac_ = NodeAnchor(obj=self)
+        self._jac_.__setstate__(state["_jac_"])
 
 
 class EdgeArchitype(Architype):
     """Edge Architype Protocol."""
 
+    _jac_: EdgeAnchor
+    persistent: bool = False
+
     def __init__(self) -> None:
         """Create edge architype."""
         self._jac_: EdgeAnchor = EdgeAnchor(obj=self)
+        Jac.context().save_obj(self, persistent=self.persistent)
+
+    def save(self) -> None:
+        """Save the edge to the memory/storage hierarchy."""
+        self.persistent = True
+        Jac.context().save_obj(self, persistent=True)
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        state = self.__dict__.copy()
+        state["_jac_"] = self._jac_.__getstate__()
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Override setstate for pickle and shelve."""
+        self.__dict__.update(state)
+        self._jac_ = EdgeAnchor(obj=self)
+        self._jac_.__setstate__(state["_jac_"])
+
+    def populate_nodes(self) -> None:
+        """Populate nodes for the edges from node ids."""
+        if self._jac_.source_id:
+            obj = Jac.context().get_obj(self._jac_.source_id)
+            if obj is None:
+                raise ValueError(f"Node with id {self._jac_.source_id} not found.")
+            elif not isinstance(obj, NodeArchitype):
+                raise ValueError(
+                    f"Object with id {self._jac_.source_id} is not a node."
+                )
+            else:
+                self._jac_.source = obj
+                self._jac_.source_id = None
+        if self._jac_.target_id:
+            obj = Jac.context().get_obj(self._jac_.target_id)
+            if obj is None:
+                raise ValueError(f"Node with id {self._jac_.target_id} not found.")
+            elif not isinstance(obj, NodeArchitype):
+                raise ValueError(
+                    f"Object with id {self._jac_.target_id} is not a node."
+                )
+            else:
+                self._jac_.target = obj
+                self._jac_.target_id = None
 
 
 class WalkerArchitype(Architype):
     """Walker Architype Protocol."""
 
+    _jac_: WalkerAnchor
+
     def __init__(self) -> None:
         """Create walker architype."""
         self._jac_: WalkerAnchor = WalkerAnchor(obj=self)
@@ -301,6 +447,12 @@ class Root(NodeArchitype):
     reachable_nodes: list[NodeArchitype] = []
     connections: set[tuple[NodeArchitype, NodeArchitype, EdgeArchitype]] = set()
 
+    def __init__(self) -> None:
+        """Create root node."""
+        super().__init__()
+        self._jac_.id = UUID(int=0)
+        self._jac_.persistent = True
+
     def reset(self) -> None:
         """Reset the root."""
         self.reachable_nodes = []
@@ -315,19 +467,6 @@ class GenericEdge(EdgeArchitype):
     _jac_exit_funcs_ = []
 
 
-@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 JacTestResult(unittest.TextTestResult):
     """Jac test result class."""
 
@@ -407,9 +546,6 @@ class JacTestCheck:
         """Create a new test."""
         JacTestCheck.test_suite.addTest(unittest.FunctionTestCase(test_fun))
 
-    def __getattr__(self, name: str) -> Union[bool, Any]:
+    def __getattr__(self, name: str) -> object:
         """Make convenient check.Equal(...) etc."""
         return getattr(JacTestCheck.test_case, name)
-
-
-root = Root()

jaclang/core/importer.py

@@ -32,9 +32,13 @@ def jac_importer(
     module_name = path.splitext(file_name)[0]
     package_path = dir_path.replace(path.sep, ".")
 
-    if package_path and f"{package_path}.{module_name}" in sys.modules:
+    if (
+        not override_name
+        and package_path
+        and f"{package_path}.{module_name}" in sys.modules
+    ):
         return sys.modules[f"{package_path}.{module_name}"]
-    elif not package_path and module_name in sys.modules:
+    elif not override_name and not package_path and module_name in sys.modules:
         return sys.modules[module_name]
 
     caller_dir = get_caller_dir(target, base_path, dir_path)

jaclang/core/memory.py

@@ -0,0 +1,48 @@
+"""Memory abstraction for jaseci plugin."""
+
+from uuid import UUID
+
+from jaclang.core.construct import Architype
+
+
+class Memory:
+    """Memory module interface."""
+
+    mem: dict[UUID, Architype] = {}
+    save_obj_list: dict[UUID, Architype] = {}
+
+    def __init__(self) -> None:
+        """init."""
+        pass
+
+    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 has_obj(self, obj_id: UUID) -> bool:
+        """Check if the object exists."""
+        return self.has_obj_in_store(obj_id)
+
+    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 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 commit(self) -> None:
+        """Commit changes to persistent storage, if applicable."""
+        pass
+
+    def close(self) -> None:
+        """Close any connection, if applicable."""
+        self.mem.clear()

jaclang/core/shelve_storage.py

@@ -0,0 +1,55 @@
+"""Shelve storage for persistence storage of jaclang runtime object."""
+
+import shelve
+from uuid import UUID
+
+from jaclang.core.construct import Architype
+from jaclang.core.memory import Memory
+
+
+class ShelveStorage(Memory):
+    """Shelve storage for jaclang runtime object."""
+
+    storage: shelve.Shelf | None = None
+
+    def __init__(self, session: str = "") -> None:
+        """Init shelve storage."""
+        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)
+
+    def close(self) -> None:
+        """Close the storage."""
+        super().close()
+        self.commit()
+        if self.storage:
+            self.storage.close()
+        self.storage = None

jaclang/plugin/__init__.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from .default import hookimpl
-from .spec import Architype, DSFunc
+from .default import Architype, DSFunc, hookimpl
 
 __all__ = ["Architype", "DSFunc", "hookimpl"]

jaclang/plugin/builtin.py

@@ -20,9 +20,9 @@ def dotgen(
     dot_file: Optional[str] = None,
 ) -> str:
     """Print the dot graph."""
-    from jaclang.core.construct import root
     from jaclang.plugin.feature import pm
 
+    root = pm.hook.get_root()
     node = node if node is not None else root
     depth = depth if depth is not None else -1
     traverse = traverse if traverse is not None else False

jaclang/plugin/default.py

@@ -7,9 +7,11 @@ import html
 import os
 import pickle
 import types
+from contextvars import ContextVar
 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
@@ -34,10 +36,11 @@ from jaclang.core.construct import (
     Root,
     WalkerAnchor,
     WalkerArchitype,
-    root,
 )
 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
@@ -55,11 +58,10 @@ __all__ = [
     "WalkerAnchor",
     "NodeArchitype",
     "EdgeArchitype",
+    "Root",
     "WalkerArchitype",
     "Architype",
     "DSFunc",
-    "root",
-    "Root",
     "jac_importer",
     "T",
 ]
@@ -68,11 +70,95 @@ __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."""
 
     pm = pluggy.PluginManager("jac")
 
+    @staticmethod
+    @hookimpl
+    def context(session: str = "") -> ExecutionContext:
+        """Get the execution context."""
+        ctx = ExecContext.get()
+        if ctx is None:
+            ctx = ExecutionContext()
+            ExecContext.set(ctx)
+        return ctx
+
+    @staticmethod
+    @hookimpl
+    def reset_context() -> None:
+        """Reset the execution context."""
+        ctx = ExecContext.get()
+        if ctx:
+            ctx.reset()
+        ExecContext.set(None)
+
+    @staticmethod
+    @hookimpl
+    def memory_hook() -> Memory | None:
+        """Return the memory hook."""
+        return Jac.context().mem
+
     @staticmethod
     @hookimpl
     def make_architype(
@@ -377,6 +463,12 @@ class JacFeatureDefaults:
                 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()
+
         return right if not edges_only else edges
 
     @staticmethod
@@ -429,7 +521,7 @@ class JacFeatureDefaults:
     @hookimpl
     def get_root() -> Root:
         """Jac's assign comprehension feature."""
-        return root
+        return Jac.context().get_root()
 
     @staticmethod
     @hookimpl
@@ -603,6 +695,7 @@ class JacFeatureDefaults:
         )
 
         type_collector: list = []
+        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 = []

jaclang/plugin/feature.py

@@ -3,18 +3,22 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, Type, Union
+from typing import Any, Callable, Optional, TYPE_CHECKING, Type, Union
 
 from jaclang.compiler.absyntree import Module
-from jaclang.core.construct import (
-    Architype,
-    EdgeArchitype,
-    NodeArchitype,
-    Root,
-    WalkerArchitype,
-)
 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
 
@@ -28,8 +32,23 @@ class JacFeature:
     """Jac Feature."""
 
     import abc
-    from jaclang.plugin.spec import DSFunc
     from jaclang.compiler.constant import EdgeDir
+    from jaclang.plugin.spec import DSFunc
+
+    @staticmethod
+    def context(session: str = "") -> ExecutionContext:
+        """Create execution context."""
+        return pm.hook.context(session=session)
+
+    @staticmethod
+    def reset_context() -> None:
+        """Reset execution context."""
+        return pm.hook.reset_context()
+
+    @staticmethod
+    def memory_hook() -> Memory | None:
+        """Create memory abstraction."""
+        return pm.hook.memory_hook()
 
     @staticmethod
     def make_architype(