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

jaclang/langserve/tests/server_test/utils.py

@@ -2,21 +2,19 @@
 
 import os
 import tempfile
-
+from typing import Optional
+from dataclasses import dataclass
+
+from lsprotocol.types import (
+    DidOpenTextDocumentParams,
+    TextDocumentItem,
+    DidSaveTextDocumentParams,
+    DidChangeTextDocumentParams,
+    VersionedTextDocumentIdentifier,
+)
 from jaclang.vendor.pygls.uris import from_fs_path
 from jaclang.vendor.pygls.workspace import Workspace
 
-from textwrap import dedent
-
-
-def get_jac_file_path():
-    """Return the absolute path to the sample Jac file used for testing."""
-    return os.path.abspath(
-        os.path.join(
-            os.path.dirname(__file__), "../../../../examples/manual_code/circle.jac"
-        )
-    )
-
 
 def create_temp_jac_file(initial_content: str = "") -> str:
     """Create a temporary Jac file with optional initial content and return its path."""
@@ -28,110 +26,11 @@ def create_temp_jac_file(initial_content: str = "") -> str:
     return temp.name
 
 
-def get_code(code: str) -> str:
-    """Generate a sample Jac code snippet with optional test code injected."""
-    jac_code = dedent(
-        f'''
-    """
-    This module demonstrates a simple circle class and a function to calculate
-    the area of a circle in all of Jac's glory.
-    """
-
-    import math;
-
-    # Module-level global variable
-    glob RAD = 5;
-
-    """Function to calculate the area of a circle."""
-    def calculate_area(radius: float) -> float {{
-        return math.pi * radius * radius;
-    }}
-
-    #* (This is a multiline comment in Jac)
-    Above we have the demonstration of a function to calculate the area of a circle.
-    Below we have the demonstration of a class to calculate the area of a circle.
-    *#
-
-    """Enum for shape types"""
-    enum ShapeType {{
-        CIRCLE = "Circle",
-        UNKNOWN = "Unknown"
-    }}
-
-    """Base class for a shape."""
-    obj Shape {{
-        has shape_type: ShapeType;
-
-        """Abstract method to calculate the area of a shape."""
-        def area -> float abs;
-    }}
-
-    """Circle class inherits from Shape."""
-    obj Circle(Shape) {{
-        def init(radius: float) {{
-            super.init(ShapeType.CIRCLE);
-            self.radius = radius;
-        }}
-
-        """Overridden method to calculate the area of the circle."""
-        override def area -> float {{
-            return math.pi * self.radius * self.radius;
-        }}
-    }}
-
-    with entry {{
-        c = Circle(RAD);
-    }}
-
-    # Global also works here
-
-    with entry:__main__ {{
-        # To run the program functionality
-        print(
-            f"Area of a circle with radius {{RAD}} using function: {{calculate_area(RAD)}}"
-        );
-        print(
-            f"Area of a {{c.shape_type.value}} with radius {{RAD}} using class: {{c.area()}}"
-        );
-    }}
-
-    # Unit Tests!
-    glob expected_area = 78.53981633974483;
-    {code}
-
-    test calc_area {{
-        check almostEqual(calculate_area(RAD), expected_area);
-    }}
-
-    test circle_area {{
-        c = Circle(RAD);
-        check almostEqual(c.area(), expected_area);
-    }}
-
-    test circle_type {{
-        c = Circle(RAD);
-        check c.shape_type == ShapeType.CIRCLE;
-    }}
-'''
-    )
-    return jac_code
-
-
-def get_simple_code(code: str) -> str:
-    """Generate a sample Jac code snippet with optional test code injected."""
-    jac_code = dedent(
-        f"""
-    
-    # Unit Tests!
-    glob expected_area0 = 78.53981633974483;
-    glob expected_area1 = 78.53981633974483;
-    {code}
-    glob expected_area2 = 78.53981633974483;
-
-
-"""
-    )
-    return jac_code
+def load_jac_template(template_file: str, code: str = "") -> str:
+    """Load a Jac template file and inject code into placeholder."""
+    with open(template_file, "r") as f:
+        jac_template = f.read()
+    return jac_template.replace("#{{INJECT_CODE}}", code)
 
 
 def create_ls_with_workspace(file_path: str):
@@ -142,3 +41,141 @@ def create_ls_with_workspace(file_path: str):
     uri = from_fs_path(file_path)
     ls.lsp._workspace = Workspace(os.path.dirname(file_path), ls)
     return uri, ls
