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

jaclang/runtimelib/machine.py

@@ -10,6 +10,7 @@ import sys
 import tempfile
 import types
 from collections import OrderedDict
+from collections.abc import Mapping, Sequence
 from concurrent.futures import Future, ThreadPoolExecutor
 from dataclasses import MISSING, dataclass, field
 from functools import wraps
@@ -27,6 +28,7 @@ from typing import (
     TypeVar,
     Union,
     cast,
+    get_type_hints,
 )
 from uuid import UUID
 
@@ -34,10 +36,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 (
@@ -55,6 +57,7 @@ from jaclang.runtimelib.constructs import (
     WalkerArchetype,
 )
 from jaclang.runtimelib.memory import Memory, Shelf, ShelfStorage
+from jaclang.runtimelib.mtp import MTIR
 from jaclang.runtimelib.utils import (
     all_issubclass,
     traverse_graph,
@@ -85,37 +88,31 @@ class ExecutionContext:
         self.mem: Memory = ShelfStorage(session)
         self.reports: list[Any] = []
         self.custom: Any = MISSING
-        if not isinstance(
-            system_root := self.mem.find_by_id(UUID(Con.SUPER_ROOT_UUID)), NodeAnchor
-        ):
-            system_root = cast(NodeAnchor, Root().__jac__)  # type: ignore[attr-defined]
-            system_root.id = UUID(Con.SUPER_ROOT_UUID)
-            self.mem.set(system_root.id, system_root)
-
-        self.system_root = system_root
-
-        self.entry_node = self.root_state = self.init_anchor(root, self.system_root)
+        self.system_root = self.mem.find_by_id(UUID(Con.SUPER_ROOT_UUID))
+        if not isinstance(self.system_root, NodeAnchor):
+            self.system_root = cast(NodeAnchor, Root().__jac__)
+            self.system_root.id = UUID(Con.SUPER_ROOT_UUID)
+            self.mem.set(self.system_root.id, self.system_root)
+        self.entry_node = self.root_state = (
+            self._get_anchor(root) if root else self.system_root
+        )
 
-    def init_anchor(
-        self,
-        anchor_id: str | None,
-        default: NodeAnchor,
-    ) -> NodeAnchor:
-        """Load initial anchors."""
-        if anchor_id:
-            if isinstance(anchor := self.mem.find_by_id(UUID(anchor_id)), NodeAnchor):
-                return anchor
+    def _get_anchor(self, anchor_id: str) -> NodeAnchor:
+        """Get anchor by ID or raise error."""
+        anchor = self.mem.find_by_id(UUID(anchor_id))
+        if not isinstance(anchor, NodeAnchor):
             raise ValueError(f"Invalid anchor id {anchor_id} !")
-        return default
+        return anchor
 
     def set_entry_node(self, entry_node: str | None) -> None:
-        """Override entry."""
-        self.entry_node = self.init_anchor(entry_node, self.root_state)
+        """Override entry node."""
+        self.entry_node = (
+            self._get_anchor(entry_node) if entry_node else self.root_state
+        )
 
     def close(self) -> None:
         """Close current ExecutionContext."""
         self.mem.close()
-        JacMachine.reset_machine()
 
     def get_root(self) -> Root:
         """Get current root."""
@@ -267,7 +264,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 +297,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 +334,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 +421,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 +685,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 +695,7 @@ class JacClassReferences:
     Root: TypeAlias = _Root
     GenericEdge: TypeAlias = _GenericEdge
 
-    Path: TypeAlias = DataSpatialPath
+    OPath: TypeAlias = ObjectSpatialPath
 
 
 class JacBuiltin:
@@ -967,45 +934,163 @@ class JacBasics:
         target: str,
         base_path: str,
         absorb: bool = False,
-        mdl_alias: Optional[str] = None,
         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 (
-            ImportPathSpec,
-            JacImporter,
-            PythonImporter,
-        )
+        """Import a Jac or Python module using Python's standard import machinery.
+
+        This function bridges Jac's import semantics with Python's import system,
+        leveraging importlib.import_module() which automatically invokes our
+        JacMetaImporter (registered in sys.meta_path).
+
+        Args:
+            target: Module name to import (e.g., "foo.bar" or ".relative")
+            base_path: Base directory for resolving the module
+            absorb: If True with items, return module instead of items
+            override_name: Special handling for "__main__" execution context
+            items: Specific items to import from module (like "from X import Y")
+            reload_module: Force reload even if already in sys.modules
+            lng: Language hint ("jac", "py", etc.) - auto-detected if None
+
+        Returns:
+            Tuple of imported module(s) or item(s)
+
+        Examples:
+            # Import entire module
+            (mod,) = jac_import("mymod", "/path/to/base")
+
+            # Import specific items
+            (func, cls) = jac_import("mymod", "/path", items={"myfunc": None, "MyClass": None})
+
+            # Run as __main__
+            jac_import("mymod", "/path", override_name="__main__")
+        """
+        import importlib
+        import importlib.util
 
         if lng is None:
             lng = infer_language(target, base_path)
 
-        spec = ImportPathSpec(
-            target,
-            base_path,
-            absorb,
-            mdl_alias,
-            override_name,
-            lng,
-            items,
-        )
-
         if not JacMachine.program:
             JacMachineInterface.attach_program(JacProgram())
 
-        if lng == "py":
-            import_result = PythonImporter().run_import(spec)
+        # Compute the module name
+        # Convert relative imports (e.g., ".foo") to absolute
+        if target.startswith("."):
+            # Relative import - need to resolve against base_path
+            caller_dir = (
+                base_path if os.path.isdir(base_path) else os.path.dirname(base_path)
+            )
+            chomp_target = target
+            while chomp_target.startswith("."):
+                if len(chomp_target) > 1 and chomp_target[1] == ".":
+                    caller_dir = os.path.dirname(caller_dir)
+                    chomp_target = chomp_target[1:]
+                else:
+                    chomp_target = chomp_target[1:]
+                    break
+            module_name = chomp_target
         else:
-            import_result = JacImporter().run_import(spec, reload_module)
+            module_name = target
 
-        return (
-            (import_result.ret_mod,)
-            if absorb or not items
-            else tuple(import_result.ret_items)
+        # Add base_path to sys.path for import resolution
+        # The meta importer uses this for finding modules
+        caller_dir = (
+            base_path if os.path.isdir(base_path) else os.path.dirname(base_path)
         )
+        original_path = None
+
+        # Only modify sys.path if the directory isn't already there
+        if caller_dir and caller_dir not in sys.path:
+            original_path = sys.path.copy()
+            sys.path.insert(0, caller_dir)
+
+        try:
+            # Handle special case: override_name="__main__" means run as script
+            if override_name == "__main__":
+                # For __main__ execution, we use spec_from_file_location
+                from jaclang.runtimelib.meta_importer import JacMetaImporter
+
+                finder = JacMetaImporter()
+                # Pass None as path for top-level imports (e.g., "micro.simple_walk")
+                # This ensures the meta importer searches sys.path correctly
+                spec = finder.find_spec(module_name, None)
+                if (
+                    spec
+                    and spec.origin
+                    and spec.origin.endswith(".jac")
+                    and lng == "py"
+                ):
+                    spec = None
+
+                if (not spec or not spec.origin) and lng == "py":
+                    file_path = os.path.join(caller_dir, f"{module_name}.py")
+                    if os.path.isfile(file_path):
+                        spec_name = (
+                            "__main__" if override_name == "__main__" else module_name
+                        )
+                        spec = importlib.util.spec_from_file_location(
+                            spec_name, file_path
+                        )
+
+                if not spec or not spec.origin:
+                    raise ImportError(f"Cannot find module {module_name}")
+
+                # Create or get __main__ module
+                if "__main__" in sys.modules and not reload_module:
+                    module = sys.modules["__main__"]
+                    # Clear the module's dict except for special attributes
+                    to_keep = {
+                        k: v for k, v in module.__dict__.items() if k.startswith("__")
+                    }
+                    # module.__dict__.clear()
+                    module.__dict__.update(to_keep)
+                else:
+                    module = types.ModuleType("__main__")
+                    sys.modules["__main__"] = module
+
+                # Set module attributes
+                module.__file__ = spec.origin
+                module.__name__ = "__main__"
+                module.__spec__ = spec
+                if spec.submodule_search_locations:
+                    module.__path__ = spec.submodule_search_locations
+
+                # Register in JacMachine
+                JacMachineInterface.load_module("__main__", module)
+
+                # Execute the module
+                if spec.loader:
+                    spec.loader.exec_module(module)
+            elif reload_module and module_name in sys.modules:
+                # Handle reload case
+                module = importlib.reload(sys.modules[module_name])
+            else:
+                # Use Python's standard import machinery
+                # This will invoke JacMetaImporter.find_spec() and exec_module()
+                module = importlib.import_module(module_name)
+
+            # Handle selective item imports
+            if items:
+                imported_items = []
+                for item_name, _ in items.items():
+                    if hasattr(module, item_name):
+                        item = getattr(module, item_name)
+                        imported_items.append(item)
+                    else:
+                        raise ImportError(
+                            f"Cannot import name '{item_name}' from '{module_name}'"
+                        )
+                return tuple(imported_items) if not absorb else (module,)
+
+            return (module,)
+
+        finally:
+            # Restore original sys.path if we modified it
+            if original_path is not None:
+                sys.path[:] = original_path
 
     @staticmethod
     def jac_test(test_fun: Callable) -> Callable:
@@ -1021,6 +1106,30 @@ class JacBasics:
 
         return test_deco
 
+    @staticmethod
+    def jsx(
+        tag: object,
+        attributes: Mapping[str, object] | None = None,
+        children: Sequence[object] | None = None,
+    ) -> dict[str, object]:
+        """JSX interface for creating elements.
+
+        Args:
+            tag: Element tag (string for HTML elements, callable for components)
+            attributes: Element attributes/props
+            children: Child elements
+
+        Returns:
+            JSX element representation (implementation-defined)
+        """
+        props: dict[str, object] = dict(attributes) if attributes else {}
+        child_list = list(children) if children else []
+        return {
+            "tag": tag,
+            "props": props,
+            "children": child_list,
+        }
+
     @staticmethod
     def run_test(
         filepath: str,
@@ -1096,23 +1205,24 @@ class JacBasics:
         return field(init=init)
 
     @staticmethod
-    def report(expr: Any, custom: bool = False) -> None:  # noqa: ANN401
+    def log_report(expr: Any, custom: bool = False) -> None:  # noqa: ANN401
         """Jac's report stmt feature."""
         ctx = JacMachineInterface.get_context()
         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
 
@@ -1134,13 +1244,13 @@ class JacBasics:
 
     @staticmethod
     async def arefs(
-        path: DataSpatialPath | NodeArchetype | list[NodeArchetype],
+        path: ObjectSpatialPath | NodeArchetype | list[NodeArchetype],
     ) -> None:
         """Jac's apply_dir stmt feature."""
         pass
 
     @staticmethod
-    def filter(
+    def filter_on(
         items: list[Archetype],
         func: Callable[[Archetype], bool],
     ) -> list[Archetype]:
@@ -1226,7 +1336,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
@@ -1328,17 +1438,28 @@ 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[int | str, object], call_params: dict[str, object]
+    ) -> MTIR:
+        """Get byLLM library."""
+        return MTIR(caller=caller, args=args, call_params=call_params)
+
     @staticmethod
     def sem(semstr: str, inner_semstr: dict[str, str]) -> Callable:
         """Attach the semstring to the given object."""
@@ -1351,11 +1472,47 @@ class JacBasics:
         return decorator
 
     @staticmethod
-    def call_llm(model: object, mtir: object) -> Any:  # noqa: ANN401
+    def call_llm(model: object, mtir: MTIR) -> Any:  # noqa: ANN401
         """Call the LLM model."""
-        raise ImportError(
-            "byLLM is not installed. Please install it with `pip install byllm` and run `jac clean`."
-        )
+        from jaclang.utils.NonGPT import random_value_for_type
+
+        try:
+            type_hints = get_type_hints(
+                mtir.caller,
+                globalns=getattr(mtir.caller, "__globals__", {}),
+                localns=None,
+                include_extras=True,
+            )
+        except Exception:
+            type_hints = getattr(mtir.caller, "__annotations__", {})
+        return_type = type_hints.get("return", Any)
+
+        # Generate and return a random value matching the return type
+        return random_value_for_type(return_type)
+
+    @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:
@@ -1387,7 +1544,11 @@ class JacUtils:
         if module:
             walkers = []
             for name, obj in inspect.getmembers(module):
-                if isinstance(obj, type) and issubclass(obj, WalkerArchetype):
+                if (
+                    isinstance(obj, type)
+                    and issubclass(obj, WalkerArchetype)
+                    and obj.__module__ == module_name
+                ):
                     walkers.append(name)
             return walkers
         return []
@@ -1399,7 +1560,11 @@ class JacUtils:
         if module:
             nodes = []
             for name, obj in inspect.getmembers(module):
-                if isinstance(obj, type) and issubclass(obj, NodeArchetype):
+                if (
+                    isinstance(obj, type)
+                    and issubclass(obj, NodeArchetype)
+                    and obj.__module__ == module_name
+                ):
                     nodes.append(name)
             return nodes
         return []
@@ -1409,11 +1574,15 @@ class JacUtils:
         """List all edges in a specific module."""
         module = JacMachine.loaded_modules.get(module_name)
         if module:
-            nodes = []
+            edges = []
             for name, obj in inspect.getmembers(module):
-                if isinstance(obj, type) and issubclass(obj, EdgeArchetype):
-                    nodes.append(name)
-            return nodes
+                if (
+                    isinstance(obj, type)
+                    and issubclass(obj, EdgeArchetype)
+                    and obj.__module__ == module_name
+                ):
+                    edges.append(name)
+            return edges
         return []
 
     @staticmethod
@@ -1424,9 +1593,11 @@ class JacUtils:
         cachable: bool = False,
         keep_temporary_files: bool = False,
     ) -> Optional[types.ModuleType]:
-        """Dynamically creates archetypes (nodes, walkers, etc.) from Jac source code."""
-        from jaclang.runtimelib.importer import JacImporter, ImportPathSpec
+        """Dynamically creates archetypes (nodes, walkers, etc.) from Jac source code.
 
+        This leverages Python's standard import machinery via jac_import(),
+        which will automatically invoke JacMetaImporter.
+        """
         if not base_path:
             base_path = JacMachine.base_path_dir or os.getcwd()
 
@@ -1434,6 +1605,7 @@ class JacUtils:
             os.makedirs(base_path)
         if not module_name:
             module_name = f"_dynamic_module_{len(JacMachine.loaded_modules)}"
+
         with tempfile.NamedTemporaryFile(
             mode="w",
             suffix=".jac",
@@ -1445,24 +1617,20 @@ class JacUtils:
             tmp_file.write(source_code)
 
         try:
-            importer = JacImporter()
             tmp_file_basename = os.path.basename(tmp_file_path)
             tmp_module_name, _ = os.path.splitext(tmp_file_basename)
 
-            spec = ImportPathSpec(
+            # Use simplified jac_import which delegates to importlib
+            result = JacMachineInterface.jac_import(
                 target=tmp_module_name,
                 base_path=base_path,
-                absorb=False,
-                mdl_alias=None,
                 override_name=module_name,
                 lng="jac",
-                items=None,
             )
+            module = result[0] if result else None
 
-            import_result = importer.run_import(spec, reload=False)
-            module = import_result.ret_mod
-
-            JacMachine.loaded_modules[module_name] = module
+            if module:
+                JacMachine.loaded_modules[module_name] = module
             return module
         except Exception as e:
             logger.error(f"Error importing dynamic module '{module_name}': {e}")
@@ -1476,36 +1644,31 @@ class JacUtils:
         module_name: str,
         items: Optional[dict[str, Union[str, Optional[str]]]],
     ) -> tuple[types.ModuleType, ...]:
-        """Reimport the module."""
-        from .importer import JacImporter, ImportPathSpec
-
+        """Reimport the module using Python's reload mechanism."""
         if module_name in JacMachine.loaded_modules:
             try:
                 old_module = JacMachine.loaded_modules[module_name]
-                importer = JacImporter()
-                spec = ImportPathSpec(
+
+                # Use jac_import with reload flag
+                result = JacMachineInterface.jac_import(
                     target=module_name,
                     base_path=JacMachine.base_path_dir,
-                    absorb=False,
-                    mdl_alias=None,
-                    override_name=None,
-                    lng="jac",
                     items=items,
+                    reload_module=True,
+                    lng="jac",
                 )
-                import_result = importer.run_import(spec, reload=True)
-                ret_items = []
+
+                # Update the old module's attributes if specific items were requested
                 if items:
-                    for item_name in items:
-                        if hasattr(old_module, item_name):
-                            new_attr = getattr(import_result.ret_mod, item_name, None)
-                            if new_attr:
-                                ret_items.append(new_attr)
-                                setattr(
-                                    old_module,
-                                    item_name,
-                                    new_attr,
-                                )
-                return (old_module,) if not items else tuple(ret_items)
+                    ret_items = []
+                    for idx, item_name in enumerate(items.keys()):
+                        if hasattr(old_module, item_name) and idx < len(result):
+                            new_attr = result[idx]
+                            ret_items.append(new_attr)
+                            setattr(old_module, item_name, new_attr)
+                    return tuple(ret_items)
+
+                return (old_module,)
             except Exception as e:
                 logger.error(f"Failed to update module {module_name}: {e}")
         else:
@@ -1573,6 +1736,7 @@ class JacMachineInterface(
     JacBuiltin,
     JacCmd,
     JacBasics,
+    JacByLLM,
     JacUtils,
 ):
     """Jac Feature."""
@@ -1710,10 +1874,15 @@ class JacMachine(JacMachineInterface):
     @staticmethod
     def reset_machine() -> None:
         """Reset the machine."""
-        # for i in JacMachine.loaded_modules.values():
-        #     sys.modules.pop(i.__name__, None)
+        # Remove Jac modules from sys.modules, but skip special module names
+        # that Python relies on (like __main__, __mp_main__, etc.)
+        special_modules = {"__main__", "__mp_main__", "builtins"}
+        for i in JacMachine.loaded_modules.values():
+            if i.__name__ not in special_modules:
+                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.mem.close()
         JacMachine.exec_ctx = ExecutionContext()