jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/{core → runtimelib}/context.py

@@ -4,73 +4,100 @@ from __future__ import annotations
 
 import unittest
 from contextvars import ContextVar
-from typing import Callable, Optional
+from typing import Any, Callable, Optional, cast
 from uuid import UUID
 
-from .architype import Architype, Root
-from .memory import Memory, ShelveStorage
+from .architype import NodeAnchor, Root
+from .memory import Memory, ShelfStorage
+
+
+EXECUTION_CONTEXT = ContextVar[Optional["ExecutionContext"]]("ExecutionContext")
+
+SUPER_ROOT_UUID = UUID("00000000-0000-0000-0000-000000000000")
+SUPER_ROOT_ARCHITYPE = object.__new__(Root)
+SUPER_ROOT_ANCHOR = NodeAnchor(
+    id=SUPER_ROOT_UUID, architype=SUPER_ROOT_ARCHITYPE, persistent=False, edges=[]
+)
+SUPER_ROOT_ARCHITYPE.__jac__ = SUPER_ROOT_ANCHOR
 
 
 class ExecutionContext:
-    """Default Execution Context implementation."""
+    """Execution Context."""
+
+    mem: Memory
+    reports: list[Any]
+    system_root: NodeAnchor
+    root: NodeAnchor
+    entry_node: NodeAnchor
 
