declinate 0.0.1__py3-none-any.whl

declinate/__init__.py

@@ -0,0 +1,3 @@
+# Copyright 2022-2023  Ternaris.
+# SPDX-License-Identifier: Apache-2.0
+"""Declinate CLI wrapper generator."""

declinate/check.py

@@ -0,0 +1,30 @@
+# Copyright 2022-2023  Ternaris.
+# SPDX-License-Identifier: Apache-2.0
+"""CLI generators."""
+
+from __future__ import annotations
+
+import importlib
+from pathlib import Path
+
+from .gen import generate_code
+
+
+def check_package(package: str) -> str | None:
+    """Check if package CLI is up to date.
+
+    Args:
+        package: Name of package to check.
+
+    Returns:
+        Instructions how to update package or None.
+
+    """
+    code = generate_code(package, write=False)
+    module = importlib.import_module(name=package)
+    assert module
+    assert module.__file__
+    clipath = Path(module.__file__).parent / 'cli.py'
+    if not clipath.exists() or clipath.read_text() != code:
+        return f'CLI is outdated, run "declinate generate -w {package}"'
+    return None

declinate/cli.py

@@ -0,0 +1,394 @@
+"""Generated declinate CLI."""
+
+# DO NOT EDIT THIS FILE MANUALLY
+# ruff: noqa
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Callable, NoReturn
+
+
+class HelpFormatter(argparse.HelpFormatter):
+    """Help formatter."""
+
+    def __init__(
+        self,
+        prog: str,
+        indent_increment: int = 2,
+        max_help_position: int = 24,
+        width: int | None = None,
+    ) -> None:
+        """Init."""
+        super().__init__(prog, indent_increment, max_help_position, width)
+        self._width = min(self._width, 78)
+
+    def _fill_text(self, text: str, width: int, indent: str) -> str:
+        """Reformat individual paragraphs."""
+        parent = super()._fill_text
+
+        def idn(text: str) -> str:
+            if re.match(r'(?m)(^.*?:$)|(^ )', text):
+                return text
+            return parent(text, width, indent)
+
+        return '\n\n'.join(map(idn, text.split('\n\n')))
+
+    def _metavar_formatter(
+        self,
+        action: argparse.Action,
+        default_metavar: str,
+    ) -> Callable[[int], tuple[str, ...]]:
+        if isinstance(action, argparse._SubParsersAction) and action.choices:
+            choice_strs = [
+                k for k, v in action.choices.items() if not v.description.startswith('SUPPRESS.')
+            ]
+            result = f'{{{",".join(choice_strs)}}}'
+            return lambda x: (result,) * x
+        return super()._metavar_formatter(action, default_metavar)
+
+
+class ArgumentParser(argparse.ArgumentParser):
+    """Argument parser."""
+
+    def _check_value(self, action: argparse.Action, value: str) -> None:
+        """Filter suppressed actions."""
+        if isinstance(action, argparse._SubParsersAction):
+            if action.choices and value not in action.choices:
+                msg = f'invalid action: {value!r}'
+                raise argparse.ArgumentError(action, msg)
+        else:
+            super()._check_value(action, value)
+
+
+PARSER = ArgumentParser(
+    allow_abbrev=False,
+    argument_default=argparse.SUPPRESS,
+    formatter_class=HelpFormatter,
+    description='CLI generator for Python.',
+)
+PARSER.add_argument(
+    '--version',
+    help='Print version number.',
+    dest='version',
+    action='store_true',
+)
+
+SUBS = PARSER.add_subparsers(
+    title='sub commands',
+    dest='_command',
+    required=False,
+)
+
+SUB = SUBS.add_parser(
+    'generate',
+    allow_abbrev=False,
+    argument_default=argparse.SUPPRESS,
+    formatter_class=HelpFormatter,
+    description=(
+        'Generate CLI code.\n'
+        '\n'
+        'This command parses the declarative CLI definition from a Python package\n'
+        'and generates the code for the CLI.'
+    ),
+    help='Generate CLI code.',
+)
+SUB.add_argument(
+    'package',
+    help='Name of the Python package.',
+    type=str,
+)
+SUB.add_argument(
+    '-w',
+    '--write',
+    help='Write cli module into package.',
+    dest='write',
+    action='store_true',
+)
+
+SUB = SUBS.add_parser(
+    'check',
+    allow_abbrev=False,
+    argument_default=argparse.SUPPRESS,
+    formatter_class=HelpFormatter,
+    description='Check if generated cli is up to date.',
+    help='Check if generated cli is up to date.',
+)
+SUB.add_argument(
+    'package',
+    help='Name of the Python package.',
+    type=str,
+)
+
+
+def custom_complete(action: argparse.Action, args: list[str], arg: str) -> list[str]:
+    """Complete action."""
+    ret: list[str] = []
+    addargs: dict[str, str] = {}
+
+    return ret
+
+
+COMPLETER_BASH = """\
+_completer__%(name)s() {
+    local IFS=$'\\n'
+    for reply in $(env _COMPLETER=bash COMP_LINE="$COMP_LINE" COMP_POINT=$COMP_POINT $1); do
+        IFS=',' read type value descr <<< "$reply"
+        if [[ $type == "directory" ]]; then
+            compopt -o dirnames
+        elif [[ $type == "file" ]]; then
+            compopt -o default
+        elif [[ $type == "string" ]]; then
+            COMPREPLY+=($value)
+        fi
+    done
+    return 0
+}
+complete -o nosort -F _completer__%(name)s %(name)s;
+"""
+
+COMPLETER_ZSH = """\
+#compdef %(name)s
+_completer__%(name)s() {
+    local -a values values_descrs
+    (( ! $+commands[%(name)s] )) && return 1
+    for reply in "${(@f)$(env _COMPLETER=zsh COMP_LINE="$BUFFER" COMP_POINT=$CURSOR %(name)s)}"; do
+       IFS="," read type value descr <<< "$reply"
+       if [[ "$type" == "directory" ]]; then
+           _path_files -/
+       elif [[ "$type" == "file" ]]; then
+           _path_files -f
+       elif [[ "$type" == "string" ]]; then
+           if [[ -n "$descr" ]]; then
+               values_descrs+=("$value":"$descr")
+           else
+               values+=("$value")
+           fi
+       fi
+    done
+    if [ -n "$values_descrs" ]; then
+        _describe -V unsorted values_descrs -U
+    fi
+    if [ -n "$values" ]; then
+        compadd -U -V unsorted -a values
+    fi
+}
+compdef _completer__%(name)s %(name)s;
+"""
+
+
+def generate_source_completion() -> None:
+    """Generate snippet for sourcing from shell."""
+    completer = os.getenv('_COMPLETER')
+    assert completer
+    completers = {
+        'bash': COMPLETER_BASH,
+        'zsh': COMPLETER_ZSH,
+    }
+    print(completers[completer] % {'name': Path(sys.argv[0]).name})
+
+
+def consume_action(action: argparse.Action, arg: str) -> None:
+    """Consume arg in action."""
+    if action.choices and arg not in action.choices:
+        raise ValueError
+
+
+def consume_parser(
+    parser: ArgumentParser,
+    excluded: list[argparse.Action],
+    arg: str,
+) -> tuple[ArgumentParser, argparse.Action | None]:
+    """Consume parser."""
+    for action in parser._actions:
+        if isinstance(action, argparse._SubParsersAction):
+            for option, subaction in action.choices.items():
+                if option == arg:
+                    return subaction, None
+
+        if arg.startswith('-'):
+            if any(x == arg for x in action.option_strings):
+                break
+        else:
+            if not action.option_strings:
+                break
+    else:
+        raise ValueError
+
+    if not isinstance(action, argparse._CountAction) and \
+            not (isinstance(action.nargs, str) and action.nargs in '*+'):
+        excluded.append(action)
+    for group in parser._mutually_exclusive_groups:
+        if action in group._group_actions:
+            for subaction in group._group_actions:
+                if subaction != action and subaction not in excluded:
+                    excluded.append(subaction)
+    return parser, action if (
+        action.option_strings or action.choices
+    ) and action.nargs != 0 else None
+
+
+def complete_actions(
+    actions: list[argparse.Action],
+    excluded: list[argparse.Action],
+    args: list[str],
+    arg: str,
+) -> None:
+    """Complete actions."""
+    completed: list[tuple[str, str]] = []
+    for action in sorted(actions, key=lambda x: not x.required):
+        if action in excluded:
+            continue
+
+        if isinstance(action, argparse._SubParsersAction):
+            completed += [
+                (k, v.description)
+                for k, v in action.choices.items()
+                if not v.description.startswith('SUPPRESS.')
+            ]
+
+        elif action.option_strings:
+            completed += [(x, action.help or '') for x in action.option_strings]
+
+        elif action.choices:
+            completed += [(x, '') for x in action.choices]
+
+        else:
+            completed += [(x, '') for x in custom_complete(action, args, arg)]
+
+        if not arg and action.required:
+            break
+
+    have_positinal = any(not x.startswith('-') for x, _ in completed)
+    for option, descr in sorted(completed):
+        if have_positinal and not arg and option.startswith('-'):
+            continue
+        if option.startswith(arg):
+            print(f'string,{option},{descr}')
+
+
+def complete_action(action: argparse.Action, args: list[str], arg: str) -> None:
+    """Complete action."""
+    completed: list[tuple[str, str]] = []
+
+    if action.type == Path:
+        print('file,,')
+
+    if action.choices:
+        if isinstance(action.choices, dict):
+            completed += action.choices.items()
+        else:
+            completed += [(x, '') for x in action.choices]
+
+    completed += [(x, '') for x in custom_complete(action, args, arg)]
+
+    for option, descr in sorted(completed):
+        if not arg and option.startswith('-'):
+            continue
+        if option.startswith(arg):
+            print(f'string,{option},{descr}')
+
+
+def generate_completion() -> None:
+    """Generate snippet for sourcing from shell."""
+    import shlex
+
+    lexer = shlex.shlex(os.getenv('COMP_LINE'), posix=True)
+    pos = int(os.getenv('COMP_POINT', '0'))
+    lexer.whitespace_split = True
+    lexer.commenters = ""
+    args = []
+    cword = None
+
+    next(lexer)
+    laststate = lexer.state  # type: ignore[attr-defined]
+    try:
+        for index, token in enumerate(lexer):
+            args.append(token)
+            laststate = lexer.state  # type: ignore[attr-defined]
+            if cword is None and lexer.instream.tell() > pos:
+                cword = index
+    except ValueError:
+        args.append(lexer.token)
+        laststate = 'error'
+    if laststate == ' ':
+        args.append('')
+    if cword is None:
+        cword = len(args) - 1
+
+    parser = PARSER
+    action = None
+    excluded: list[argparse.Action] = []
+
+    # interpret_args(parser, action, excluded, args, cword)
+    for arg in args[:cword]:
+        # print('string,try', arg)
+        if action:
+            try:
+                consume_action(action, arg)
+                action = None
+            except ValueError:
+                sys.exit(0)
+            continue
+
+        try:
+            parser, action = consume_parser(parser, excluded, arg)
+        except ValueError:
+            sys.exit(0)
+
+    arg = args[cword]
+
+    if action:
+        complete_action(action, args, arg)
+        sys.exit(0)
+
+    complete_actions(parser._actions, excluded, args, arg)
+    sys.exit(0)
+
+
+def main() -> NoReturn:  # pragma: no cover
+    """CLI entrypoint."""
+    if 'COMP_LINE' in os.environ:
+        generate_completion()
+        sys.exit(0)
+
+    if '_COMPLETER' in os.environ:
+        generate_source_completion()
+        sys.exit(0)
+    args = PARSER.parse_args().__dict__
+
+    from declinate.declinate import command
+    runargs = args
+    res = command(argparser=PARSER, **runargs)
+
+    _command = args.pop('_command')
+    _subaction = args['subaction'] if 'subaction' in args else None
+    if _command == 'generate':
+        from declinate.declinate import generate
+        runargs = {
+            k: v for k, v in args.items()
+            if k in {
+                'package',
+                'write',
+            }
+        }  # yapf: disable
+        sys.exit(generate(**runargs))
+
+    if _command == 'check':
+        from declinate.declinate import check
+        runargs = {
+            k: v for k, v in args.items()
+            if k in {
+                'package',
+            }
+        }  # yapf: disable
+        sys.exit(check(**runargs))
+
+    sys.exit(res)

