jaclang 0.5.7__py3-none-any.whl → 0.5.9__py3-none-any.whl

jaclang/cli/cli.py

@@ -1,8 +1,11 @@
 """Command line interface tool for the Jac language."""
 
+import importlib
+import marshal
 import os
 import pickle
 import shutil
+import types
 from typing import Optional
 
 from jaclang import jac_import
@@ -11,8 +14,10 @@ from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.constant import Constants
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool.schedules import format_pass
+from jaclang.plugin.builtin import dotgen
 from jaclang.plugin.feature import JacCmd as Cmd
 from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
 
@@ -90,8 +95,7 @@ def build(filename: str) -> None:
         warnings = len(out.warnings_had)
         print(f"Errors: {errs}, Warnings: {warnings}")
         for i in out.ir.flatten():
-            i.gen.mypy_ast = []
-            i.gen.py = ""
+            i.gen.clean()
         with open(filename[:-4] + ".jir", "wb") as f:
             pickle.dump(out.ir, f)
     else:
@@ -141,12 +145,33 @@ def enter(filename: str, entrypoint: str, args: list) -> None:
 
 
 @cmd_registry.register
-def test(filename: str) -> None:
+def test(
+    filepath: str,
+    filter: str = "",
+    xit: bool = False,
+    maxfail: int = None,  # type:ignore
+    directory: str = "",
+    verbose: bool = False,
+) -> None:
     """Run the test suite in the specified .jac file.
 
-    :param filename: The path to the .jac file.
+    :param filepath: Path/to/file.jac
+    :param filter: Filter the files using Unix shell style conventions.
+    :param xit(exit): Stop(exit) running tests as soon as finds an error.
+    :param maxfail: Stop running tests after n failures.
+    :param directory: Run tests from the specified directory.
+    :param verbose: Show more info.
+
+    jac test => jac test -d .
     """
-    Jac.run_test(filename)
+    Jac.run_test(
+        filepath=filepath,
+        filter=filter,
+        xit=xit,
+        maxfail=maxfail,
+        directory=directory,
+        verbose=verbose,
+    )
 
 
 @cmd_registry.register
@@ -162,8 +187,9 @@ def tool(tool: str, args: Optional[list] = None) -> None:
                 print(getattr(AstTool(), tool)(args))
             else:
                 print(getattr(AstTool(), tool)())
-        except Exception:
-            print(f"Error while running ast tool {tool}, check args.")
+        except Exception as e:
+            print(f"Error while running ast tool {tool}, check args: {e}")
+            raise e
     else:
         print(f"Ast tool {tool} not found.")
 
@@ -184,6 +210,86 @@ def clean() -> None:
     print("Done cleaning.")
 
 
