jaclang 0.0.5__py3-none-any.whl → 0.0.8__py3-none-any.whl

jaclang/__init__.py

@@ -1,4 +1,5 @@
 """The Jac Programming Language."""
-from jaclang.jac.importer import handle_jac_error, jac_blue_import, jac_purple_import
+from jaclang.jac.importer import jac_blue_import, jac_purple_import
+from jaclang.utils.helpers import handle_jac_error
 
 __all__ = ["jac_blue_import", "jac_purple_import", "handle_jac_error"]

jaclang/cli/__jac_gen__/cli.py

@@ -0,0 +1,175 @@
+"""
+This is the implementation of the command line interface tool for the
+Jac language. It's built with the Jac language via bootstraping and
+represents the first such complete Jac program.
+"""  # 0 1
+from __future__ import annotations
+from jaclang import jac_purple_import as __jac_import__  # -1 0
+import traceback as __jac_traceback__  # -1 0
+from jaclang import handle_jac_error as __jac_error__  # -1 0
+from jaclang.core import exec_ctx as _jac_exec_ctx_  # -1 0
+from jaclang.core import Object as _jac_Object_  # -1 0
+from jaclang.core import make_architype as _jac_make_architype_  # -1 0
+import inspect  # 0 7
+
+import argparse  # 0 8
+
+import cmd  # 0 9
+
+__jac_import__(target='impl.cli_impl', base_path=__file__)  # 0 10
+from impl.cli_impl import *  # 0 10
+
+@_jac_make_architype_(_jac_Object_)  # 0 13
+class Command:  # 0 13
+    def __init__(self,  # 0 0
+        func = None,      # 0 0
+        sig = None,      # 0 0
+        *args, **kwargs):      # 0 0
+        self.func = func      # 0 0
+        self.sig = sig      # 0 0
+        self.func = func  # 1 4
+        self.sig = inspect.signature(func)  # 1 4
+    
+    def call(self,*args: list, **kwargs: dict):  # 0 18
+        try:      # 0 18
+            return self.func(*args, **kwargs)  # 1 9
+        except Exception as e:      # 0 18
+            tb = __jac_traceback__.extract_tb(e.__traceback__)          # 0 18
+            __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 0 18
+            e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 0 18
+            raise e          # 0 18      # 0 13
+
+@_jac_make_architype_(_jac_Object_)  # 0 22
+class CommandRegistry:  # 0 22
+    def __init__(self,  # 0 0
+        registry = None,      # 0 0
+        sub_parsers = None,      # 0 0
+        parser = None,      # 0 0
+        *args, **kwargs):      # 0 0
+        self.registry = registry      # 0 0
+        self.sub_parsers = sub_parsers      # 0 0
+        self.parser = parser      # 0 0
+        self.registry = {}  # 1 13
+        self.parser = argparse.ArgumentParser(prog = "CLI")  # 1 13
+        self.sub_parsers = self.parser.add_subparsers(title = "commands", dest = "command")  # 1 13
+    
+    def register(self,func: callable):  # 0 28
+        try:      # 0 28
+            name = func.__name__  # 1 20
+            cmd = Command(func)  # 1 20
+            self.registry[name] = cmd  # 1 20
+            cmd_parser = self.sub_parsers.add_parser(name)  # 1 20
+            param_items = cmd.sig.parameters.items  # 1 20
+            first = True  # 1 20
+            for param_name,param in cmd.sig.parameters.items():  # 1 26
+                if param_name == "args":  # 1 27
+                    cmd_parser.add_argument('args', nargs = argparse.REMAINDER)  # 1 28
+                
+                elif param.default is param.empty:  # 1 31
+                    if first:  # 1 32
+                        first = False  # 1 33
+                        cmd_parser.add_argument(f"{param_name}", type = eval(param.annotation))  # 1 33
+                    
+                    else:  # 1 37
+                        cmd_parser.add_argument(f"-{param_name[:1]}", f"--{param_name}", required = True, type = eval(param.annotation))  # 1 38
+                    
+                
+                else:  # 1 44
+                    if first:  # 1 45
+                        first = False  # 1 46
+                        cmd_parser.add_argument(f"{param_name}", default = param.default, type = eval(param.annotation))  # 1 46
+                    
+                    else:  # 1 50
+                        cmd_parser.add_argument(f"-{param_name[:1]}", f"--{param_name}", default = param.default, type = eval(param.annotation))  # 1 51      # 1 26
+            return func  # 1 57
+        except Exception as e:      # 0 28
+            tb = __jac_traceback__.extract_tb(e.__traceback__)          # 0 28
+            __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 0 28
+            e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 0 28
+            raise e          # 0 28
+    
+    def get(self,name: str) -> Command:  # 0 29
+        try:      # 0 29
+            return self.registry.get(name)  # 1 61
+        except Exception as e:      # 0 29
+            tb = __jac_traceback__.extract_tb(e.__traceback__)          # 0 29
+            __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 0 29
+            e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 0 29
+            raise e          # 0 29
+    
+    def items(self,) -> dict[str, Command]:  # 0 30
+        try:      # 0 30
+            return self.registry.items()  # 1 65
+        except Exception as e:      # 0 30
+            tb = __jac_traceback__.extract_tb(e.__traceback__)          # 0 30
+            __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 0 30
+            e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 0 30
+            raise e          # 0 30      # 0 22
+
+@_jac_make_architype_(_jac_Object_)  # 0 34
+class CommandShell(cmd.Cmd):  # 0 34
+    intro: str = "Welcome to the Jac CLI!"  # 0 35
+    prompt: str = "jac> "  # 0 35
+    
+    def __init__(self,  # 0 0
+        cmd_reg = None,      # 0 0
+        *args, **kwargs):      # 0 0
+        self.cmd_reg = cmd_reg      # 0 0
+        self.cmd_reg = cmd_reg  # 1 70
+        cmd.Cmd.__init__(self)  # 1 70
+    
+    def do_exit(self,arg: list) -> bool:  # 0 40
+        try:      # 0 40
+            return True  # 1 75
+        except Exception as e:      # 0 40
+            tb = __jac_traceback__.extract_tb(e.__traceback__)          # 0 40
+            __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 0 40
+            e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 0 40
+            raise e          # 0 40
+    
+    def default(self,line: str):  # 0 41
+        try:      # 0 41
+            try:  # 1 79
+                args = vars(self.cmd_reg.parser.parse_args(line.split()))  # 1 80
+                command = self.cmd_reg.get(args["command"])  # 1 80
+                if command:  # 1 82
+                    args.pop("command")  # 1 83
+                    ret = command.call(**args)  # 1 83
+                    if ret:  # 1 85
+                        print(ret)  # 1 86      # 1 79
+            except Exception as e:  # 1 90
+                print(e)  # 1 91      # 1 90  # 1 90  # 1 79
+        except Exception as e:      # 0 41
+            tb = __jac_traceback__.extract_tb(e.__traceback__)          # 0 41
+            __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 0 41
+            e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 0 41
+            raise e          # 0 41      # 0 34
+
+cmd_registry = CommandRegistry()  # 0 45
+
+def start_cli():  # 0 46
+    try:      # 0 46
+        parser = cmd_registry.parser  # 1 96
+        args = parser.parse_args()  # 1 96
+        command = cmd_registry.get(args.command)  # 1 96
+        if command:  # 1 99
+            args = vars(args)  # 1 100
+            args.pop("command")  # 1 100
+            ret = command.call(**args)  # 1 100
+            if ret:  # 1 103
+                print(ret)  # 1 104
+            
+        
+        else:  # 1 107
+            shell = CommandShell(cmd_registry).cmdloop()  # 1 108
+        
+    except Exception as e:      # 0 46
+        tb = __jac_traceback__.extract_tb(e.__traceback__)          # 0 46
+        __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 0 46
+        e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 0 46
+        raise e          # 0 46
+
+r""" JAC DEBUG INFO
+/home/ninja/jaclang/jaclang/cli/cli.jac
+/home/ninja/jaclang/jaclang/cli/impl/cli_impl.jac
+JAC DEBUG INFO """

