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

jaclang/cli/cli.py

@@ -2,7 +2,6 @@
 
 import ast as ast3
 import importlib
-import inspect
 import marshal
 import os
 import pickle
@@ -19,10 +18,12 @@ from jaclang.compiler.constant import Constants
 from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool.schedules import format_pass
-from jaclang.core.constructs import Architype
 from jaclang.plugin.builtin import dotgen
 from jaclang.plugin.feature import JacCmd as Cmd
 from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.runtimelib.constructs import WalkerArchitype
+from jaclang.runtimelib.context import ExecutionContext
+from jaclang.runtimelib.machine import JacMachine, JacProgram
 from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
@@ -67,12 +68,7 @@ def format(path: str, outfile: str = "", debug: bool = False) -> None:
 
 @cmd_registry.register
 def run(
-    filename: str,
-    session: str = "",
-    main: bool = True,
-    cache: bool = True,
-    walker: str = "",
-    node: str = "",
+    filename: str, session: str = "", main: bool = True, cache: bool = True
 ) -> None:
     """Run the specified .jac file."""
     # if no session specified, check if it was defined when starting the command shell
@@ -86,81 +82,93 @@ def run(
             else ""
         )
 
-    Jac.context().init_memory(session)
-
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
+
+    jctx = ExecutionContext.create(session=session)
+
     if filename.endswith(".jac"):