-    mem: Optional[Memory]
-    root: Optional[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
+            raise ValueError(f"Invalid anchor id {anchor_id} !")
+        return default
+
+    def validate_access(self) -> bool:
+        """Validate access."""
+        return self.root.has_read_access(self.entry_node)
+
+    def set_entry_node(self, entry_node: str | None) -> None:
+        """Override entry."""
+        self.entry_node = self.init_anchor(entry_node, self.root)
+
+    def close(self) -> None:
+        """Close current ExecutionContext."""
+        self.mem.close()
+        EXECUTION_CONTEXT.set(None)
 
-    def __init__(self) -> None:
-        """Create execution context."""
-        super().__init__()
-        self.mem = ShelveStorage()
-        self.root = None
+    @staticmethod
+    def create(
+        session: Optional[str] = None,
+        root: Optional[str] = None,
+        auto_close: bool = True,
+    ) -> ExecutionContext:
+        """Create ExecutionContext."""
+        ctx = ExecutionContext()
+        ctx.mem = ShelfStorage(session)
+        ctx.reports = []
 
-    def init_memory(self, session: str = "") -> None:
-        """Initialize memory."""
-        if session:
-            self.mem = ShelveStorage(session)
-        else:
-            self.mem = Memory()
-
-    def get_root(self) -> Root:
-        """Get the root object."""
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        if not self.root:
-            root = self.mem.get_obj(UUID(int=0))
-            if root is None:
-                self.root = Root()
-                self.mem.save_obj(self.root, persistent=self.root._jac_.persistent)
-            elif not isinstance(root, Root):
-                raise ValueError(f"Invalid root object: {root}")
-            else:
-                self.root = root
-        return self.root
-
-    def get_obj(self, obj_id: UUID) -> Architype | None:
-        """Get object from memory."""
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        return self.mem.get_obj(obj_id)
-
-    def save_obj(self, item: Architype, persistent: bool) -> None:
-        """Save object to memory."""
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        self.mem.save_obj(item, persistent)
-
-    def reset(self) -> None:
-        """Reset the execution context."""
-        if self.mem:
-            self.mem.close()
-        self.mem = None
-        self.root = None
-
-
-exec_context: ContextVar[ExecutionContext | None] = ContextVar(
-    "ExecutionContext", default=None
-)
+        if not isinstance(
+            system_root := ctx.mem.find_by_id(SUPER_ROOT_UUID), NodeAnchor
+        ):
+            system_root = Root().__jac__
+            system_root.id = SUPER_ROOT_UUID
+            ctx.mem.set(system_root.id, system_root)
+
+        ctx.system_root = system_root
+
+        ctx.entry_node = ctx.root = ctx.init_anchor(root, ctx.system_root)
+
+        if auto_close and (old_ctx := EXECUTION_CONTEXT.get(None)):
+            old_ctx.close()
+
+        EXECUTION_CONTEXT.set(ctx)
+
+        return ctx
+
+    @staticmethod
+    def get() -> ExecutionContext:
+        """Get current ExecutionContext."""
+        if ctx := EXECUTION_CONTEXT.get(None):
+            return ctx
+        raise Exception("ExecutionContext is not yet available!")
+
+    @staticmethod
+    def get_root() -> Root:
+        """Get current root."""
+        if ctx := EXECUTION_CONTEXT.get(None):
+            return cast(Root, ctx.root.architype)
+
+        return SUPER_ROOT_ARCHITYPE
 
 
 class JacTestResult(unittest.TextTestResult):

jaclang/runtimelib/importer.py

@@ -0,0 +1,361 @@
+"""Special Imports for Jac Code."""
+
+from __future__ import annotations
+
+import importlib
+import os
+import sys
+import types
+from os import getcwd, path
+from typing import Optional, Union
+
+from jaclang.runtimelib.machine import JacMachine
+from jaclang.runtimelib.utils import sys_path_context
+from jaclang.utils.helpers import dump_traceback
+from jaclang.utils.log import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ImportPathSpec:
+    """Import Specification."""
+
+    def __init__(
+        self,
+        target: str,
+        base_path: str,
+        absorb: bool,
+        cachable: bool,
+        mdl_alias: Optional[str],
+        override_name: Optional[str],
+        lng: Optional[str],
+        items: Optional[dict[str, Union[str, Optional[str]]]],
+    ) -> None:
+        """Initialize the ImportPathSpec object."""
+        self.target = target
+        self.base_path = base_path
+        self.absorb = absorb
+        self.cachable = cachable
+        self.mdl_alias = mdl_alias
+        self.override_name = override_name
+        self.language = lng
+        self.items = items
+        self.dir_path, self.file_name = path.split(path.join(*(target.split("."))))
+        self.module_name = path.splitext(self.file_name)[0]
+        self.package_path = self.dir_path.replace(path.sep, ".")
+        self.caller_dir = self.get_caller_dir()
+        self.full_target = path.abspath(path.join(self.caller_dir, self.file_name))
+
+    def get_caller_dir(self) -> str:
+        """Get the directory of the caller."""
+        caller_dir = (
+            self.base_path
+            if path.isdir(self.base_path)
+            else path.dirname(self.base_path)
+        )
+        caller_dir = caller_dir if caller_dir else getcwd()
+        chomp_target = self.target
+        if chomp_target.startswith("."):
+            chomp_target = chomp_target[1:]
+            while chomp_target.startswith("."):
+                caller_dir = path.dirname(caller_dir)
+                chomp_target = chomp_target[1:]
+        return path.join(caller_dir, self.dir_path)
+
+
+class ImportReturn:
+    """Import Return Object."""
+
+    def __init__(
+        self,
+        ret_mod: types.ModuleType,
+        ret_items: list[types.ModuleType],
+        importer: Importer,
+    ) -> None:
+        """Initialize the ImportReturn object."""
+        self.ret_mod = ret_mod
+        self.ret_items = ret_items
+        self.importer = importer
+
+    def process_items(
+        self,
+        module: types.ModuleType,
+        items: dict[str, Union[str, Optional[str]]],
+        caller_dir: str,
+        lang: Optional[str],
+        cachable: bool = True,
+    ) -> None:
+        """Process items within a module by handling renaming and potentially loading missing attributes."""
+
+        def handle_item_loading(
+            item: types.ModuleType, alias: Union[str, Optional[str]]
+        ) -> None:
+            if item:
+                self.ret_items.append(item)
+                setattr(module, name, item)
+                if alias and alias != name and not isinstance(alias, bool):
+                    setattr(module, alias, item)
+
+        for name, alias in items.items():
+            try:
+                item = getattr(module, name)
+                handle_item_loading(item, alias)
+            except AttributeError:
+                if lang == "jac":
+                    jac_file_path = (
+                        os.path.join(module.__path__[0], f"{name}.jac")
+                        if hasattr(module, "__path__")
+                        else module.__file__
+                    )
+
+                    if jac_file_path and os.path.isfile(jac_file_path):
+                        item = self.load_jac_mod_as_item(
+                            module=module,
+                            name=name,
+                            jac_file_path=jac_file_path,
+                            cachable=cachable,
+                            caller_dir=caller_dir,
+                        )
+                        handle_item_loading(item, alias)
+                else:
+                    if hasattr(module, "__path__"):
+                        full_module_name = f"{module.__name__}.{name}"
+                        item = importlib.import_module(full_module_name)
+                        handle_item_loading(item, alias)
+
+    def load_jac_mod_as_item(
+        self,
+        module: types.ModuleType,
+        name: str,
+        jac_file_path: str,
+        cachable: bool,
+        caller_dir: str,
+    ) -> Optional[types.ModuleType]:
+        """Load a single .jac file into the specified module component."""
+        try:
+            package_name = (
+                f"{module.__name__}.{name}"
+                if hasattr(module, "__path__")
+                else module.__name__
+            )
+            if isinstance(self.importer, JacImporter):
+                new_module = self.importer.jac_machine.loaded_modules.get(
+                    package_name,
+                    self.importer.create_jac_py_module(
+                        self.importer.get_sys_mod_name(jac_file_path),
+                        module.__name__,
+                        jac_file_path,
+                    ),
+                )
+            codeobj = self.importer.jac_machine.get_bytecode(
+                name, jac_file_path, caller_dir=caller_dir, cachable=cachable
+            )
+            if not codeobj:
+                raise ImportError(f"No bytecode found for {jac_file_path}")
+
+            exec(codeobj, new_module.__dict__)
+            return getattr(new_module, name, new_module)
+        except ImportError as e:
+            logger.error(dump_traceback(e))
+            # logger.error(
+            #     f"Failed to load {name} from {jac_file_path} in {module.__name__}: {str(e)}"
+            # )
+            return None
+
+
+class Importer:
+    """Abstract base class for all importers."""
+
+    def __init__(self, jac_machine: JacMachine) -> None:
+        """Initialize the Importer object."""
+        self.jac_machine = jac_machine
+        self.result: Optional[ImportReturn] = None
+
+    def run_import(self, spec: ImportPathSpec) -> ImportReturn:
+        """Run the import process."""
+        raise NotImplementedError
+
+    def update_sys(self, module: types.ModuleType, spec: ImportPathSpec) -> None:
+        """Update sys.modules with the newly imported module."""
+        if spec.module_name not in self.jac_machine.loaded_modules:
+            self.jac_machine.load_module(spec.module_name, module)
+
+
+class PythonImporter(Importer):
+    """Importer for Python modules."""
+
+    def __init__(self, jac_machine: JacMachine) -> None:
+        """Initialize the PythonImporter object."""
+        self.jac_machine = jac_machine
+
+    def run_import(self, spec: ImportPathSpec) -> ImportReturn:
+        """Run the import process for Python modules."""
+        try:
+            loaded_items: list = []
+            if spec.target.startswith("."):
+                spec.target = spec.target.lstrip(".")
+                full_target = path.normpath(path.join(spec.caller_dir, spec.target))
+                imp_spec = importlib.util.spec_from_file_location(
+                    spec.target, full_target + ".py"
+                )
+                if imp_spec and imp_spec.loader:
+                    imported_module = importlib.util.module_from_spec(imp_spec)
+                    sys.modules[imp_spec.name] = imported_module
+                    imp_spec.loader.exec_module(imported_module)
+                else:
+                    raise ImportError(
+                        f"Cannot find module {spec.target} at {full_target}"
+                    )
+            else:
+                imported_module = importlib.import_module(name=spec.target)
+
+            main_module = __import__("__main__")
+            if spec.absorb:
+                for name in dir(imported_module):
+                    if not name.startswith("_"):
+                        setattr(main_module, name, getattr(imported_module, name))
+
+            elif spec.items:
+                for name, alias in spec.items.items():
+                    if isinstance(alias, bool):
+                        alias = name
+                    try:
+                        item = getattr(imported_module, name)
+                        if item not in loaded_items:
+                            setattr(
+                                main_module,
+                                alias if isinstance(alias, str) else name,
+                                item,
+                            )
+                            loaded_items.append(item)
+                    except AttributeError as e:
+                        if hasattr(imported_module, "__path__"):
+                            item = importlib.import_module(f"{spec.target}.{name}")
+                            if item not in loaded_items:
+                                setattr(
+                                    main_module,
+                                    alias if isinstance(alias, str) else name,
+                                    item,
+                                )
+                                loaded_items.append(item)
+                        else:
+                            raise e
+
+            else:
+                setattr(
+                    __import__("__main__"),
+                    spec.mdl_alias if isinstance(spec.mdl_alias, str) else spec.target,
+                    imported_module,
+                )
+            self.result = ImportReturn(imported_module, loaded_items, self)
+            return self.result
+
+        except ImportError as e:
+            raise e
+
+
+class JacImporter(Importer):
+    """Importer for Jac modules."""
+
+    def __init__(self, jac_machine: JacMachine) -> None:
+        """Initialize the JacImporter object."""
+        self.jac_machine = jac_machine
+
+    def get_sys_mod_name(self, full_target: str) -> str:
+        """Generate the system module name based on full target path and package path."""
+        if full_target == self.jac_machine.base_path_dir:
+            return path.basename(self.jac_machine.base_path_dir)
+        relative_path = path.relpath(full_target, start=self.jac_machine.base_path_dir)
+        base_name = path.splitext(relative_path)[0]
+        sys_mod_name = base_name.replace(os.sep, ".").strip(".")
+        return sys_mod_name
+
+    def handle_directory(
+        self, module_name: str, full_mod_path: str
+    ) -> types.ModuleType:
+        """Import from a directory that potentially contains multiple Jac modules."""
+        module_name = self.get_sys_mod_name(full_mod_path)
+        module = types.ModuleType(module_name)
+        module.__name__ = module_name
+        module.__path__ = [full_mod_path]
+        module.__file__ = None
+
+        if module_name not in self.jac_machine.loaded_modules:
+            self.jac_machine.load_module(module_name, module)
+        return module
+
+    def create_jac_py_module(
+        self,
+        module_name: str,
+        package_path: str,
+        full_target: str,
+    ) -> types.ModuleType:
+        """Create a module."""
+        module = types.ModuleType(module_name)
+        module.__file__ = full_target
+        module.__name__ = module_name
+        if package_path:
+            base_path = full_target.split(package_path.replace(".", path.sep))[0]
+            parts = package_path.split(".")
+            for i in range(len(parts)):
+                package_name = ".".join(parts[: i + 1])
+                if package_name not in self.jac_machine.loaded_modules:
+                    full_mod_path = path.join(
+                        base_path, package_name.replace(".", path.sep)
+                    )
+                    self.handle_directory(
+                        module_name=package_name,
+                        full_mod_path=full_mod_path,
+                    )
+        self.jac_machine.load_module(module_name, module)
+        return module
+
+    def run_import(
+        self, spec: ImportPathSpec, reload: Optional[bool] = False
+    ) -> ImportReturn:
+        """Run the import process for Jac modules."""
+        unique_loaded_items: list[types.ModuleType] = []
+        module = None
+        if os.path.isfile(spec.full_target + ".jac"):
+            module_name = self.get_sys_mod_name(spec.full_target + ".jac")
+            module_name = spec.override_name if spec.override_name else module_name
+        else:
+            module_name = self.get_sys_mod_name(spec.full_target)
+
+        module = self.jac_machine.loaded_modules.get(module_name)
+
+        if not module or module.__name__ == "__main__" or reload:
+            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"
+                module = self.create_jac_py_module(
+                    module_name,
+                    spec.package_path,
+                    spec.full_target,
+                )
+                codeobj = self.jac_machine.get_bytecode(
+                    module_name,
+                    spec.full_target,
+                    caller_dir=spec.caller_dir,
+                    cachable=spec.cachable,
+                )
+                try:
+                    if not codeobj:
+                        raise ImportError(f"No bytecode found for {spec.full_target}")
+                    with sys_path_context(spec.caller_dir):
+                        exec(codeobj, module.__dict__)
+                except Exception as e:
+                    logger.error(dump_traceback(e))
+                    raise e
+        import_return = ImportReturn(module, unique_loaded_items, self)
+        if spec.items:
+            import_return.process_items(
+                module=module,
+                items=spec.items,
+                caller_dir=spec.caller_dir,
+                cachable=spec.cachable,
+                lang=spec.language,
+            )
+        self.result = import_return
+        return self.result

jaclang/runtimelib/machine.py

@@ -0,0 +1,158 @@
+"""Jac Machine module."""
+
+import inspect
+import marshal
+import os
+import sys
+import types
+from contextvars import ContextVar
+from typing import Optional
+
+from jaclang.compiler.absyntree import Module
+from jaclang.compiler.compile import compile_jac
+from jaclang.compiler.constant import Constants as Con
+from jaclang.runtimelib.architype import EdgeArchitype, NodeArchitype, WalkerArchitype
+from jaclang.utils.log import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+JACMACHINE_CONTEXT = ContextVar["JacMachine | None"]("JacMachine")
+
+
+class JacMachine:
+    """JacMachine to handle the VM-related functionalities and loaded programs."""
+
+    def __init__(self, base_path: str = "") -> None:
+        """Initialize the JacMachine object."""
+        self.loaded_modules: dict[str, types.ModuleType] = {}
+        if not base_path:
+            base_path = os.getcwd()
+        self.base_path = base_path
+        self.base_path_dir = (
+            os.path.dirname(base_path)
+            if not os.path.isdir(base_path)
+            else os.path.abspath(base_path)
+        )
+        self.jac_program: Optional[JacProgram] = None
+
+        JACMACHINE_CONTEXT.set(self)
+
+    def attach_program(self, jac_program: "JacProgram") -> None:
+        """Attach a JacProgram to the machine."""
+        self.jac_program = jac_program
+
+    def get_mod_bundle(self) -> Optional[Module]:
+        """Retrieve the mod_bundle from the attached JacProgram."""
+        if self.jac_program:
+            return self.jac_program.mod_bundle
+        return None
+
+    def get_bytecode(
+        self,
+        module_name: str,
+        full_target: str,
+        caller_dir: str,
+        cachable: bool = True,
+    ) -> Optional[types.CodeType]:
+        """Retrieve bytecode from the attached JacProgram."""
+        if self.jac_program:
+            return self.jac_program.get_bytecode(
+                module_name, full_target, caller_dir, cachable
+            )
+        return None
+
+    def load_module(self, module_name: str, module: types.ModuleType) -> None:
+        """Load a module into the machine."""
+        self.loaded_modules[module_name] = module
+        sys.modules[module_name] = module
+
+    def list_modules(self) -> list[str]:
+        """List all loaded modules."""
+        return list(self.loaded_modules.keys())
+
+    def list_walkers(self, module_name: str) -> list[str]:
+        """List all walkers in a specific module."""
+        module = self.loaded_modules.get(module_name)
+        if module:
+            walkers = []
+            for name, obj in inspect.getmembers(module):
+                if isinstance(obj, type) and issubclass(obj, WalkerArchitype):
+                    walkers.append(name)
+            return walkers
+        return []
+
+    def list_nodes(self, module_name: str) -> list[str]:
+        """List all nodes in a specific module."""
+        module = self.loaded_modules.get(module_name)
+        if module:
+            nodes = []
+            for name, obj in inspect.getmembers(module):
+                if isinstance(obj, type) and issubclass(obj, NodeArchitype):
+                    nodes.append(name)
+            return nodes
+        return []
+
+    def list_edges(self, module_name: str) -> list[str]:
+        """List all edges in a specific module."""
+        module = self.loaded_modules.get(module_name)
+        if module:
+            nodes = []
+            for name, obj in inspect.getmembers(module):
+                if isinstance(obj, type) and issubclass(obj, EdgeArchitype):
+                    nodes.append(name)
+            return nodes
+        return []
+
+    @staticmethod
+    def get(base_path: str = "") -> "JacMachine":
+        """Get current jac machine."""
+        if (jac_machine := JACMACHINE_CONTEXT.get(None)) is None:
+            jac_machine = JacMachine(base_path)
+        return jac_machine
+
+    @staticmethod
+    def detach() -> None:
+        """Detach current jac machine."""
+        JACMACHINE_CONTEXT.set(None)
+
+
+class JacProgram:
+    """Class to hold the mod_bundle and bytecode for Jac modules."""
+
+    def __init__(
+        self, mod_bundle: Optional[Module], bytecode: Optional[dict[str, bytes]]
+    ) -> None:
+        """Initialize the JacProgram object."""
+        self.mod_bundle = mod_bundle
+        self.bytecode = bytecode or {}
+
+    def get_bytecode(
+        self,
+        module_name: str,
+        full_target: str,
+        caller_dir: str,
+        cachable: bool = True,
+    ) -> Optional[types.CodeType]:
+        """Get the bytecode for a specific module."""
+        if self.mod_bundle and isinstance(self.mod_bundle, Module):
+            codeobj = self.mod_bundle.mod_deps[full_target].gen.py_bytecode
+            return marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
+        gen_dir = os.path.join(caller_dir, Con.JAC_GEN_DIR)
+        pyc_file_path = os.path.join(gen_dir, module_name + ".jbc")
+        if cachable and os.path.exists(pyc_file_path):
+            with open(pyc_file_path, "rb") as f:
+                return marshal.load(f)
+
+        result = compile_jac(full_target, cache_result=cachable)
+        if result.errors_had or not result.ir.gen.py_bytecode:
+            logger.error(
+                f"While importing {len(result.errors_had)} errors"
+                f" found in {full_target}"
+            )
+            return None
+        if result.ir.gen.py_bytecode is not None:
+            return marshal.loads(result.ir.gen.py_bytecode)
+        else:
+            return None