jaclang 0.8.5__py3-none-any.whl → 0.8.7__py3-none-any.whl

jaclang/langserve/tests/server_test/test_lang_serve.py

@@ -16,7 +16,6 @@ from lsprotocol.types import (
 from jaclang.langserve.tests.server_test.utils import (
     create_temp_jac_file,
     get_code,
-    get_jac_file_path,
     get_simple_code,
     create_ls_with_workspace,  # new helper
 )
@@ -26,8 +25,6 @@ from jaclang import JacMachineInterface as _
 from jaclang.langserve.engine import JacLangServer
 from jaclang.langserve.server import did_open, did_save, did_change, formatting
 
-JAC_FILE = get_jac_file_path()
-
 
 class TestLangServe:
     """Test class for Jac language server features."""
@@ -190,7 +187,7 @@ class TestLangServe:
         await did_save(ls, params)
         sem_tokens = ls.get_semantic_tokens(uri)
         # semantic tokens should still be present even if there is a syntax error
-        assert len(sem_tokens.data) == 300
+        assert len(sem_tokens.data) == 340
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
         assert len(diagnostics) == 1
@@ -254,7 +251,7 @@ class TestLangServe:
         await did_change(ls, params)
         sem_tokens = ls.get_semantic_tokens(uri)
         # semantic tokens should still be present even if there is a syntax error
-        assert len(sem_tokens.data) == 300
+        assert len(sem_tokens.data) == 340
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
         assert len(diagnostics) == 1

jaclang/langserve/tests/test_dev_server.py

@@ -0,0 +1,80 @@
+from jaclang.utils.test import TestCase
+from jaclang.vendor.pygls import uris
+from jaclang.vendor.pygls.workspace import Workspace
+
+import lsprotocol.types as lspt
+from jaclang.langserve.engine import JacLangServer
+
+
+class TestJacLangServer(TestCase):
+
+    def test_type_annotation_assignment_server(self) -> None:
+        """Test that the server doesn't run if there is a syntax error."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+        circle_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/type_annotation_assignment.jac"
+            )
+        )
+        lsp.deep_check(circle_file)
+        self.assertIn(
+            "(public variable) should_fail1: int",
+            lsp.get_hover_info(circle_file, lspt.Position(1, 15)).contents.value,
+        )
+        self.assertIn(
+            "(public variable) should_pass2: str",
+            lsp.get_hover_info(circle_file, lspt.Position(2, 15)).contents.value,
+        )
+        self.assertIn(
+            "(public variable) should_fail2: str",
+            lsp.get_hover_info(circle_file, lspt.Position(3, 15)).contents.value,
+        )
+        diagnostics_list = list(lsp.diagnostics.values())[0]
+        self.assertEqual(len(diagnostics_list), 2)
+        self.assertIn(
+            "Cannot assign",
+            diagnostics_list[0].message,
+        )
+        self.assertEqual(
+            "1:5-1:30",
+            str(diagnostics_list[0].range),
+        )
+        self.assertEqual(
+            "3:5-3:27",
+            str(diagnostics_list[1].range),
+        )
+
+
+    def test_member_access_type_inferred_server(self) -> None:
+        """Test that the server doesn't run if there is a syntax error."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+        circle_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/member_access_type_inferred.jac"
+            )
+        )
+        lsp.deep_check(circle_file)
+        self.assertIn(
+            "(public variable) i: int",
+            lsp.get_hover_info(circle_file, lspt.Position(10, 2)).contents.value,
+        )
+        self.assertIn(
+            "(public variable) s: str",
+            lsp.get_hover_info(circle_file, lspt.Position(11, 2)).contents.value,
+        )
+        diagnostics_list = list(lsp.diagnostics.values())[0]
+        self.assertEqual(len(diagnostics_list), 1)
+        self.assertIn(
+            "Cannot assign",
+            diagnostics_list[0].message,
+        )
+        self.assertEqual(
+            "11:2-11:12",
+            str(diagnostics_list[0].range),
+        )

jaclang/langserve/tests/test_server.py

@@ -127,6 +127,9 @@ class TestJacLangServer(TestCase):
             str(lsp.get_definition(circle_file, lspt.Position(20, 16))),
         )
 