declinate/declinate.py

@@ -0,0 +1,109 @@
+# Copyright 2022-2023  Ternaris.
+# SPDX-License-Identifier: Apache-2.0
+"""CLI declaration."""
+
+from __future__ import annotations
+
+import importlib.metadata
+import sys
+from typing import TYPE_CHECKING, TypedDict
+
+from .check import check_package
+from .gen import generate_code
+
+if TYPE_CHECKING:
+    from argparse import ArgumentParser
+    from typing import Annotated
+
+
+class Kwargs(TypedDict):
+    """All keyword arg types."""
+    package: str
+    version: bool
+    write: bool
+
+
+def command(
+    argparser: ArgumentParser,
+    *,
+    version: Annotated[bool, {
+        'flags': ['--version'],
+    }] = False,
+    **kwargs: Kwargs,
+) -> int:
+    """CLI generator for Python.
+
+    Args:
+        argparser: Argument parser,
+            with mnoew text.
+        version: Print version number.
+        kwargs: Rest of all CLI params.
+
+    Groups:
+        x: SUPPRESS
+
+    Returns:
+        0 if success.
+
+    """
+    if version:
+        print(importlib.metadata.version('declinate'))  # noqa: T201
+        sys.exit(0)
+
+    if not kwargs.get('_command'):
+        argparser.print_help()
+        sys.exit(0)
+
+    return 1
+
+
+def generate(
+    package: str,
+    *,
+    write: Annotated[\
+        bool, {
+            'flags': ['-w', '--write'],
+        },
+    ] = False,
+) -> int:
+    """Generate CLI code.
+
+    This command parses the declarative CLI definition from a Python package
+    and generates the code for the CLI.
+
+    Args:
+        package: Name of the Python package.
+        write: Write cli module into package.
+
+    Returns:
+        0 if success.
+
+    """
+    code = generate_code(package, write=write)
+    if not write:
+        print(code)  # noqa: T201
+    return 0
+
+
+def check(package: str) -> int:
+    """Check if generated cli is up to date.
+
+    Args:
+        package: Name of the Python package.
+
+    Returns:
+        0 if success.
+
+    """
+    if res := check_package(package):
+        print(res)  # noqa: T201
+        return 1
+    return 0
+
+
+COMMAND = command
+
+SUBCOMMANDS = [
+    generate,
+    check,
+]