jaclang/cli/__jac_gen__/cmds.py

@@ -0,0 +1,132 @@
+"""
+This is the implementation of the command line interface tool for the
+Jac language. It's built with the Jac language via bootstraping and
+represents the first such production Jac program.
+"""  # 2 1
+from __future__ import annotations
+from jaclang import jac_purple_import as __jac_import__  # -1 0
+from jaclang.core import exec_ctx as _jac_exec_ctx_  # -1 0
+from jaclang.core import Object as _jac_Object_  # -1 0
+from jaclang.core import make_architype as _jac_make_architype_  # -1 0
+import traceback as __jac_traceback__  # -1 0
+from jaclang import handle_jac_error as __jac_error__  # -1 0
+__jac_import__(target='cli', base_path=__file__)  # 2 6
+from cli import cmd_registry as cmd_reg  # 2 6
+
+__jac_import__(target='impl.cmds_impl', base_path=__file__)  # 2 8
+from impl.cmds_impl import *  # 2 8
+
+@cmd_reg.register  # 2 10
+def run(filename: str):  # 2 11
+    try:      # 2 11
+        if filename.endswith(".jac"):  # 3 10
+            [base, mod] = os.path.split(filename)  # 3 11
+            base = './' if not base else base  # 3 11
+            mod = mod[:-4]  # 3 11
+            __jac_import__(target = mod, base_path = base, override_name = "__main__")  # 3 11
+        
+        else:  # 3 15
+            print("Not a .jac file.")  # 3 16
+        
+    except Exception as e:      # 2 11
+        tb = __jac_traceback__.extract_tb(e.__traceback__)          # 2 11
+        __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 2 11
+        e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 2 11
+        raise e          # 2 11
+
+@cmd_reg.register  # 2 13
+def enter(filename: str, entrypoint: str, args: list):  # 2 14
+    try:      # 2 14
+        if filename.endswith(".jac"):  # 3 23
+            [base, mod] = os.path.split(filename)  # 3 24
+            base = './' if not base else base  # 3 24
+            mod = mod[:-4]  # 3 24
+            mod = __jac_import__(target = mod, base_path = base)  # 3 24
+            if not mod:  # 3 28
+                print('Errors occured while importing the module.')  # 3 29
+                return  # 3 30
+            
+            else:  # 3 32
+                (getattr(mod, entrypoint))()  # 3 33
+            
+        
+        else:  # 3 35
+            print("Not a .jac file.")  # 3 36
+        
+    except Exception as e:      # 2 14
+        tb = __jac_traceback__.extract_tb(e.__traceback__)          # 2 14
+        __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 2 14
+        e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 2 14
+        raise e          # 2 14
+
+@cmd_reg.register  # 2 16
+def test(filename: str):  # 2 17
+    try:      # 2 17
+        if filename.endswith(".jac"):  # 3 43
+            [base, mod] = os.path.split(filename)  # 3 44
+            base = './' if not base else base  # 3 44
+            mod = mod[:-4]  # 3 44
+            mod = __jac_import__(target = mod, base_path = base)  # 3 44
+            unittest.TextTestRunner().run(mod.__jac_suite__)  # 3 44
+        
+        else:  # 3 49
+            print("Not a .jac file.")  # 3 50
+        
+    except Exception as e:      # 2 17
+        tb = __jac_traceback__.extract_tb(e.__traceback__)          # 2 17
+        __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 2 17
+        e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 2 17
+        raise e          # 2 17
+
+@cmd_reg.register  # 2 19
+def ast_tool(tool: str):  # 2 20
+    try:      # 2 20
+        from jaclang.utils.lang_tools import AstTool  # 3 56
+        if (hasattr(AstTool, tool)):  # 3 57
+            print(getattr(AstTool(), tool)())  # 3 58
+        
+        else:  # 3 59
+            print(f"Ast tool {tool} not found.")  # 3 60
+        
+    except Exception as e:      # 2 20
+        tb = __jac_traceback__.extract_tb(e.__traceback__)          # 2 20
+        __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 2 20
+        e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 2 20
+        raise e          # 2 20
+
+@cmd_reg.register  # 2 22
+def lsp():  # 2 23
+    try:      # 2 23
+        from jaclang.jac.langserve import server  # 3 66
+        print("Starting server...")  # 3 66
+        server.start_io()  # 3 66
+    except Exception as e:      # 2 23
+        tb = __jac_traceback__.extract_tb(e.__traceback__)          # 2 23
+        __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 2 23
+        e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 2 23
+        raise e          # 2 23
+
+@cmd_reg.register  # 2 25
+def clean():  # 2 26
+    try:      # 2 26
+        current_dir = os.getcwd()  # 3 73
+        py_cache = "__pycache__"  # 3 73
+        for root,dirs,files in os.walk(current_dir, topdown = True):  # 3 75
+            for folder_name in dirs[:]:  # 3 76
+                if folder_name == C.JAC_GEN_DIR or folder_name == py_cache:  # 3 77
+                    folder_to_remove = os.path.join(root, folder_name)  # 3 78
+                    shutil.rmtree(folder_to_remove)  # 3 78
+                    print(f"Removed folder: {folder_to_remove}")  # 3 78      # 3 76      # 3 75
+        print("Done cleaning.")  # 3 73
+    except Exception as e:      # 2 26
+        tb = __jac_traceback__.extract_tb(e.__traceback__)          # 2 26
+        __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 2 26
+        e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 2 26
+        raise e          # 2 26
+
+r""" JAC DEBUG INFO
+/home/ninja/jaclang/jaclang/cli/cli.jac
+/home/ninja/jaclang/jaclang/cli/impl/cli_impl.jac
+/home/ninja/jaclang/jaclang/cli/cmds.jac
+/home/ninja/jaclang/jaclang/cli/impl/cmds_impl.jac
+JAC DEBUG INFO """

