jaclang 0.7.8__tar.gz → 0.7.11__tar.gz

{jaclang-0.7.8 → jaclang-0.7.11}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.8
+Version: 0.7.11
 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
-Keywords: jac,jaclang,programming-language,machine-learning,artificial-intelligence
+Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence
 Author: Jason Mars
 Author-email: jason@jaseci.org
 Requires-Python: >=3.11.0,<4.0.0

{jaclang-0.7.8 → jaclang-0.7.11}/jaclang/cli/cli.py

@@ -243,7 +243,7 @@ def test(
 
     jac test => jac test -d .
     """
-    Jac.run_test(
+    failcount = Jac.run_test(
         filepath=filepath,
         filter=filter,
         xit=xit,
@@ -251,6 +251,8 @@ def test(
         directory=directory,
         verbose=verbose,
     )
+    if failcount:
+        raise SystemExit(f"Tests failed: {failcount}")
 
 
 @cmd_registry.register

{jaclang-0.7.8 → jaclang-0.7.11}/jaclang/compiler/absyntree.py

@@ -676,7 +676,7 @@ class Module(AstDocNode):
         if self.doc:
             new_kid.append(self.doc)
         new_kid.extend(self.body)
-        self.set_kids(nodes=new_kid)
+        self.set_kids(nodes=new_kid if len(new_kid) else [EmptyToken()])
         return res
 
     def unparse(self) -> str:

{jaclang-0.7.8 → jaclang-0.7.11}/jaclang/compiler/passes/ir_pass.py

@@ -1,9 +1,11 @@
 """Abstract class for IR Passes for Jac."""
 
+import time
 from typing import Optional, Type, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes.transform import Transform
+from jaclang.settings import settings
 from jaclang.utils.helpers import pascal_to_snake
 
 T = TypeVar("T", bound=ast.AstNode)
@@ -17,6 +19,7 @@ class Pass(Transform[T]):
         self.term_signal = False
         self.prune_signal = False
         self.ir: ast.AstNode = input_ir
+        self.time_taken = 0.0
         Transform.__init__(self, input_ir, prior)
 
     def before_pass(self) -> None:
@@ -104,11 +107,17 @@ class Pass(Transform[T]):
         # Only performs passes on proper ASTs
         if not isinstance(ir, ast.AstNode):
             return ir
+        start_time = time.time()
         self.before_pass()
         if not isinstance(ir, ast.AstNode):
             raise ValueError("Current node is not an AstNode.")
         self.traverse(ir)
         self.after_pass()
+        self.time_taken = time.time() - start_time
+        if settings.pass_timer:
+            print(
+                f"Time taken in {self.__class__.__name__}: {self.time_taken:.4f} seconds"
+            )
         return self.ir
 
     def traverse(self, node: ast.AstNode) -> ast.AstNode:

{jaclang-0.7.8 → jaclang-0.7.11}/jaclang/compiler/passes/main/import_pass.py

@@ -25,11 +25,14 @@ class JacImportPass(Pass):
     def before_pass(self) -> None:
         """Run once before pass."""
         self.import_table: dict[str, ast.Module] = {}
+        self.__py_imports: set[str] = set()
+        self.py_resolve_list: set[str] = set()
 
     def enter_module(self, node: ast.Module) -> None:
         """Run Importer."""
         self.cur_node = node
         self.import_table[node.loc.mod_path] = node
+        self.__py_imports.clear()
         self.__annex_impl(node)
         self.terminate()  # Turns off auto traversal for deliberate traversal
         self.run_again = True
@@ -40,6 +43,10 @@ class JacImportPass(Pass):
                 self.process_import(node, i)
                 self.enter_module_path(i)
             SubNodeTabPass(prior=self, input_ir=node)
+
+        for i in self.get_all_sub_nodes(node, ast.AtomTrailer):
+            self.enter_atom_trailer(i)
+
         node.mod_deps = self.import_table
 
     def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
@@ -50,6 +57,8 @@ class JacImportPass(Pass):
                 node=i,
                 mod_path=node.loc.mod_path,
             )
+        elif lang == "py":
+            self.__py_imports.add(i.path_str)
 
     def attach_mod_to_node(
         self, node: ast.ModulePath | ast.ModuleItem, mod: ast.Module | None
@@ -122,6 +131,11 @@ class JacImportPass(Pass):
             node.sub_module.name = node.alias.value
         # Items matched during def/decl pass
 
+    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None:
+        """Iterate on AtomTrailer nodes to get python paths to resolve."""
+        if node.as_attr_list[0].sym_name in self.__py_imports:
+            self.py_resolve_list.add(".".join([i.sym_name for i in node.as_attr_list]))
+
     def import_jac_module(self, node: ast.ModulePath, mod_path: str) -> None:
         """Import a module."""
         self.cur_node = node  # impacts error reporting
@@ -206,10 +220,9 @@ class PyImportPass(JacImportPass):
 
     def before_pass(self) -> None:
         """Only run pass if settings are set to raise python."""
+        super().before_pass()
         if not settings.py_raise:
             self.terminate()
-        else:
-            return super().before_pass()
 
     def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
         """Process an import."""

{jaclang-0.7.8 → jaclang-0.7.11}/jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -49,3 +49,16 @@ class ImportPassPassTests(TestCase):
         )
         for i in state.ir.get_all_sub_nodes(ast.Module):
             self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
+
+    def test_py_resolve_list(self) -> None:
+        """Basic test for pass."""
+        state: JacImportPass = jac_file_to_pass(
+            self.examples_abs_path("rpg_game/jac_impl/jac_impl_5/main.jac"),
+            JacImportPass,
+        )
+        self.assertGreater(len(state.py_resolve_list), 20)
+        self.assertIn("pygame.sprite.Sprite.__init__", state.py_resolve_list)
+        self.assertIn("pygame.mouse.get_pressed", state.py_resolve_list)
+        self.assertIn("pygame.K_SPACE", state.py_resolve_list)
+        self.assertIn("random.randint", state.py_resolve_list)
+        self.assertIn("pygame.font.Font", state.py_resolve_list)

{jaclang-0.7.8 → jaclang-0.7.11}/jaclang/compiler/passes/main/tests/test_pyast_gen_pass.py

@@ -36,7 +36,7 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
     def test_hodge_podge(self) -> None:
         """Basic test for pass."""
         code_gen = jac_file_to_pass(
-            self.fixture_abs_path("../../../../../../examples/micro/hodge_podge.jac"),
+            self.examples_abs_path("micro/hodge_podge.jac"),
             target=PyastGenPass,
         )
 
@@ -45,7 +45,7 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
     def test_circle_py_ast(self) -> None:
         """Basic test for pass."""
         code_gen = jac_file_to_pass(
-            self.fixture_abs_path("../../../../../../examples/manual_code/circle.jac"),
+            self.examples_abs_path("manual_code/circle.jac"),
             target=PyastGenPass,
         )
         import ast as ast3

{jaclang-0.7.8 → jaclang-0.7.11}/jaclang/compiler/passes/main/tests/test_sub_node_pass.py

@@ -15,9 +15,7 @@ class SubNodePassTests(TestCase):
     def test_sub_node_pass(self) -> None:
         """Basic test for pass."""
         code_gen = jac_file_to_pass(
-            file_path=self.fixture_abs_path(
-                "../../../../../../examples/manual_code/circle.jac"
-            ),
+            file_path=self.examples_abs_path("manual_code/circle.jac"),
             target=SubNodeTabPass,
         )
         for i in code_gen.ir.kid[1].kid:

{jaclang-0.7.8 → jaclang-0.7.11}/jaclang/compiler/passes/main/type_check_pass.py

@@ -8,6 +8,7 @@ import os
 import pathlib
 import sys
 
+# import jaclang
 import jaclang.compiler.absyntree as ast
 import jaclang.compiler.passes.utils.mypy_ast_build as myab
 from jaclang.compiler.constant import Constants as Con
@@ -93,12 +94,29 @@ class JacTypeCheckPass(Pass):
             mypy_graph[module.name] = st
             new_modules.append(st)
 
+        # def get_stub(mod: str) -> myab.BuildSource:
+        #     """Get stub file path."""
+        #     return myab.BuildSource(
+        #         path=str(
+        #             pathlib.Path(os.path.dirname(jaclang.__file__)).parent
+        #             / "stubs"
+        #             / "jaclang"
+        #             / "plugin"
+        #             / f"{mod}.pyi"
+        #         ),
+        #         module=f"jaclang.plugin.{mod}",
+        #     )
+
         graph = myab.load_graph(
             [
                 myab.BuildSource(
                     path=str(self.__path / "typeshed" / "stdlib" / "builtins.pyi"),
                     module="builtins",
-                )
+                ),
+                # get_stub("default"),
+                # get_stub("feature"),
+                # get_stub("spec"),
+                # get_stub("builtin"),
             ],
             manager,
             old_graph=mypy_graph,

{jaclang-0.7.8 → jaclang-0.7.11}/jaclang/compiler/passes/tool/tests/test_unparse_validate.py

@@ -3,7 +3,7 @@
 import ast as ast3
 from difflib import unified_diff
 
-import jaclang.compiler.absyntree as ast
+
 from jaclang.compiler.compile import jac_file_to_pass, jac_str_to_pass
 from jaclang.compiler.passes.main import PyastGenPass
 from jaclang.compiler.passes.main.schedules import py_code_gen as without_format
@@ -18,10 +18,9 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
     def test_double_unparse(self) -> None:
         """Parse micro jac file."""
-        filename = "../../../../../../examples/manual_code/circle.jac"
         try:
             code_gen_pure = jac_file_to_pass(
-                self.fixture_abs_path(filename),
+                self.examples_abs_path("manual_code/circle.jac"),
                 target=PyastGenPass,
                 schedule=without_format,
             )

jaclang-0.7.11/jaclang/core/importer.py

@@ -0,0 +1,307 @@
+"""Special Imports for Jac Code."""
+
+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.core.utils import sys_path_context
+
+
+def handle_directory(
+    module_name: str, full_mod_path: str, mod_bundle: Module
+) -> types.ModuleType:
+    """Import from a directory that potentially contains multiple Jac modules."""
+    module = types.ModuleType(module_name)
+    module.__name__ = module_name
+    module.__path__ = [full_mod_path]
+    module.__dict__["__jac_mod_bundle__"] = mod_bundle
+    if module not in sys.modules:
+        sys.modules[module_name] = module
+    return module
+
+
+def process_items(
+    module: types.ModuleType,
+    items: dict[str, Union[str, bool]],
+    caller_dir: str,
+    mod_bundle: Optional[Module] = None,
+    cachable: bool = True,
+) -> None:
+    """Process items within a module by handling renaming and potentially loading missing attributes."""
+    module_dir = (
+        module.__path__[0]
+        if hasattr(module, "__path__")
+        else os.path.dirname(getattr(module, "__file__", ""))
+    )
+    for name, alias in items.items():
+        try:
+            item = getattr(module, name)
+            if alias and alias != name and not isinstance(alias, bool):
+                setattr(module, alias, item)
+        except AttributeError:
+            jac_file_path = os.path.join(module_dir, f"{name}.jac")
+            if hasattr(module, "__path__") and os.path.isfile(jac_file_path):
+                item = load_jac_file(
+                    module=module,
+                    name=name,
+                    jac_file_path=jac_file_path,
+                    mod_bundle=mod_bundle,
+                    cachable=cachable,
+                    caller_dir=caller_dir,
+                )
+                if item:
+                    setattr(module, name, item)
+                    if alias and alias != name and not isinstance(alias, bool):
+                        setattr(module, alias, item)
+
+
+def load_jac_file(
+    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__
+        )
+        new_module = sys.modules.get(
+            package_name,
+            create_jac_py_module(mod_bundle, name, module.__name__, jac_file_path),
+        )
+
+        codeobj = 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:
+        print(
+            f"Failed to load {name} from {jac_file_path} in {module.__name__}: {str(e)}"
+        )
+        return None
+
+
+def get_codeobj(
+    full_target: str,
+    module_name: str,
+    mod_bundle: Optional[Module],
+    cachable: bool,
+    caller_dir: str,
+) -> Optional[types.CodeType]:
+    """Execcutes the code 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:
+        for e in result.errors_had:
+            print(e)
+            return None
+    if result.ir.gen.py_bytecode is not None:
+        return marshal.loads(result.ir.gen.py_bytecode)
+    else:
+        return None
+
+
+def jac_importer(
+    target: str,
+    base_path: str,
+    absorb: bool = False,
+    cachable: bool = True,
+    mdl_alias: Optional[str] = None,
+    override_name: Optional[str] = None,
+    mod_bundle: Optional[Module | str] = None,
+    lng: Optional[str] = "jac",
+    items: Optional[dict[str, Union[str, bool]]] = None,
+) -> Optional[types.ModuleType]:
+    """Core Import Process."""
+    dir_path, file_name = path.split(
+        path.join(*(target.split("."))) + (".jac" if lng == "jac" else ".py")
+    )
+    module_name = path.splitext(file_name)[0]
+    package_path = dir_path.replace(path.sep, ".")
+
+    if (
+        not override_name
+        and package_path
+        and f"{package_path}.{module_name}" in sys.modules
+    ):
+        return sys.modules[f"{package_path}.{module_name}"]
+    elif not override_name and not package_path and module_name in sys.modules:
+        return sys.modules[module_name]
+
+    valid_mod_bundle = (
+        sys.modules[mod_bundle].__jac_mod_bundle__
+        if isinstance(mod_bundle, str)
+        and mod_bundle in sys.modules
+        and "__jac_mod_bundle__" in sys.modules[mod_bundle].__dict__
+        else None
+    )
+
+    caller_dir = get_caller_dir(target, base_path, dir_path)
+    full_target = path.normpath(path.join(caller_dir, file_name))
+
+    if lng == "py":
+        module = py_import(
+            target=target,
+            items=items,
+            absorb=absorb,
+            mdl_alias=mdl_alias,
+            caller_dir=caller_dir,
+        )
+    else:
+        module_name = override_name if override_name else module_name
+
+        if os.path.isdir(path.splitext(full_target)[0]):
+            module = handle_directory(
+                module_name, path.splitext(full_target)[0], valid_mod_bundle
+            )
+            if items:
+                process_items(
+                    module,
+                    items,
+                    caller_dir,
+                    mod_bundle=valid_mod_bundle,
+                    cachable=cachable,
+                )
+        else:
+            module = create_jac_py_module(
+                valid_mod_bundle, module_name, package_path, full_target
+            )
+            codeobj = get_codeobj(
+                full_target=full_target,
+                module_name=module_name,
+                mod_bundle=valid_mod_bundle,
+                cachable=cachable,
+                caller_dir=caller_dir,
+            )
+            try:
+                if not codeobj:
+                    raise ImportError(f"No bytecode found for {full_target}")
+                with sys_path_context(caller_dir):
+                    exec(codeobj, module.__dict__)
+            except Exception as e:
+                print(f"Error importing {full_target}: {str(e)}")
+                return None
+    return module
+
+
+def create_jac_py_module(
+    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
+    if package_path:
+        parts = package_path.split(".")
+        for i in range(len(parts)):
+            package_name = ".".join(parts[: i + 1])
+            if package_name not in sys.modules:
+                sys.modules[package_name] = types.ModuleType(package_name)
+
+        setattr(sys.modules[package_path], module_name, module)
+        sys.modules[f"{package_path}.{module_name}"] = module
+    sys.modules[module_name] = module
+    return module
+
+
+def get_caller_dir(target: str, base_path: str, dir_path: str) -> str:
+    """Get the directory of the caller."""
+    caller_dir = base_path if path.isdir(base_path) else path.dirname(base_path)
+    caller_dir = caller_dir if caller_dir else getcwd()
+    chomp_target = 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:]
+    caller_dir = path.join(caller_dir, dir_path)
+    return caller_dir
+
+
+def py_import(
+    target: str,
+    caller_dir: str,
+    items: Optional[dict[str, Union[str, bool]]] = None,
+    absorb: bool = False,
+    mdl_alias: Optional[str] = None,
+) -> types.ModuleType:
+    """Import a Python module."""
+    try:
+        if target.startswith("."):
+            target = target.lstrip(".")
+            full_target = path.normpath(path.join(caller_dir, target))
+            spec = importlib.util.spec_from_file_location(target, full_target + ".py")
+            if spec and spec.loader:
+                imported_module = importlib.util.module_from_spec(spec)
+                sys.modules[spec.name] = imported_module
+                spec.loader.exec_module(imported_module)
+            else:
+                raise ImportError(f"Cannot find module {target} at {full_target}")
+        else:
+            imported_module = importlib.import_module(name=target)
+        main_module = __import__("__main__")
+        if absorb:
+            for name in dir(imported_module):
+                if not name.startswith("_"):
+                    setattr(main_module, name, getattr(imported_module, name))
+
+        elif items:
+            for name, alias in items.items():
+                try:
+                    setattr(
+                        main_module,
+                        alias if isinstance(alias, str) else name,
+                        getattr(imported_module, name),
+                    )
+                except AttributeError as e:
+                    if hasattr(imported_module, "__path__"):
+                        setattr(
+                            main_module,
+                            alias if isinstance(alias, str) else name,
+                            importlib.import_module(f"{target}.{name}"),
+                        )
+                    else:
+                        raise e
+
+        else:
+            setattr(
+                __import__("__main__"),
+                mdl_alias if isinstance(mdl_alias, str) else target,
+                imported_module,
+            )
+        return imported_module
+    except ImportError as e:
+        print(f"Failed to import module {target}")
+        raise e