+@cmd_registry.register
+def debug(filename: str, main: bool = True, cache: bool = False) -> None:
+    """Debug the specified .jac file using pdb."""
+    base, mod = os.path.split(filename)
+    base = base if base else "./"
+    mod = mod[:-4]
+    if filename.endswith(".jac"):
+        bytecode = jac_file_to_pass(filename).ir.gen.py_bytecode
+        if bytecode:
+            code = marshal.loads(bytecode)
+            if db.has_breakpoint(bytecode):
+                run(filename, main, cache)
+            else:
+                func = types.FunctionType(code, globals())
+
+                print("Debugging with Jac debugger.\n")
+                db.runcall(func)
+                print("Done debugging.")
+        else:
+            print(f"Error while generating bytecode in {filename}.")
+    else:
+        print("Not a .jac file.")
+
+
+@cmd_registry.register
+def graph(
+    filename: str,
+    initial: str = "",
+    depth: int = -1,
+    traverse: bool = False,
+    connection: list[str] = [],  # noqa: B006
+    bfs: bool = False,
+    edge_limit: int = 512,
+    node_limit: int = 512,
+    saveto: str = "",
+) -> None:
+    """Generate and Visualize a graph based on the specified .jac file contents and parameters.
+
+    :param filename: The name of the file to generate the graph from.
+    :param initial: The initial node for graph traversal (default is root node).
+    :param depth: The maximum depth for graph traversal (-1 for unlimited depth, default is -1).
+    :param traverse: Flag to indicate whether to traverse the graph (default is False).
+    :param connection: List of node connections(edge type) to include in the graph (default is an empty list).
+    :param bfs: Flag to indicate whether to use breadth-first search for traversal (default is False).
+    :param edge_limit: The maximum number of edges allowed in the graph.
+    :param node_limit: The maximum number of nodes allowed in the graph.
+    :param saveto: Path to save the generated graph.
+    """
+    base, mod = os.path.split(filename)
+    base = base if base else "./"
+    mod = mod[:-4]
+    if filename.endswith(".jac"):
+        jac_import(
+            target=mod,
+            base_path=base,
+        )
+        module = importlib.import_module(mod)
+        globals().update(vars(module))
+        try:
+            node = globals().get(initial, eval(initial)) if initial else None
+            graph = dotgen(
+                node=node,
+                depth=depth,
+                traverse=traverse,
+                edge_type=connection,
+                bfs=bfs,
+                edge_limit=edge_limit,
+                node_limit=node_limit,
+            )
+        except Exception as e:
+            print(f"Error while generating graph: {e}")
+            return
+        file_name = saveto if saveto else f"{mod}.dot"
+        with open(file_name, "w") as file:
+            file.write(graph)
+        print(f">>> Graph content saved to {os.path.join(os.getcwd(), file_name)}")
+    else:
+        print("Not a .jac file.")
+
+
 def start_cli() -> None:
     """
     Start the command line interface.

jaclang/cli/cmdreg.py

@@ -50,6 +50,18 @@ class CommandRegistry:
             arg_msg = f"type: {param.annotation.__name__}"
             if param_name == "args":
                 cmd_parser.add_argument("args", nargs=argparse.REMAINDER, help=arg_msg)
+            elif param_name == "filepath":
+                first = False
+                cmd_parser.add_argument(
+                    f"{param_name}",
+                    type=(
+                        eval(param.annotation)
+                        if isinstance(param.annotation, str)
+                        else param.annotation
+                    ),
+                    help=arg_msg,
+                    nargs="?",
+                )
             elif param.default is param.empty:
                 if first:
                     first = False

jaclang/compiler/__init__.py

@@ -1,5 +1,5 @@
-# type: ignore
 """Jac compiler tools."""
+
 import contextlib
 import logging
 import os
@@ -8,6 +8,7 @@ import sys
 cur_dir = os.path.dirname(__file__)
 if not os.path.exists(os.path.join(cur_dir, "__jac_gen__", "jac_parser.py")):
     from jaclang.vendor.lark.tools import standalone
+    from jaclang.utils.helpers import auto_generate_refs
 
     os.makedirs(os.path.join(cur_dir, "__jac_gen__"), exist_ok=True)
     with open(os.path.join(cur_dir, "__jac_gen__", "__init__.py"), "w"):
@@ -22,11 +23,66 @@ if not os.path.exists(os.path.join(cur_dir, "__jac_gen__", "jac_parser.py")):
     ]
     standalone.main()  # type: ignore
     sys.argv = save_argv
+    auto_generate_refs()
+
 
 from .__jac_gen__ import jac_parser as jac_lark  # noqa: E402
 
 
 jac_lark.logger.setLevel(logging.DEBUG)
 contextlib.suppress(AttributeError)
+TOKEN_MAP = {
+    x.name: x.pattern.value
+    for x in jac_lark.Lark_StandAlone().parser.lexer_conf.terminals
+}
+
+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_EQ": "**=",
+        "MUL_EQ": "*=",
+        "FLOOR_DIV_EQ": "//=",
+        "DIV_EQ": "/=",
+        "BW_OR_EQ": "|=",
+        "BW_XOR_EQ": "^=",
+        "STAR_POW": "**",
+        "STAR_MUL": "*",
+        "FLOOR_DIV": "//",
+        "DIV": "/",
+    }
+)
+
 
-__all__ = ["jac_lark"]
+__all__ = ["jac_lark", "TOKEN_MAP"]