jaclang/cli/cli.jac

@@ -14,7 +14,7 @@ object Command {
     has func: callable,
         sig: inspect.Signature;
 
-    can:private <init>(func: callable);
+    can:private <init>;
     can call(*args: list, **kwargs: dict);
 }
 
@@ -36,7 +36,7 @@ object CommandShell:cmd.Cmd {
                prompt: str = "jac> ";
     has cmd_reg: CommandRegistry;
 
-    can <init>(cmd_reg: CommandRegistry);
+    can <init>;
     can do_exit(arg: list) -> bool;
     can default(line: str);
 }

jaclang/cli/cmds.jac

@@ -8,13 +8,19 @@ import:jac from cli, cmd_registry as cmd_reg;
 include:jac impl.cmds_impl;
 
 @cmd_reg.register
-can load(filename: str);
+can run(filename: str);
 
 @cmd_reg.register
-can run(filename: str, entrypoint: str, args: list);
+can enter(filename: str, entrypoint: str, args: list);
+
+@cmd_reg.register
+can <>test(filename: str);
 
 @cmd_reg.register
 can ast_tool(tool: str);
 
+@cmd_reg.register
+can lsp;
+
 @cmd_reg.register
 can clean;

jaclang/cli/impl/__jac_gen__/cli_impl.py