+
+
+@dataclass
+class TestFile:
+    """Encapsulates test file information and operations."""
+    
+    path: str
+    uri: str
+    code: str
+    version: int = 1
+    
+    @classmethod
+    def from_template(cls, template_name: str, content: str = "") -> "TestFile":
+        """Create a test file from a template."""
+        code = load_jac_template(cls._get_template_path(template_name), content)
+        temp_path = create_temp_jac_file(code)
+        uri = from_fs_path(temp_path)
+        return cls(
+            path=temp_path,
+            uri=uri or "",
+            code=code,
+        )
+    
+    @staticmethod
+    def _get_template_path(file_name: str) -> str:
+        """Get absolute path to test template file."""
+        return os.path.abspath(
+            os.path.join(os.path.dirname(__file__), file_name)
+        )
+    
+    def cleanup(self):
+        """Remove temporary test file."""
+        if os.path.exists(self.path):
+            os.remove(self.path)
+    
+    def increment_version(self) -> int:
+        """Increment and return the version number."""
+        self.version += 1
+        return self.version
+
+
+class LanguageServerTestHelper:
+    """Helper class for language server testing operations."""
+    
+    def __init__(self, ls, test_file: TestFile):
+        self.ls = ls
+        self.test_file = test_file
+    
+    async def open_document(self) -> None:
+        """Open a document in the language server."""
+        from jaclang.langserve.server import did_open
+        
+        params = DidOpenTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=self.test_file.uri,
+                language_id="jac",
+                version=self.test_file.version,
+                text=self.test_file.code,
+            )
+        )
+        await did_open(self.ls, params)
+    
+    async def save_document(self, code: Optional[str] = None) -> None:
+        """Save a document in the language server."""
+        from jaclang.langserve.server import did_save
+        
+        content = code if code is not None else self.test_file.code
+        version = self.test_file.increment_version()
+        
+        if code:
+            self._update_workspace(code, version)
+        
+        from lsprotocol.types import TextDocumentIdentifier
+        
+        params = DidSaveTextDocumentParams(
+            text_document=TextDocumentIdentifier(uri=self.test_file.uri),
+            text=content
+        )
+        await did_save(self.ls, params)
+    
+    async def change_document(self, code: str) -> None:
+        """Change document content in the language server."""
+        from jaclang.langserve.server import did_change
+        
+        version = self.test_file.increment_version()
+        self._update_workspace(code, version)
+        
+        params = DidChangeTextDocumentParams(
+            text_document=VersionedTextDocumentIdentifier(
+                uri=self.test_file.uri,
+                version=version
+            ),
+            content_changes=[{"text": code}],  # type: ignore
+        )
+        await did_change(self.ls, params)
+    
+    def _update_workspace(self, code: str, version: int) -> None:
+        """Update workspace with new document content."""
+        self.ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=self.test_file.uri,
+                language_id="jac",
+                version=version,
+                text=code,
+            )
+        )
+    
+    def get_diagnostics(self) -> list:
+        """Get diagnostics for the current document."""
+        return self.ls.diagnostics.get(self.test_file.uri, [])
+    
+    def get_semantic_tokens(self):
+        """Get semantic tokens for the current document."""
+        return self.ls.get_semantic_tokens(self.test_file.uri)
+    
+    def assert_no_diagnostics(self) -> None:
+        """Assert that there are no diagnostics."""
+        diagnostics = self.get_diagnostics()
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == 0, f"Expected no diagnostics, found {len(diagnostics)}"
+    
+    def assert_has_diagnostics(self, count: int = 1, message_contains: Optional[str] = None) -> None:
+        """Assert that diagnostics exist with optional message validation."""
+        diagnostics = self.get_diagnostics()
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == count, f"Expected {count} diagnostic(s), found {len(diagnostics)}"
+        
+        if message_contains:
+            assert message_contains in diagnostics[0].message, \
+                f"Expected '{message_contains}' in diagnostic message"
+    
+    def assert_semantic_tokens_count(self, expected_count: int) -> None:
+        """Assert semantic tokens data has expected count."""
+        tokens = self.get_semantic_tokens()
+        assert hasattr(tokens, "data")
+        assert isinstance(tokens.data, list)
+        assert len(tokens.data) == expected_count, \
+            f"Expected {expected_count} tokens, found {len(tokens.data)}"

jaclang/langserve/tests/test_server.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from jaclang.utils.test import TestCase
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.workspace import Workspace
@@ -310,7 +311,6 @@ class TestJacLangServer(TestCase):
         for token_type, expected_count in expected_counts:
             self.assertEqual(str(sem_list).count(token_type), expected_count)
 
