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

jaclang/plugin/spec.py

@@ -8,7 +8,7 @@ from typing import Any, Callable, Optional, TYPE_CHECKING, Type, TypeVar, Union
 from jaclang.compiler.absyntree import Module
 
 if TYPE_CHECKING:
-    from jaclang.core.constructs import EdgeArchitype, NodeArchitype
+    from jaclang.runtimelib.constructs import EdgeArchitype, NodeArchitype
     from jaclang.plugin.default import (
         Architype,
         EdgeDir,
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
         Root,
         DSFunc,
     )
-    from jaclang.core.memory import Memory
+    from jaclang.runtimelib.memory import Memory
 
 import pluggy
 

jaclang/{core → runtimelib}/architype.py

@@ -8,7 +8,7 @@ from typing import Any, Callable, Optional
 from uuid import UUID, uuid4
 
 from jaclang.compiler.constant import EdgeDir
-from jaclang.core.utils import collect_node_connections
+from jaclang.runtimelib.utils import collect_node_connections
 
 
 @dataclass(eq=False)

jaclang/{core → runtimelib}/context.py

@@ -8,6 +8,7 @@ from typing import Callable, Optional
 from uuid import UUID
 
 from .architype import Architype, Root
+from .machine import JacMachine
 from .memory import Memory, ShelveStorage
 
 
@@ -22,13 +23,15 @@ class ExecutionContext:
         super().__init__()
         self.mem = ShelveStorage()
         self.root = None
+        self.jac_machine = JacMachine()
 
-    def init_memory(self, session: str = "") -> None:
+    def init_memory(self, base_path: str = "", session: str = "") -> None:
         """Initialize memory."""
         if session:
             self.mem = ShelveStorage(session)
         else:
             self.mem = Memory()
+        self.jac_machine = JacMachine(base_path)
 
     def get_root(self) -> Root:
         """Get the root object."""

jaclang/runtimelib/importer.py