@@ -0,0 +1,16 @@
+"""Implemenation for Jac's command line interface."""  # 1 1
+from __future__ import annotations
+
+
+
+
+
+
+
+
+
+
+r""" JAC DEBUG INFO
+/home/ninja/jaclang/jaclang/cli/cli.jac
+/home/ninja/jaclang/jaclang/cli/impl/cli_impl.jac
+JAC DEBUG INFO """

jaclang/cli/impl/__jac_gen__/cmds_impl.py

@@ -0,0 +1,26 @@
+"""Implementations for the jac command line interface."""  # 3 1
+from __future__ import annotations
+from jaclang import jac_purple_import as __jac_import__  # -1 0
+from jaclang.core import exec_ctx as _jac_exec_ctx_  # -1 0
+from jaclang.core import Object as _jac_Object_  # -1 0
+from jaclang.core import make_architype as _jac_make_architype_  # -1 0
+import os  # 3 2
+
+import shutil  # 3 3
+
+import unittest  # 3 4
+
+from jaclang.jac.constant import Constants as C  # 3 5
+
+
+
+
+
+
+
+r""" JAC DEBUG INFO
+/home/ninja/jaclang/jaclang/cli/cli.jac
+/home/ninja/jaclang/jaclang/cli/impl/cli_impl.jac
+/home/ninja/jaclang/jaclang/cli/cmds.jac
+/home/ninja/jaclang/jaclang/cli/impl/cmds_impl.jac
+JAC DEBUG INFO """

jaclang/cli/impl/cli_impl.jac

@@ -1,6 +1,6 @@
 """Implemenation for Jac's command line interface."""
 
-:o:Command:a:<init>(func: callable) {
+:o:Command:a:<init> {
     <s>.func = func;
     <s>.sig = func |> inspect.signature;
 }
@@ -21,20 +21,37 @@
     cmd = func |> Command;
     <s>.registry[name] = cmd;
     cmd_parser = name |> <s>.sub_parsers.add_parser;
+    param_items = cmd.sig.parameters.items;
+    first = True;
     for param_name, param in |> cmd.sig.parameters.items {
         if param_name == "args" {
             ('args', nargs=argparse.REMAINDER)
                 |> cmd_parser.add_argument;
         }
         elif param.default is param.empty {
-            (f"-{param_name[:1]}", f"--{param_name}",
-            required=True, type=param.annotation|>eval)
-                |> cmd_parser.add_argument;
+            if first {
+                first = False;
+                (f"{param_name}", type=param.annotation|>eval)
+                    |> cmd_parser.add_argument;
+            }
+            else {
+                (f"-{param_name[:1]}", f"--{param_name}",
+                required=True, type=param.annotation|>eval)
+                    |> cmd_parser.add_argument;
+            }
+
         }
         else {
-            (f"-{param_name[:1]}", f"--{param_name}",
-            default=param.default, type=param.annotation|>eval)
-                |> cmd_parser.add_argument;
+            if first {
+                first = False;
+                (f"{param_name}", default=param.default, type=param.annotation|>eval)
+                    |> cmd_parser.add_argument;
+            }
+            else {
+                (f"-{param_name[:1]}", f"--{param_name}",
+                default=param.default, type=param.annotation|>eval)
+                    |> cmd_parser.add_argument;
+            }
         }
     }
     return func;
@@ -49,7 +66,7 @@
 }
 
 
-:o:CommandShell:a:<init>(cmd_reg: CommandRegistry) {
+:o:CommandShell:a:<init> {
     <s>.cmd_reg = cmd_reg;
     <s> |> cmd.Cmd.<init>;
 }

jaclang/cli/impl/cmds_impl.jac

@@ -1,29 +1,51 @@
 """Implementations for the jac command line interface."""
 import:py os;
 import:py shutil;
+import:py unittest;
+import:py from jaclang.jac.constant, Constants as C;
 
 """Load a .jac file and return the entrypoint function."""
-:a:load
+:a:run
 (filename: str) {
     if filename.endswith(".jac"){
         [base, mod] = os.path.split(filename);
         base = './' if not base else base;
         mod=mod[:-4];
-        __jac_import__(target=mod, base_path=base);
+        __jac_import__(target=mod, base_path=base, override_name="__main__");
     } else {
         "Not a .jac file." :> print;
     }
 }
 
 """Run the entrypoint of the given .jac file."""
-:a:run
+:a:enter
 (filename: str, entrypoint: str, args: list) {
+    if filename.endswith(".jac") {
+        [base, mod] = os.path.split(filename);
+        base = './' if not base else base;
+        mod=mod[:-4];
+        mod = __jac_import__(target=mod, base_path=base);
+        if not mod {
+            print('Errors occured while importing the module.');
+            return;
+        }
+        else {
+            :> ((mod, entrypoint) :> getattr );
+        }
+    } else {
+        "Not a .jac file." :> print;
+    }
+}
+
+"""Load a .jac file and return the entrypoint function."""
+:a:<>test
+(filename: str) {
     if filename.endswith(".jac"){
         [base, mod] = os.path.split(filename);
         base = './' if not base else base;
         mod=mod[:-4];
         mod = __jac_import__(target=mod, base_path=base);
-        :> ((mod, entrypoint) :> getattr );
+        unittest.TextTestRunner().run(mod.__jac_suite__);
     } else {
         "Not a .jac file." :> print;
     }
@@ -39,14 +61,20 @@ import:py shutil;
     }
 }
 
+"""Run language server for Jac."""
+:a:lsp {
+    import:py from jaclang.jac.langserve, server;
+    print("Starting server...");
+    server.start_io();
+}
+
 """Remove the __jac_gen__ , __pycache__ folders from the current directory recursevely."""
 :a:clean {
     current_dir = os.getcwd();
-    jac_gen = "__jac_gen__";
     py_cache = "__pycache__";
     for root, dirs, files in os.walk(current_dir, topdown=True) {
         for folder_name in dirs[:] {
-            if folder_name == jac_gen or folder_name == py_cache {
+            if folder_name == C.JAC_GEN_DIR or folder_name == py_cache {
                 folder_to_remove = os.path.join(root, folder_name);
                 shutil.rmtree(folder_to_remove);
                 print(f"Removed folder: {folder_to_remove}");
@@ -55,3 +83,4 @@ import:py shutil;
     }
     print("Done cleaning.");
 }
+