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

jaclang/runtimelib/machine.py

@@ -34,10 +34,10 @@ from uuid import UUID
 from jaclang.compiler.constant import Constants as Con, EdgeDir, colors
 from jaclang.compiler.program import JacProgram
 from jaclang.runtimelib.archetype import (
-    DataSpatialDestination,
-    DataSpatialFunction,
-    DataSpatialPath,
     GenericEdge as _GenericEdge,
+    ObjectSpatialDestination,
+    ObjectSpatialFunction,
+    ObjectSpatialPath,
     Root as _Root,
 )
 from jaclang.runtimelib.constructs import (
@@ -267,7 +267,7 @@ class JacNode:
 
     @staticmethod
     def get_edges(
-        origin: list[NodeArchetype], destination: DataSpatialDestination
+        origin: list[NodeArchetype], destination: ObjectSpatialDestination
     ) -> list[EdgeArchetype]:
         """Get edges connected to this node."""
         edges: OrderedDict[EdgeAnchor, EdgeArchetype] = OrderedDict()
@@ -300,7 +300,7 @@ class JacNode:
     @staticmethod
     def get_edges_with_node(
         origin: list[NodeArchetype],
-        destination: DataSpatialDestination,
+        destination: ObjectSpatialDestination,
         from_visit: bool = False,
     ) -> list[EdgeArchetype | NodeArchetype]:
         """Get edges connected to this node and the node."""
@@ -337,7 +337,7 @@ class JacNode:
 
     @staticmethod
     def edges_to_nodes(
-        origin: list[NodeArchetype], destination: DataSpatialDestination
+        origin: list[NodeArchetype], destination: ObjectSpatialDestination
     ) -> list[NodeArchetype]:
         """Get set of nodes connected to this node."""
         nodes: OrderedDict[NodeAnchor, NodeArchetype] = OrderedDict()
@@ -424,36 +424,6 @@ class JacWalker:
         else:
             raise TypeError("Invalid walker object")
 
-    @staticmethod
-    def ignore(
-        walker: WalkerArchetype,
-        expr: (
-            list[NodeArchetype | EdgeArchetype]
-            | list[NodeArchetype]
-            | list[EdgeArchetype]
-            | NodeArchetype
-            | EdgeArchetype
-        ),
-    ) -> bool:  # noqa: ANN401
-        """Jac's ignore stmt feature."""
-        if isinstance(walker, WalkerArchetype):
-            wanch = walker.__jac__
-            before_len = len(wanch.ignores)
-            for anchor in (
-                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
-            ):
-                if anchor not in wanch.ignores:
-                    if isinstance(anchor, NodeAnchor):
-                        wanch.ignores.append(anchor)
-                    elif isinstance(anchor, EdgeAnchor):
-                        if target := anchor.target:
-                            wanch.ignores.append(target)
-                        else:
-                            raise ValueError("Edge has no target.")
-            return len(wanch.ignores) > before_len
-        else:
-            raise TypeError("Invalid walker object")
-
     @staticmethod
     def spawn_call(
         walker: WalkerAnchor,
@@ -718,7 +688,7 @@ class JacClassReferences:
 
     TYPE_CHECKING: bool = TYPE_CHECKING
     EdgeDir: TypeAlias = EdgeDir
-    DSFunc: TypeAlias = DataSpatialFunction
+    DSFunc: TypeAlias = ObjectSpatialFunction
 
     Obj: TypeAlias = Archetype
     Node: TypeAlias = NodeArchetype
@@ -728,7 +698,7 @@ class JacClassReferences:
     Root: TypeAlias = _Root
     GenericEdge: TypeAlias = _GenericEdge
 
-    Path: TypeAlias = DataSpatialPath
+    Path: TypeAlias = ObjectSpatialPath
 
 
 class JacBuiltin:
@@ -1102,17 +1072,18 @@ class JacBasics:
         if custom:
             ctx.custom = expr
         else:
+            print(expr)
             ctx.reports.append(expr)
 
     @staticmethod
     def refs(
-        path: DataSpatialPath | NodeArchetype | list[NodeArchetype],
+        path: ObjectSpatialPath | NodeArchetype | list[NodeArchetype],
     ) -> (
         list[NodeArchetype] | list[EdgeArchetype] | list[NodeArchetype | EdgeArchetype]
     ):
         """Jac's apply_dir stmt feature."""
-        if not isinstance(path, DataSpatialPath):
-            path = DataSpatialPath(path, [DataSpatialDestination(EdgeDir.OUT)])
+        if not isinstance(path, ObjectSpatialPath):
+            path = ObjectSpatialPath(path, [ObjectSpatialDestination(EdgeDir.OUT)])
 
         origin = path.origin
 
@@ -1133,7 +1104,14 @@ class JacBasics:
         return origin
 
     @staticmethod
-    def filter(
+    async def arefs(
+        path: ObjectSpatialPath | NodeArchetype | list[NodeArchetype],
+    ) -> None:
+        """Jac's apply_dir stmt feature."""
+        pass
+
+    @staticmethod
+    def filter_on(
         items: list[Archetype],
         func: Callable[[Archetype], bool],
     ) -> list[Archetype]:
@@ -1219,7 +1197,7 @@ class JacBasics:
         return disconnect_occurred
 
     @staticmethod
-    def assign(target: list[T], attr_val: tuple[tuple[str], tuple[Any]]) -> list[T]:
+    def assign_all(target: list[T], attr_val: tuple[tuple[str], tuple[Any]]) -> list[T]:
         """Jac's assign comprehension feature."""
         for obj in target:
             attrs, values = attr_val
@@ -1321,17 +1299,26 @@ class JacBasics:
                 JacMachineInterface.get_context().mem.remove(anchor.id)
 
     @staticmethod
-    def entry(func: Callable) -> Callable:
+    def on_entry(func: Callable) -> Callable:
         """Mark a method as jac entry with this decorator."""
         setattr(func, "__jac_entry", None)  # noqa:B010
         return func
 
     @staticmethod
-    def exit(func: Callable) -> Callable:
+    def on_exit(func: Callable) -> Callable:
         """Mark a method as jac exit with this decorator."""
         setattr(func, "__jac_exit", None)  # noqa:B010
         return func
 
+
+class JacByLLM:
+    """Jac byLLM integration."""
+
+    @staticmethod
+    def get_mtir(caller: Callable, args: dict, call_params: dict) -> object:
+        """Get byLLM library."""
+        return None
+
     @staticmethod
     def sem(semstr: str, inner_semstr: dict[str, str]) -> Callable:
         """Attach the semstring to the given object."""
@@ -1345,11 +1332,39 @@ class JacBasics:
 
     @staticmethod
     def call_llm(model: object, mtir: object) -> Any:  # noqa: ANN401
-        """Call the LLM model."""
+        """Call the LLM model.
+
+        Note: This is for future uses of the feature in contexts that cannot be decorated.
+        For most use cases, use the `by` decorator instead.
+        """
         raise ImportError(
             "byLLM is not installed. Please install it with `pip install byllm` and run `jac clean`."
         )
 
+    @staticmethod
+    def by(model: object) -> Callable:
+        """Python library mode decorator for Jac's by llm() syntax."""
+
+        def _decorator(caller: Callable) -> Callable:
+            def _wrapped_caller(*args: object, **kwargs: object) -> object:
+                invoke_args: dict[int | str, object] = {}
+                for i, arg in enumerate(args):
+                    invoke_args[i] = arg
+                for key, value in kwargs.items():
+                    invoke_args[key] = value
+                mtir = JacMachine.get_mtir(
+                    caller=caller,
+                    args=invoke_args,
+                    call_params=(
+                        model.call_params if hasattr(model, "call_params") else {}
+                    ),
+                )
+                return JacMachine.call_llm(model, mtir)
+
+            return _wrapped_caller
+
+        return _decorator
+
 
 class JacUtils:
     """Jac Machine Utilities."""
@@ -1566,6 +1581,7 @@ class JacMachineInterface(
     JacBuiltin,
     JacCmd,
     JacBasics,
+    JacByLLM,
     JacUtils,
 ):
     """Jac Feature."""
@@ -1709,4 +1725,5 @@ class JacMachine(JacMachineInterface):
         JacMachine.base_path_dir = os.getcwd()
         JacMachine.program = JacProgram()
         JacMachine.pool = ThreadPoolExecutor()
+        JacMachine.exec_ctx.mem.close()
         JacMachine.exec_ctx = ExecutionContext()

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
 
 
@@ -13,17 +14,21 @@ class Settings:
     filter_sym_builtins: bool = True
     ast_symbol_info_detailed: bool = False
     pass_timer: bool = False
-    collect_py_dep_debug: bool = False
     print_py_raised_ast: bool = False
 
     # Compiler configuration
-    disable_mtllm: bool = False
     ignore_test_annex: bool = False
-    pyout_jaclib_alias: str = "_"
+    pyout_jaclib_alias: str = "_jl"
+    library_mode: bool = False
+    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 +47,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 +71,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/attr_pattern_case.jac

@@ -0,0 +1,18 @@
+obj A {
+    has b: B;
+}
+obj B {
+    has c: str;
+}
+
+
+with entry {
+    expr = "Hello Jaseci!";
+    a = A(B(expr));
+    match expr {
+        case a.b.c:
+            print("Matched a.b.c", a.b.c);
+        case _:
+            print("No match");
+    }
+}

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/funccall_genexpr.jac

@@ -0,0 +1,7 @@
+def total(values: Any) {
+    return sum(values);
+}
+with entry {
+    result = total((x * x) for x in range(5));
+    print(f"Result: {result}");
+}

jaclang/tests/fixtures/funccall_genexpr.py

@@ -0,0 +1,5 @@
+def total(values):
+    return sum(values)
+
+result = total((x * x) for x in range(5))
+print(result) 

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"));
+}