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

jaclang/langserve/dev_server.jac

@@ -0,0 +1,201 @@
+"""Jaclang Language Server."""
+
+import from typing { Optional }
+
+import from jaclang.compiler.constant {
+    JacSemTokenModifier as SemTokMod,
+    JacSemTokenType as SemTokType
+}
+
+import from dev_engine { JacLangServer }
+import from jaclang.settings { settings }
+
+import lsprotocol.types as lspt;
+
+
+with entry {
+    server = JacLangServer();
+}
+
+
+"""Check syntax on change."""
+@server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
+async def did_open(ls: JacLangServerV2, params: lspt.DidOpenTextDocumentParams) -> None {
+    await ls.launch_deep_check(params.text_document.uri);
+    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+}
+
+
+"""Check syntax on change."""
+@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
+async def did_save(ls: JacLangServerV2, params: lspt.DidOpenTextDocumentParams) -> None {
+    file_path = params.text_document.uri;
+    quick_check_passed = await ls.launch_quick_check(file_path);
+    if not quick_check_passed {
+        return;
+    }
+    await ls.launch_deep_check(file_path);
+    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+}
+
+
+"""Check syntax on change."""
+@server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
+async def did_change(
+    ls: JacLangServerV2,
+    params: lspt.DidChangeTextDocumentParams
+) -> None {
+    file_path = params.text_document.uri;
+    quick_check_passed = await ls.launch_quick_check(file_path);
+
+    if quick_check_passed {
+        document = ls.workspace.get_text_document(file_path);
+        lines = document.source.splitlines();
+        sem_manager = ls.sem_managers[file_path.removeprefix('file://')];
+        sem_manager.update_sem_tokens(
+            params,sem_manager.sem_tokens,lines
+        );
+        ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+        await ls.launch_deep_check(file_path);
+        ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+    }
+}
+
+
+"""Format the given document."""
+@server.feature(lspt.TEXT_DOCUMENT_FORMATTING)
+def formatting(
+    ls: JacLangServerV2,
+    params: lspt.DocumentFormattingParams
+) -> list[lspt.TextEdit] {
+    return ls.formatted_jac(params.text_document.uri);
+}
+
+
+"""Check syntax on file creation."""
+@server.feature(
+    lspt.WORKSPACE_DID_CREATE_FILES,
+    lspt.FileOperationRegistrationOptions(
+        filters=[lspt.FileOperationFilter(pattern=lspt.FileOperationPattern('**/*.jac'))]
+    )
+)
+def did_create_files(ls: JacLangServerV2, params: lspt.CreateFilesParams) -> None {}
+
+
+"""Check syntax on file rename."""
+@server.feature(
+    lspt.WORKSPACE_DID_RENAME_FILES,
+    lspt.FileOperationRegistrationOptions(
+        filters=[lspt.FileOperationFilter(pattern=lspt.FileOperationPattern('**/*.jac'))]
+    )
+)
+def did_rename_files(ls: JacLangServerV2, params: lspt.RenameFilesParams) -> None {
+    new_uris = [ file.new_uri for file in params.files ];
+    old_uris = [ file.old_uri for file in params.files ];
+    for i in range(len(new_uris)) {
+        ls.rename_module(old_uris[i], new_uris[i]);
+    }
+}
+
+
+"""Check syntax on file delete."""
+@server.feature(
+    lspt.WORKSPACE_DID_DELETE_FILES,
+    lspt.FileOperationRegistrationOptions(
+        filters=[lspt.FileOperationFilter(pattern=lspt.FileOperationPattern('**/*.jac'))]
+    )
+)
+def did_delete_files(ls: JacLangServerV2, params: lspt.DeleteFilesParams) -> None {
+    for file in params.files {
+        ls.delete_module(file.uri);
+    }
+}
+
+
+"""Provide completion."""
+@server.feature(
+    lspt.TEXT_DOCUMENT_COMPLETION,
+    lspt.CompletionOptions(trigger_characters=['.', ':', 'a-zA-Z0-9'])
+)
+def completion(ls: JacLangServerV2, params: lspt.CompletionParams) -> lspt.CompletionList {
+    return ls.get_completion(
+        params.text_document.uri,
+        params.position,
+        params.context.trigger_character if params.context else None
+    );
+}
+
+
+"""Provide hover information for the given hover request."""
+@server.feature(lspt.TEXT_DOCUMENT_HOVER, lspt.HoverOptions(work_done_progress=True))
+def hover(
+    ls: JacLangServerV2,
+    params: lspt.TextDocumentPositionParams
+) -> Optional[lspt.Hover] {
+    return ls.get_hover_info(params.text_document.uri, params.position);
+}
+
+
+"""Provide document symbols."""
+@server.feature(lspt.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+def document_symbol(
+    ls: JacLangServerV2,
+    params: lspt.DocumentSymbolParams
+) -> list[lspt.DocumentSymbol] {
+    return ls.get_outline(params.text_document.uri);
+}
+
+
+"""Provide definition."""
+@server.feature(lspt.TEXT_DOCUMENT_DEFINITION)
+def definition(
+    ls: JacLangServerV2,
+    params: lspt.TextDocumentPositionParams
+) -> Optional[lspt.Location] {
+    return ls.get_definition(params.text_document.uri, params.position);
+}
+
+
+"""Provide references."""
+@server.feature(lspt.TEXT_DOCUMENT_REFERENCES)
+def references(ls: JacLangServerV2, params: lspt.ReferenceParams) -> list[lspt.Location] {
+    return ls.get_references(params.text_document.uri, params.position);
+}
+
+
+"""Rename symbol."""
+@server.feature(lspt.TEXT_DOCUMENT_RENAME)
+def rename(ls: JacLangServerV2, params: lspt.RenameParams) -> Optional[lspt.WorkspaceEdit] {
+    ls.log_warning('Auto Rename is Experimental, Please use with caution.');
+    return ls.rename_symbol(params.text_document.uri, params.position, params.new_name);
+}
+
+
+"""Provide semantic tokens."""
+@server.feature(
+    lspt.TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+    lspt.SemanticTokensLegend(
+        token_types=SemTokType.as_str_list(),
+        token_modifiers=SemTokMod.as_str_list()
+    )
+)
+def semantic_tokens_full(
+    ls: JacLangServerV2,
+    params: lspt.SemanticTokensParams
+) -> lspt.SemanticTokens {
+    return ls.get_semantic_tokens(params.text_document.uri);
+}
+
+
+"""Run the language server."""
+def run_lang_server() -> None {
+    settings.pass_timer = True;
+    server.start_io();
+}
+
+
+with entry {
+    if __name__ == '__main__' {
+        run_lang_server();
+    }
+}

jaclang/langserve/engine.jac

@@ -134,7 +134,7 @@ class JacLangServer(JacProgram , LanguageServer) {
             file_path_fs = file_path.removeprefix('file://');
             document = self.workspace.get_text_document(file_path);
             self._clear_alerts_for_file(file_path_fs);
-            build = self.build(use_str=document.source, file_path=document.path);
+            build = self.build(use_str=document.source, file_path=document.path,type_check=True);
             self.update_modules(file_path_fs, build);
             if build.annexable_by {
                 return self.deep_check(

jaclang/langserve/tests/server_test/test_lang_serve.py

@@ -190,7 +190,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) == 320
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
         assert len(diagnostics) == 1
@@ -254,7 +254,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) == 320
         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.dev_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/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);
     }