@@ -0,0 +1,414 @@
+"""Special Imports for Jac Code."""
+
+from __future__ import annotations
+
+import importlib
+import marshal
+import os
+import sys
+import types
+from os import getcwd, path
+from typing import Optional, Union
+
+from jaclang.compiler.absyntree import Module
+from jaclang.compiler.compile import compile_jac
+from jaclang.compiler.constant import Constants as Con
+from jaclang.runtimelib.machine import JacMachine
+from jaclang.runtimelib.utils import sys_path_context
+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],
+        mod_bundle: Optional[Module | 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.mod_bundle = mod_bundle
+        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],
+        mod_bundle: Optional[Module] = None,
+        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_file(
+                            module=module,
+                            name=name,
+                            jac_file_path=jac_file_path,
+                            mod_bundle=mod_bundle,
+                            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_file(
+        self,
+        module: types.ModuleType,
+        name: str,
+        jac_file_path: str,
+        mod_bundle: Optional[Module],
+        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 = sys.modules.get(
+                    package_name,
+                    self.importer.create_jac_py_module(
+                        mod_bundle, name, module.__name__, jac_file_path
+                    ),
+                )
+            codeobj = self.importer.get_codeobj(
+                full_target=jac_file_path,
+                module_name=name,
+                mod_bundle=mod_bundle,
+                cachable=cachable,
+                caller_dir=caller_dir,
+            )
+            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(
+                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 sys.modules:
+            sys.modules[spec.module_name] = module
+
+    def get_codeobj(
+        self,
+        full_target: str,
+        module_name: str,
+        mod_bundle: Optional[Module],
+        cachable: bool,
+        caller_dir: str,
+    ) -> Optional[types.CodeType]:
+        """Get the code object for a given module."""
+        if mod_bundle:
+            codeobj = 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
+
+
+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, mod_bundle: Optional[Module | 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
+        module.__dict__["__jac_mod_bundle__"] = mod_bundle
+
+        if module_name not in sys.modules:
+            sys.modules[module_name] = module
+        return module
+
+    def create_jac_py_module(
+        self,
+        mod_bundle: Optional[Module | str],
+        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
+        module.__dict__["__jac_mod_bundle__"] = mod_bundle
+        sys.modules[module_name] = module
+        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 sys.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,
+                        mod_bundle=mod_bundle,
+                    )
+            setattr(sys.modules[package_path], module_name, module)
+            sys.modules[f"{package_path}.{module_name}"] = module
+
+        return module
+
+    def run_import(self, spec: ImportPathSpec) -> ImportReturn:
+        """Run the import process for Jac modules."""
+        unique_loaded_items: list[types.ModuleType] = []
+        module = None
+        valid_mod_bundle = (
+            sys.modules[spec.mod_bundle].__jac_mod_bundle__
+            if isinstance(spec.mod_bundle, str)
+            and spec.mod_bundle in sys.modules
+            and "__jac_mod_bundle__" in sys.modules[spec.mod_bundle].__dict__
+            else None
+        )
+
+        if not module:
+            if os.path.isdir(spec.full_target):
+                module = self.handle_directory(
+                    spec.module_name, spec.full_target, valid_mod_bundle
+                )
+            else:
+                spec.full_target += ".jac" if spec.language == "jac" else ".py"
+                module_name = self.get_sys_mod_name(spec.full_target)
+                module_name = (
+                    spec.override_name if spec.override_name else spec.module_name
+                )
+                module = self.create_jac_py_module(
+                    valid_mod_bundle,
+                    module_name,
+                    spec.package_path,
+                    spec.full_target,
+                )
+                codeobj = self.get_codeobj(
+                    spec.full_target,
+                    module_name,
+                    valid_mod_bundle,
+                    spec.cachable,
+                    caller_dir=spec.caller_dir,
+                )
+                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:
+                    raise ImportError(f"Error importing {spec.full_target}: {str(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,
+                mod_bundle=valid_mod_bundle,
+                cachable=spec.cachable,
+                lang=spec.language,
+            )
+        self.result = import_return
+        return self.result

jaclang/runtimelib/machine.py

@@ -0,0 +1,19 @@
+"""Jac Machine module."""
+
+import os
+
+
+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 len(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)
+        )

jaclang/{core → runtimelib}/utils.py

@@ -11,7 +11,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.semtable import SemScope
 
 if TYPE_CHECKING:
-    from jaclang.core.constructs import NodeAnchor, NodeArchitype
+    from jaclang.runtimelib.constructs import NodeAnchor, NodeArchitype
 
 
 @contextmanager

jaclang/tests/fixtures/deep/one_lev.jac

@@ -1,8 +1,8 @@
 import:jac from .deeper, snd_lev as snd_lev;
-import:jac from ..deep, deeper;
-import:jac from ., deeper as mydeeper;
+# import:jac from ..deep, deeper;
+# import:jac from ., deeper as mydeeper;
 
 can olprint -> str {
     # deeper.snd_lev.slprint(); FIXME:
     return "one level deeper" + snd_lev.slprint();
-}
+}

jaclang/tests/fixtures/deep/one_lev_dup.jac

@@ -1,6 +1,5 @@
-import:jac deeper.snd_lev as snd_lev;
+import:jac from .deeper, snd_lev as snd_lev;
 
-can olprint ->str {
+can olprint -> str {
     return "one level deeper" + snd_lev.slprint();
 }
-

jaclang/tests/test_cli.py

@@ -46,7 +46,7 @@ class JacCliTests(TestCase):
         sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         # print(stdout_value)
-        self.assertIn("Syntax Error", stdout_value)
+        self.assertIn("Error", stdout_value)
 
     def test_jac_ast_tool_pass_template(self) -> None:
         """Basic test for pass."""

jaclang/tests/test_language.py

@@ -60,6 +60,7 @@ class JacLanguageTests(TestCase):
 
     def test_simple_jac_red(self) -> None:
         """Parse micro jac file."""
+        Jac.context().init_memory(base_path=self.examples_abs_path(""))
         captured_output = io.StringIO()
         sys.stdout = captured_output
         jac_import("micro.simple_walk", base_path=self.examples_abs_path(""))
@@ -151,6 +152,7 @@ class JacLanguageTests(TestCase):
 
     def test_filter_compr(self) -> None:
         """Testing filter comprehension."""
+        Jac.context().init_memory(base_path=self.examples_abs_path("./"))
         captured_output = io.StringIO()
         sys.stdout = captured_output
         jac_import(
@@ -207,8 +209,10 @@ class JacLanguageTests(TestCase):
     def test_deep_imports(self) -> None:
         """Parse micro jac file."""
         Jac.get_root()._jac_.edges.clear()
+        Jac.context().init_memory(base_path=self.fixture_abs_path("./"))
         captured_output = io.StringIO()
         sys.stdout = captured_output
+
         jac_import("deep_import", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -217,6 +221,7 @@ class JacLanguageTests(TestCase):
     def test_deep_outer_imports_one(self) -> None:
         """Parse micro jac file."""
         Jac.get_root()._jac_.edges.clear()
+        Jac.context().init_memory(base_path=self.fixture_abs_path("./"))
         captured_output = io.StringIO()
         sys.stdout = captured_output
         jac_import(
@@ -230,6 +235,7 @@ class JacLanguageTests(TestCase):
     def test_deep_outer_imports_from_loc(self) -> None:
         """Parse micro jac file."""
         Jac.get_root()._jac_.edges.clear()
+        Jac.context().init_memory(base_path=self.fixture_abs_path("./deep/deeper/"))
         captured_output = io.StringIO()
         sys.stdout = captured_output
         os.chdir(self.fixture_abs_path("./deep/deeper/"))
@@ -383,6 +389,7 @@ class JacLanguageTests(TestCase):
 
     def test_typed_filter_compr(self) -> None:
         """Parse micro jac file."""
+        Jac.context().init_memory(base_path=self.examples_abs_path(""))
         captured_output = io.StringIO()
         sys.stdout = captured_output
         jac_import(

jaclang/utils/treeprinter.py

@@ -248,10 +248,6 @@ def _build_symbol_tree_common(
         symbol_node = SymbolTree(node_name=f"{sym.sym_name}", parent=symbols)
         SymbolTree(node_name=f"{sym.access} {sym.sym_type}", parent=symbol_node)
 
-        # if isinstance(node.owner, ast.AstSymbolNode) and node.owner.sym_info:
-        #     print("From tree printer", id(node.owner))
-        #     SymbolTree(node_name=f"Datatype: {node.owner.sym_info.typ}", parent=symbol_node)
-
         if sym.decl and sym.decl.loc.first_line > 0:
             SymbolTree(
                 node_name=f"decl: line {sym.decl.loc.first_line}, col {sym.decl.loc.col_start}",

{jaclang-0.7.14.dist-info → jaclang-0.7.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.14
+Version: 0.7.15
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT