Merge pull request #63 from python-ellar/drop_typer

Drop Typer for Click

Author: eadwinCode

.github/workflows/publish.yml

@@ -18,8 +18,11 @@ jobs:
         run: pip install flit
       - name: Install Dependencies
         run: flit install --symlink
+      - name: Install build dependencies
+        run: pip install build
+      - name: Build distribution
+        run: python -m build
       - name: Publish
-        env:
-          FLIT_USERNAME: ${{ secrets.FLIT_USERNAME }}
-          FLIT_PASSWORD: ${{ secrets.FLIT_PASSWORD }}
-        run: flit publish
+        uses: pypa/[email protected]
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

Makefile

@@ -17,8 +17,7 @@ install-full: ## Install dependencies
 	make install
 	pre-commit install -f
 
-lint: ## Run code linters
-	black --check ellar_cli tests
+lint:fmt ## Run code linters
 	ruff check ellar_cli tests
 	mypy ellar_cli
 

ellar_cli/__init__.py

@@ -1,3 +1,3 @@
 """Ellar CLI Tool for Scaffolding Ellar Projects, Modules and also running Ellar Commands"""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"

ellar_cli/__main__.py

@@ -1,4 +1,4 @@
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     from ellar_cli.cli import main
 
     main()

ellar_cli/cli.py

@@ -1,33 +1,23 @@
 import os
 import sys
-import typing as t
 
-from typer import echo
+import ellar_cli.click as click
 
-from .main import _typer, build_typers
+from .main import app_cli
 
 __all__ = ["main"]
 
 
-def register_commands(*typer_commands: t.Any) -> None:
-    for typer_command in typer_commands:
-        _typer.add_typer(typer_command)
-
-
-@_typer.command()
+@app_cli.command()
+@click.argument("name")
 def say_hi(name: str):
-    echo(f"Welcome {name}, to Ellar CLI, python web framework")
-
-
-# register all EllarTyper(s) to root typer
-# register_commands(*other_commands)
+    click.echo(f"Welcome {name}, to Ellar CLI, ASGI Python Web framework\n")
 
 
 def main():
     sys.path.append(os.getcwd())
-    build_typers()
-    _typer(prog_name="Ellar, Python Web framework")
+    app_cli()
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     main()

ellar_cli/click/__init__.py

@@ -0,0 +1,143 @@
+import typing as t
+
+import click
+from click.core import Context as Context
+from click.core import Group as Group
+from click.core import Option as Option
+from click.core import Parameter as Parameter
+from click.decorators import confirmation_option as confirmation_option
+from click.decorators import help_option as help_option
+from click.decorators import make_pass_decorator as make_pass_decorator
+from click.decorators import pass_context as pass_context
+from click.decorators import pass_obj as pass_obj
+from click.decorators import password_option as password_option
+from click.decorators import version_option as version_option
+from click.exceptions import Abort as Abort
+from click.exceptions import BadArgumentUsage as BadArgumentUsage
+from click.exceptions import BadOptionUsage as BadOptionUsage
+from click.exceptions import BadParameter as BadParameter
+from click.exceptions import ClickException as ClickException
+from click.exceptions import Exit as Exit
+from click.exceptions import FileError as FileError
+from click.exceptions import MissingParameter as MissingParameter
+from click.exceptions import NoSuchOption as NoSuchOption
+from click.exceptions import UsageError as UsageError
+from click.types import BOOL as BOOL
+from click.types import FLOAT as FLOAT
+from click.types import INT as INT
+from click.types import STRING as STRING
+from click.types import UNPROCESSED as UNPROCESSED
+from click.types import UUID as UUID
+from click.types import Choice as Choice
+from click.types import DateTime as DateTime
+from click.types import File as File
+from click.types import FloatRange as FloatRange
+from click.types import IntRange as IntRange
+from click.types import ParamType as ParamType
+from click.types import Path as Path
+from click.types import Tuple as Tuple
+from click.utils import echo as echo
+from click.utils import format_filename as format_filename
+from click.utils import get_app_dir as get_app_dir
+from click.utils import get_binary_stream as get_binary_stream
+from click.utils import get_text_stream as get_text_stream
+from click.utils import open_file as open_file
+
+from .argument import Argument
+from .command import Command
+from .group import AppContextGroup, EllarCommandGroup
+from .util import with_app_context
+
+
+def argument(
+    *param_decls: str,
+    cls: t.Optional[t.Type[click.Argument]] = None,
+    required: bool = True,
+    help: t.Optional[str] = None,
+    hidden: t.Optional[bool] = None,
+    **attrs: t.Any,
+) -> t.Callable:
+    return click.argument(
+        *param_decls,
+        cls=cls or Argument,
+        required=required,
+        hidden=hidden,
+        help=help,
+        **attrs,
+    )
+
+
+def option(
+    *param_decls: str, cls: t.Optional[t.Type[Option]] = None, **attrs: t.Any
+) -> t.Callable:
+    return click.option(*param_decls, cls=cls, **attrs)
+
+
+def command(
+    name: t.Optional[str] = None, cls: t.Optional[click.Command] = None, **attrs: t.Any
+) -> t.Union[click.Command, t.Any]:
+    return click.command(name=name, cls=cls or Command, **attrs)  # type:ignore[arg-type]
+
+
+def group(
+    name: t.Union[str, t.Callable, None] = None,
+    cls: t.Optional[t.Type[click.Group]] = None,
+    **attrs: t.Any,
+) -> t.Callable:
+    return click.group(name=name, cls=cls or AppContextGroup, **attrs)  # type:ignore[arg-type]
+
+
+__all__ = [
+    "argument",
+    "Argument",
+    "Option",
+    "option",
+    "AppContextGroup",
+    "EllarCommandGroup",
+    "with_app_context",
+    "Context",
+    "Group",
+    "Parameter",
+    "make_pass_decorator",
+    "confirmation_option",
+    "help_option",
+    "group",
+    "pass_context",
+    "password_option",
+    "version_option",
+    "Abort",
+    "BadArgumentUsage",
+    "BadOptionUsage",
+    "BadParameter",
+    "ClickException",
+    "FileError",
+    "MissingParameter",
+    "NoSuchOption",
+    "UsageError",
+    "pass_obj",
+    "BOOL",
+    "Choice",
+    "DateTime",
+    "File",
+    "FLOAT",
+    "FloatRange",
+    "INT",
+    "IntRange",
+    "ParamType",
+    "Path",
+    "STRING",
+    "Tuple",
+    "UNPROCESSED",
+    "UUID",
+    "echo",
+    "format_filename",
+    "get_app_dir",
+    "get_binary_stream",
+    "get_text_stream",
+    "open_file",
+    "Exit",
+]
+
+
+def __dir__() -> t.List[str]:
+    return sorted(__all__)  # pragma: no cover

