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

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 {

jaclang/tests/fixtures/chandra_bugs2.jac

@@ -1,14 +1,14 @@
 import re;
 
 
-glob a : int = 5;
+glob a: int = 5;
 
 
 with entry {
     arguments = { x : None for x in re.findall(r'\{([A-Za-z0-9_]+)\}', "Apple {apple} pineapple {pineapple}") };
-    a : int = 5;
+    a: int = 5;
     if False {
-        with open(f"Apple{apple}.txt") as f {
+        with open(f"Apple{apple}.txt") as f  {
             # Fix syntax highlighting
             print(
                 f.read()

jaclang/tests/fixtures/create_dynamic_archetype.jac

@@ -2,23 +2,23 @@ import from jaclang.runtimelib.machine { JacMachine }
 # Dynamically create a node archetype
  glob source_code =
     """
-    node dynamic_node {
-    has value:int;
-    can print_value with entry {
-    print("Dynamic Node Value:", f'{self.value}');
-    }
-    }
-    """;
+node dynamic_node {
+has value:int;
+can print_value with entry {
+print("Dynamic Node Value:", f'{self.value}');
+}
+}
+""";
 
 # Create a new walker archetype dynamically
  glob walker_code =
     """
-    walker dynamic_walker {
-    can visit_nodes with entry {
-    visit [-->];
-    }
-    }
-    """;
+walker dynamic_walker {
+can visit_nodes with entry {
+visit [-->];
+}
+}
+""";
 
 
 with entry {

jaclang/tests/fixtures/jac_run_py_bugs.py

@@ -0,0 +1,18 @@
+from jaclang.tests.fixtures.jac_run_py_import import MyModule
+
+class SimpleClass:
+    def __init__(self, name: str, age: int) -> None:
+        self.name = name
+        self.age = age
+
+    def greet(self):
+        return f"Hello, my name is {self.name} and I am {self.age} years old."
+
+
+# Create an object of the class
+person = SimpleClass("Alice", 30)
+
+# Run the greet method
+print(person.greet())
+
+MyModule.init()

jaclang/tests/fixtures/jac_run_py_import.py

@@ -0,0 +1,13 @@
+class MyModule:
+    @staticmethod
+    def init():
+        print("MyModule initialized!")
+
+    @staticmethod
+    def do_something():
+        print("Doing something...")
+
+
+
+
+

jaclang/tests/fixtures/lambda_arg_annotation.jac

@@ -0,0 +1,15 @@
+
+
+with entry {
+    x = lambda a: int, b: int : b + a;
+    print(x(5, 4));
+    y = lambda : 567;
+    print(y());
+}
+
+
+with entry{
+    f = lambda x:Any :"even" if x % 2 == 0 else "odd";
+    print(f(7));
+
+}

jaclang/tests/fixtures/lambda_self.jac

@@ -0,0 +1,18 @@
+
+
+walker Tourist {
+    can travel with City entry {
+
+        def foo(a:int){}
+        x = lambda a: int, b: int : b + a;
+        y = lambda : 567;
+        sorted_users = sorted(
+            users, 
+            key=lambda x: dict: x["email"], reverse=True
+        );
+
+    }
+    def visit_city(c:City){
+        print("Visiting", c.name);
+    }
+}

jaclang/tests/fixtures/maxfail_run_test.jac

@@ -1,17 +1,17 @@
 glob x = 5, y = 2;
 
 test a {
-    check almostEqual(5, x);
+    assert almostEqual(5, x);
 }
 
 test b {
-    check "l" in "llm";
+    assert "l" in "llm";
 }
 
 test c {
-    check x - y == 3;
+    assert x - y == 3;
 }
 
 test d {
-    check 1 == 2;
+    assert 1 == 2;
 }

jaclang/tests/fixtures/params/param_syntax_err.jac

@@ -0,0 +1,9 @@
+
+
+def foo(a:int,/,/){}
+def foo(a:int,/,*,*){}
+def foo(a:int,/,*,**kwargs:int,*){}
+def foo(a:int,/,*,**kwargs:int,*){}
+def foo(a:int,/,*,**kwargs:int,/){}
+def foo(a:int,/,*,**kwargs:int,/){}
+def foo(a:int,/,*,/,**kwargs:int,/){}

jaclang/tests/fixtures/params/test_complex_params.jac

@@ -0,0 +1,42 @@
+# Test complex parameter combinations
+
+def ultimate_signature(
+    pos_only: int,
+    pos_def: str = "def",
+    /,
+    reg_def: bool = True,
+    *args: int,
+    kw_req: str,
+    kw_opt: int = 100,
+    **kwargs: any
+) -> str {
+    return f"{pos_only}|{pos_def}|{reg_def}|{len(args)}|{kw_req}|{kw_opt}|{len(kwargs)}";
+}
+
+def separators_only(/, *, x: int) -> int {
+    return x;
+}
+
+def edge_case_mix(a: int, /, b: str, *args: float, c: bool, **kwargs: str) -> str {
+    return f"{a}-{b}-{len(args)}-{c}-{len(kwargs)}";
+}
+
+def recursive_test(data: int, /, depth: int = 0, *, max_depth: int = 2) -> int {
+    if depth >= max_depth {
+        return data;
+    }
+    return recursive_test(data + 1, depth + 1, max_depth=max_depth);
+}
+
+def validation_test(x: int, y: str = "test", /, z: float, *args: int, w: bool, **kwargs: str) -> str {
+    return f"x:{x},y:{y},z:{z},args:{len(args)},w:{w},kwargs:{len(kwargs)}";
+}
+
+with entry {
+    print("ULTIMATE_MIN:", ultimate_signature(1, reg_def=2.5, kw_req="test"));
+    print("ULTIMATE_FULL:", ultimate_signature(1, "custom", 3.14, False, 10, 20, kw_req="req", kw_opt=200, extra="data"));
+    print("SEPARATORS:", separators_only(x=42));
+    print("EDGE_MIX:", edge_case_mix(1, "test", 1.1, 2.2, c=True, name="edge"));
+    print("RECURSIVE:", recursive_test(5), recursive_test(10, max_depth=1));
+    print("VALIDATION:", validation_test(1, 2.5, 10, 20, w=True, debug="on"));
+}

jaclang/tests/fixtures/params/test_failing_kwonly.jac

@@ -0,0 +1,207 @@
+# Test failing keyword-only parameter cases
+
+def strict_kwonly(*, x: int, y: str) -> str {
+    return f"{x}: {y}";
+}
+
+def kwonly_with_defaults(*, req: int, opt: str = "default") -> str {
+    return f"{req}-{opt}";
+}
+
+def mixed_kwonly(a: int, *, kw1: str, kw2: bool = False) -> dict {
+    return {"a": a, "kw1": kw1, "kw2": kw2};
+}
+
+def complex_kwonly(pos: int, /, reg: str, *args: float, kw_req: bool, kw_opt: int = 10, **kwargs: any) -> dict {
+    return {"pos": pos, "reg": reg, "args": list(args), "kw_req": kw_req, "kw_opt": kw_opt, "kwargs": kwargs};
+}
+
+def only_star_separator(*, x: int) -> int {
+    return x * 2;
+}
+
+def nested_kwonly_issues(*, outer: dict, inner: list = []) -> int {
+    return len(outer) + len(inner);
+}
+
+with entry {
+    print("=== TESTING KEYWORD-ONLY FAILURES ===");
+    
+    # Test 1: Calling kw-only with positional arguments
+    try {
+        result = strict_kwonly(42, "test");
+        print("❌ FAIL: Should reject positional for kw-only");
+    } except Exception as e {
+        print("✅ PASS: Caught kw-only positional error:", type(e).__name__);
+    }
+    
+    # Test 2: Missing required keyword-only argument
+    try {
+        result = strict_kwonly(x=42);
+        print("❌ FAIL: Should reject missing required kw-only");
+    } except Exception as e {
+        print("✅ PASS: Caught missing kw-only error:", type(e).__name__);
+    }
+    
+    # Test 3: Missing required in defaults mix
+    try {
+        result = kwonly_with_defaults(opt="custom");
+        print("❌ FAIL: Should reject missing required kw-only");
+    } except Exception as e {
+        print("✅ PASS: Caught missing required in defaults:", type(e).__name__);
+    }
+    
+    # Test 4: Extra unknown keyword arguments (without **kwargs)
+    try {
+        result = strict_kwonly(x=42, y="test", extra="unknown");
+        print("❌ FAIL: Should reject unknown keyword");
+    } except Exception as e {
+        print("✅ PASS: Caught unknown keyword error:", type(e).__name__);
+    }
+    
+    # Test 5: Mixed signature - wrong positional count
+    try {
+        result = mixed_kwonly(1, 2, kw1="test");
+        print("❌ FAIL: Should reject too many positional");
+    } except Exception as e {
+        print("✅ PASS: Caught too many positional error:", type(e).__name__);
+    }
+    
+    # Test 6: Mixed signature - missing kw-only required
+    try {
+        result = mixed_kwonly(42);
+        print("❌ FAIL: Should reject missing kw-only in mixed");
+    } except Exception as e {
+        print("✅ PASS: Caught missing kw-only in mixed:", type(e).__name__);
+    }
+    
+    # Test 7: Complex signature - kw-only as positional
+    try {
+        result = complex_kwonly(1, "reg", 1.5, True);
+        print("❌ FAIL: Should reject kw-only as positional");
+    } except Exception as e {
+        print("✅ PASS: Caught kw-only as positional error:", type(e).__name__);
+    }
+    
+    # Test 8: Complex signature - missing required kw-only
+    try {
+        result = complex_kwonly(1, "reg", 1.5, 2.5);
+        print("❌ FAIL: Should reject missing kw-only in complex");
+    } except Exception as e {
+        print("✅ PASS: Caught missing kw-only in complex:", type(e).__name__);
+    }
+    
+    # Test 9: Only star separator - positional call
+    try {
+        result = only_star_separator(42);
+        print("❌ FAIL: Should reject positional for star-only");
+    } except Exception as e {
+        print("✅ PASS: Caught star-only positional error:", type(e).__name__);
+    }
+    
+    
+    # Test 11: Mutable default issues
+    try {
+        result1 = nested_kwonly_issues(outer={"a": 1});
+        result2 = nested_kwonly_issues(outer={"b": 2});
+        print("✅ INFO: Mutable defaults - result1:", result1, "result2:", result2);
+    } except Exception as e {
+        print("❌ FAIL: Mutable defaults caused error:", type(e).__name__);
+    }
+    
+    # Test 12: Valid calls that should work
+    try {
+        result = strict_kwonly(x=42, y="valid");
+        print("✅ PASS: Valid kw-only call:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid kw-only call rejected:", type(e).__name__);
+    }
+    
+    try {
+        result = kwonly_with_defaults(req=100);
+        print("✅ PASS: Valid kw-only with defaults:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid defaults call rejected:", type(e).__name__);
+    }
+    
+    try {
+        result = mixed_kwonly(5, kw1="test");
+        print("✅ PASS: Valid mixed kw-only:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid mixed call rejected:", type(e).__name__);
+    }
+}
+
+def additional_kwonly_edge_cases() -> None {
+    print("\n=== ADDITIONAL KEYWORD-ONLY EDGE CASES ===");
+    
+    # Test 14: Keyword argument name conflicts with Python keywords
+    def python_keyword_conflicts(*, class_name: str, import_path: str = "default") -> str {
+        return f"{class_name}: {import_path}";
+    }
+    
+    try {
+        result = python_keyword_conflicts(class_name="TestClass");
+        print("✅ PASS: Python keyword as param name:", result);
+    } except Exception as e {
+        print("❌ FAIL: Python keyword param failed:", type(e).__name__);
+    }
+    
+    # Test 15: Very long keyword-only parameter lists
+    def many_kwonly_params(
+        *,
+        p1: int, p2: int, p3: int, p4: int, p5: int,
+        p6: str = "d6", p7: str = "d7", p8: str = "d8"
+    ) -> dict {
+        return {"sum": p1+p2+p3+p4+p5, "strings": [p6, p7, p8]};
+    }
+    
+    try {
+        result = many_kwonly_params(p1=1, p2=2, p3=3, p4=4, p5=5);
+        print("✅ PASS: Many kw-only params:", result);
+    } except Exception as e {
+        print("❌ FAIL: Many kw-only params failed:", type(e).__name__);
+    }
+    
+    # Test 16: Nested function calls as keyword arguments
+    def helper_func() -> str {
+        return "helper_result";
+    }
+    
+    def kwonly_with_function_calls(*, data: str, processed: bool = True) -> str {
+        return f"data={data}, processed={processed}";
+    }
+    
+    try {
+        result = kwonly_with_function_calls(data=helper_func(), processed=False);
+        print("✅ PASS: Function calls as kw args:", result);
+    } except Exception as e {
+        print("❌ FAIL: Function calls as kw args failed:", type(e).__name__);
+    }
+    
+    # Test 17: Empty string and special values
+    try {
+        result = strict_kwonly(x=0, y="");
+        print("✅ PASS: Edge values (0, empty string):", result);
+    } except Exception as e {
+        print("❌ FAIL: Edge values failed:", type(e).__name__);
+    }
+    
+    # Test 18: Really test duplicate keyword detection properly
+    # Note: This might not be detectable at runtime in some languages
+    def test_duplicate_detection() -> None {
+        try {
+            # This should be a syntax error, but let's see what happens
+            call_string = "strict_kwonly(x=42, y='test', x=99)";
+            print("INFO: Would test duplicate keywords, but this is syntax-level");
+        } except Exception as e {
+            print("✅ PASS: Duplicate detection works:", type(e).__name__);
+        }
+    }
+    
+    test_duplicate_detection();
+}
+
+with entry {
+    additional_kwonly_edge_cases();
+}