clig 0.2.0__tar.gz

clig-0.2.0/.gitignore

@@ -0,0 +1,5 @@
+dist/*
+**/__pycache__/
+.coverage
+/docs/sphinx/build/
+/docs/sphinx/source/notebooks/*.py

clig-0.2.0/.private/argparser_examples/example.py

@@ -0,0 +1,14 @@
+from argparse import ArgumentParser
+
+parser = ArgumentParser()
+
+parser.add_argument("-o")
+
+sub = parser.add_subparsers(dest="opa")
+subp = sub.add_parser("teste")
+subp.add_argument("-a")
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+    print(args)

clig-0.2.0/.private/argparser_examples/example4.py

@@ -0,0 +1,44 @@
+import sys
+from pathlib import Path
+from pprint import pprint
+from argparse import ArgumentParser, HelpFormatter
+
+# path = Path(__file__).parent
+# sys.path.insert(0, str((path).resolve()))
+# sys.path.insert(0, str((path / "../../../../src/clig").resolve()))
+# import clig
+
+
+# def main(lista: list[str]):
+#     print(locals())
+
+
+# cmd = clig.Command(main, subcommands_description="Teste de descri", formatter_class=HelpFormatter)
+
+
+# @cmd.subcommand(help="opa remove1")
+# def remove(name: str):
+#     print(locals())
+
+
+# @cmd.subcommand(help="opa add1")
+# def add(name: str):
+#     print(locals())
+
+
+# cmd.run()
+# cmd.add_parsers()
+# pprint(cmd.arguments)
+
+
+parser = ArgumentParser(prog="main")
+parser.add_argument("lista", nargs="*")
+subparsers = parser.add_subparsers(dest="subcommand_1", description="Teste de descri")
+subparser1 = subparsers.add_parser("remove", help="opa remove")
+subparser1.add_argument("name")
+subparser2 = subparsers.add_parser("add", help="opa add")
+subparser2.add_argument("name")
+args = parser.parse_args()
+print(args)
+#
+# assert parser == cmd.parser

clig-0.2.0/.private/argparser_examples/test.py

@@ -0,0 +1,9 @@
+from argparse import ArgumentParser
+
+parser = ArgumentParser()
+
+subparsers1 = parser.add_subparsers(dest="sub1")
+subparsers2 = parser.add_subparsers(dest="sub2")  # This is not allowed
+
+
+args = parser.parse_args(["-h"])

clig-0.2.0/.private/argparser_examples/test0.py

@@ -0,0 +1,16 @@
+from argparse import ArgumentParser
+
+parser = ArgumentParser(prog="Diogo")
+
+subparsers1 = parser.add_subparsers(dest="sub1", description="Desc do grupo")  # prog="opa")
+cmd1 = subparsers1.add_parser("command1")
+subparser11 = cmd1.add_subparsers(dest="sub1")
+cmd11 = subparser11.add_parser("cmd11")
+cmd2 = subparsers1.add_parser("command2")
+
+cmd1.add_argument()
+
+args = parser.parse_args("command1 -h".split())
+args = parser.parse_args("command1".split())
+
+print(args)

clig-0.2.0/.private/argparser_examples/test1.py

@@ -0,0 +1,41 @@
+from functools import partial
+from typing import Callable, overload
+
+
+@overload
+def foo[**P, T](func: Callable[P, T]) -> Callable[P, T]: ...
+
+
+@overload
+def foo[**P, T](**kwargs) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
+
+
+def foo[**P, T](func: Callable[P, T] | None = None, **kwargs) -> Callable[P, T] | Callable[[Callable[P, T]], Callable[P, T]]:
+    # foo called as decorator without arguments
+    if func is not None:
+        # do something using func
+        return func
+
+    # foo is called as decorator with arguments
+    return partial(foo, **kwargs)
+
+    def wrap(func: Callable[P, T]) -> Callable[P, T]:
+        # do something using kwargs
+        # do something using func
+        return func
+
+    # foo is called as decorator with arguments
+    return wrap
+
+    # print("setting " + str(kwargs))
+    # foo is called as decorator with arguments
+    return partial(foo, **kwargs)
+
+
+@foo  # (b=666, c="opa")
+def bar(a):
+    print(a)
+
+
+if __name__ == "__main__":
+    bar("aba gue")

clig-0.2.0/.private/clig_draft.py

@@ -0,0 +1,64 @@
+def get_argument_data(func: Callable[..., Any]) -> list[ArgumentData]:
+    argument_data: list[ArgumentData] = []
+    parameters = inspect.signature(func).parameters
+    docstring_data = get_docstring_data(len(parameters), func.__doc__)
+    helps = docstring_data.helps if docstring_data else {}
+    for par in parameters:
+        parameter = parameters[par]
+        argument = ArgumentData(name=parameter.name)
+        argument.help = helps.get(argument.name)
+        if parameter.default != parameter.empty:
+            argument.default = parameter.default
+            argument.name = f"--{argument.name}"
+        if parameter.annotation != parameter.empty:
+            if callable(parameter.annotation):
+                argument.kind = parameter.annotation
+        argument_data.append(argument)
+    return argument_data
+
+
+if __name__ == "__main__":
+
+    def foo(
+        a: int, b: str, c: float, d: bool = True, e: list[str] | None = None
+    ) -> tuple[str, ...]:
+        """Iure qui iusto debitis sit temporibus quos saepe.
+
+        Dolores laudantium quisquam consequuntur placeat dolor incidunt optio dolor. Ipsum et
+        accusamus quibusdam et. Quo tempora aut suscipit enim velit aperiam et accusamus. Illum sunt
+        voluptatum et.
+
+        Parameters
+        ----------
+        a : int
+            Aliquid ratione quam.
+        b : str
+            Id voluptatem maiores repellat qui.
+        c : float
+            Distinctio sit nesciunt.
+        d : bool, optional
+            Qui sit et sequi cupiditate deleniti eaque amet., by default True
+        e : list[str] | None, optional
+            Facilis quam asperiores repudiandae cupiditate sapiente., by default None
+
+        Returns
+        -------
+        tuple[str, ...]
+            Sequi labore ut molestias id ea suscipit.
+        """
+        ...
+
+    assert foo.__doc__ is not None
+    docstring_data = get_docstring_data(5, foo.__doc__)
+    assert docstring_data is not None
+    arg_data = get_argument_data(foo)
+
+    parser = ArgumentParser(
+        description=docstring_data.description,
+        epilog=docstring_data.epilog,
+        formatter_class=ArgumentDefaultsHelpFormatter,
+    )
+
+    for arg in arg_data:
+        parser.add_argument(arg.name, type=arg.kind, default=arg.default, help=arg.help)
+    parser.parse_args(["-h"])

clig-0.2.0/.private/cyclops_examples/example.py

@@ -0,0 +1,20 @@
+import sys
+from pathlib import Path
+
+path = Path(__file__).parent
+sys.path.insert(0, str((path).resolve()))
+sys.path.insert(0, str((path / "../../src").resolve()))
+
+
+from cyclopts import App
+
+app = App()
+
+
+@app.default
+def main(nome: str, idade: int):
+    print("Hello World!")
+
+
+if __name__ == "__main__":
+    app()

clig-0.2.0/.private/dataclass_examples/teste.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field, fields
+
+
+@dataclass
+class Person:
+    name: str
+    age: int = field(metadata={"frozen": True})
+
+    def __post_init__(self):
+        self.__set_fields_frozen(self)
+
+    @classmethod
+    def __set_fields_frozen(cls, self):
+        flds = fields(cls)
+        for fld in flds:
+            if fld.metadata.get("frozen"):
+                field_name = fld.name
+                field_value = getattr(self, fld.name)
+                setattr(self, f"_{fld.name}", field_value)
+
+                def local_getter(self):
+                    return getattr(self, f"_{field_name}")
+
+                def frozen(name):
+                    def local_setter(self, value):
+                        raise RuntimeError(f"Field '{name}' is frozen!")
+
+                    return local_setter
+
+                setattr(cls, field_name, property(local_getter, frozen(field_name)))
+
+
+person = Person("John", 22)
+
+print(person)  # prints: Person(name='John', age=36)
+print(person.age)  # prints: 36
+person.age = 56  # raise: RuntimeError: Field 'age' is frozen!

clig-0.2.0/.private/dataclass_examples/teste0.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass, field, InitVar
+
+
+@dataclass(repr=True)
+class Person:
+    name: InitVar[str]
+    _name: str = field(init=False)
+    age: int
+
+    @property
+    def name_(self) -> str:
+        self._name
+
+    def __post_init__(self, name: str) -> None:
+        self._name = name
+
+
+p = Person(name="digo", age=36)
+
+print(p)

clig-0.2.0/.private/draft_old.py

@@ -0,0 +1,35 @@
+import inspect
+from argparse import ArgumentParser
+from inspect import Parameter, Signature, signature
+from typing import Any, Callable, Tuple
+
+
+def run(command: Callable[..., Any]):
+    parser = ArgumentParser()
+    signature: Signature = inspect.signature(command)
+    parameters = signature.parameters
+    for name in parameters:
+        parameter: Parameter = parameters[name]
+
+        default = None
+        name = name.replace("_", "-")
+        if parameter.default != parameter.empty:
+            default = parameter.default
+            name = f"--{name}"
+        kwargs: dict[str, Any] = dict(type=str, action="store")
+
+        if parameter.annotation != parameter.empty:
+            if hasattr(parameter.annotation, "__metadata__"):
+                kwargs["type"] = parameter.annotation.__origin__
+                metadata = parameter.annotation.__metadata__
+            if callable(parameter.annotation):
+                kwargs["type"] = parameter.annotation
+
+        if kwargs.get("type", None) == bool:
+            kwargs["action"] = "store_false" if default else "store_true"
+
+        if kwargs.get("action", None) in ["store_const", "store_true", "store_false", "help"]:
+            kwargs.pop("type", None)
+
+        parser.add_argument(name, default=default, **kwargs)
+    command(**vars(parser.parse_args()))

clig-0.2.0/.private/example.py

@@ -0,0 +1,31 @@
+from pprint import pprint
+
+import numpy as np
+
+from clig import NUMPY_DOCSTRING, get_docstring_data
+
+np.array
+
+if __name__ == "__main__":
+    # Example usage
+    docstring = """
+            Compute the square root of a number.
+            
+            Teste
+
+            Parameters
+            ----------
+            x : float
+                The number for which to compute the square root.
+            y : float, optional
+                An additional number to adjust the result.
+            z : int
+                A parameter affecting the rounding.
+
+            Returns
+            -------
+            float
+                The square root of the given number.
+        """
+
+    pprint(get_docstring_data(3, docstring, NUMPY_DOCSTRING))

clig-0.2.0/.private/examples_clig/example.py

@@ -0,0 +1,10 @@
+import clig
+
+
+def hello():
+    pass
+
+
+app = clig.Command(hello).add_subcommand(hello)
+
+print(app.subparsers_dest)

clig-0.2.0/.private/examples_clig/git_clone.py

@@ -0,0 +1,152 @@
+import sys
+from pathlib import Path
+
+path = Path(__file__).parent
+sys.path.insert(0, str((path).resolve()))
+sys.path.insert(0, str((path / "../../src").resolve()))
+from clig import Command, data, Arg
+
+
+def git(
+    exec_path: str = "git",
+    bare: bool = False,
+    git_dir: str = ".git",
+    work_tree: str = ".",
+):
+    """The Git version control system
+
+    'git help -a' and 'git help -g' list available subcommands and some concept guides. See 'git help
+    <command>' or 'git help <concept>' to read about a specific subcommand or concept. See 'git help git' for
+    an overview of the system.
+
+    Parameters
+    ----------
+    - `exec_path` (`str`, optional): Defaults to `"git"`.
+        The path to the executable.
+
+    - `bare` (`bool`, optional): Defaults to `False`.
+        Whether the repository is bare or not
+
+    - `git_dir` (`str`, optional): Defaults to `".git"`.
+        The path to the repository data base.
+
+    - `work_tree` (`str`, optional): Defaults to `"."`.
+        The path to the worktree.
+    """
+    print(locals())
+    return "Exec git"
+
+
+def add(pathspec: list[str], interactive: Arg[bool, data("-i")] = False, edit: Arg[bool, data("-e")] = False):
+    """Add file contents to the index
+
+    Used to add file contents to the index
+
+    Parameters
+    ----------
+    - `pathspec` (`list[str]`):
+        The paths to add
+
+    - `interactive` (`Arg[bool, data`, optional): Defaults to `False`.
+        interactive picking
+
+    - `edit` (`Arg[bool, data`, optional): Defaults to `False`.
+        edit current diff and apply
+
+    """
+    print(locals())
+    return "Exec add"
+
+
+def commit(message: Arg[str, data("-m")], amend: bool = False):
+    """Record changes to the repository
+
+    Use this to commit changes
+
+    Parameters
+    ----------
+    - `message` (`Arg[str, data`):
+        commit message
+
+    - `amend` (`bool`, optional): Defaults to `False`.
+        amend previous commit
+    """
+    print(locals())
+    return "Exec commit"
+
+
+def remote(verbose: bool = False):
+    """Manage remote repositories
+
+    Use this subcommand to manage fetched remote repos.
+
+    Parameters
+    ----------
+    - `verbose` (`bool`, optional): Defaults to `False`.
+        Whether the subcommand is verbose
+
+    """
+    print(locals())
+    return "Exec remote"
+
+
+def rename(old: str, new: str):
+    """Renames the remote
+
+    Use to rename the remote repo
+
+    Parameters
+    ----------
+    - `old` (`str`):
+        Old name of the repo
+
+    - `new` (`str`):
+        New name of the remote
+    """
+    print(locals())
+    return "Exec rename"
+
+
+def remove(name: str):
+    """Removes a remote
+
+    Use to remove a remote reference
+
+    Parameters
+    ----------
+    - `name` (`str`):
+        Name of the remote
+    """
+    print(locals())
+    return "Exec remove"
+
+
+def prune(name: str, dry_run: bool = False):
+    """Prune the remote repo
+
+    Use to prune the remote repo
+
+    Parameters
+    ----------
+    - `name` (`str`):
+        Name of the remote
+
+    - `dry_run` (`bool`, optional): Defaults to `False`.
+        Whether to dry run
+    """
+    print(locals())
+    return "Exec prune"
+
+
+app = (
+    Command(git, subcommands_description="These are common Git commands used in various situations:")
+    .add_subcommand(add)
+    .add_subcommand(commit)
+)
+remote_cmd = (
+    app.new_subcommand(remote, subcommands_description="Comands used with git remote")
+    .add_subcommand(rename)
+    .add_subcommand(remove)
+    .add_subcommand(prune)
+)
+print(app.run())

clig-0.2.0/.private/examples_clig/positional.py

@@ -0,0 +1,47 @@
+# cSpell:disable
+import sys
+from pathlib import Path
+
+path = Path(__file__).parent
+sys.path.insert(0, str((path).resolve()))
+sys.path.insert(0, str((path / "../../src").resolve()))
+from clig import Command, data, Arg
+
+
+def print_echo(
+    echo: str,
+    upper: Arg[bool, data("-u")] = True,
+    value: Arg[int, data("-c", "--const", make_flag=True, action="store_const", const=123)] = 666,
+):
+    """Quam blanditiis qui corporis aut dolor qui officiis quo.
+
+    Dolor totam repudiandae quam ea sit. Officiis nostrum repellendus. Ut odio omnis sed aut. Est qui fugit
+    fuga et dolorem sapiente. Nostrum qui vero cumque tempore. Necessitatibus quo facilis numquam impedit quia
+    ipsa minima aliquid vitae.
+
+    Parameters
+    ----------
+    - `echo` (`str`):
+        Repellendus id distinctio reiciendis dignissimos sit voluptatem et omnis corporis.
+
+    - `upper` (`Arg[bool, data`, optional): Defaults to `True`.
+        Amet sunt nihil consequatur ut dolorem provident aut.
+
+    - `value` (`Arg[int, data`, optional): Defaults to `"store_const", const=123)]=666`.
+        Et facilis cumque voluptatum.
+
+    """
+    print(locals())
+
+
+def hello(word: str):
+    pass
+
+
+def hi(word: str):
+    pass
+
+
+cmd = Command(print_echo, description="opa")
+cmd.add_command(hi)
+cmd.run()

clig-0.2.0/.private/fire_examples/example.py

@@ -0,0 +1,17 @@
+import fire
+
+
+class BrokenCalculator(object):
+
+    def __init__(self, offset=1):
+        self._offset = offset
+
+    def add(self, x, y):
+        return x + y + self._offset
+
+    def multiply(self, x, y, *args, **kwargs):
+        return x * y + self._offset
+
+
+if __name__ == "__main__":
+    fire.Fire(BrokenCalculator)

clig-0.2.0/.private/prototype.py

@@ -0,0 +1,99 @@
+from pprint import pprint
+import re
+
+# Example usage
+docstring_template = r"""
+(.*)
+
+Parameters
+----------
+(.*) : (.*)
+    (.*)
+(.*) : (.*)
+    (.*)
+(.*) : (.*)
+    (.*)
+
+Returns
+-------
+float
+    The square root of the given number.
+"""
+
+# Example usage
+docstring = """
+Compute the square root of a number.
+
+Parameters
+----------
+x : float
+    The number for which to compute the square root.
+y : float, optional
+    An additional number to adjust the result.
+z : int
+    A parameter affecting the rounding.
+
+Returns
+-------
+float
+    The square root of the given number.
+"""
+
+docstring_temp = """
+{{description}}
+
+Parameters
+----------
+{{parameter_name}} : {{parameter_type}}
+    {{parameter_description}}
+"""
+
+place_holders: dict[str, int | None | str] = {
+    "description": None,
+    "parameter_name": None,
+    "parameter_type": None,
+    "parameter_description": None,
+}
+
+list_indexes = []
+for place_holder in place_holders:
+    place = f"{{{place_holder}}}"
+    if place in docstring_temp:
+        index = docstring_temp.index(place)
+        place_holders[place_holder] = index
+        list_indexes.append(index)
+list_indexes.sort()
+
+for place_holder in place_holders:
+    place_holders[place_holder] = list_indexes.index(place_holders[place_holder])
+
+PARAMETER_NUMBER = 3
+
+place = "{{parameter_name}}"
+if place in docstring_temp:
+    index = docstring_temp.index(place)
+    substring = docstring_temp[index:]
+
+regex_string = docstring_temp
+for i in range(PARAMETER_NUMBER - 1):
+    regex_string += substring
+
+for place_holder in place_holders:
+    place = f"{{{{{place_holder}}}}}"
+    regex_string = regex_string.replace(place, "(.*)")
+
+# pprint(substring)
+
+# pprint(regex_string)
+
+
+# current_param = None
+
+match = re.match(regex_string, docstring)
+if match:
+    params = match.groups()
+    # for place_holder in place_holders:
+    #     place_holders[place_holder] = params[place_holders[place_holder]]
+    #     pprint(place_holders)
+
+# pprint(place_holders)