jaclang 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

jaclang/cli/cli.py

@@ -2,12 +2,14 @@
 
 import ast as ast3
 import importlib
+import inspect
 import marshal
 import os
 import pickle
 import shutil
 import types
 from typing import Optional
+from uuid import UUID
 
 import jaclang.compiler.absyntree as ast
 from jaclang import jac_import
@@ -17,6 +19,7 @@ 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.construct import Architype
 from jaclang.plugin.builtin import dotgen
 from jaclang.plugin.feature import JacCmd as Cmd
 from jaclang.plugin.feature import JacFeature as Jac
@@ -63,13 +66,33 @@ def format(path: str, outfile: str = "", debug: bool = False) -> None:
 
 
 @cmd_registry.register
-def run(filename: str, main: bool = True, cache: bool = True) -> None:
+def run(
+    filename: str,
+    session: str = "",
+    main: bool = True,
+    cache: bool = True,
+    walker: str = "",
+    node: str = "",
+) -> None:
     """Run the specified .jac file."""
+    # if no session specified, check if it was defined when starting the command shell
+    # otherwise default to jaclang.session
+    if session == "":
+        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 filename.endswith(".jac"):
-        jac_import(
+        loaded_mod = jac_import(
             target=mod,
             base_path=base,
             cachable=cache,
@@ -78,7 +101,7 @@ def run(filename: str, main: bool = True, cache: bool = True) -> None:
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
             ir = pickle.load(f)
-            jac_import(
+            loaded_mod = jac_import(
                 target=mod,
                 base_path=base,
                 cachable=cache,
@@ -87,6 +110,49 @@ def run(filename: str, main: bool = True, cache: bool = True) -> None:
             )
     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.")
+
+    Jac.reset_context()
+
+
+@cmd_registry.register
+def get_object(id: str, session: str = "") -> dict:
+    """Get the object with the specified id."""
+    if session == "":
+        session = cmd_registry.args.session if "session" in cmd_registry.args else ""
+
+    Jac.context().init_memory(session)
+
+    if id == "root":
+        id_uuid = UUID(int=0)
+    else:
+        id_uuid = UUID(id)
+
+    obj = Jac.context().get_obj(id_uuid)
+    if obj is None:
+        print(f"Object with id {id} not found.")
+        Jac.reset_context()
+        return {}
+    else:
+        Jac.reset_context()
+        return obj.__getstate__()
 
 
 @cmd_registry.register
@@ -242,6 +308,7 @@ def debug(filename: str, main: bool = True, cache: bool = False) -> None:
 @cmd_registry.register
 def dot(
     filename: str,
+    session: str = "",
     initial: str = "",
     depth: int = -1,
     traverse: bool = False,
@@ -263,6 +330,17 @@ def dot(
     :param node_limit: The maximum number of nodes allowed in the graph.
     :param saveto: Path to save the generated graph.
     """
+    if session == "":
+        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]
@@ -286,6 +364,10 @@ def dot(
             )
         except Exception as e:
             print(f"Error while generating graph: {e}")
+            import traceback
+
+            traceback.print_exc()
+            Jac.reset_context()
             return
         file_name = saveto if saveto else f"{mod}.dot"
         with open(file_name, "w") as file:
@@ -294,6 +376,8 @@ def dot(
     else:
         print("Not a .jac file.")
 
+    Jac.reset_context()
+
 
 @cmd_registry.register
 def py_to_jac(filename: str, tree: bool = False) -> None:
@@ -321,10 +405,13 @@ def start_cli() -> None:
     """
     parser = cmd_registry.parser
     args = parser.parse_args()
+    cmd_registry.args = args
     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")
         ret = command.call(**args_dict)
         if ret:
             print(ret)

jaclang/cli/cmdreg.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import argparse
 import cmd
 import inspect
+import pprint
 from typing import Callable, Optional
 
 
@@ -30,12 +31,17 @@ class CommandRegistry:
     registry: dict[str, Command]
     sub_parsers: argparse._SubParsersAction
     parser: argparse.ArgumentParser
+    args: argparse.Namespace
 
     def __init__(self) -> None:
         """Initialize a CommandRegistry instance."""
         self.registry = {}
-        self.parser = argparse.ArgumentParser(prog="CLI")
+        self.parser = argparse.ArgumentParser(prog="jac")
+        self.parser.add_argument(
+            "--session", help="Session file path", nargs="?", default=""
+        )
         self.sub_parsers = self.parser.add_subparsers(title="commands", dest="command")
+        self.args = argparse.Namespace()
 
     def register(self, func: Callable) -> Callable:
         """Register a command in the registry."""
@@ -48,6 +54,11 @@ class CommandRegistry:
         first = True
         for param_name, param in cmd.sig.parameters.items():
             arg_msg = f"type: {param.annotation.__name__}"
+            # shorthand is first character by default,
+            # If already taken, use the first 2 characters
+            shorthand = param_name[:1]
+            if f"-{shorthand}" in cmd_parser._option_string_actions:
+                shorthand = param_name[:2]
             if param_name == "args":
                 cmd_parser.add_argument("args", nargs=argparse.REMAINDER, help=arg_msg)
             elif param_name == "filepath":
@@ -76,7 +87,7 @@ class CommandRegistry:
                     )
                 else:
                     cmd_parser.add_argument(
-                        f"-{param_name[:1]}",
+                        f"-{shorthand}",
                         f"--{param_name}",
                         required=True,
                         type=(
@@ -99,14 +110,14 @@ class CommandRegistry:
                 arg_msg += f", default: {param.default}"
                 if param.annotation == bool:
                     cmd_parser.add_argument(
-                        f"-{param_name[:1]}",
+                        f"-{shorthand}",
                         f"--{param_name}",
                         default=param.default,
                         action="store_true",
                         help=arg_msg,
                     )
                     cmd_parser.add_argument(
-                        f"-n{param_name[:1]}",
+                        f"-n{shorthand}",
                         f"--no-{param_name}",
                         dest=param_name,
                         action="store_false",
@@ -114,7 +125,7 @@ class CommandRegistry:
                     )
                 else:
                     cmd_parser.add_argument(
-                        f"-{param_name[:1]}",
+                        f"-{shorthand}",
                         f"--{param_name}",
                         default=param.default,
                         help=arg_msg,
@@ -168,7 +179,8 @@ class CommandShell(cmd.Cmd):
                 args.pop("command")
                 ret = command.call(**args)
                 if ret:
-                    self.stdout.write(ret + "\n")
+                    ret_str = pprint.pformat(ret, indent=2)
+                    self.stdout.write(f"{ret_str}\n")
         except Exception as e:
             print(e)
 

jaclang/compiler/absyntree.py

@@ -391,7 +391,6 @@ class Module(AstDocNode):
         body: Sequence[ElementStmt | String | EmptyToken],
         is_imported: bool,
         kid: Sequence[AstNode],
-        impl_mod: Optional[Module] = None,
         test_mod: Optional[Module] = None,
         registry: Optional[SemRegistry] = None,
     ) -> None:
@@ -400,7 +399,7 @@ class Module(AstDocNode):
         self.source = source
         self.body = body
         self.is_imported = is_imported
-        self.impl_mod = impl_mod
+        self.impl_mod: list[Module] = []
         self.test_mod = test_mod
         self.mod_deps: dict[str, Module] = {}
         self.registry = registry