jaclang 0.6.0__py3-none-any.whl → 0.6.5__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/langserve/__init__.py

@@ -0,0 +1 @@
+"""Jac Language Server Protocol implementation."""

jaclang/langserve/server.py

@@ -0,0 +1,108 @@
+"""Jaclang Language Server."""
+
+from __future__ import annotations
+
+from jaclang.compiler.compile import jac_str_to_pass
+from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
+from jaclang.langserve.utils import debounce, log, log_error
+from jaclang.vendor.pygls.server import LanguageServer
+
+import lsprotocol.types as lspt
+
+server = LanguageServer("jac-lsp", "v0.1")
+
+
+@server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
+@debounce(0.3)
+async def did_change(
+    ls: LanguageServer, params: lspt.DidChangeTextDocumentParams
+) -> None:
+    """Check syntax on change."""
+    document = ls.workspace.get_document(params.text_document.uri)
+    try:
+        result = jac_str_to_pass(
+            jac_str=document.source,
+            file_path=document.path,
+            schedule=[],
+        )
+        if not result.errors_had and not result.warnings_had:
+            ls.publish_diagnostics(document.uri, [])
+        else:
+            ls.publish_diagnostics(
+                document.uri,
+                [
+                    lspt.Diagnostic(
+                        range=lspt.Range(
+                            start=lspt.Position(
+                                line=error.loc.first_line, character=error.loc.col_start
+                            ),
+                            end=lspt.Position(
+                                line=error.loc.last_line,
+                                character=error.loc.col_end,
+                            ),
+                        ),
+                        message=error.msg,
+                        severity=lspt.DiagnosticSeverity.Error,
+                    )
+                    for error in result.errors_had
+                ],
+            )
+    except Exception as e:
+        log_error(ls, f"Error during syntax check: {e}")
+        log(f"Error during syntax check: {e}")
+
+
+@server.feature(
+    lspt.TEXT_DOCUMENT_COMPLETION,
+    lspt.CompletionOptions(trigger_characters=[".", ":", ""]),
+)
+def completions(params: lspt.CompletionParams) -> lspt.CompletionList:
+    """Provide completions for the given completion request."""
+    items = []
+    document = server.workspace.get_text_document(params.text_document.uri)
+    current_line = document.lines[params.position.line].strip()
+    if current_line.endswith("hello."):
+
+        items = [
+            lspt.CompletionItem(label="world"),
+            lspt.CompletionItem(label="friend"),
+        ]
+    return lspt.CompletionList(is_incomplete=False, items=items)
+
+
+@server.feature(lspt.TEXT_DOCUMENT_FORMATTING)
+def formatting(
+    ls: LanguageServer, params: lspt.DocumentFormattingParams
+) -> list[lspt.TextEdit]:
+    """Format the given document."""
+    try:
+        document = ls.workspace.get_document(params.text_document.uri)
+        formatted_text = jac_str_to_pass(
+            jac_str=document.source,
+            file_path=document.path,
+            target=JacFormatPass,
+            schedule=[FuseCommentsPass, JacFormatPass],
+        ).ir.gen.jac
+    except Exception as e:
+        log_error(ls, f"Error during formatting: {e}")
+        formatted_text = document.source
+    return [
+        lspt.TextEdit(
+            range=lspt.Range(
+                start=lspt.Position(line=0, character=0),
+                end=lspt.Position(
+                    line=len(formatted_text.splitlines()) + 1, character=0
+                ),
+            ),
+            new_text=formatted_text,
+        )
+    ]
+
+
+def run_lang_server() -> None:
+    """Run the language server."""
+    server.start_io()
+
+
+if __name__ == "__main__":
+    run_lang_server()

jaclang/langserve/tests/__init__.py

@@ -0,0 +1 @@
+"""Langserve Tests."""