jaclang 0.0.5__tar.gz → 0.0.8__tar.gz

{jaclang-0.0.5 → jaclang-0.0.8}/PKG-INFO

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

jaclang-0.0.8/README.md

@@ -0,0 +1,197 @@
+# Getting Started with the Jac Programming Language
+
+Welcome to JacLang, a unique and powerful programming language that runs on top of Python. To get you started, this guide will walk you through the process of installation, running Jac files, and importing Jac into existing Python modules.
+
+## Installation
+
+Firstly, you'll need to install JacLang. You can do this easily through Python's package manager, pip. Run the following command:
+
+```bash
+pip install jaclang
+```
+
+And from source simply use,
+
+```bash
+pip install -e .
+```
+
+Upon successful installation, you'll have a script named `jac` at your disposal. This script is used to load and run `.jac` files.
+
+## Running Jac Files
+
+Here's how you can use `jac`:
+
+- To simply load a sample Jac module and exit, run:
+    ```bash
+    jac load -f sample.jac
+    ```
+
+- To load a sample Jac module and execute a particular function (considered the entrypoint for execution in Jac), run:
+    ```bash
+    jac run -f sample.jac -e my_func
+    ```
+
+Now Try it with this example jac program with both load and calling `test_run`
+
+```jac
+"""Example of simple walker walking nodes."""
+
+node item {
+    has value: int;
+}
+
+walker Creator {
+    has count: int = 0;
+    can create with <root>|:n:item entry {
+        <here> ++> spawn :n:item;
+        <self>.count += 1;
+        if <self>.count < 10 {
+            visit -->;
+        }
+    }
+}
+
+walker Walk {
+    has count: int = 0;
+    can skip_root with <root> entry { visit -->; }
+    can step with :n:item entry {
+        <here>.value = <self>.count;
+        <self>.count += 1;
+        visit --> else {
+            f"Final Value: {<here>.value-1}" |> print;
+            "Done walking." |> print;
+            disengage;
+        }
+        f"Value: {<here>.value-1}" |> print;
+    }
+}
+
+can test_run {
+    spawn :w:Creator |> <root>;
+    spawn :w:Walk |> <root>;
+}
+
+with entry {
+    |> test_run;
+}
+```
+
+## Integrating Jac into Python Modules
+
+JacLang also provides a seamless way to import Jac into existing Python modules through library functions. Here's an example:
+
+```python
+"""CLI for jaclang."""
+from jaclang import jac_purple_import as jac_import
+
+cli = jac_import("cli")
+cmds = jac_import("cmds")
+
+cli.cmd_registry = cmds.cmd_reg  # type: ignore
+```
+
+In the above code snippet, `cli` and `cmds` are modules that are imported similar to how you'd typically import modules in Python, i.e., `import cli` or `import cmds`.
+
+Below is a sample `cli.jac` file to provide some insight into how Jac code looks:
+
+```jac
+"""
+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.
+"""
+
+import:py inspect;
+import:py argparse;
+import:py cmd;
+include:jac impl.cli_impl;
+
+object Command {
+    has func: callable,
+        sig: inspect.Signature;
+
+    can:private init(func: callable);
+    can call(*args: list, **kwargs: dict);
+}
+
+
+object CommandRegistry {
+    has:private registry: dict[str, Command],
+             sub_parsers: argparse._SubParsersActionp;
+    has:public parser: argparse.ArgumentParser;
+
+    can init;
+    can register(func: callable);
+    can get(name: str) -> Command;
+    can items -> dict[str, Command];
+}
+
+
+object CommandShell:cmd.Cmd {
+    static has intro: str = "Welcome to the Jac CLI!",
+               prompt: str = "jac> ";
+    has cmd_reg: CommandRegistry;
+
+    can init (cmd_reg: CommandRegistry);
+    can do_exit(arg: list) -> bool;
+    can default(line: str);
+}
+
+global cmd_registry = |> CommandRegistry;
+can start_cli;
+```
+
+That's all you need to get started with JacLang. As you delve into this new language, you'll discover how it beautifully combines the power of Python with a modern and intuitive syntax. Happy coding!
+
+## Installing JacLang Extension in Visual Studio Code (VSCode)
+
+In addition to setting up JacLang itself, you may also want to take advantage of the JacLang language extension for Visual Studio Code (VSCode). This will give you enhanced code highlighting, autocomplete, and other useful language features within your VSCode environment.
+
+Here's a step-by-step guide on how to package and install the JacLang VSCode extension.
+
+### Setting Up VSCE
+
+To create the VSIX file for the extension, you'll need `vsce`, a command-line tool for packaging VSCode extensions. If you don't have it installed already, follow these steps:
+
+1. Ensure that you have Node.js (>= 0.10.x) and npm installed on your machine.
+
+2. Open a terminal (or command prompt) and install `vsce` globally by running the following command:
+
+    ```bash
+    npm install -g vsce
+    ```
+
+### Packaging the Extension
+
+Once you have `vsce` set up, navigate to the JacLang extension directory in your local JacLang repository by running:
+
+```bash
+cd /path/to/repo/jaclang/support/vscode_ext/jac
+```
+
+In the `jac` directory, package the extension into a VSIX file by running:
+
+```bash
+vsce package
+```
+
+This will create a `.vsix` file, which is the packaged extension.
+
+### Installing the VSIX File in VSCode
+
+To install the packaged JacLang extension in VSCode:
+
+1. Open Visual Studio Code.
+
+2. Click on the Extensions view icon on the Sidebar (or press `Ctrl+Shift+X`).
+
+3. Click on the three-dot menu (`...`) in the top-right corner of the Extensions view.
+
+4. Select `Install from VSIX...` from the dropdown menu.
+
+5. In the file picker, find and select the `.vsix` file you created earlier and click `Open`.
+
+6. After a brief moment, the extension will be installed. You might have to reload VSCode for the changes to take effect.
+
+Now, you're all set to use the JacLang language extension in your VSCode editor! Enjoy your enhanced JacLang development experience.

jaclang-0.0.8/jaclang/__init__.py

@@ -0,0 +1,5 @@
+"""The Jac Programming Language."""
+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-0.0.8/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-0.0.8/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-0.0.5 → jaclang-0.0.8}/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-0.0.5 → jaclang-0.0.8}/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-0.0.8/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-0.0.8/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-0.0.5 → jaclang-0.0.8}/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>;
 }