ellar_cli/click/argument.py

@@ -0,0 +1,77 @@
+import inspect as _inspect
+import typing as t
+
+import click
+from click.formatting import join_options as _join_options
+
+
+class Argument(click.Argument):
+    """
+    Regular click.Argument with extra formatting for printing command arguments
+    """
+
+    def __init__(
+        self,
+        param_decls: t.Sequence[str],
+        required: t.Optional[bool] = None,
+        help: t.Optional[str] = None,
+        hidden: t.Optional[bool] = None,
+        **attrs: t.Any,
+    ) -> None:
+        super().__init__(param_decls, required=required, **attrs)
+        self.help = help
+        self.hidden = hidden
+
+    # overridden to customize the automatic formatting of metavars
+    def make_metavar(self) -> str:
+        if self.metavar is not None:
+            return self.metavar
+        var = "" if self.required else "["
+        var += "<" + self.name + ">"  # type:ignore[operator]
+        if self.nargs != 1:
+            var += ", ..."
+        if not self.required:
+            var += "]"
+        return var
+
+    # this code is 90% copied from click.Option.get_help_record
+    def get_help_record(self, ctx: click.Context) -> t.Optional[t.Tuple[str, str]]:
+        any_prefix_is_slash: t.List[bool] = []
+
+        if self.hidden:
+            # TODO: test
+            return None
+
+        def _write_opts(opts: t.Any) -> str:
+            rv, any_slashes = _join_options(opts)
+            if any_slashes:
+                # TODO: test
+                any_prefix_is_slash[:] = [True]
+            rv += ": " + self.make_metavar()
+            return rv
+
+        rv = [_write_opts(self.opts)]
+        if self.secondary_opts:
+            # TODO: test
+            rv.append(_write_opts(self.secondary_opts))
+
+        help_ = self.help or ""
+        extra = []
+
+        if self.default is not None:
+            if isinstance(self.default, (list, tuple)):
+                # TODO: test
+                default_string = ", ".join("%s" % d for d in self.default)
+            elif _inspect.isfunction(self.default):
+                # TODO: test
+                default_string = "(dynamic)"
+            else:
+                default_string = self.default  # type:ignore[assignment]
+            extra.append("default: {}".format(default_string))
+
+        if self.required:
+            extra.append("required")
+        if extra:
+            help_ = "%s[%s]" % (help_ and help_ + "  " or "", "; ".join(extra))
+
+        return (any_prefix_is_slash and "; " or " / ").join(rv), help_

ellar_cli/click/command.py

@@ -0,0 +1,44 @@
+import typing as t
+
+import click
+
+
+class Command(click.Command):
+    """
+    The same as click.Command with extra behavior to print command args and options
+    """
+
+    # overridden to support displaying args before the options metavar
+    def collect_usage_pieces(self, ctx: click.Context) -> t.List[str]:
+        rv: t.List[str] = []
+        for param in self.get_params(ctx):
+            rv.extend(param.get_usage_pieces(ctx))
+
+        rv.append(self.options_metavar)  # type:ignore[arg-type]
+        return rv
+
+    # overridden to group arguments separately from options
+    def format_options(
+        self, ctx: click.Context, formatter: click.HelpFormatter
+    ) -> None:
+        args, opts = [], []
+        for param in self.get_params(ctx):
+            rv = param.get_help_record(ctx)
+            if rv is not None:
+                if isinstance(param, click.Argument):
+                    args.append(rv)
+                else:
+                    opts.append(rv)
+
+        def print_args() -> None:
+            if args:
+                with formatter.section("Arguments".upper()):
+                    formatter.write_dl(args)
+
+        def print_opts() -> None:
+            if opts:
+                with formatter.section(self.options_metavar):  # type:ignore[arg-type]
+                    formatter.write_dl(opts)
+
+        print_args()
+        print_opts()