diff options
Diffstat (limited to 'venv/lib/python3.11/site-packages/rich_click')
25 files changed, 1988 insertions, 0 deletions
diff --git a/venv/lib/python3.11/site-packages/rich_click/__init__.py b/venv/lib/python3.11/site-packages/rich_click/__init__.py new file mode 100644 index 0000000..18ad228 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__init__.py @@ -0,0 +1,104 @@ +# flake8: noqa: F401 +""" +rich-click is a minimal Python module to combine the efforts of the excellent packages 'rich' and 'click'. + +The intention is to provide attractive help output from click, formatted with rich, with minimal +customisation required. +""" + +__version__ = "1.7.4" + +# Import the entire click API here. +# We need to manually import these instead of `from click import *` to force mypy to recognize a few type annotation overrides for the rich_click decorators. +from click.core import Argument as Argument +from click.core import Command as Command +from click.core import CommandCollection as CommandCollection +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 argument as argument +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 option as option +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 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.formatting import HelpFormatter as HelpFormatter +from click.formatting import wrap_text as wrap_text +from click.globals import get_current_context as get_current_context +from click.termui import clear as clear +from click.termui import confirm as confirm +from click.termui import echo_via_pager as echo_via_pager +from click.termui import edit as edit +from click.termui import getchar as getchar +from click.termui import launch as launch +from click.termui import pause as pause +from click.termui import progressbar as progressbar +from click.termui import prompt as prompt +from click.termui import secho as secho +from click.termui import style as style +from click.termui import unstyle as unstyle +from click.types import BOOL as BOOL +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 FLOAT as FLOAT +from click.types import FloatRange as FloatRange +from click.types import INT as INT +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 STRING as STRING +from click.types import Tuple as Tuple +from click.types import UNPROCESSED as UNPROCESSED +from click.types import UUID as UUID +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 . import rich_click as rich_click + +from rich_click.decorators import command as command +from rich_click.decorators import group as group +from rich_click.decorators import pass_context as pass_context +from rich_click.decorators import rich_config as rich_config +from rich_click.rich_command import RichCommand as RichCommand +from rich_click.rich_command import RichCommandCollection as RichCommandCollection +from rich_click.rich_command import RichGroup as RichGroup +from rich_click.rich_context import RichContext as RichContext +from rich_click.rich_help_configuration import RichHelpConfiguration as RichHelpConfiguration + + +def __getattr__(name: str) -> object: + from rich_click._compat_click import CLICK_IS_BEFORE_VERSION_9X + + if name == "RichMultiCommand" and CLICK_IS_BEFORE_VERSION_9X: + import warnings + + warnings.warn( + "'RichMultiCommand' is deprecated and will be removed in Click 9.0. Use 'RichGroup' instead.", + DeprecationWarning, + stacklevel=2, + ) + from rich_click.rich_command import RichMultiCommand + + return RichMultiCommand + + else: + import click + + return getattr(click, name) diff --git a/venv/lib/python3.11/site-packages/rich_click/__main__.py b/venv/lib/python3.11/site-packages/rich_click/__main__.py new file mode 100644 index 0000000..9406f8f --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__main__.py @@ -0,0 +1,13 @@ +""" +Entry-point module for the command line prefixer, called in case you use `python -m rich_click`. + +Why does this file exist, and why `__main__`? For more info, read: +- https://www.python.org/dev/peps/pep-0338/ +- https://docs.python.org/3/using/cmdline.html#cmdoption-m +""" + +from rich_click.cli import main + +if __name__ == "__main__": + # main will run a Click command which will either exit or raise + main() diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/__init__.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..16b88c4 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/__init__.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/__main__.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/__main__.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..bc3f2f9 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/__main__.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/_compat_click.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/_compat_click.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..a1ddde3 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/_compat_click.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/cli.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/cli.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..7c9ec62 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/cli.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/decorators.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/decorators.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..31e15f2 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/decorators.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_click.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_click.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..a7f037d --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_click.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_command.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_command.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..aa6e009 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_command.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_context.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_context.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..7a7565c --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_context.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_group.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_group.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..cde8f18 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_group.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_help_configuration.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_help_configuration.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..e5349e1 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_help_configuration.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_help_formatter.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_help_formatter.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..3ea5313 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/rich_help_formatter.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/__pycache__/utils.cpython-311.pyc b/venv/lib/python3.11/site-packages/rich_click/__pycache__/utils.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..62c3a8b --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/__pycache__/utils.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/rich_click/_compat_click.py b/venv/lib/python3.11/site-packages/rich_click/_compat_click.py new file mode 100644 index 0000000..89a13e7 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/_compat_click.py @@ -0,0 +1,25 @@ +try: + from importlib import metadata # type: ignore[import,unused-ignore] +except ImportError: + # Python < 3.8 + import importlib_metadata as metadata # type: ignore[no-redef,import-not-found] + + +click_version = metadata.version("click") +_major = int(click_version.split(".")[0]) +_minor = int(click_version.split(".")[1]) + + +CLICK_IS_BEFORE_VERSION_8X = _major < 8 +CLICK_IS_BEFORE_VERSION_9X = _major < 9 +CLICK_IS_VERSION_80 = _major == 8 and _minor == 0 + + +if CLICK_IS_BEFORE_VERSION_8X: + import warnings + + warnings.warn( + "rich-click support for click 7.x is deprecated and will be removed soon." + " Please upgrade click to a newer version.", + DeprecationWarning, + ) diff --git a/venv/lib/python3.11/site-packages/rich_click/cli.py b/venv/lib/python3.11/site-packages/rich_click/cli.py new file mode 100644 index 0000000..a7041a9 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/cli.py @@ -0,0 +1,154 @@ +"""The command line interface.""" + +import sys +from importlib import import_module +from textwrap import dedent +from typing import Any, List, Optional + +try: + from importlib import metadata # type: ignore[import,unused-ignore] +except ImportError: + # Python < 3.8 + import importlib_metadata as metadata # type: ignore[no-redef,import-not-found,unused-ignore] + +import click +from rich.console import Console +from rich.padding import Padding +from rich.panel import Panel +from rich.text import Text + +from rich_click.decorators import command as rich_command +from rich_click.decorators import group as rich_group +from rich_click.rich_click import ( + ALIGN_ERRORS_PANEL, + ERRORS_PANEL_TITLE, + STYLE_ERRORS_PANEL_BORDER, + STYLE_HELPTEXT, + STYLE_HELPTEXT_FIRST_LINE, + STYLE_USAGE, + STYLE_USAGE_COMMAND, +) +from rich_click.rich_command import RichCommand, RichCommandCollection, RichGroup, RichMultiCommand + +console = Console() + + +def _print_usage() -> None: + console.print( + Padding( + Text.from_markup(f"[{STYLE_USAGE}]Usage:[/] rich-click [SCRIPT | MODULE:FUNCTION] [-- SCRIPT_ARGS...]"), + 1, + ), + style=STYLE_USAGE_COMMAND, + ) + + +def _print_help() -> None: + help_paragraphs = dedent(main.__doc__ or "").split("\n\n") + help_paragraphs = [x.replace("\n", " ").strip() for x in help_paragraphs] + console.print( + Padding( + Text.from_markup(help_paragraphs[0].strip()), + (0, 1), + ), + style=STYLE_HELPTEXT_FIRST_LINE, + ) + console.print( + Padding( + Text.from_markup("\n\n".join(help_paragraphs[1:]).strip()), + (0, 1), + ), + style=STYLE_HELPTEXT, + ) + + +def patch() -> None: + """Patch Click internals to use Rich-Click types.""" + click.group = rich_group + click.command = rich_command + click.Group = RichGroup # type: ignore[misc] + click.Command = RichCommand # type: ignore[misc] + click.CommandCollection = RichCommandCollection # type: ignore[misc] + if "MultiCommand" in dir(click): + click.MultiCommand = RichMultiCommand # type: ignore[assignment,misc,unused-ignore] + + +def entry_points(*, group: str) -> "metadata.EntryPoints": # type: ignore[name-defined] + """entry_points function that is compatible with Python 3.7+.""" + if sys.version_info >= (3, 10): + return metadata.entry_points(group=group) + + epg = metadata.entry_points() + + if sys.version_info < (3, 8) and hasattr(epg, "select"): + return epg.select(group=group) + + return epg.get(group, []) + + +def main(args: Optional[List[str]] = None) -> Any: + """ + The [link=https://github.com/ewels/rich-click]rich-click[/] CLI provides attractive help output from any + tool using [link=https://click.palletsprojects.com/]click[/], formatted with + [link=https://github.com/Textualize/rich]rich[/]. + + The rich-click command line tool can be prepended before any Python package + using native click to provide attractive richified click help output. + + For example, if you have a package called [blue]my_package[/] that uses click, + you can run: + + [blue] rich-click my_package --help [/] + + It only works if the package is using vanilla click without customised [cyan]group()[/] + or [cyan]command()[/] classes. + If in doubt, please suggest to the authors that they use rich_click within their + tool natively - this will always give a better experience. + """ # noqa: D400, D401 + args = args or sys.argv[1:] + if not args or args == ["--help"]: + # Print usage if we got no args, or only --help + _print_usage() + _print_help() + sys.exit(0) + else: + script_name = args[0] + scripts = {script.name: script for script in entry_points(group="console_scripts")} + if script_name in scripts: + # a valid script was passed + script = scripts[script_name] + module_path, function_name = script.value.split(":", 1) + prog = script_name + elif ":" in script_name: + # the path to a function was passed + module_path, function_name = args[0].split(":", 1) + prog = module_path.split(".", 1)[0] + else: + _print_usage() + console.print( + Panel( + Text.from_markup(f"No such script: [bold]{script_name}[/]"), + border_style=STYLE_ERRORS_PANEL_BORDER, + title=ERRORS_PANEL_TITLE, + title_align=ALIGN_ERRORS_PANEL, + ) + ) + console.print( + Padding( + "Please run [yellow bold]rich-click --help[/] for usage information.", + (0, 1), + ), + style="dim", + ) + sys.exit(1) + if len(args) > 1: + if args[1] == "--": + del args[1] + sys.argv = [prog, *args[1:]] + # patch click before importing the program function + patch() + # import the program function + module = import_module(module_path) + function = getattr(module, function_name) + # simply run it: it should be patched as well + return function() diff --git a/venv/lib/python3.11/site-packages/rich_click/decorators.py b/venv/lib/python3.11/site-packages/rich_click/decorators.py new file mode 100644 index 0000000..3656be8 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/decorators.py @@ -0,0 +1,216 @@ +""" +rich-click is a minimal Python module to combine the efforts of the excellent packages 'rich' and 'click'. + +The intention is to provide attractive help output from click, formatted with rich, with minimal +customisation required. +""" + +from typing import Any, Callable, cast, Dict, Optional, overload, Type, TYPE_CHECKING, TypeVar, Union + +from click import Command +from click import command as click_command +from click import Group +from click import group as click_group +from click import pass_context as click_pass_context +from rich.console import Console +from typing_extensions import Concatenate, ParamSpec + +from . import rich_click # noqa: F401 + +from rich_click._compat_click import CLICK_IS_BEFORE_VERSION_8X +from rich_click.rich_command import RichCommand, RichGroup, RichMultiCommand # noqa: F401 +from rich_click.rich_context import RichContext +from rich_click.rich_help_configuration import RichHelpConfiguration + +# MyPy does not like star imports. Therefore when we are type checking, we import each individual module +# from click here. This way MyPy will recognize the import and not throw any errors. Furthermore, because of +# the TYPE_CHECKING check, it does not influence the start routine at all. + +_AnyCallable = Callable[..., Any] +F = TypeVar("F", bound=Callable[..., Any]) +FC = TypeVar("FC", bound=Union[Command, _AnyCallable]) + + +GrpType = TypeVar("GrpType", bound=Group) + + +# variant: no call, directly as decorator for a function. +@overload +def group(name: _AnyCallable) -> RichGroup: + ... + + +# variant: with positional name and with positional or keyword cls argument: +# @group(namearg, GroupCls, ...) or @group(namearg, cls=GroupCls, ...) +@overload +def group( + name: Optional[str], + cls: Type[GrpType], + **attrs: Any, +) -> Callable[[_AnyCallable], GrpType]: + ... + + +# variant: name omitted, cls _must_ be a keyword argument, @group(cmd=GroupCls, ...) +@overload +def group( + name: None = None, + *, + cls: Type[GrpType], + **attrs: Any, +) -> Callable[[_AnyCallable], GrpType]: + ... + + +# variant: with optional string name, no cls argument provided. +@overload +def group(name: Optional[str] = ..., cls: None = None, **attrs: Any) -> Callable[[_AnyCallable], RichGroup]: + ... + + +def group( + name: Union[str, _AnyCallable, None] = None, + cls: Optional[Type[GrpType]] = None, + **attrs: Any, +) -> Union[Group, Callable[[_AnyCallable], Union[RichGroup, GrpType]]]: + """ + Group decorator function. + + Defines the group() function so that it uses the RichGroup class by default. + """ + if cls is None: + cls = cast(Type[GrpType], RichGroup) + + if callable(name): + return command(cls=cls, **attrs)(name) + + return command(name, cls, **attrs) + + +CmdType = TypeVar("CmdType", bound=Command) + + +# variant: no call, directly as decorator for a function. +@overload +def command(name: _AnyCallable) -> RichCommand: + ... + + +# variant: with positional name and with positional or keyword cls argument: +# @command(namearg, CommandCls, ...) or @command(namearg, cls=CommandCls, ...) +@overload +def command( + name: Optional[str], + cls: Type[CmdType], + **attrs: Any, +) -> Callable[[_AnyCallable], CmdType]: + ... + + +# variant: name omitted, cls _must_ be a keyword argument, @command(cls=CommandCls, ...) +@overload +def command( + name: None = None, + *, + cls: Type[CmdType], + **attrs: Any, +) -> Callable[[_AnyCallable], CmdType]: + ... + + +# variant: with optional string name, no cls argument provided. +@overload +def command(name: Optional[str] = ..., cls: None = None, **attrs: Any) -> Callable[[_AnyCallable], RichCommand]: + ... + + +def command( + name: Union[Optional[str], _AnyCallable] = None, + cls: Optional[Type[CmdType]] = None, + **attrs: Any, +) -> Union[Command, Callable[[_AnyCallable], Union[RichCommand, CmdType]]]: + """ + Command decorator function. + + Defines the command() function so that it uses the RichCommand class by default. + """ + if cls is None: + cls = cast(Type[CmdType], RichCommand) + + if callable(name): + return click_command(cls=cls, **attrs)(name) + + return click_command(name, cls=cls, **attrs) + + +class NotSupportedError(Exception): + """Not Supported Error.""" + + pass + + +def rich_config( + console: Optional[Console] = None, help_config: Optional[RichHelpConfiguration] = None +) -> Callable[[FC], FC]: + """Use decorator to configure Rich Click settings. + + Args: + console: A Rich Console that will be accessible from the `RichContext`, `RichCommand`, and `RichGroup` instances + Defaults to None. + help_config: Rich help configuration that is used internally to format help messages and exceptions + Defaults to None. + """ + if CLICK_IS_BEFORE_VERSION_8X: + + def decorator_with_warning(obj: FC) -> FC: + import warnings + + warnings.warn( + "`rich_config()` does not work with versions of click prior to version 8.0.0." + " Please update to a newer version of click to use this functionality.", + RuntimeWarning, + ) + return obj + + return decorator_with_warning + + def decorator(obj: FC) -> FC: + extra: Dict[str, Any] = {} + if console is not None: + extra["rich_console"] = console + if help_config is not None: + extra["rich_help_config"] = help_config + + if isinstance(obj, (RichCommand, RichGroup)): + obj.context_settings.update(extra) + elif callable(obj) and not isinstance(obj, (Command, Group)): + if hasattr(obj, "__rich_context_settings__"): + obj.__rich_context_settings__.update(extra) + else: + setattr(obj, "__rich_context_settings__", extra) + else: + raise NotSupportedError("`rich_config` requires a `RichCommand` or `RichGroup`. Try using the cls keyword") + return obj + + return decorator + + +# Users of rich_click would face issues using mypy with this code, +# if not for wrapping `pass_context` with a new function signature: +# +# @click.command() +# @click.pass_context +# def cli(ctx: click.RichContext) -> None: +# ... + + +P = ParamSpec("P") +R = TypeVar("R") + + +def pass_context(f: Callable[Concatenate[RichContext, P], R]) -> Callable[P, R]: + # flake8: noqa: D400,D401 + """Marks a callback as wanting to receive the current context + object as first argument. + """ + return click_pass_context(f) # type: ignore[arg-type] diff --git a/venv/lib/python3.11/site-packages/rich_click/py.typed b/venv/lib/python3.11/site-packages/rich_click/py.typed new file mode 100644 index 0000000..ee90bd6 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/py.typed @@ -0,0 +1 @@ +# Marker file for PEP 561. rich-click uses inline types. diff --git a/venv/lib/python3.11/site-packages/rich_click/rich_click.py b/venv/lib/python3.11/site-packages/rich_click/rich_click.py new file mode 100644 index 0000000..215c170 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/rich_click.py @@ -0,0 +1,893 @@ +import inspect +import re +from typing import Dict, Iterable, List, Optional, Tuple, TYPE_CHECKING, Union + +import click +import rich.columns +import rich.markdown +import rich.text + +# Due to how rich_click.cli.patch() works, it is safer to import Command types directly +# rather than use the click module e.g. click.Command +from click import Command, Group +from rich import box +from rich.align import Align +from rich.columns import Columns +from rich.emoji import Emoji +from rich.highlighter import RegexHighlighter +from rich.markdown import Markdown +from rich.padding import Padding +from rich.panel import Panel +from rich.style import StyleType +from rich.table import Table +from rich.text import Text +from typing_extensions import Literal + +from rich_click._compat_click import CLICK_IS_BEFORE_VERSION_8X, CLICK_IS_BEFORE_VERSION_9X, CLICK_IS_VERSION_80 +from rich_click.rich_help_configuration import ( + force_terminal_default, + OptionHighlighter, + RichHelpConfiguration, + terminal_width_default, +) +from rich_click.rich_help_formatter import RichHelpFormatter + +# Support rich <= 10.6.0 +try: + from rich.console import group +except ImportError: + from rich.console import render_group as group # type: ignore[attr-defined,no-redef] + + +if CLICK_IS_BEFORE_VERSION_9X: + from click import MultiCommand +else: + MultiCommand = Group # type: ignore[misc,assignment] + + +# Default styles +STYLE_OPTION: rich.style.StyleType = "bold cyan" +STYLE_ARGUMENT: rich.style.StyleType = "bold cyan" +STYLE_COMMAND: rich.style.StyleType = "bold cyan" +STYLE_SWITCH: rich.style.StyleType = "bold green" +STYLE_METAVAR: rich.style.StyleType = "bold yellow" +STYLE_METAVAR_APPEND: rich.style.StyleType = "dim yellow" +STYLE_METAVAR_SEPARATOR: rich.style.StyleType = "dim" +STYLE_HEADER_TEXT: rich.style.StyleType = "" +STYLE_EPILOG_TEXT: rich.style.StyleType = "" +STYLE_FOOTER_TEXT: rich.style.StyleType = "" +STYLE_USAGE: rich.style.StyleType = "yellow" +STYLE_USAGE_COMMAND: rich.style.StyleType = "bold" +STYLE_DEPRECATED: rich.style.StyleType = "red" +STYLE_HELPTEXT_FIRST_LINE: rich.style.StyleType = "" +STYLE_HELPTEXT: rich.style.StyleType = "dim" +STYLE_OPTION_HELP: rich.style.StyleType = "" +STYLE_OPTION_DEFAULT: rich.style.StyleType = "dim" +STYLE_OPTION_ENVVAR: rich.style.StyleType = "dim yellow" +STYLE_REQUIRED_SHORT: rich.style.StyleType = "red" +STYLE_REQUIRED_LONG: rich.style.StyleType = "dim red" +STYLE_OPTIONS_PANEL_BORDER: rich.style.StyleType = "dim" +ALIGN_OPTIONS_PANEL: rich.align.AlignMethod = "left" +STYLE_OPTIONS_TABLE_SHOW_LINES: bool = False +STYLE_OPTIONS_TABLE_LEADING: int = 0 +STYLE_OPTIONS_TABLE_PAD_EDGE: bool = False +STYLE_OPTIONS_TABLE_PADDING: rich.padding.PaddingDimensions = (0, 1) +STYLE_OPTIONS_TABLE_BOX: rich.style.StyleType = "" +STYLE_OPTIONS_TABLE_ROW_STYLES: Optional[List[rich.style.StyleType]] = None +STYLE_OPTIONS_TABLE_BORDER_STYLE: Optional[rich.style.StyleType] = None +STYLE_COMMANDS_PANEL_BORDER: rich.style.StyleType = "dim" +ALIGN_COMMANDS_PANEL: rich.align.AlignMethod = "left" +STYLE_COMMANDS_TABLE_SHOW_LINES: bool = False +STYLE_COMMANDS_TABLE_LEADING: int = 0 +STYLE_COMMANDS_TABLE_PAD_EDGE: bool = False +STYLE_COMMANDS_TABLE_PADDING: rich.padding.PaddingDimensions = (0, 1) +STYLE_COMMANDS_TABLE_BOX: rich.style.StyleType = "" +STYLE_COMMANDS_TABLE_ROW_STYLES: Optional[List[rich.style.StyleType]] = None +STYLE_COMMANDS_TABLE_BORDER_STYLE: Optional[rich.style.StyleType] = None +STYLE_COMMANDS_TABLE_COLUMN_WIDTH_RATIO: Optional[Union[Tuple[None, None], Tuple[int, int]]] = (None, None) +STYLE_ERRORS_PANEL_BORDER: rich.style.StyleType = "red" +ALIGN_ERRORS_PANEL: rich.align.AlignMethod = "left" +STYLE_ERRORS_SUGGESTION: rich.style.StyleType = "dim" +STYLE_ERRORS_SUGGESTION_COMMAND: rich.style.StyleType = "blue" +STYLE_ABORTED: rich.style.StyleType = "red" +WIDTH: Optional[int] = terminal_width_default() +MAX_WIDTH: Optional[int] = terminal_width_default() +COLOR_SYSTEM: Optional[ + Literal["auto", "standard", "256", "truecolor", "windows"] +] = "auto" # Set to None to disable colors +FORCE_TERMINAL: Optional[bool] = force_terminal_default() + +# Fixed strings +HEADER_TEXT: Optional[str] = None +FOOTER_TEXT: Optional[str] = None +DEPRECATED_STRING: str = "(Deprecated) " +DEFAULT_STRING: str = "[default: {}]" +ENVVAR_STRING: str = "[env var: {}]" +REQUIRED_SHORT_STRING: str = "*" +REQUIRED_LONG_STRING: str = "[required]" +RANGE_STRING: str = " [{}]" +APPEND_METAVARS_HELP_STRING: str = "({})" +ARGUMENTS_PANEL_TITLE: str = "Arguments" +OPTIONS_PANEL_TITLE: str = "Options" +COMMANDS_PANEL_TITLE: str = "Commands" +ERRORS_PANEL_TITLE: str = "Error" +ERRORS_SUGGESTION: Optional[str] = None # Default: Try 'cmd -h' for help. Set to False to disable. +ERRORS_EPILOGUE: Optional[str] = None +ABORTED_TEXT: str = "Aborted." + +# Behaviours +SHOW_ARGUMENTS: bool = False # Show positional arguments +SHOW_METAVARS_COLUMN: bool = True # Show a column with the option metavar (eg. INTEGER) +APPEND_METAVARS_HELP: bool = False # Append metavar (eg. [TEXT]) after the help text +GROUP_ARGUMENTS_OPTIONS: bool = False # Show arguments with options instead of in own panel +OPTION_ENVVAR_FIRST: bool = False # Show env vars before option help text instead of avert +USE_MARKDOWN: bool = False # Parse help strings as markdown +USE_MARKDOWN_EMOJI: bool = True # Parse emoji codes in markdown :smile: +USE_RICH_MARKUP: bool = False # Parse help strings for rich markup (eg. [red]my text[/]) +# Define sorted groups of panels to display subcommands +COMMAND_GROUPS: Dict[str, List[Dict[str, Union[str, List[str]]]]] = {} +# Define sorted groups of panels to display options and arguments +OPTION_GROUPS: Dict[str, List[Dict[str, Union[str, List[str], Dict[str, List[str]]]]]] = {} +USE_CLICK_SHORT_HELP: bool = False # Use click's default function to truncate help text + +highlighter: rich.highlighter.Highlighter = OptionHighlighter() +_formatter: Optional[RichHelpFormatter] = None + + +def _get_rich_formatter(formatter: Optional[click.HelpFormatter] = None) -> RichHelpFormatter: + """Get Rich Help Formatter. + + Resolves the rich help formatter from the following: + - formatter, if exists and is a `RichHelpFormatter` object + - cached, module-level formatter + - active click Context, that is cached as module-level attr + - module-level settings (default) + + Args: + formatter: A possible Rich help formatter + """ + if formatter and isinstance(formatter, RichHelpFormatter): + return formatter + + global _formatter + if _formatter: + return _formatter + ctx = click.get_current_context(True) + if ctx: + formatter = ctx.make_formatter() + if isinstance(formatter, RichHelpFormatter): + _formatter = formatter + return _formatter + + _formatter = RichHelpFormatter(config=get_module_help_configuration()) + return _formatter + + +def _make_rich_rext( + text: str, style: StyleType = "", formatter: Optional[RichHelpFormatter] = None +) -> Union[rich.markdown.Markdown, Text]: + """Take a string, remove indentations, and return styled text. + + By default, return the text as a Rich Text with the request style. + If config.use_rich_markup is True, also parse the text for Rich markup strings. + If config.use_markdown is True, parse as Markdown. + + Only one of config.use_markdown or config.use_rich_markup can be True. + If both are True, config.use_markdown takes precedence. + + Args: + text (str): Text to style + style (str): Rich style to apply + + Returns: + MarkdownElement or Text: Styled text object + """ + formatter = _get_rich_formatter(formatter) + config = formatter.config + # Remove indentations from input text + text = inspect.cleandoc(text) + if config.use_markdown: + if config.use_markdown_emoji: + text = Emoji.replace(text) + return Markdown(text, style=style) + if config.use_rich_markup: + return config.highlighter(Text.from_markup(text, style=style)) + else: + return config.highlighter(Text(text, style=style)) + + +@group() +def _get_help_text( + obj: Union[Command, Group], formatter: Optional[RichHelpFormatter] = None +) -> Iterable[Union[rich.markdown.Markdown, rich.text.Text]]: + """Build primary help text for a click command or group. + + Returns the prose help text for a command or group, rendered either as a + Rich Text object or as Markdown. + If the command is marked as depreciated, the depreciated string will be prepended. + + Args: + obj (click.Command or click.Group): Command or group to build help text for + + Yields: + Text or Markdown: Multiple styled objects (depreciated, usage) + """ + if TYPE_CHECKING: + assert isinstance(obj.help, str) + formatter = _get_rich_formatter(formatter) + config = formatter.config + # Prepend deprecated status + if obj.deprecated: + yield Text(config.deprecated_string, style=config.style_deprecated) + + # Fetch and dedent the help text + help_text = inspect.cleandoc(obj.help) + + # Trim off anything that comes after \f on its own line + help_text = help_text.partition("\f")[0] + + # Get the first paragraph + first_line = help_text.split("\n\n")[0] + # Remove single linebreaks + if not config.use_markdown and not first_line.startswith("\b"): + first_line = first_line.replace("\n", " ") + yield _make_rich_rext(first_line.strip(), config.style_helptext_first_line, formatter) + + # Get remaining lines, remove single line breaks and format as dim + remaining_paragraphs = help_text.split("\n\n")[1:] + if len(remaining_paragraphs) > 0: + if not config.use_markdown: + # Remove single linebreaks + remaining_paragraphs = [ + x.replace("\n", " ").strip() if not x.startswith("\b") else "{}\n".format(x.strip("\b\n")) + for x in remaining_paragraphs + ] + # Join back together + remaining_lines = "\n".join(remaining_paragraphs) + else: + # Join with double linebreaks if markdown + remaining_lines = "\n\n".join(remaining_paragraphs) + + yield _make_rich_rext(remaining_lines, config.style_helptext, formatter) + + +def _get_option_help( + param: Union[click.Argument, click.Option], ctx: click.Context, formatter: Optional[RichHelpFormatter] = None +) -> rich.columns.Columns: + """Build primary help text for a click option or argument. + + Returns the prose help text for an option or argument, rendered either + as a Rich Text object or as Markdown. + Additional elements are appended to show the default and required status if applicable. + + Args: + param (click.Argument or click.Option): Parameter to build help text for + ctx (click.Context): Click Context object + + Returns: + Columns: A columns element with multiple styled objects (help, default, required) + """ + formatter = _get_rich_formatter(formatter) + config = formatter.config + items: List[rich.console.RenderableType] = [] + + if TYPE_CHECKING: + assert isinstance(param.name, str) + + # Get the environment variable first + envvar = getattr(param, "envvar", None) + # https://github.com/pallets/click/blob/0aec1168ac591e159baf6f61026d6ae322c53aaf/src/click/core.py#L2720-L2726 + if envvar is None: + if ( + getattr(param, "allow_from_autoenv", None) + and getattr(ctx, "auto_envvar_prefix", None) is not None + and param.name is not None + ): + envvar = f"{ctx.auto_envvar_prefix}_{param.name.upper()}" + if envvar is not None: + envvar = ", ".join(envvar) if type(envvar) is list else envvar + + # Environment variable config.before help text + if getattr(param, "show_envvar", None) and config.option_envvar_first and envvar is not None: + items.append(Text(config.envvar_string.format(envvar), style=config.style_option_envvar)) + + # Main help text + if getattr(param, "help", None): + if TYPE_CHECKING: + assert isinstance(param, click.Option) + assert hasattr(param, "help") + assert isinstance(param.help, str) + paragraphs = param.help.split("\n\n") + # Remove single linebreaks + if not config.use_markdown: + paragraphs = [ + x.replace("\n", " ").strip() if not x.startswith("\b") else "{}\n".format(x.strip("\b\n")) + for x in paragraphs + ] + items.append(_make_rich_rext("\n".join(paragraphs).strip(), config.style_option_help, formatter)) + + # Append metavar if requested + if config.append_metavars_help: + metavar_str = param.make_metavar() + # Do it ourselves if this is a positional argument + if isinstance(param, click.core.Argument) and re.match(rf"\[?{param.name.upper()}]?", metavar_str): + metavar_str = param.type.name.upper() + # Attach metavar if param is a positional argument, or if it is a non boolean and non flag option + if isinstance(param, click.core.Argument) or (metavar_str != "BOOLEAN" and not param.is_flag): + metavar_str = metavar_str.replace("[", "").replace("]", "") + items.append( + Text( + config.append_metavars_help_string.format(metavar_str), + style=config.style_metavar_append, + overflow="fold", + ) + ) + + # Environment variable config.after help text + if getattr(param, "show_envvar", None) and not config.option_envvar_first and envvar is not None: + items.append(Text(config.envvar_string.format(envvar), style=config.style_option_envvar)) + + # Default value + # Click 7.x, 8.0, and 8.1 all behave slightly differently when handling the default value help text. + if not hasattr(param, "show_default"): + parse_default = False + elif CLICK_IS_BEFORE_VERSION_8X: + parse_default = bool(param.default is not None and (param.show_default or getattr(ctx, "show_default", None))) + elif CLICK_IS_VERSION_80: + show_default_is_str = isinstance(param.show_default, str) + parse_default = bool( + show_default_is_str or (param.default is not None and (param.show_default or ctx.show_default)) + ) + else: + show_default_is_str = False + if param.show_default is not None: + if isinstance(param.show_default, str): + show_default_is_str = show_default = True + else: + show_default = bool(param.show_default) + else: + show_default = bool(getattr(ctx, "show_default", False)) + parse_default = bool(show_default_is_str or (show_default and (param.default is not None))) + + if parse_default: + help_record = param.get_help_record(ctx) + if TYPE_CHECKING: + assert isinstance(help_record, tuple) + default_str_match = re.search(r"\[(?:.+; )?default: (.*)\]", help_record[-1]) + if default_str_match: + # Don't show the required string, as we show that afterwards anyway + default_str = default_str_match.group(1).replace("; required", "") + items.append( + Text( + config.default_string.format(default_str), + style=config.style_option_default, + ) + ) + + # Required? + if param.required: + items.append(Text(config.required_long_string, style=config.style_required_long)) + + # Use Columns - this allows us to group different renderable types + # (Text, Markdown) onto a single line. + return Columns(items) + + +def _make_command_help( + help_text: str, formatter: Optional[RichHelpFormatter] = None +) -> Union[rich.text.Text, rich.markdown.Markdown]: + """Build cli help text for a click group command. + + That is, when calling help on groups with multiple subcommands + (not the main help text when calling the subcommand help). + + Returns the first paragraph of help text for a command, rendered either as a + Rich Text object or as Markdown. + Ignores single newlines as paragraph markers, looks for double only. + + Args: + help_text (str): Help text + + Returns: + Text or Markdown: Styled object + """ + formatter = _get_rich_formatter(formatter) + config = formatter.config + paragraphs = inspect.cleandoc(help_text).split("\n\n") + # Remove single linebreaks + if not config.use_markdown and not paragraphs[0].startswith("\b"): + paragraphs[0] = paragraphs[0].replace("\n", " ") + elif paragraphs[0].startswith("\b"): + paragraphs[0] = paragraphs[0].replace("\b\n", "") + + return _make_rich_rext(paragraphs[0].strip(), config.style_option_help, formatter) + + +def get_rich_usage( + obj: Union[Command, Group], + ctx: click.Context, + formatter: click.HelpFormatter, +) -> None: + """Get usage text for a command.""" + formatter = _get_rich_formatter(formatter) + config = formatter.config + console = formatter.console + + # Highlighter for options and arguments + class UsageHighlighter(RegexHighlighter): + highlights = [ + r"(?P<argument>\w+)", + ] + + usage_highlighter = UsageHighlighter() + + # Print usage + console.print( + Padding( + Columns( + ( + Text("Usage:", style=config.style_usage), + Text(ctx.command_path, style=config.style_usage_command), + usage_highlighter(" ".join(obj.collect_usage_pieces(ctx))), + ) + ), + 1, + ), + ) + + +def rich_format_help( + obj: Command, + ctx: click.Context, + formatter: click.HelpFormatter, +) -> None: + """Print nicely formatted help text using rich. + + Based on original code from rich-cli, by @willmcgugan. + https://github.com/Textualize/rich-cli/blob/8a2767c7a340715fc6fbf4930ace717b9b2fc5e5/src/rich_cli/__main__.py#L162-L236 + + Replacement for the click function format_help(). + Takes a command or group and builds the help text output. + + Args: + obj (click.Command or click.Group): Command or group to build help text for + ctx (click.Context): Click Context object + formatter (click.HelpFormatter): Click HelpFormatter object + """ + formatter = _get_rich_formatter(formatter) + config = formatter.config + console = formatter.console + highlighter = formatter.config.highlighter + + # Header text if we have it + if config.header_text: + console.print( + Padding( + _make_rich_rext(config.header_text, config.style_header_text, formatter), + (1, 1, 0, 1), + ), + ) + + # Print usage + get_rich_usage(obj, ctx, formatter) + + # Print command / group help if we have some + if obj.help: + # Print with some padding + console.print( + Padding( + Align(_get_help_text(obj, formatter), pad=False), + (0, 1, 1, 1), + ) + ) + + # Look through config.option_groups for this command + # stick anything unmatched into a default group at the end + option_groups = config.option_groups.get(ctx.command_path, []).copy() + option_groups.append({"options": []}) + argument_group_options = [] + + for param in obj.get_params(ctx): + # Skip positional arguments - they don't have opts or helptext and are covered in usage + # See https://click.palletsprojects.com/en/8.0.x/documentation/#documenting-arguments + if isinstance(param, click.core.Argument) and not config.show_arguments: + continue + + # Skip if option is hidden + if getattr(param, "hidden", False): + continue + + # Already mentioned in a config option group + for option_group in option_groups: + if any([opt in option_group.get("options", []) for opt in param.opts]): + break + + # No break, no mention - add to the default group + else: + if isinstance(param, click.core.Argument) and not config.group_arguments_options: + argument_group_options.append(param.opts[0]) + else: + list_of_option_groups: List[str] = option_groups[-1]["options"] # type: ignore[assignment] + list_of_option_groups.append(param.opts[0]) + + # If we're not grouping arguments and we got some, prepend before default options + if len(argument_group_options) > 0: + extra_option_group = {"name": config.arguments_panel_title, "options": argument_group_options} + option_groups.insert(len(option_groups) - 1, extra_option_group) + + # print("!", option_groups) + + # Print each option group panel + for option_group in option_groups: + options_rows = [] + for opt in option_group.get("options", []): + # Get the param + for param in obj.get_params(ctx): + if any([opt in param.opts]): + break + # Skip if option is not listed in this group + else: + continue + + # Short and long form + opt_long_strs = [] + opt_short_strs = [] + for idx, opt in enumerate(param.opts): + opt_str = opt + try: + opt_str += "/" + param.secondary_opts[idx] + except IndexError: + pass + + if isinstance(param, click.core.Argument): + opt_long_strs.append(opt_str.upper()) + elif "--" in opt: + opt_long_strs.append(opt_str) + else: + opt_short_strs.append(opt_str) + + # Column for a metavar, if we have one + metavar = Text(style=config.style_metavar, overflow="fold") + metavar_str = param.make_metavar() + + if TYPE_CHECKING: + assert isinstance(param.name, str) + assert isinstance(param, click.Option) + + # Do it ourselves if this is a positional argument + if isinstance(param, click.core.Argument) and re.match(rf"\[?{param.name.upper()}]?", metavar_str): + metavar_str = param.type.name.upper() + + # Attach metavar if param is a positional argument, or if it is a non boolean and non flag option + if isinstance(param, click.core.Argument) or ( + metavar_str != "BOOLEAN" and not getattr(param, "is_flag", None) + ): + metavar.append(metavar_str) + + # Range - from + # https://github.com/pallets/click/blob/c63c70dabd3f86ca68678b4f00951f78f52d0270/src/click/core.py#L2698-L2706 # noqa: E501 + try: + # skip count with default range type + if isinstance(param.type, click.types._NumberRangeBase) and not ( + param.count and param.type.min == 0 and param.type.max is None + ): + range_str = param.type._describe_range() + if range_str: + metavar.append(config.range_string.format(range_str)) + except AttributeError: + # click.types._NumberRangeBase is only in Click 8x onwards + pass + + # Required asterisk + required: Union[Text, str] = "" + if param.required: + required = Text(config.required_short_string, style=config.style_required_short) + + # Highlighter to make [ | ] and <> dim + class MetavarHighlighter(RegexHighlighter): + highlights = [ + r"^(?P<metavar_sep>(\[|<))", + r"(?P<metavar_sep>\|)", + r"(?P<metavar_sep>(\]|>)$)", + ] + + metavar_highlighter = MetavarHighlighter() + + rows = [ + required, + highlighter(highlighter(",".join(opt_long_strs))), + highlighter(highlighter(",".join(opt_short_strs))), + metavar_highlighter(metavar), + _get_option_help(param, ctx, formatter), + ] + + # Remove metavar if specified in config + if not config.show_metavars_column: + rows.pop(3) + + options_rows.append(rows) + + if len(options_rows) > 0: + t_styles = { + "show_lines": config.style_options_table_show_lines, + "leading": config.style_options_table_leading, + "box": config.style_options_table_box, + "border_style": config.style_options_table_border_style, + "row_styles": config.style_options_table_row_styles, + "pad_edge": config.style_options_table_pad_edge, + "padding": config.style_options_table_padding, + } + t_styles.update(option_group.get("table_styles", {})) # type: ignore[arg-type] + box_style = getattr(box, t_styles.pop("box"), None) # type: ignore[arg-type] + + options_table = Table( + highlight=True, + show_header=False, + expand=True, + box=box_style, + **t_styles, # type: ignore[arg-type] + ) + # Strip the required column if none are required + if all([x[0] == "" for x in options_rows]): + options_rows = [x[1:] for x in options_rows] + for row in options_rows: + options_table.add_row(*row) + console.print( + Panel( + options_table, + border_style=config.style_options_panel_border, + title=option_group.get("name", config.options_panel_title), + title_align=config.align_options_panel, + ) + ) + + # + # Groups only: + # List click command groups + # + + if isinstance(obj, MultiCommand): + # Look through COMMAND_GROUPS for this command + # stick anything unmatched into a default group at the end + cmd_groups = config.command_groups.get(ctx.command_path, []).copy() + cmd_groups.append({"commands": []}) + for command in obj.list_commands(ctx): + for cmd_group in cmd_groups: + if command in cmd_group.get("commands", []): + break + else: + commands: List[str] = cmd_groups[-1]["commands"] # type: ignore[assignment] + commands.append(command) + + # Print each command group panel + for cmd_group in cmd_groups: + t_styles = { + "show_lines": config.style_commands_table_show_lines, + "leading": config.style_commands_table_leading, + "box": config.style_commands_table_box, + "border_style": config.style_commands_table_border_style, + "row_styles": config.style_commands_table_row_styles, + "pad_edge": config.style_commands_table_pad_edge, + "padding": config.style_commands_table_padding, + } + t_styles.update(cmd_group.get("table_styles", {})) # type: ignore[arg-type] + box_style = getattr(box, t_styles.pop("box"), None) # type: ignore[arg-type] + + commands_table = Table( + highlight=False, + show_header=False, + expand=True, + box=box_style, + **t_styles, # type: ignore[arg-type] + ) + # Define formatting in first column, as commands don't match highlighter regex + # and set column ratio for first and second column, if a ratio has been set + if config.style_commands_table_column_width_ratio is None: + table_column_width_ratio: Union[Tuple[None, None], Tuple[int, int]] = (None, None) + else: + table_column_width_ratio = config.style_commands_table_column_width_ratio + + commands_table.add_column(style=config.style_command, no_wrap=True, ratio=table_column_width_ratio[0]) + commands_table.add_column( + no_wrap=False, + ratio=table_column_width_ratio[1], + ) + for command in cmd_group.get("commands", []): + # Skip if command does not exist + if command not in obj.list_commands(ctx): + continue + cmd = obj.get_command(ctx, command) + if TYPE_CHECKING: + assert cmd is not None + if cmd.hidden: + continue + # Use the truncated short text as with vanilla text if requested + if config.use_click_short_help: + helptext = cmd.get_short_help_str() + else: + # Use short_help function argument if used, or the full help + helptext = cmd.short_help or cmd.help or "" + commands_table.add_row(command, _make_command_help(helptext, formatter)) + if commands_table.row_count > 0: + console.print( + Panel( + commands_table, + border_style=config.style_commands_panel_border, + title=cmd_group.get("name", config.commands_panel_title), + title_align=config.align_commands_panel, + ) + ) + + # Epilogue if we have it + if isinstance(obj, Command) and obj.epilog: + # Remove single linebreaks, replace double with single + lines = obj.epilog.split("\n\n") + epilogue = "\n".join([x.replace("\n", " ").strip() for x in lines]) + console.print(Padding(Align(_make_rich_rext(epilogue, config.style_epilog_text, formatter), pad=False), 1)) + + # Footer text if we have it + if config.footer_text: + console.print(Padding(_make_rich_rext(config.footer_text, config.style_footer_text, formatter), (1, 1, 0, 1))) + + +def rich_format_error(self: click.ClickException, formatter: Optional[RichHelpFormatter] = None) -> None: + """Print richly formatted click errors. + + Called by custom exception handler to print richly formatted click errors. + Mimics original click.ClickException.echo() function but with rich formatting. + + Args: + click.ClickException: Click exception to format. + """ + formatter = _get_rich_formatter(formatter) + console = formatter.console + config = formatter.config + highlighter = formatter.config.highlighter + # Print usage + if getattr(self, "ctx", None) is not None: + if TYPE_CHECKING: + assert hasattr(self, "ctx") + get_rich_usage(self.ctx.command, self.ctx, formatter) + if config.errors_suggestion: + console.print( + Padding( + config.errors_suggestion, + (0, 1, 0, 1), + ), + style=config.style_errors_suggestion, + ) + elif ( + config.errors_suggestion is None + and getattr(self, "ctx", None) is not None + and self.ctx.command.get_help_option(self.ctx) is not None # type: ignore[attr-defined] + ): + cmd_path = self.ctx.command_path # type: ignore[attr-defined] + help_option = self.ctx.help_option_names[0] # type: ignore[attr-defined] + console.print( + Padding( + Columns( + ( + Text("Try"), + Text(f"'{cmd_path} {help_option}'", style=config.style_errors_suggestion_command), + Text("for help"), + ) + ), + (0, 1, 0, 1), + ), + style=config.style_errors_suggestion, + ) + + # A major Python library using click (dbt-core) has its own exception + # logic that subclasses ClickException, but does not use the message + # attribute. Checking for the 'message' attribute works to make the + # rich-click CLI compatible. + if hasattr(self, "message"): + console.print( + Padding( + Panel( + highlighter(self.format_message()), + border_style=config.style_errors_panel_border, + title=config.errors_panel_title, + title_align=config.align_errors_panel, + ), + (0, 0, 1, 0), + ) + ) + if config.errors_epilogue: + console.print(Padding(config.errors_epilogue, (0, 1, 1, 1))) + + +def rich_abort_error(formatter: Optional[RichHelpFormatter] = None) -> None: + """Print richly formatted abort error.""" + formatter = _get_rich_formatter(formatter) + config = formatter.config + formatter.console.print(config.aborted_text, style=config.style_aborted) + + +module_config: Optional[RichHelpConfiguration] = None + + +def get_module_help_configuration() -> RichHelpConfiguration: + """Get Module-level help configuration resolved into a `RichHelpConfiguration` instance.""" + global module_config + if module_config: + return module_config + module_config = RichHelpConfiguration( + STYLE_OPTION, + STYLE_ARGUMENT, + STYLE_COMMAND, + STYLE_SWITCH, + STYLE_METAVAR, + STYLE_METAVAR_APPEND, + STYLE_METAVAR_SEPARATOR, + STYLE_HEADER_TEXT, + STYLE_EPILOG_TEXT, + STYLE_FOOTER_TEXT, + STYLE_USAGE, + STYLE_USAGE_COMMAND, + STYLE_DEPRECATED, + STYLE_HELPTEXT_FIRST_LINE, + STYLE_HELPTEXT, + STYLE_OPTION_HELP, + STYLE_OPTION_DEFAULT, + STYLE_OPTION_ENVVAR, + STYLE_REQUIRED_SHORT, + STYLE_REQUIRED_LONG, + STYLE_OPTIONS_PANEL_BORDER, + ALIGN_OPTIONS_PANEL, + STYLE_OPTIONS_TABLE_SHOW_LINES, + STYLE_OPTIONS_TABLE_LEADING, + STYLE_OPTIONS_TABLE_PAD_EDGE, + STYLE_OPTIONS_TABLE_PADDING, + STYLE_OPTIONS_TABLE_BOX, + STYLE_OPTIONS_TABLE_ROW_STYLES, + STYLE_OPTIONS_TABLE_BORDER_STYLE, + STYLE_COMMANDS_PANEL_BORDER, + ALIGN_COMMANDS_PANEL, + STYLE_COMMANDS_TABLE_SHOW_LINES, + STYLE_COMMANDS_TABLE_LEADING, + STYLE_COMMANDS_TABLE_PAD_EDGE, + STYLE_COMMANDS_TABLE_PADDING, + STYLE_COMMANDS_TABLE_BOX, + STYLE_COMMANDS_TABLE_ROW_STYLES, + STYLE_COMMANDS_TABLE_BORDER_STYLE, + STYLE_COMMANDS_TABLE_COLUMN_WIDTH_RATIO, + STYLE_ERRORS_PANEL_BORDER, + ALIGN_ERRORS_PANEL, + STYLE_ERRORS_SUGGESTION, + STYLE_ERRORS_SUGGESTION_COMMAND, + STYLE_ABORTED, + WIDTH, + MAX_WIDTH, + COLOR_SYSTEM, + FORCE_TERMINAL, + HEADER_TEXT, + FOOTER_TEXT, + DEPRECATED_STRING, + DEFAULT_STRING, + ENVVAR_STRING, + REQUIRED_SHORT_STRING, + REQUIRED_LONG_STRING, + RANGE_STRING, + APPEND_METAVARS_HELP_STRING, + ARGUMENTS_PANEL_TITLE, + OPTIONS_PANEL_TITLE, + COMMANDS_PANEL_TITLE, + ERRORS_PANEL_TITLE, + ERRORS_SUGGESTION, + ERRORS_EPILOGUE, + ABORTED_TEXT, + SHOW_ARGUMENTS, + SHOW_METAVARS_COLUMN, + APPEND_METAVARS_HELP, + GROUP_ARGUMENTS_OPTIONS, + OPTION_ENVVAR_FIRST, + USE_MARKDOWN, + USE_MARKDOWN_EMOJI, + USE_RICH_MARKUP, + COMMAND_GROUPS, + OPTION_GROUPS, + USE_CLICK_SHORT_HELP, + highlighter, + ) + return module_config diff --git a/venv/lib/python3.11/site-packages/rich_click/rich_command.py b/venv/lib/python3.11/site-packages/rich_click/rich_command.py new file mode 100644 index 0000000..eef4eda --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/rich_command.py @@ -0,0 +1,257 @@ +import errno +import os +import sys +import warnings +from functools import wraps +from typing import Any, Callable, cast, Optional, overload, Sequence, TextIO, Type, TYPE_CHECKING, Union + +import click + +# Group, Command, and CommandCollection need to be imported directly, +# or else rich_click.cli.patch() causes a recursion error. +from click import Command, CommandCollection, Group +from click.utils import make_str, PacifyFlushWrapper +from rich.console import Console + +from rich_click._compat_click import CLICK_IS_BEFORE_VERSION_8X, CLICK_IS_BEFORE_VERSION_9X +from rich_click.rich_click import rich_abort_error, rich_format_error, rich_format_help +from rich_click.rich_context import RichContext +from rich_click.rich_help_configuration import RichHelpConfiguration +from rich_click.rich_help_formatter import RichHelpFormatter + + +class RichCommand(click.Command): + """Richly formatted click Command. + + Inherits click.Command and overrides help and error methods + to print richly formatted output. + + This class can be used as a mixin for other click command objects. + """ + + context_class: Type[RichContext] = RichContext + _formatter: Optional[RichHelpFormatter] = None + + @wraps(Command.__init__) + def __init__(self, *args: Any, **kwargs: Any): + """Create Rich Command instance.""" + super().__init__(*args, **kwargs) + self._register_rich_context_settings_from_callback() + + def _register_rich_context_settings_from_callback(self) -> None: + if self.callback is not None: + if hasattr(self.callback, "__rich_context_settings__"): + rich_context_settings = getattr(self.callback, "__rich_context_settings__", {}) + for k, v in rich_context_settings.items(): + self.context_settings.setdefault(k, v) + del self.callback.__rich_context_settings__ + + @property + def console(self) -> Optional[Console]: + """Rich Console. + + This is a separate instance from the help formatter that allows full control of the + console configuration. + + See `rich_config` decorator for how to apply the settings. + """ + return self.context_settings.get("rich_console") + + @property + def help_config(self) -> Optional[RichHelpConfiguration]: + """Rich Help Configuration.""" + return self.context_settings.get("rich_help_config") + + @property + def formatter(self) -> RichHelpFormatter: + """Rich Help Formatter. + + This is separate instance from the formatter used to display help, + but is created from the same `RichHelpConfiguration`. Currently only used + for error reporting. + """ + if self._formatter is None: + self._formatter = RichHelpFormatter(config=self.help_config) + return self._formatter + + def main( + self, + args: Optional[Sequence[str]] = None, + prog_name: Optional[str] = None, + complete_var: Optional[str] = None, + standalone_mode: bool = True, + windows_expand_args: bool = True, + **extra: Any, + ) -> Any: + # It's not feasible to use super().main() in this context and retain exact parity in behavior. + # The reason why is explained in a comment in click's source code in the "except Exit as e" block. + + if args is None: + if CLICK_IS_BEFORE_VERSION_8X: + from click.utils import get_os_args # type: ignore[attr-defined] + + args: Sequence[str] = get_os_args() # type: ignore[no-redef] + else: + args = sys.argv[1:] + + if os.name == "nt" and windows_expand_args: + from click.utils import _expand_args + + args = _expand_args(args) + else: + args = list(args) + + if TYPE_CHECKING: + assert args is not None + + if prog_name is None: + if CLICK_IS_BEFORE_VERSION_8X: + prog_name = make_str(os.path.basename(sys.argv[0] if sys.argv else __file__)) + else: + from click.utils import _detect_program_name + + prog_name = _detect_program_name() + + # Process shell completion requests and exit early. + if CLICK_IS_BEFORE_VERSION_8X: + from click.core import _bashcomplete # type: ignore[attr-defined] + + _bashcomplete(self, prog_name, complete_var) + else: + self._main_shell_completion(extra, prog_name, complete_var) + + try: + try: + with self.make_context(prog_name, args, **extra) as ctx: + rv = self.invoke(ctx) + if not standalone_mode: + return rv + # it's not safe to `ctx.exit(rv)` here! + # note that `rv` may actually contain data like "1" which + # has obvious effects + # more subtle case: `rv=[None, None]` can come out of + # chained commands which all returned `None` -- so it's not + # even always obvious that `rv` indicates success/failure + # by its truthiness/falsiness + ctx.exit() + except (EOFError, KeyboardInterrupt): + click.echo(file=sys.stderr) + raise click.exceptions.Abort() from None + except click.exceptions.ClickException as e: + rich_format_error(e, self.formatter) + if not standalone_mode: + raise + sys.stderr.write(self.formatter.getvalue()) + sys.exit(e.exit_code) + except OSError as e: + if e.errno == errno.EPIPE: + sys.stdout = cast(TextIO, PacifyFlushWrapper(sys.stdout)) + sys.stderr = cast(TextIO, PacifyFlushWrapper(sys.stderr)) + sys.exit(1) + else: + raise + except click.exceptions.Exit as e: + if standalone_mode: + sys.exit(e.exit_code) + else: + return e.exit_code + except click.exceptions.Abort: + rich_abort_error(self.formatter) + if not standalone_mode: + raise + sys.stderr.write(self.formatter.getvalue()) + sys.exit(1) + + def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None: + rich_format_help(self, ctx, formatter) + + +class RichGroup(RichCommand, Group): + """Richly formatted click Group. + + Inherits click.Group and overrides help and error methods + to print richly formatted output. + """ + + command_class: Optional[Type[RichCommand]] = RichCommand + group_class: Optional[Union[Type[Group], Type[type]]] = type + + @wraps(Group.__init__) + def __init__(self, *args: Any, **kwargs: Any) -> None: + """Initialize RichGroup class.""" + Group.__init__(self, *args, **kwargs) + self._register_rich_context_settings_from_callback() + + if CLICK_IS_BEFORE_VERSION_8X: + + @overload + def command(self, __func: Callable[..., Any]) -> Command: + ... + + @overload + def command(self, *args: Any, **kwargs: Any) -> Callable[[Callable[..., Any]], Command]: + ... + + def command(self, *args: Any, **kwargs: Any) -> Union[Callable[[Callable[..., Any]], Command], Command]: + # This method override is required for Click 7.x compatibility. + # (The command_class ClassVar was not added until 8.0.) + if self.command_class is not None: + kwargs.setdefault("cls", self.command_class) + return super().command(*args, **kwargs) # type: ignore[no-any-return] + + @overload + def group(self, __func: Callable[..., Any]) -> Group: + ... + + @overload + def group(self, *args: Any, **kwargs: Any) -> Callable[[Callable[..., Any]], Group]: + ... + + def group(self, *args: Any, **kwargs: Any) -> Union[Callable[[Callable[..., Any]], Group], Group]: + # This method override is required for Click 7.x compatibility. + # (The group_class ClassVar was not added until 8.0.) + if self.group_class is type: + kwargs.setdefault("cls", self.__class__) + elif self.group_class is not None: + kwargs.setdefault("cls", self.group_class) + return super().group(*args, **kwargs) # type: ignore[no-any-return] + + +if CLICK_IS_BEFORE_VERSION_9X: + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", category=DeprecationWarning, module="click") + from click import MultiCommand + + class RichMultiCommand(RichCommand, MultiCommand): + """Richly formatted click MultiCommand. + + Inherits click.MultiCommand and overrides help and error methods + to print richly formatted output. + """ + + @wraps(MultiCommand.__init__) + def __init__(self, *args: Any, **kwargs: Any) -> None: # type: ignore[no-untyped-def] + """Initialize RichGroup class.""" + from click import MultiCommand + + MultiCommand.__init__(self, *args, **kwargs) + self._register_rich_context_settings_from_callback() + +else: + + class RichMultiCommand(RichGroup): # type: ignore[no-redef] + """This class is deprecated.""" + + +class RichCommandCollection(RichGroup, CommandCollection): + """Richly formatted click CommandCollection. + + Inherits click.CommandCollection and overrides help and error methods + to print richly formatted output. + """ + + @wraps(CommandCollection.__init__) + def __init__(self, *args: Any, **kwargs: Any) -> None: + """Initialize RichCommandCollection class.""" + CommandCollection.__init__(self, *args, **kwargs) + self._register_rich_context_settings_from_callback() diff --git a/venv/lib/python3.11/site-packages/rich_click/rich_context.py b/venv/lib/python3.11/site-packages/rich_click/rich_context.py new file mode 100644 index 0000000..8e5e0a2 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/rich_context.py @@ -0,0 +1,47 @@ +from typing import Any, Optional, Type + +import click +from rich.console import Console + +from rich_click.rich_help_configuration import RichHelpConfiguration +from rich_click.rich_help_formatter import RichHelpFormatter + + +class RichContext(click.Context): + """Click Context class endowed with Rich superpowers.""" + + formatter_class: Type[RichHelpFormatter] = RichHelpFormatter + + def __init__( + self, + *args: Any, + rich_console: Optional[Console] = None, + rich_help_config: Optional[RichHelpConfiguration] = None, + **kwargs: Any, + ) -> None: + """Create Rich Context instance. + + Args: + rich_console: Rich Console. + Defaults to None. + rich_help_config: Rich help configuration. + Defaults to None. + """ + super().__init__(*args, **kwargs) + parent: Optional[RichContext] = kwargs.pop("parent", None) + + if rich_console is None and hasattr(parent, "console"): + rich_console = parent.console # type: ignore[has-type,union-attr] + + self.console = rich_console + + if rich_help_config is None and hasattr(parent, "help_config"): + rich_help_config = parent.help_config # type: ignore[has-type,union-attr] + + self.help_config = rich_help_config + + def make_formatter(self) -> RichHelpFormatter: + """Create the Rich Help Formatter.""" + return self.formatter_class( + width=self.terminal_width, max_width=self.max_content_width, config=self.help_config + ) diff --git a/venv/lib/python3.11/site-packages/rich_click/rich_group.py b/venv/lib/python3.11/site-packages/rich_click/rich_group.py new file mode 100644 index 0000000..659f2f2 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/rich_group.py @@ -0,0 +1,11 @@ +import warnings + +from rich_click.rich_command import RichGroup + +warnings.warn( + "RichCommand is moving from rich_click.rich_group to rich_click.rich_command in a future version.", + DeprecationWarning, +) + + +__all__ = ["RichGroup"] diff --git a/venv/lib/python3.11/site-packages/rich_click/rich_help_configuration.py b/venv/lib/python3.11/site-packages/rich_click/rich_help_configuration.py new file mode 100644 index 0000000..e011fe1 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/rich_help_configuration.py @@ -0,0 +1,148 @@ +import os +from dataclasses import dataclass, field +from os import getenv +from typing import Any, Dict, List, Optional, Tuple, Union + +import rich.align +import rich.highlighter +import rich.padding +import rich.style +import rich.table +from typing_extensions import Literal + +from rich_click.utils import truthy + + +def force_terminal_default() -> Optional[bool]: + """Use as the default factory for `force_terminal`.""" + env_vars = {"GITHUB_ACTIONS", "FORCE_COLOR", "PY_COLORS"} + if all(i not in os.environ for i in env_vars): + return None + else: + return any(truthy(getenv(i)) for i in env_vars) + + +def terminal_width_default() -> Optional[int]: + """Use as the default factory for `width` and `max_width`.""" + width = getenv("TERMINAL_WIDTH") + if width: + try: + return int(width) + except ValueError: + import warnings + + warnings.warn("Environment variable `TERMINAL_WIDTH` cannot be cast to an integer.", UserWarning) + return None + return None + + +class OptionHighlighter(rich.highlighter.RegexHighlighter): + """Highlights our special options.""" + + highlights = [ + r"(^|\W)(?P<switch>\-\w+)(?![a-zA-Z0-9])", + r"(^|\W)(?P<option>\-\-[\w\-]+)(?![a-zA-Z0-9])", + r"(?P<metavar>\<[^\>]+\>)", + ] + + +@dataclass +class RichHelpConfiguration: + """Rich Help Configuration Class.""" + + # Default styles + style_option: rich.style.StyleType = field(default="bold cyan") + style_argument: rich.style.StyleType = field(default="bold cyan") + style_command: rich.style.StyleType = field(default="bold cyan") + style_switch: rich.style.StyleType = field(default="bold green") + style_metavar: rich.style.StyleType = field(default="bold yellow") + style_metavar_append: rich.style.StyleType = field(default="dim yellow") + style_metavar_separator: rich.style.StyleType = field(default="dim") + style_header_text: rich.style.StyleType = field(default="") + style_epilog_text: rich.style.StyleType = field(default="") + style_footer_text: rich.style.StyleType = field(default="") + style_usage: rich.style.StyleType = field(default="yellow") + style_usage_command: rich.style.StyleType = field(default="bold") + style_deprecated: rich.style.StyleType = field(default="red") + style_helptext_first_line: rich.style.StyleType = field(default="") + style_helptext: rich.style.StyleType = field(default="dim") + style_option_help: rich.style.StyleType = field(default="") + style_option_default: rich.style.StyleType = field(default="dim") + style_option_envvar: rich.style.StyleType = field(default="dim yellow") + style_required_short: rich.style.StyleType = field(default="red") + style_required_long: rich.style.StyleType = field(default="dim red") + style_options_panel_border: rich.style.StyleType = field(default="dim") + align_options_panel: rich.align.AlignMethod = field(default="left") + style_options_table_show_lines: bool = field(default=False) + style_options_table_leading: int = field(default=0) + style_options_table_pad_edge: bool = field(default=False) + style_options_table_padding: rich.padding.PaddingDimensions = field(default_factory=lambda: (0, 1)) + style_options_table_box: rich.style.StyleType = field(default="") + style_options_table_row_styles: Optional[List[rich.style.StyleType]] = field(default=None) + style_options_table_border_style: Optional[rich.style.StyleType] = field(default=None) + style_commands_panel_border: rich.style.StyleType = field(default="dim") + align_commands_panel: rich.align.AlignMethod = field(default="left") + style_commands_table_show_lines: bool = field(default=False) + style_commands_table_leading: int = field(default=0) + style_commands_table_pad_edge: bool = field(default=False) + style_commands_table_padding: rich.padding.PaddingDimensions = field(default_factory=lambda: (0, 1)) + style_commands_table_box: rich.style.StyleType = field(default="") + style_commands_table_row_styles: Optional[List[rich.style.StyleType]] = field(default=None) + style_commands_table_border_style: Optional[rich.style.StyleType] = field(default=None) + style_commands_table_column_width_ratio: Optional[Union[Tuple[None, None], Tuple[int, int]]] = field( + default_factory=lambda: (None, None) + ) + style_errors_panel_border: rich.style.StyleType = field(default="red") + align_errors_panel: rich.align.AlignMethod = field(default="left") + style_errors_suggestion: rich.style.StyleType = field(default="dim") + style_errors_suggestion_command: rich.style.StyleType = field(default="blue") + style_aborted: rich.style.StyleType = field(default="red") + width: Optional[int] = field(default_factory=terminal_width_default) + max_width: Optional[int] = field(default_factory=terminal_width_default) + color_system: Optional[Literal["auto", "standard", "256", "truecolor", "windows"]] = field(default="auto") + force_terminal: Optional[bool] = field(default_factory=force_terminal_default) + + # Fixed strings + header_text: Optional[str] = field(default=None) + footer_text: Optional[str] = field(default=None) + deprecated_string: str = field(default="(Deprecated) ") + default_string: str = field(default="[default: {}]") + envvar_string: str = field(default="[env var: {}]") + required_short_string: str = field(default="*") + required_long_string: str = field(default="[required]") + range_string: str = field(default=" [{}]") + append_metavars_help_string: str = field(default="({})") + arguments_panel_title: str = field(default="Arguments") + options_panel_title: str = field(default="Options") + commands_panel_title: str = field(default="Commands") + errors_panel_title: str = field(default="Error") + errors_suggestion: Optional[str] = field(default=None) + """Defaults to Try 'cmd -h' for help. Set to False to disable.""" + errors_epilogue: Optional[str] = field(default=None) + aborted_text: str = field(default="Aborted.") + + # Behaviours + show_arguments: bool = field(default=False) + """Show positional arguments""" + show_metavars_column: bool = field(default=True) + """Show a column with the option metavar (eg. INTEGER)""" + append_metavars_help: bool = field(default=False) + """Append metavar (eg. [TEXT]) after the help text""" + group_arguments_options: bool = field(default=False) + """Show arguments with options instead of in own panel""" + option_envvar_first: bool = field(default=False) + """Show env vars before option help text instead of after""" + use_markdown: bool = field(default=False) + use_markdown_emoji: bool = field(default=True) + """Parse emoji codes in markdown :smile:""" + use_rich_markup: bool = field(default=False) + """Parse help strings for rich markup (eg. [red]my text[/])""" + command_groups: Dict[str, List[Dict[str, Union[str, Any]]]] = field(default_factory=lambda: {}) + """Define sorted groups of panels to display subcommands""" + option_groups: Dict[str, List[Dict[str, Union[str, Any]]]] = field(default_factory=lambda: {}) + """Define sorted groups of panels to display options and arguments""" + use_click_short_help: bool = field(default=False) + """Use click's default function to truncate help text""" + highlighter: rich.highlighter.Highlighter = field(default_factory=lambda: OptionHighlighter()) + """Rich regex highlighter for help highlighting""" + legacy_windows: Optional[bool] = field(default=None) diff --git a/venv/lib/python3.11/site-packages/rich_click/rich_help_formatter.py b/venv/lib/python3.11/site-packages/rich_click/rich_help_formatter.py new file mode 100644 index 0000000..b068ec5 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/rich_help_formatter.py @@ -0,0 +1,103 @@ +from typing import Any, IO, Optional + +import click +import rich +import rich.highlighter +import rich.markdown +import rich.padding +import rich.text +import rich.theme +from rich.console import Console + +from rich_click.rich_help_configuration import RichHelpConfiguration + + +def create_console(config: RichHelpConfiguration, file: Optional[IO[str]] = None) -> Console: + """Create a Rich Console configured from Rich Help Configuration. + + Args: + config: Rich Help Configuration instance + file: Optional IO stream to write Rich Console output + Defaults to None. + """ + console = Console( + theme=rich.theme.Theme( + { + "option": config.style_option, + "command": config.style_command, + "argument": config.style_argument, + "switch": config.style_switch, + "metavar": config.style_metavar, + "metavar_sep": config.style_metavar_separator, + "usage": config.style_usage, + } + ), + highlighter=config.highlighter, + color_system=config.color_system, + force_terminal=config.force_terminal, + file=file, + width=config.width, + legacy_windows=config.legacy_windows, + ) + if isinstance(config.max_width, int): + console.width = min(config.max_width, console.size.width) + return console + + +def get_module_config() -> RichHelpConfiguration: + """Get the module-level help configuration. + + A function-level import is used to avoid a circular dependency + between the formatter and formatter operations. + """ + from rich_click.rich_click import get_module_help_configuration + + return get_module_help_configuration() + + +class RichHelpFormatter(click.HelpFormatter): + """Rich Help Formatter. + + This class is a container for the help configuration and Rich Console that + are used internally by the help and error printing methods. + """ + + def __init__( + self, + indent_increment: int = 2, + width: Optional[int] = None, + max_width: Optional[int] = None, + *args: Any, + config: Optional[RichHelpConfiguration] = None, + **kwargs: Any, + ) -> None: + """Create Rich Help Formatter. + + Args: + config: Configuration. + Defaults to None. + """ + if config is not None: + # Rich config overrides width and max width if set. + width = config.width or width + max_width = config.max_width or max_width + super().__init__(indent_increment, width, max_width, *args, **kwargs) + self._config = config or get_module_config() + self._console = create_console(self._config) + + @property + def config(self) -> RichHelpConfiguration: + """Rich Help Configuration.""" + return self._config + + @property + def console(self) -> Console: + """Rich Console created from the help configuration. + + This console is meant only for use with the formatter and should + not be created directly + """ + return self._console + + def write(self, string: str) -> None: + return self._console.print(string) diff --git a/venv/lib/python3.11/site-packages/rich_click/utils.py b/venv/lib/python3.11/site-packages/rich_click/utils.py new file mode 100644 index 0000000..128f8b1 --- /dev/null +++ b/venv/lib/python3.11/site-packages/rich_click/utils.py @@ -0,0 +1,16 @@ +from typing import Any, Optional + + +def truthy(o: Any) -> Optional[bool]: + """Check if string or other obj is truthy.""" + if isinstance(o, str): + if o.lower() in {"y", "yes", "t", "true", "1"}: + return True + elif o.lower() in {"n", "no", "f", "false", "0"}: + return False + else: + return None + elif o is None: + return None + else: + return bool(o) |