-    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_completion(self) -> None:
         """Test that the completions are correct."""
         lsp = JacLangServer()
@@ -318,95 +318,28 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         base_module_file = uris.from_fs_path(
-            self.fixture_abs_path("base_module_structure.jac")
+            self.fixture_abs_path("completion_test_err.jac")
         )
         lsp.deep_check(base_module_file)
-        test_cases = [
-            (lspt.Position(38, 16), ["get_color1", "color1", "point1"], 3),
-            (lspt.Position(42, 22), ["RED", "GREEN", "BLUE"], 3),
-            (lspt.Position(42, 33), ["RED", "GREEN", "BLUE"], 3),
-            (lspt.Position(42, 45), ["RED", "GREEN", "BLUE"], 3),
-            (lspt.Position(46, 20), ["RED22", "GREEN22", "BLUE22"], 3),
-            (lspt.Position(46, 30), ["RED22", "GREEN22", "BLUE22"], 3),
-            (lspt.Position(46, 41), ["RED22", "GREEN22", "BLUE22"], 3),
-            (
-                lspt.Position(51, 32),
-                ["RED22", "GREEN22", "BLUE22"],
-                3,
-            ),
-            (
-                lspt.Position(65, 13),
-                [
-                    "get_color1",
-                    "color1",
-                    "point1",
-                    "base_colorred",
-                    "pointred",
-                    "inner_red",
-                    "doubleinner",
-                    "apply_red",
-                ],
-                11,
-            ),
-            (
-                lspt.Position(65, 23),
-                ["color22", "doublepoint22", "point22", "apply_inner_red", "enum_red"],
-                5,
-            ),
-            (
-                lspt.Position(65, 31),
-                ["RED22", "GREEN22", "BLUE22"],
-                3,
-            ),
-            (
-                lspt.Position(35, 28),
-                [],
-                0,
-            ),
-            (
-                lspt.Position(72, 12),
-                [
-                    "get_color1",
-                    "color1",
-                    "point1",
-                    "base_colorred",
-                    "pointred",
-                    "inner_red",
-                    "doubleinner",
-                    "apply_red",
-                ],
-                11,
-            ),
-            (
-                lspt.Position(73, 22),
-                ["color22", "doublepoint22", "apply_inner_red", "point22", "enum_red"],
-                5,
-            ),
-            (
-                lspt.Position(37, 12),
-                ["self", "add", "subtract", "x", "Colorenum", "Colour1", "red", "r"],
-                153,
-                None,
+
+        @dataclass
+        class Case:
+            pos: lspt.Position
+            expected: list[str]
+            trigger: str = "."
+
+        test_cases: list[Case] = [
+            Case(
+                lspt.Position(8, 8),
+                ["bar", "baz"],
             ),
         ]
-        default_trigger = "."
         for case in test_cases:
-            position, expected_completions, expected_length = case[:3]
-            completion_trigger = case[3] if len(case) > 3 else default_trigger
             completions = lsp.get_completion(
-                base_module_file, position, completion_trigger=completion_trigger
+                base_module_file, case.pos, completion_trigger=case.trigger
             ).items
-            for completion in expected_completions:
+            for completion in case.expected:
                 self.assertIn(completion, str(completions))
-            self.assertEqual(expected_length, len(completions))
-
-            if position == lspt.Position(73, 12):
-                self.assertEqual(
-                    2, str(completions).count("kind=<CompletionItemKind.Function: 3>")
-                )
-                self.assertEqual(
-                    4, str(completions).count("kind=<CompletionItemKind.Field: 5>")
-                )
 
     def test_go_to_reference(self) -> None:
         """Test that the go to reference is correct."""
@@ -419,8 +352,8 @@ class TestJacLangServer(TestCase):
         lsp.deep_check(circle_file)
         test_cases = [
             (47, 12, ["circle.jac:47:8-47:14", "69:8-69:14", "74:8-74:14"]),
-            (54, 66, ["54:62-54:76", "65:22-65:36"]),
-            (62, 14, ["65:43-65:56", "70:32-70:45"]),
+            (54, 66, ["54:62-54:76", "65:23-65:37"]),
+            (62, 14, ["65:44-65:57", "70:33-70:46"]),
         ]
         for line, char, expected_refs in test_cases:
             references = str(lsp.get_references(circle_file, lspt.Position(line, char)))
@@ -608,3 +541,7 @@ class TestJacLangServer(TestCase):
             "/tests/fixtures/M1.jac:0:0-0:0",
             str(lsp.get_definition(guess_game_file, lspt.Position(29, 9))),
         )
+
+
+
+TestJacLangServer().test_completion()

jaclang/langserve/utils.jac

@@ -1,5 +1,6 @@
 """Utility functions for the language server."""
 
+
 import asyncio;
 import builtins;
 import re;
@@ -112,25 +113,21 @@ def find_deepest_symbol_node_at_pos(
 
 
 """Check if the position falls within the node's location."""
-def position_within_node(<>node: uni.UniNode, line: int, character: int) -> bool {
-    if <>node.loc.first_line < (line + 1) < <>node.loc.last_line {
+# All lines and columns are 1-Based
+def position_within_node(n: uni.UniNode, line: int, character: int) -> bool {
+    if n.loc.first_line < line < n.loc.last_line {
         return True;
     }
-    if <>node.loc.first_line == (line + 1)
-    and <>node.loc.col_start <= (character + 1)
-    and <>node.loc.last_line == (line + 1)
-    and <>node.loc.col_end >= (character + 1)
-
-    or <>node.loc.last_line > (line + 1)
-     {
-        return True;
+    if line < n.loc.first_line or line > n.loc.last_line {
+        return False;
     }
-    if <>node.loc.last_line == (line + 1)
-    and <>node.loc.col_start <= (character + 1) <= <>node.loc.col_end
-     {
-        return True;
+    if line == n.loc.first_line and character < n.loc.col_start {
+        return False;
+    }
+    if line == n.loc.last_line and character >= n.loc.col_end {
+        return False;
     }
-    return False;
+    return True;
 }
 
 

jaclang/runtimelib/machine.py

@@ -1132,6 +1132,13 @@ class JacBasics:
             return JacMachineInterface.get_edges(origin, path.destinations[-1])
         return origin
 
+    @staticmethod
+    async def arefs(
+        path: DataSpatialPath | NodeArchetype | list[NodeArchetype],
+    ) -> None:
+        """Jac's apply_dir stmt feature."""
+        pass
+
     @staticmethod
     def filter(
         items: list[Archetype],

jaclang/runtimelib/meta_importer.py

@@ -9,7 +9,8 @@ from typing import Optional, Sequence
 
 from jaclang.runtimelib.machine import JacMachine as Jac
 from jaclang.runtimelib.machine import JacMachineInterface
-from jaclang.utils.module_resolver import get_jac_search_paths
+from jaclang.settings import settings
+from jaclang.utils.module_resolver import get_jac_search_paths, get_py_search_paths
 
 
 class JacMetaImporter(importlib.abc.MetaPathFinder, importlib.abc.Loader):
@@ -48,6 +49,30 @@ class JacMetaImporter(importlib.abc.MetaPathFinder, importlib.abc.Loader):
                 return importlib.util.spec_from_file_location(
                     fullname, candidate_path + ".jac", loader=self
                 )
+
+        # TODO: We can remove it once python modules are fully supported in jac
+        if path is None and settings.pyfile_raise:
+            if settings.pyfile_raise_full:
+                paths_to_search = get_jac_search_paths()
+            else:
+                paths_to_search = get_py_search_paths()
+            for search_path in paths_to_search:
+                candidate_path = os.path.join(search_path, *module_path_parts)
+                # Check for directory package
+                if os.path.isdir(candidate_path):
+                    init_file = os.path.join(candidate_path, "__init__.py")
+                    if os.path.isfile(init_file):
+                        return importlib.util.spec_from_file_location(
+                            fullname,
+                            init_file,
+                            loader=self,
+                            submodule_search_locations=[candidate_path],
+                        )
+                # Check for .py file
+                if os.path.isfile(candidate_path + ".py"):
+                    return importlib.util.spec_from_file_location(
+                        fullname, candidate_path + ".py", loader=self
+                    )
         return None
 
     def create_module(
@@ -78,6 +103,7 @@ class JacMetaImporter(importlib.abc.MetaPathFinder, importlib.abc.Loader):
             target=target,
             base_path=base_path,
             override_name=module.__name__,
+            lng="py" if file_path.endswith(".py") else "jac",
         )
         if ret:
             loaded_module = ret[0]

jaclang/runtimelib/tests/fixtures/custom_access_validation.jac

@@ -27,7 +27,7 @@ node A {
 walker create_other_root {
     can enter with `root entry {
         other_root = `root().__jac__;
-        _.save(other_root);
+        _jl.save(other_root);
         print(other_root.id);
     }
 }

jaclang/runtimelib/tests/fixtures/savable_object.jac

@@ -44,7 +44,7 @@ walker create_custom_object {
 
     can exit1 with `root exit {
         # get directly from shelf
-        o = _.get_context().mem.__shelf__.get(str(self.obj.__jac__.id)).archetype;
+        o = _jl.get_context().mem.__shelf__.get(str(self.obj.__jac__.id)).archetype;
         print(jid(o));
         print(o);
     }
@@ -87,6 +87,6 @@ walker delete_custom_object {
     has object_id: str;
 
     can enter1 with `root entry {
-        _.destroy([&(self.object_id)]);
+        _jl.destroy([&(self.object_id)]);
     }
 }

jaclang/settings.py

@@ -2,6 +2,7 @@
 
 import configparser
 import os
+from argparse import Namespace
 from dataclasses import dataclass, fields
 
 
@@ -19,11 +20,16 @@ class Settings:
     # Compiler configuration
     disable_mtllm: bool = False
     ignore_test_annex: bool = False
-    pyout_jaclib_alias: str = "_"
+    pyout_jaclib_alias: str = "_jl"
+    pyfile_raise: bool = False
+    pyfile_raise_full: bool = False
 
     # Formatter configuration
     max_line_length: int = 88
 
+    # pytorch configuration
+    predynamo_pass: bool = False
+
     # LSP configuration
     lsp_debug: bool = False
 
@@ -42,6 +48,8 @@ class Settings:
         """Load settings from all available sources."""
         self.load_config_file()
         self.load_env_vars()
+        # CLI arguments are applied by the CLI after parsing, via
+        # `settings.load_command_line_arguments(args)` in start_cli.
 
     def load_config_file(self) -> None:
         """Load settings from a configuration file."""
@@ -64,19 +72,15 @@ class Settings:
             if env_value is not None:
                 setattr(self, key, self.convert_type(env_value))
 
-        # def load_command_line_arguments(self):
-        #     """Override settings from command-line arguments if provided."""
-        #     parser = argparse.ArgumentParser()
-        #     parser.add_argument(
-        #         "--debug",
-        #         type=self.str_to_bool,
-        #         nargs="?",
-        #         const=True,
-        #         default=self.config["debug"],
-        #     )
-        #     parser.add_argument("--port", type=int, default=self.config["port"])
-        #     parser.add_argument("--host", default=self.config["host"])
-        #     args = parser.parse_args()
+    def load_command_line_arguments(self, args: Namespace) -> None:
+        """Override settings from command-line arguments if provided."""
+        args_dict = vars(args) if not isinstance(args, dict) else args
+        for key in [f.name for f in fields(self)]:
+            if key in args_dict and args_dict[key] is not None:
+                val = args_dict[key]
+                if isinstance(val, str):
+                    val = self.convert_type(val)
+                setattr(self, key, val)
 
     def str_to_bool(self, value: str) -> bool:
         """Convert string to boolean."""

jaclang/tests/fixtures/abc_check.jac

@@ -63,15 +63,15 @@ with entry:__main__ {
 glob expected_area = 78.53981633974483;
 
 test calc_area {
-    check almostEqual(calculate_area(RAD), expected_area);
+    assert almostEqual(calculate_area(RAD), expected_area);
 }
 
 test circle_area {
     c = Circle(RAD);
-    check almostEqual(c.area(), expected_area);
+    assert almostEqual(c.area(), expected_area);
 }
 
 test circle_type {
     c = Circle(RAD);
-    check c.shape_type == ShapeType.CIRCLE;
+    assert c.shape_type == ShapeType.CIRCLE;
 }

jaclang/tests/fixtures/arch_rel_import_creation.jac

@@ -3,20 +3,20 @@ import from jaclang.runtimelib.machine { JacMachine }
 
 glob dynamic_module_source =
     """
-    import from arch_create_util {UtilityNode}
+import from arch_create_util {UtilityNode}
 
-    walker DynamicWalker {
-    can start with entry {
-    print("DynamicWalker Started");
-    here ++> UtilityNode(data=42);
-    visit [-->](`?UtilityNode);
-    }
+walker DynamicWalker {
+can start with entry {
+print("DynamicWalker Started");
+here ++> UtilityNode(data=42);
+visit [-->](`?UtilityNode);
+}
 
-    def UtilityNode {
-    here.display_data();
-    }
-    }
-    """;
+def UtilityNode {
+here.display_data();
+}
+}
+""";
 
 
 with entry {