-        ret_module = jac_import(
+        jac_import(
             target=mod,
             base_path=base,
             cachable=cache,
             override_name="__main__" if main else None,
         )
-        if ret_module is None:
-            loaded_mod = None
-        else:
-            (loaded_mod,) = ret_module
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
-            ir = pickle.load(f)
-            ret_module = jac_import(
+            JacMachine(base).attach_program(
+                JacProgram(mod_bundle=pickle.load(f), bytecode=None)
+            )
+            jac_import(
                 target=mod,
                 base_path=base,
                 cachable=cache,
                 override_name="__main__" if main else None,
-                mod_bundle=ir,
             )
-            if ret_module is None:
-                loaded_mod = None
-            else:
-                (loaded_mod,) = ret_module
     else:
-        print("Not a .jac file.")
-        return
-
-    if not node or node == "root":
-        entrypoint: Architype = Jac.get_root()
-    else:
-        obj = Jac.context().get_obj(UUID(node))
-        if obj is None:
-            print(f"Entrypoint {node} not found.")
-            return
-        entrypoint = obj
-
-    # TODO: handle no override name
-    if walker:
-        walker_module = dict(inspect.getmembers(loaded_mod)).get(walker)
-        if walker_module:
-            Jac.spawn_call(entrypoint, walker_module())
-        else:
-            print(f"Walker {walker} not found.")
+        jctx.close()
+        JacMachine.detach()
+        raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
 
-    Jac.reset_context()
+    jctx.close()
+    JacMachine.detach()
 
 
 @cmd_registry.register
-def get_object(id: str, session: str = "") -> dict:
+def get_object(
+    filename: str, id: str, session: str = "", main: bool = True, cache: bool = True
+) -> dict:
     """Get the object with the specified id."""
     if session == "":
-        session = cmd_registry.args.session if "session" in cmd_registry.args else ""
+        session = (
+            cmd_registry.args.session
+            if hasattr(cmd_registry, "args")
+            and hasattr(cmd_registry.args, "session")
+            and cmd_registry.args.session
+            else ""
+        )
 
-    Jac.context().init_memory(session)
+    base, mod = os.path.split(filename)
+    base = base if base else "./"
+    mod = mod[:-4]
 
-    if id == "root":
-        id_uuid = UUID(int=0)
+    jctx = ExecutionContext.create(session=session)
+
+    if filename.endswith(".jac"):
+        jac_import(
+            target=mod,
+            base_path=base,
+            cachable=cache,
+            override_name="__main__" if main else None,
+        )
+    elif filename.endswith(".jir"):
+        with open(filename, "rb") as f:
+            JacMachine(base).attach_program(
+                JacProgram(mod_bundle=pickle.load(f), bytecode=None)
+            )
+            jac_import(
+                target=mod,
+                base_path=base,
+                cachable=cache,
+                override_name="__main__" if main else None,
+            )
     else:
-        id_uuid = UUID(id)
+        jctx.close()
+        JacMachine.detach()
+        raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
 
-    obj = Jac.context().get_obj(id_uuid)
-    if obj is None:
-        print(f"Object with id {id} not found.")
-        Jac.reset_context()
-        return {}
+    data = {}
+    if id == "root":
+        data = jctx.root.__getstate__()
+    elif obj := jctx.mem.find_by_id(UUID(id)):
+        data = obj.__getstate__()
     else:
-        Jac.reset_context()
-        return obj.__getstate__()
+        print(f"Object with id {id} not found.")
+
+    jctx.close()
+    JacMachine.detach()
+    return data
 
 
 @cmd_registry.register
@@ -210,25 +218,78 @@ def lsp() -> None:
 
 
 @cmd_registry.register
-def enter(filename: str, entrypoint: str, args: list) -> None:
-    """Run the specified entrypoint function in the given .jac file.
+def enter(
+    filename: str,
+    entrypoint: str,
+    args: list,
+    session: str = "",
+    main: bool = True,
+    cache: bool = True,
+    root: str = "",
+    node: str = "",
+) -> None:
+    """
+    Run the specified entrypoint function in the given .jac file.
 
     :param filename: The path to the .jac file.
     :param entrypoint: The name of the entrypoint function.
     :param args: Arguments to pass to the entrypoint function.
+    :param session: shelve.Shelf file path.
+    :param root: root executor.
+    :param node: starting node.
     """
+    if session == "":
+        session = (
+            cmd_registry.args.session
+            if hasattr(cmd_registry, "args")
+            and hasattr(cmd_registry.args, "session")
+            and cmd_registry.args.session
+            else ""
+        )
+
+    base, mod = os.path.split(filename)
+    base = base if base else "./"
+    mod = mod[:-4]
+
+    jctx = ExecutionContext.create(session=session, root=root)
+
     if filename.endswith(".jac"):
-        base, mod_name = os.path.split(filename)
-        base = base if base else "./"
-        mod_name = mod_name[:-4]
-        mod = jac_import(target=mod_name, base_path=base)
-        if not mod:
+        ret_module = jac_import(
+            target=mod,
+            base_path=base,
+            cachable=cache,
+            override_name="__main__" if main else None,
+        )
+    elif filename.endswith(".jir"):
+        with open(filename, "rb") as f:
+            JacMachine(base).attach_program(
+                JacProgram(mod_bundle=pickle.load(f), bytecode=None)
+            )
+            ret_module = jac_import(
+                target=mod,
+                base_path=base,
+                cachable=cache,
+                override_name="__main__" if main else None,
+            )
+    else:
+        jctx.close()
+        JacMachine.detach()
+        raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
+
+    if ret_module:
+        (loaded_mod,) = ret_module
+        if not loaded_mod:
             print("Errors occurred while importing the module.")
-            return
         else:
-            getattr(mod, entrypoint)(*args)
-    else:
-        print("Not a .jac file.")
+            architype = getattr(loaded_mod, entrypoint)(*args)
+
+            jctx.set_entry_node(node)
+
+            if isinstance(architype, WalkerArchitype) and jctx.validate_access():
+                Jac.spawn_call(jctx.entry_node.architype, architype)
+
+    jctx.close()
+    JacMachine.detach()
 
 
 @cmd_registry.register
@@ -251,6 +312,8 @@ def test(
 
     jac test => jac test -d .
     """
+    jctx = ExecutionContext.create()
+
     failcount = Jac.run_test(
         filepath=filepath,
         filter=filter,
@@ -259,6 +322,9 @@ def test(
         directory=directory,
         verbose=verbose,
     )
+
+    jctx.close()
+
     if failcount:
         raise SystemExit(f"Tests failed: {failcount}")
 
@@ -357,17 +423,16 @@ def dot(
             else ""
         )
 
-    Jac.context().init_memory(session)
-
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
+
+    jctx = ExecutionContext.create(session=session)
+
     if filename.endswith(".jac"):
-        jac_import(
-            target=mod,
-            base_path=base,
-        )
-        module = importlib.import_module(mod)
+        jac_machine = JacMachine(base)
+        jac_import(target=mod, base_path=base)
+        module = jac_machine.loaded_modules.get(mod)
         globals().update(vars(module))
         try:
             node = globals().get(initial, eval(initial)) if initial else None
@@ -385,7 +450,7 @@ def dot(
             import traceback
 
             traceback.print_exc()
-            Jac.reset_context()
+            jctx.close()
             return
         file_name = saveto if saveto else f"{mod}.dot"
         with open(file_name, "w") as file:
@@ -394,7 +459,7 @@ def dot(
     else:
         print("Not a .jac file.")
 
-    Jac.reset_context()
+    jctx.close()
 
 
 @cmd_registry.register
@@ -437,12 +502,17 @@ def start_cli() -> None:
     parser = cmd_registry.parser
     args = parser.parse_args()
     cmd_registry.args = args
+
+    if args.version:
+        version = importlib.metadata.version("jaclang")
+        print(f"Jac version {version}")
+        return
+
     command = cmd_registry.get(args.command)
     if command:
         args_dict = vars(args)
         args_dict.pop("command")
-        if command not in ["run"]:
-            args_dict.pop("session")
+        args_dict.pop("version", None)
         ret = command.call(**args_dict)
         if ret:
             print(ret)

jaclang/cli/cmdreg.py

@@ -38,7 +38,7 @@ class CommandRegistry:
         self.registry = {}
         self.parser = argparse.ArgumentParser(prog="jac")
         self.parser.add_argument(
-            "--session", help="Session file path", nargs="?", default=""
+            "-V", "--version", action="store_true", help="Show the Jac version"
         )
         self.sub_parsers = self.parser.add_subparsers(title="commands", dest="command")
         self.args = argparse.Namespace()
@@ -172,17 +172,14 @@ class CommandShell(cmd.Cmd):
 
     def default(self, line: str) -> None:
         """Process the command line input."""
-        try:
-            args = vars(self.cmd_reg.parser.parse_args(line.split()))
-            command = self.cmd_reg.get(args["command"])
-            if command:
-                args.pop("command")
-                ret = command.call(**args)
-                if ret:
-                    ret_str = pprint.pformat(ret, indent=2)
-                    self.stdout.write(f"{ret_str}\n")
-        except Exception as e:
-            print(e)
+        args = vars(self.cmd_reg.parser.parse_args(line.split()))
+        command = self.cmd_reg.get(args["command"])
+        if command:
+            args.pop("command")
+            ret = command.call(**args)
+            if ret:
+                ret_str = pprint.pformat(ret, indent=2)
+                self.stdout.write(f"{ret_str}\n")
 
     def do_help(self, arg: str) -> None:
         """Jac CLI 'help' implementaion."""

jaclang/compiler/__init__.py

@@ -35,7 +35,6 @@ def generate_static_parser(force: bool = False) -> None:
             logging.error(f"Error generating reference files: {e}")
 
 
-generate_static_parser()
 try:
     from jaclang.compiler.generated import jac_parser as jac_lark
 except ModuleNotFoundError:
@@ -50,62 +49,29 @@ TOKEN_MAP = {
     for x in jac_lark.Lark_StandAlone().parser.lexer_conf.terminals
 }
 
+# fmt: off
 TOKEN_MAP.update(
     {
-        "CARROW_L": "<++",
-        "CARROW_R": "++>",
-        "GLOBAL_OP": ":global:",
-        "NONLOCAL_OP": ":nonlocal:",
-        "WALKER_OP": ":walker:",
-        "NODE_OP": ":node:",
-        "EDGE_OP": ":edge:",
-        "CLASS_OP": ":class:",
-        "OBJECT_OP": ":obj:",
-        "TYPE_OP": "`",
-        "ABILITY_OP": ":can:",
-        "ELVIS_OP": "?:",
-        "NULL_OK": "?",
-        "KW_OR": "|",
-        "ARROW_BI": "<-->",
-        "ARROW_L": "<--",
-        "ARROW_R": "-->",
-        "ARROW_L_P1": "<-:",
-        "ARROW_R_P2": ":->",
-        "ARROW_L_P2": ":-",
-        "ARROW_R_P1": "-:",
-        "CARROW_BI": "<++>",
-        "CARROW_L": "<++",
-        "CARROW_R": "++>",
-        "CARROW_L_P1": "<+:",
-        "CARROW_R_P2": ":+>",
-        "CARROW_L_P2": ":+",
-        "CARROW_R_P1": "+:",
-        "PIPE_FWD": "|>",
-        "PIPE_BKWD": "<|",
-        "A_PIPE_FWD": ":>",
-        "A_PIPE_BKWD": "<:",
-        "DOT_FWD": ".>",
-        "STAR_POW": "**",
-        "STAR_MUL": "*",
-        "FLOOR_DIV": "//",
-        "DIV": "/",
-        "PYNLINE": "::py::",
-        "ADD_EQ": "+=",
-        "SUB_EQ": "-=",
-        "STAR_POW_EQ": "**=",
-        "MUL_EQ": "*=",
-        "FLOOR_DIV_EQ": "//=",
-        "DIV_EQ": "/=",
-        "MOD_EQ": "%=",
-        "BW_AND_EQ": "&=",
-        "BW_OR_EQ": "|=",
-        "BW_XOR_EQ": "^=",
-        "BW_NOT_EQ": "~=",
-        "LSHIFT_EQ": "<<=",
-        "RSHIFT_EQ": ">>=",
-        "ELLIPSIS": "...",
+        "CARROW_L": "<++", "CARROW_R": "++>", "GLOBAL_OP": ":global:",
+        "NONLOCAL_OP": ":nonlocal:", "WALKER_OP": ":walker:", "NODE_OP": ":node:",
+        "EDGE_OP": ":edge:", "CLASS_OP": ":class:", "OBJECT_OP": ":obj:",
+        "TYPE_OP": "`", "ABILITY_OP": ":can:", "ELVIS_OP": "?:", "NULL_OK": "?",
+        "KW_OR": "|", "ARROW_BI": "<-->", "ARROW_L": "<--",
+        "ARROW_R": "-->", "ARROW_L_P1": "<-:", "ARROW_R_P2": ":->",
+        "ARROW_L_P2": ":-", "ARROW_R_P1": "-:", "CARROW_BI": "<++>",
+        "CARROW_L": "<++", "CARROW_R": "++>", "CARROW_L_P1": "<+:",
+        "CARROW_R_P2": ":+>", "CARROW_L_P2": ":+", "CARROW_R_P1": "+:",
+        "PIPE_FWD": "|>", "PIPE_BKWD": "<|", "A_PIPE_FWD": ":>",
+        "A_PIPE_BKWD": "<:", "DOT_FWD": ".>", "STAR_POW": "**",
+        "STAR_MUL": "*", "FLOOR_DIV": "//", "DIV": "/",
+        "PYNLINE": "::py::", "ADD_EQ": "+=", "SUB_EQ": "-=",
+        "STAR_POW_EQ": "**=", "MUL_EQ": "*=", "FLOOR_DIV_EQ": "//=",
+        "DIV_EQ": "/=", "MOD_EQ": "%=", "BW_AND_EQ": "&=",
+        "BW_OR_EQ": "|=", "BW_XOR_EQ": "^=", "BW_NOT_EQ": "~=",
+        "LSHIFT_EQ": "<<=", "RSHIFT_EQ": ">>=", "ELLIPSIS": "...",
     }
 )
+# fmt: on
 
 
 __all__ = ["jac_lark", "TOKEN_MAP"]

jaclang/compiler/absyntree.py

@@ -55,15 +55,10 @@ class AstNode:
         """Get symbol table."""
         # sym_tab should never be accessed without being set in codebase
         if not self._sym_tab:
-            import traceback
-
-            if self.parent:
-                print(f"Parent: {self.parent.pp()}")
-            print("Node: ", self.pp())
-            stack_trace = traceback.format_stack()
-            print("".join(stack_trace))
             raise ValueError(
-                f"Symbol table not set for {type(self).__name__}. Impossible."
+                f"Symbol table not set for {type(self).__name__}. Impossible.\n"
+                f"Node: {self.pp()}\n"
+                f"Parent: {self.parent.pp() if self.parent else None}\n"
             )
         return self._sym_tab
 
@@ -163,7 +158,7 @@ class AstNode:
         """Get parent of type."""
         from jaclang.compiler.passes import Pass
 
-        return Pass.has_parent_of_type(node=self, typ=typ)
+        return Pass.find_parent_of_type(node=self, typ=typ)
 
     def parent_of_type(self, typ: Type[T]) -> T:
         """Get parent of type."""
@@ -635,8 +630,11 @@ class Module(AstDocNode):
         self.impl_mod: list[Module] = []
         self.test_mod: list[Module] = []
         self.mod_deps: dict[str, Module] = {}
+        self.py_mod_dep_map: dict[str, str] = {}
+        self.py_raise_map: dict[str, str] = {}
         self.registry = registry
         self.terminals: list[Token] = terminals
+        self.is_raised_from_py: bool = False
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
@@ -863,7 +861,7 @@ class Import(ElementStmt, CodeBlockStmt):
 
     def __init__(
         self,
-        hint: SubTag[Name],
+        hint: Optional[SubTag[Name]],
         from_loc: Optional[ModulePath],
         items: SubNodeList[ModuleItem] | SubNodeList[ModulePath],
         is_absorb: bool,  # For includes
@@ -878,11 +876,52 @@ class Import(ElementStmt, CodeBlockStmt):
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
+    @property
+    def is_py(self) -> bool:
+        """Check if import is python."""
+        if self.hint and self.hint.tag.value == "py":
+            return True
+        if not self.hint:
+            return not self.__jac_detected
+        return False
+
+    @property
+    def is_jac(self) -> bool:
+        """Check if import is jac."""
+        if self.hint and self.hint.tag.value == "jac":
+            return True
+        if not self.hint:
+            return self.__jac_detected
+        return False
+
+    @property
+    def __jac_detected(self) -> bool:
+        """Check if import is jac."""
+        if self.from_loc:
+            if self.from_loc.resolve_relative_path().endswith(".jac"):
+                return True
+            if os.path.isdir(self.from_loc.resolve_relative_path()):
+                if os.path.exists(
+                    os.path.join(self.from_loc.resolve_relative_path(), "__init__.jac")
+                ):
+                    return True
+                for i in self.items.items:
+                    if isinstance(
+                        i, ModuleItem
+                    ) and self.from_loc.resolve_relative_path(i.name.value).endswith(
+                        ".jac"
+                    ):
+                        return True
+        return any(
+            isinstance(i, ModulePath) and i.resolve_relative_path().endswith(".jac")
+            for i in self.items.items
+        )
+
     def normalize(self, deep: bool = False) -> bool:
         """Normalize import node."""
         res = True
         if deep:
-            res = self.hint.normalize(deep)
+            res = self.hint.normalize(deep) if self.hint else res
             res = res and self.from_loc.normalize(deep) if self.from_loc else res
             res = res and self.items.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
@@ -893,7 +932,8 @@ class Import(ElementStmt, CodeBlockStmt):
             new_kid.append(self.gen_token(Tok.KW_INCLUDE))
         else:
             new_kid.append(self.gen_token(Tok.KW_IMPORT))
-        new_kid.append(self.hint)
+        if self.hint:
+            new_kid.append(self.hint)
         if self.from_loc:
             new_kid.append(self.gen_token(Tok.KW_FROM))
             new_kid.append(self.from_loc)
@@ -919,6 +959,7 @@ class ModulePath(AstSymbolNode):
         self.level = level
         self.alias = alias
         self.sub_module: Optional[Module] = None
+        self.abs_path: Optional[str] = None
 
         name_spec = alias if alias else path[0] if path else None
 
@@ -940,12 +981,32 @@ class ModulePath(AstSymbolNode):
         )
 
     @property
-    def path_str(self) -> str:
+    def dot_path_str(self) -> str:
         """Get path string."""
         return ("." * self.level) + ".".join(
             [p.value for p in self.path] if self.path else [self.name_spec.sym_name]
         )
 
+    def resolve_relative_path(self, target_item: Optional[str] = None) -> str:
+        """Convert an import target string into a relative file path."""
+        target = self.dot_path_str
+        if target_item:
+            target += f".{target_item}"
+        base_path = os.path.dirname(self.loc.mod_path)
+        base_path = base_path if base_path else os.getcwd()
+        parts = target.split(".")
+        traversal_levels = self.level - 1 if self.level > 0 else 0
+        actual_parts = parts[traversal_levels:]
+        for _ in range(traversal_levels):
+            base_path = os.path.dirname(base_path)
+        relative_path = os.path.join(base_path, *actual_parts)
+        relative_path = (
+            relative_path + ".jac"
+            if os.path.exists(relative_path + ".jac")
+            else relative_path
+        )
+        return relative_path
+
     def normalize(self, deep: bool = False) -> bool:
         """Normalize module path node."""
         res = True
@@ -991,6 +1052,7 @@ class ModuleItem(AstSymbolNode):
             name_spec=alias if alias else name,
             sym_category=SymbolType.MOD_VAR,
         )
+        self.abs_path: Optional[str] = None
 
     @property
     def from_parent(self) -> Import:
@@ -1132,7 +1194,6 @@ class ArchDef(AstImplOnlyNode):
         body: SubNodeList[ArchBlockStmt],
         kid: Sequence[AstNode],
         doc: Optional[String] = None,
-        decorators: Optional[SubNodeList[Expr]] = None,
         decl_link: Optional[Architype] = None,
     ) -> None:
         """Initialize arch def node."""
@@ -1473,6 +1534,23 @@ class FuncSignature(AstSemStrNode):
             and self.parent.decl_link.is_static
         )
 
+    @property
+    def is_in_py_class(self) -> bool:
+        """Check if the ability belongs to a class."""
+        is_archi = self.find_parent_of_type(Architype)
+        is_class = is_archi is not None and is_archi.arch_type.name == Tok.KW_CLASS
+
+        return (
+            isinstance(self.parent, Ability)
+            and self.parent.is_method is not None
+            and is_class
+        ) or (
+            isinstance(self.parent, AbilityDef)
+            and isinstance(self.parent.decl_link, Ability)
+            and self.parent.decl_link.is_method
+            and is_class
+        )
+
 
 class EventSignature(AstSemStrNode):
     """EventSignature node type for Jac Ast."""
@@ -4240,11 +4318,11 @@ class Ellipsis(Literal):
 class EmptyToken(Token):
     """EmptyToken node type for Jac Ast."""
 
-    def __init__(self) -> None:
+    def __init__(self, file_path: str = "") -> None:
         """Initialize empty token."""
         super().__init__(
             name="EmptyToken",
-            file_path="",
+            file_path=file_path,
             value="",
             line=0,
             end_line=0,