+    @pytest.mark.xfail(
+        reason="Incorrect handling of 'self' in DefUsePass.TODO: Fix chain_use_lookup."
+    )
     def test_go_to_definition_method(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -595,9 +598,13 @@ class TestJacLangServer(TestCase):
         workspace_path = self.fixture_abs_path("")
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
-        guess_game_file = uris.from_fs_path(self.fixture_abs_path('../../../compiler/passes/main/tests/fixtures/sym_binder.jac'))
+        guess_game_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../compiler/passes/main/tests/fixtures/sym_binder.jac"
+            )
+        )
         lsp.deep_check(guess_game_file)
         self.assertIn(
             "/tests/fixtures/M1.jac:0:0-0:0",
             str(lsp.get_definition(guess_game_file, lspt.Position(29, 9))),
-        )
+        )

jaclang/langserve/utils.jac

@@ -31,18 +31,18 @@ glob T = TypeVar('T', bound=Callable[(P, Coroutine[(Any, Any, Any)])]);
 """Return diagnostics."""
 def gen_diagnostics(
     from_path: str,
-    errors: <>list[Alert],
-    warnings: <>list[Alert]
-) -> <>list[lspt.Diagnostic] {
+    errors: list[Alert],
+    warnings: list[Alert]
+) -> list[lspt.Diagnostic] {
     return [ lspt.Diagnostic(
         range=create_range(error.loc),
         message=error.msg,
         severity=lspt.DiagnosticSeverity.Error
-    ) for error in errors if error.loc.mod_path == uris.to_fs_path(from_path) ] + [ lspt.Diagnostic(
+    ) for error in errors if error.loc.mod_path == from_path ] + [ lspt.Diagnostic(
         range=create_range(warning.loc),
         message=warning.msg,
         severity=lspt.DiagnosticSeverity.Warning
-    ) for warning in warnings if warning.loc.mod_path == uris.to_fs_path(from_path) ];
+    ) for warning in warnings if warning.loc.mod_path == from_path ];
 }
 
 
