jaclang 0.5.6__tar.gz → 0.5.8__tar.gz

{jaclang-0.5.6 → jaclang-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.5.6
+Version: 0.5.8
 Home-page: https://github.com/Jaseci-Labs/jaclang
 Author: Jason Mars
 Author-email: jason@jaseci.org

{jaclang-0.5.6 → jaclang-0.5.8}/README.md

@@ -43,10 +43,10 @@ node item {
 
 walker Creator {
     has count: int = 0;
-    can create with <root>|:n:item entry {
-        <here> ++> spawn :n:item;
-        <self>.count += 1;
-        if <self>.count < 10 {
+    can create with root|:n:item entry {
+        here ++> spawn :n:item;
+        self.count += 1;
+        if self.count < 10 {
             visit -->;
         }
     }
@@ -54,22 +54,22 @@ walker Creator {
 
 walker Walk {
     has count: int = 0;
-    can skip_root with <root> entry { visit -->; }
+    can skip_root with root entry { visit -->; }
     can step with :n:item entry {
-        <here>.value = <self>.count;
-        <self>.count += 1;
+        here.value = self.count;
+        self.count += 1;
         visit --> else {
-            f"Final Value: {<here>.value-1}" |> print;
+            f"Final Value: {here.value-1}" |> print;
             "Done walking." |> print;
             disengage;
         }
-        f"Value: {<here>.value-1}" |> print;
+        f"Value: {here.value-1}" |> print;
     }
 }
 
 can test_run {
-    spawn :w:Creator |> <root>;
-    spawn :w:Walk |> <root>;
+    spawn :w:Creator |> root;
+    spawn :w:Walk |> root;
 }
 
 with entry {

{jaclang-0.5.6 → jaclang-0.5.8}/jaclang/__init__.py

@@ -5,7 +5,11 @@ import sys
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "vendor"))
 
-from jaclang.plugin.default import JacCmdDefaults, JacFeatureDefaults  # noqa: E402
+from jaclang.plugin.default import (  # noqa: E402
+    JacBuiltin,
+    JacCmdDefaults,
+    JacFeatureDefaults,
+)
 from jaclang.plugin.feature import JacFeature, pm  # noqa: E402
 from jaclang.vendor import lark  # noqa: E402
 from jaclang.vendor import mypy  # noqa: E402
@@ -20,5 +24,6 @@ __all__ = [
     "pluggy",
 ]
 pm.register(JacFeatureDefaults)
+pm.register(JacBuiltin)
 pm.register(JacCmdDefaults)
 pm.load_setuptools_entrypoints("jac")

{jaclang-0.5.6 → jaclang-0.5.8}/jaclang/cli/cli.py

@@ -1,8 +1,10 @@
 """Command line interface tool for the Jac language."""
 
+import marshal
 import os
 import pickle
 import shutil
+import types
 from typing import Optional
 
 from jaclang import jac_import
@@ -13,6 +15,7 @@ from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool.schedules import format_pass
 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
 
 
@@ -21,12 +24,7 @@ Cmd.create_cmd()
 
 @cmd_registry.register
 def format(path: str, outfile: str = "", debug: bool = False) -> None:
-    """Run the specified .jac file or format all .jac files in a given directory.
-
-    :param path: The path to the .jac file or directory containing .jac files.
-    :param outfile: The output file path (only applies when formatting a single file).
-    :param debug: If True, print debug information.
-    """
+    """Run the specified .jac file or format all .jac files in a given directory."""
 
     def format_file(filename: str) -> None:
         code_gen_format = jac_file_to_pass(filename, schedule=format_pass)
@@ -60,18 +58,17 @@ def format(path: str, outfile: str = "", debug: bool = False) -> None:
 
 
 @cmd_registry.register
-def run(filename: str, main: bool = True) -> None:
-    """Run the specified .jac file.
-
-    :param filename: The path to the .jac file.
-    :param main: If True, use '__main__' as the module name, else use the actual module name.
-    """
+def run(filename: str, main: bool = True, cache: bool = True) -> None:
+    """Run the specified .jac file."""
     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, override_name="__main__" if main else None
+            target=mod,
+            base_path=base,
+            cachable=cache,
+            override_name="__main__" if main else None,
         )
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
@@ -79,6 +76,7 @@ def run(filename: str, main: bool = True) -> None:
             jac_import(
                 target=mod,
                 base_path=base,
+                cachable=cache,
                 override_name="__main__" if main else None,
                 mod_bundle=ir,
             )
@@ -95,8 +93,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:
@@ -146,12 +143,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
@@ -167,8 +185,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.")
 
@@ -189,6 +208,30 @@ 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.")
+
+
 def start_cli() -> None:
     """
     Start the command line interface.

{jaclang-0.5.6 → jaclang-0.5.8}/jaclang/cli/cmdreg.py

@@ -42,12 +42,26 @@ class CommandRegistry:
         name = func.__name__
         cmd = Command(func)
         self.registry[name] = cmd
-        cmd_parser = self.sub_parsers.add_parser(name, description=func.__doc__)
+        cmd_parser: argparse.ArgumentParser = self.sub_parsers.add_parser(
+            name, description=func.__doc__
+        )
         first = True
         for param_name, param in cmd.sig.parameters.items():
             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
@@ -83,17 +97,33 @@ class CommandRegistry:
                 )
             else:
                 arg_msg += f", default: {param.default}"
-                cmd_parser.add_argument(
-                    f"-{param_name[:1]}",
-                    f"--{param_name}",
-                    default=param.default,
-                    help=arg_msg,
-                    type=(
-                        eval(param.annotation)
-                        if isinstance(param.annotation, str)
-                        else param.annotation
-                    ),
-                )
+                if param.annotation == bool:
+                    cmd_parser.add_argument(
+                        f"-{param_name[:1]}",
+                        f"--{param_name}",
+                        default=param.default,
+                        action="store_true",
+                        help=arg_msg,
+                    )
+                    cmd_parser.add_argument(
+                        f"-n{param_name[:1]}",
+                        f"--no-{param_name}",
+                        dest=param_name,
+                        action="store_false",
+                        help=f"Compliment of {arg_msg}",
+                    )
+                else:
+                    cmd_parser.add_argument(
+                        f"-{param_name[:1]}",
+                        f"--{param_name}",
+                        default=param.default,
+                        help=arg_msg,
+                        type=(
+                            eval(param.annotation)
+                            if isinstance(param.annotation, str)
+                            else param.annotation
+                        ),
+                    )
         return func
 
     def get(self, name: str) -> Optional[Command]:

{jaclang-0.5.6 → jaclang-0.5.8}/jaclang/compiler/__init__.py

@@ -1,5 +1,5 @@
-# type: ignore
 """Jac compiler tools."""
+
 import contextlib
 import logging
 import os
@@ -28,5 +28,8 @@ from .__jac_gen__ import jac_parser as jac_lark  # noqa: E402
 
 jac_lark.logger.setLevel(logging.DEBUG)
 contextlib.suppress(AttributeError)
-
-__all__ = ["jac_lark"]
+TOKEN_MAP = {
+    x.name: x.pattern.value
+    for x in jac_lark.Lark_StandAlone().parser.lexer_conf.terminals
+}
+__all__ = ["jac_lark", "TOKEN_MAP"]