@@ -75,7 +75,7 @@ def debounce(<>wait: float) -> Callable[[T], Callable[(..., Awaitable[None])]] {
 
 
 """Iterate through symbol table."""
-def sym_tab_list(sym_tab: UniScopeNode, file_path: str) -> <>list[UniScopeNode] {
+def sym_tab_list(sym_tab: UniScopeNode, file_path: str) -> list[UniScopeNode] {
     sym_tabs = [sym_tab]
     if not (isinstance(sym_tab, uni.Module) and sym_tab.loc.mod_path != file_path )
     else []
@@ -135,7 +135,7 @@ def position_within_node(<>node: uni.UniNode, line: int, character: int) -> bool
 
 
 """Find index."""
-def find_index(sem_tokens: <>list[int], line: int, char: int) -> Optional[int] {
+def find_index(sem_tokens: list[int], line: int, char: int) -> Optional[int] {
     index = None;
     token_start_list = [ get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5) ];
     for (i, j) in enumerate(token_start_list) {
@@ -148,7 +148,7 @@ def find_index(sem_tokens: <>list[int], line: int, char: int) -> Optional[int] {
 
 
 """Recursively collect symbols from the AST."""
-def get_symbols_for_outline(<>node: UniScopeNode) -> <>list[lspt.DocumentSymbol] {
+def get_symbols_for_outline(<>node: UniScopeNode) -> list[lspt.DocumentSymbol] {
     symbols = [];
     for (key, item) in <>node.names_in_scope.items() {
         if key in dir(builtins)
@@ -234,34 +234,30 @@ def kind_map(sub_tab: uni.UniNode) -> lspt.SymbolKind {
 
 """Map the symbol node to an lspt.CompletionItemKind."""
 def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind {
-    return lspt.CompletionItemKind.Function
-    if sub_tab in [SymbolType.ABILITY, SymbolType.TEST]
-    else lspt.CompletionItemKind.Class
-    if sub_tab in [SymbolType.OBJECT_ARCH,
-    SymbolType.NODE_ARCH,
-    SymbolType.EDGE_ARCH,
-    SymbolType.WALKER_ARCH]
-    else lspt.CompletionItemKind.Module
-    if sub_tab == SymbolType.MODULE
-    else lspt.CompletionItemKind.Enum
-    if sub_tab == SymbolType.ENUM_ARCH
-    else lspt.CompletionItemKind.Field
-    if sub_tab == SymbolType.HAS_VAR
-    else lspt.CompletionItemKind.Method
-    if sub_tab == SymbolType.METHOD
-    else lspt.CompletionItemKind.EnumMember
-    if sub_tab == SymbolType.ENUM_MEMBER
-    else lspt.CompletionItemKind.Interface
-    if sub_tab == SymbolType.IMPL
-    else lspt.CompletionItemKind.Variable
-
-
-
-
-
-
-
-    ;
+    return (
+        lspt.CompletionItemKind.Function
+        if sub_tab in [SymbolType.ABILITY, SymbolType.TEST]
+        else lspt.CompletionItemKind.Class
+        if sub_tab in [
+            SymbolType.OBJECT_ARCH,
+            SymbolType.NODE_ARCH,
+            SymbolType.EDGE_ARCH,
+            SymbolType.WALKER_ARCH
+        ]
+        else lspt.CompletionItemKind.Module
+        if sub_tab == SymbolType.MODULE
+        else lspt.CompletionItemKind.Enum
+        if sub_tab == SymbolType.ENUM_ARCH
+        else lspt.CompletionItemKind.Field
+        if sub_tab == SymbolType.HAS_VAR
+        else lspt.CompletionItemKind.Method
+        if sub_tab == SymbolType.METHOD
+        else lspt.CompletionItemKind.EnumMember
+        if sub_tab == SymbolType.ENUM_MEMBER
+        else lspt.CompletionItemKind.Interface
+        if sub_tab == SymbolType.IMPL
+        else lspt.CompletionItemKind.Variable
+    );
 }
 
 
@@ -269,9 +265,9 @@ def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind {
 def collect_all_symbols_in_scope(
     sym_tab: UniScopeNode,
     up_tree: bool = True
-) -> <>list[lspt.CompletionItem] {
+) -> list[lspt.CompletionItem] {
     symbols = [];
-    visited = <>set();
+    visited = set();
     current_tab : Optional[UniScopeNode] = sym_tab;
     while current_tab is not None and current_tab not in visited  {
         visited.add(current_tab);
@@ -295,8 +291,8 @@ def collect_all_symbols_in_scope(
 
 
 """Return all child tab's as completion items."""
-def collect_child_tabs(sym_tab: UniScopeNode) -> <>list[lspt.CompletionItem] {
-    symbols : <>list[lspt.CompletionItem] = [];
+def collect_child_tabs(sym_tab: UniScopeNode) -> list[lspt.CompletionItem] {
+    symbols : list[lspt.CompletionItem] = [];
     for tab in sym_tab.kid_scope {
         if tab.scope_name not in [ i.label for i in symbols ] {
             symbols.append(
@@ -312,7 +308,7 @@ def collect_child_tabs(sym_tab: UniScopeNode) -> <>list[lspt.CompletionItem] {
 
 
 """Parse text and return a list of symbols."""
-def parse_symbol_path(text: str, dot_position: int) -> <>list[str] {
+def parse_symbol_path(text: str, dot_position: int) -> list[str] {
     text = text[ : dot_position ][ : -1 ].strip();
     valid_character_pattern = re.compile('[a-zA-Z0-9_]');
     reversed_text = text[ : : -1 ];
@@ -342,8 +338,8 @@ def parse_symbol_path(text: str, dot_position: int) -> <>list[str] {
 """Return the starting position of a token."""
 def get_token_start(
     token_index: (int | None),
-    sem_tokens: <>list[int]
-) -> <>tuple[int, int, int] {
+    sem_tokens: list[int]
+) -> tuple[int, int, int] {
     if token_index is None or token_index >= len(sem_tokens)  {
         return (0, 0, 0);
     }
@@ -382,8 +378,8 @@ def find_surrounding_tokens(
     change_start_char: int,
     change_end_line: int,
     change_end_char: int,
-    sem_tokens: <>list[int]
-) -> <>tuple[(int | None), (int | None), bool] {
+    sem_tokens: list[int]
+) -> tuple[(int | None), (int | None), bool] {
     prev_token_index = None;
     next_token_index = None;
     inside_tok = False;
@@ -422,8 +418,8 @@ def find_surrounding_tokens(
 """Get the line of code, and the first non-space character index."""
 def get_line_of_code(
     line_number: int,
-    lines: <>list[str]
-) -> Optional[<>tuple[(str, int)]] {
+    lines: list[str]
+) -> Optional[tuple[(str, int)]] {
     if 0 <= line_number < len(lines) {
         line = lines[line_number].rstrip('\n');
         first_non_space = (len(line) - len(line.lstrip()));
@@ -439,7 +435,7 @@ def get_line_of_code(
 
 """Add a new text edit to the changes dictionary if it is unique."""
 def add_unique_text_edit(
-    changes: <>dict[(str, <>list[lspt.TextEdit])],
+    changes: dict[(str, list[lspt.TextEdit])],
     key: str,
     new_edit: lspt.TextEdit
 ) -> None {

jaclang/runtimelib/builtin.py

@@ -7,8 +7,9 @@ from abc import abstractmethod
 from enum import Enum
 from typing import ClassVar, Optional, override
 
-from jaclang.runtimelib.constructs import Archetype, NodeArchetype, Root
+from jaclang.runtimelib.constructs import NodeArchetype
 from jaclang.runtimelib.machine import JacMachineInterface as Jac
+from jaclang.runtimelib.utils import collect_node_connections
 
 
 class AccessLevelEnum(Enum):
@@ -58,53 +59,39 @@ def printgraph(
     )
 
 
-def jid(obj: Archetype) -> str:
-    """Get the id of the object."""
-    return Jac.object_ref(obj)
-
-
-def jobj(id: str) -> Archetype | None:
-    """Get the object from the id."""
-    return Jac.get_object(id)
-
-
-def grant(obj: Archetype, level: AccessLevelEnum) -> None:
-    """Grant permission for the object."""
-    assert isinstance(level, AccessLevelEnum), f'Use {ConnectPerm} instead of "CONNECT"'
-    Jac.perm_grant(obj, level=level.value)
-
-
-def revoke(obj: Archetype) -> None:
-    """Revoke permission for the object."""
-    Jac.perm_revoke(obj)
-
-
-def allroots() -> list[Jac.Root]:
-    """Get all the roots."""
-    return Jac.get_all_root()
+jid = Jac.object_ref
+jobj = Jac.get_object
+grant = Jac.perm_grant
+revoke = Jac.perm_revoke
+allroots = Jac.get_all_root
+save = Jac.save
+commit = Jac.commit
 
 
 def _jac_graph_json(file: Optional[str] = None) -> str:
     """Get the graph in json string."""
-    processed: list[Root | NodeArchetype] = []
+    visited_nodes: set = set()
+    connections: set = set()
+    edge_ids: set = set()
     nodes: list[dict] = []
     edges: list[dict] = []
-    working_set: list[tuple] = []
-
     root = Jac.root()
+
+    collect_node_connections(root, visited_nodes, connections, edge_ids)
+
+    # Create nodes list from visited nodes
     nodes.append({"id": id(root), "label": "root"})
+    for node_arch in visited_nodes:
+        if node_arch != root:
+            nodes.append({"id": id(node_arch), "label": repr(node_arch)})
+
+    # Create edges list with labels from connections
+    for _, source_node, target_node, edge_arch in connections:
+        edge_data = {"from": str(id(source_node)), "to": str(id(target_node))}
+        if repr(edge_arch) != "GenericEdge()":
+            edge_data["label"] = repr(edge_arch)
+        edges.append(edge_data)
 
-    processed.append(root)
-    working_set = [(root, ref) for ref in Jac.refs(root)]
-
-    while working_set:
-        start, end = working_set.pop(0)
-        edges.append({"from": id(start), "to": id(end)})
-        nodes.append({"id": id(end), "label": repr(end)})
-        processed.append(end)
-        for ref in Jac.refs(end):
-            if ref not in processed:
-                working_set.append((end, ref))
     output = json.dumps(
         {
             "version": "1.0",
@@ -128,6 +115,8 @@ __all__ = [
     "grant",
     "revoke",
     "allroots",
+    "save",
+    "commit",
     "NoPerm",
     "ReadPerm",
     "ConnectPerm",

jaclang/runtimelib/importer.py

@@ -322,7 +322,7 @@ class JacImporter(Importer):
             if os.path.isdir(spec.full_target):
                 module = self.handle_directory(spec.module_name, spec.full_target)
             else:
-                spec.full_target += ".jac" if spec.language == "jac" else ".py"
+                spec.full_target += ".jac" if spec.language in ["jac", "jir"] else ".py"
                 module = self.create_jac_py_module(
                     module_name,
                     spec.package_path,

jaclang/runtimelib/machine.py

@@ -57,7 +57,6 @@ from jaclang.runtimelib.constructs import (
 from jaclang.runtimelib.memory import Memory, Shelf, ShelfStorage
 from jaclang.runtimelib.utils import (
     all_issubclass,
-    collect_node_connections,
     traverse_graph,
 )
 from jaclang.utils import infer_language
@@ -266,30 +265,6 @@ class JacAccessValidation:
 class JacNode:
     """Jac Node Operations."""
 
-    @staticmethod
-    def node_dot(node: NodeArchetype, dot_file: Optional[str] = None) -> str:
-        """Generate Dot file for visualizing nodes and edges."""
-        visited_nodes: set[NodeAnchor] = set()
-        connections: set[tuple[NodeArchetype, NodeArchetype, str]] = set()
-        unique_node_id_dict = {}
-
-        collect_node_connections(node.__jac__, visited_nodes, connections)
-        dot_content = 'digraph {\nnode [style="filled", shape="ellipse", fillcolor="invis", fontcolor="black"];\n'
-        for idx, i in enumerate([nodes_.archetype for nodes_ in visited_nodes]):
-            unique_node_id_dict[i] = (i.__class__.__name__, str(idx))
-            dot_content += f'{idx} [label="{i}"];\n'
-        dot_content += 'edge [color="gray", style="solid"];\n'
-
-        for pair in list(set(connections)):
-            dot_content += (
-                f"{unique_node_id_dict[pair[0]][1]} -> {unique_node_id_dict[pair[1]][1]}"
-                f' [label="{pair[2]}"];\n'
-            )
-        if dot_file:
-            with open(dot_file, "w") as f:
-                f.write(dot_content + "}")
-        return dot_content + "}"
-
     @staticmethod
     def get_edges(
         origin: list[NodeArchetype], destination: DataSpatialDestination
@@ -879,6 +854,15 @@ class JacBasics:
         """Get current execution context."""
         return JacMachine.exec_ctx
 
+    @staticmethod
+    def commit(anchor: Anchor | Archetype | None = None) -> None:
+        """Commit all data from memory to datasource."""
+        if isinstance(anchor, Archetype):
+            anchor = anchor.__jac__
+
+        mem = JacMachineInterface.get_context().mem
+        mem.commit(anchor)
+
     @staticmethod
     def reset_graph(root: Optional[Root] = None) -> int:
         """Purge current or target graph."""
@@ -987,6 +971,7 @@ class JacBasics:
         override_name: Optional[str] = None,
         items: Optional[dict[str, Union[str, Optional[str]]]] = None,
         reload_module: Optional[bool] = False,
+        lng: Optional[str] = None,
     ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
         from jaclang.runtimelib.importer import (
@@ -995,7 +980,8 @@ class JacBasics:
             PythonImporter,
         )
 
-        lng = infer_language(target, base_path)
+        if lng is None:
+            lng = infer_language(target, base_path)
 
         spec = ImportPathSpec(
             target,
@@ -1358,12 +1344,10 @@ class JacBasics:
         return decorator
 
     @staticmethod
-    def call_llm(
-        model: object, caller: Callable, args: dict[str | int, object]
-    ) -> Any:  # noqa: ANN401
+    def call_llm(model: object, mtir: object) -> Any:  # noqa: ANN401
         """Call the LLM model."""
         raise ImportError(
-            "mtllm is not installed. Please install it with `pip install mtllm` and run `jac clean`."
+            "byLLM is not installed. Please install it with `pip install byllm` and run `jac clean`."
         )
 
 
@@ -1587,40 +1571,6 @@ class JacMachineInterface(
     """Jac Feature."""
 
 
-class JacMachine(JacMachineInterface):
-    """Jac Machine State."""
-
-    loaded_modules: dict[str, types.ModuleType] = {}
-    base_path_dir: str = os.getcwd()
-    program: JacProgram = JacProgram()
-    pool: ThreadPoolExecutor = ThreadPoolExecutor()
-    exec_ctx: ExecutionContext = ExecutionContext()
-
-    @staticmethod
-    def set_base_path(base_path: str) -> None:
-        """Set the base path for the machine."""
-        JacMachine.reset_machine()
-        JacMachine.base_path_dir = (
-            base_path if os.path.isdir(base_path) else os.path.dirname(base_path)
-        )
-
-    @staticmethod
-    def set_context(context: ExecutionContext) -> None:
-        """Set the context for the machine."""
-        JacMachine.exec_ctx = context
-
-    @staticmethod
-    def reset_machine() -> None:
-        """Reset the machine."""
-        # for i in JacMachine.loaded_modules.values():
-        #     sys.modules.pop(i.__name__, None)
-        JacMachine.loaded_modules.clear()
-        JacMachine.base_path_dir = os.getcwd()
-        JacMachine.program = JacProgram()
-        JacMachine.pool = ThreadPoolExecutor()
-        JacMachine.exec_ctx = ExecutionContext()
-
-
 def generate_plugin_helpers(
     plugin_class: Type[Any],
 ) -> tuple[Type[Any], Type[Any], Type[Any]]:
@@ -1726,3 +1676,37 @@ def generate_plugin_helpers(
 
 JacMachineSpec, JacMachineImpl, JacMachineInterface = generate_plugin_helpers(JacMachineInterface)  # type: ignore[misc]
 plugin_manager.add_hookspecs(JacMachineSpec)
+
+
+class JacMachine(JacMachineInterface):
+    """Jac Machine State."""
+
+    loaded_modules: dict[str, types.ModuleType] = {}
+    base_path_dir: str = os.getcwd()
+    program: JacProgram = JacProgram()
+    pool: ThreadPoolExecutor = ThreadPoolExecutor()
+    exec_ctx: ExecutionContext = ExecutionContext()
+
+    @staticmethod
+    def set_base_path(base_path: str) -> None:
+        """Set the base path for the machine."""
+        JacMachine.reset_machine()
+        JacMachine.base_path_dir = (
+            base_path if os.path.isdir(base_path) else os.path.dirname(base_path)
+        )
+
+    @staticmethod
+    def set_context(context: ExecutionContext) -> None:
+        """Set the context for the machine."""
+        JacMachine.exec_ctx = context
+
+    @staticmethod
+    def reset_machine() -> None:
+        """Reset the machine."""
+        # for i in JacMachine.loaded_modules.values():
+        #     sys.modules.pop(i.__name__, None)
+        JacMachine.loaded_modules.clear()
+        JacMachine.base_path_dir = os.getcwd()
+        JacMachine.program = JacProgram()
+        JacMachine.pool = ThreadPoolExecutor()
+        JacMachine.exec_ctx = ExecutionContext()

jaclang/runtimelib/memory.py

@@ -82,6 +82,9 @@ class Memory(Generic[ID, TANCH]):
             if anchor := self.__mem__.pop(id, None):
                 self.__gc__.add(anchor)
 
+    def commit(self, anchor: TANCH | None = None) -> None:
+        """Commit all data from memory to datasource."""
+
 
 @dataclass
 class ShelfStorage(Memory[UUID, Anchor]):
@@ -94,12 +97,21 @@ class ShelfStorage(Memory[UUID, Anchor]):
         super().__init__()
         self.__shelf__ = open(session) if session else None  # noqa: SIM115
 
-    def close(self) -> None:
-        """Close memory handler."""
+    def commit(self, anchor: Anchor | None = None) -> None:
+        """Commit all data from memory to datasource."""
         if isinstance(self.__shelf__, Shelf):
-            for anchor in self.__gc__:
-                self.__shelf__.pop(str(anchor.id), None)
-                self.__mem__.pop(anchor.id, None)
+            if anchor:
+                if anchor in self.__gc__:
+                    self.__shelf__.pop(str(anchor.id), None)
+                    self.__mem__.pop(anchor.id, None)
+                    self.__gc__.remove(anchor)
+                else:
+                    self.sync_mem_to_db([anchor.id])
+                return
+
+            for anc in self.__gc__:
+                self.__shelf__.pop(str(anc.id), None)
+                self.__mem__.pop(anc.id, None)
 
             keys = set(self.__mem__.keys())
 
@@ -109,7 +121,13 @@ class ShelfStorage(Memory[UUID, Anchor]):
             # additional after memory sync
             self.sync_mem_to_db(set(self.__mem__.keys() - keys))
 
+    def close(self) -> None:
+        """Close memory handler."""
+        self.commit()
+
+        if isinstance(self.__shelf__, Shelf):
             self.__shelf__.close()
+
         super().close()
 
     def sync_mem_to_db(self, keys: Iterable[UUID]) -> None:

jaclang/runtimelib/tests/fixtures/savable_object.jac

@@ -18,7 +18,7 @@ obj SavableObject {
 
 walker create_custom_object {
     can enter1 with `root entry {
-        o = SavableObject(
+        self.obj = SavableObject(
             val=0,
             arr=[],
             json={},
@@ -36,7 +36,15 @@ walker create_custom_object {
             ),
             enum_field = Enum.A
         );
-        _.save(o);
+        save(self.obj);
+
+        # commit the object to db
+        commit(self.obj);
+    }
+
+    can exit1 with `root exit {
+        # get directly from shelf
+        o = _.get_context().mem.__shelf__.get(str(self.obj.__jac__.id)).archetype;
         print(jid(o));
         print(o);
     }