3042 lines
111 KiB
Python
3042 lines
111 KiB
Python
import enum
|
|
import errno
|
|
import inspect
|
|
import os
|
|
import sys
|
|
import typing as t
|
|
from collections import abc
|
|
from contextlib import contextmanager
|
|
from contextlib import ExitStack
|
|
from functools import update_wrapper
|
|
from gettext import gettext as _
|
|
from gettext import ngettext
|
|
from itertools import repeat
|
|
from types import TracebackType
|
|
|
|
from . import types
|
|
from .exceptions import Abort
|
|
from .exceptions import BadParameter
|
|
from .exceptions import ClickException
|
|
from .exceptions import Exit
|
|
from .exceptions import MissingParameter
|
|
from .exceptions import UsageError
|
|
from .formatting import HelpFormatter
|
|
from .formatting import join_options
|
|
from .globals import pop_context
|
|
from .globals import push_context
|
|
from .parser import _flag_needs_value
|
|
from .parser import OptionParser
|
|
from .parser import split_opt
|
|
from .termui import confirm
|
|
from .termui import prompt
|
|
from .termui import style
|
|
from .utils import _detect_program_name
|
|
from .utils import _expand_args
|
|
from .utils import echo
|
|
from .utils import make_default_short_help
|
|
from .utils import make_str
|
|
from .utils import PacifyFlushWrapper
|
|
|
|
if t.TYPE_CHECKING:
|
|
import typing_extensions as te
|
|
from .shell_completion import CompletionItem
|
|
|
|
F = t.TypeVar("F", bound=t.Callable[..., t.Any])
|
|
V = t.TypeVar("V")
|
|
|
|
|
|
def _complete_visible_commands(
|
|
ctx: "Context", incomplete: str
|
|
) -> t.Iterator[t.Tuple[str, "Command"]]:
|
|
"""List all the subcommands of a group that start with the
|
|
incomplete value and aren't hidden.
|
|
|
|
:param ctx: Invocation context for the group.
|
|
:param incomplete: Value being completed. May be empty.
|
|
"""
|
|
multi = t.cast(MultiCommand, ctx.command)
|
|
|
|
for name in multi.list_commands(ctx):
|
|
if name.startswith(incomplete):
|
|
command = multi.get_command(ctx, name)
|
|
|
|
if command is not None and not command.hidden:
|
|
yield name, command
|
|
|
|
|
|
def _check_multicommand(
|
|
base_command: "MultiCommand", cmd_name: str, cmd: "Command", register: bool = False
|
|
) -> None:
|
|
if not base_command.chain or not isinstance(cmd, MultiCommand):
|
|
return
|
|
if register:
|
|
hint = (
|
|
"It is not possible to add multi commands as children to"
|
|
" another multi command that is in chain mode."
|
|
)
|
|
else:
|
|
hint = (
|
|
"Found a multi command as subcommand to a multi command"
|
|
" that is in chain mode. This is not supported."
|
|
)
|
|
raise RuntimeError(
|
|
f"{hint}. Command {base_command.name!r} is set to chain and"
|
|
f" {cmd_name!r} was added as a subcommand but it in itself is a"
|
|
f" multi command. ({cmd_name!r} is a {type(cmd).__name__}"
|
|
f" within a chained {type(base_command).__name__} named"
|
|
f" {base_command.name!r})."
|
|
)
|
|
|
|
|
|
def batch(iterable: t.Iterable[V], batch_size: int) -> t.List[t.Tuple[V, ...]]:
|
|
return list(zip(*repeat(iter(iterable), batch_size)))
|
|
|
|
|
|
@contextmanager
|
|
def augment_usage_errors(
|
|
ctx: "Context", param: t.Optional["Parameter"] = None
|
|
) -> t.Iterator[None]:
|
|
"""Context manager that attaches extra information to exceptions."""
|
|
try:
|
|
yield
|
|
except BadParameter as e:
|
|
if e.ctx is None:
|
|
e.ctx = ctx
|
|
if param is not None and e.param is None:
|
|
e.param = param
|
|
raise
|
|
except UsageError as e:
|
|
if e.ctx is None:
|
|
e.ctx = ctx
|
|
raise
|
|
|
|
|
|
def iter_params_for_processing(
|
|
invocation_order: t.Sequence["Parameter"],
|
|
declaration_order: t.Sequence["Parameter"],
|
|
) -> t.List["Parameter"]:
|
|
"""Given a sequence of parameters in the order as should be considered
|
|
for processing and an iterable of parameters that exist, this returns
|
|
a list in the correct order as they should be processed.
|
|
"""
|
|
|
|
def sort_key(item: "Parameter") -> t.Tuple[bool, float]:
|
|
try:
|
|
idx: float = invocation_order.index(item)
|
|
except ValueError:
|
|
idx = float("inf")
|
|
|
|
return not item.is_eager, idx
|
|
|
|
return sorted(declaration_order, key=sort_key)
|
|
|
|
|
|
class ParameterSource(enum.Enum):
|
|
"""This is an :class:`~enum.Enum` that indicates the source of a
|
|
parameter's value.
|
|
|
|
Use :meth:`click.Context.get_parameter_source` to get the
|
|
source for a parameter by name.
|
|
|
|
.. versionchanged:: 8.0
|
|
Use :class:`~enum.Enum` and drop the ``validate`` method.
|
|
|
|
.. versionchanged:: 8.0
|
|
Added the ``PROMPT`` value.
|
|
"""
|
|
|
|
COMMANDLINE = enum.auto()
|
|
"""The value was provided by the command line args."""
|
|
ENVIRONMENT = enum.auto()
|
|
"""The value was provided with an environment variable."""
|
|
DEFAULT = enum.auto()
|
|
"""Used the default specified by the parameter."""
|
|
DEFAULT_MAP = enum.auto()
|
|
"""Used a default provided by :attr:`Context.default_map`."""
|
|
PROMPT = enum.auto()
|
|
"""Used a prompt to confirm a default or provide a value."""
|
|
|
|
|
|
class Context:
|
|
"""The context is a special internal object that holds state relevant
|
|
for the script execution at every single level. It's normally invisible
|
|
to commands unless they opt-in to getting access to it.
|
|
|
|
The context is useful as it can pass internal objects around and can
|
|
control special execution features such as reading data from
|
|
environment variables.
|
|
|
|
A context can be used as context manager in which case it will call
|
|
:meth:`close` on teardown.
|
|
|
|
:param command: the command class for this context.
|
|
:param parent: the parent context.
|
|
:param info_name: the info name for this invocation. Generally this
|
|
is the most descriptive name for the script or
|
|
command. For the toplevel script it is usually
|
|
the name of the script, for commands below it it's
|
|
the name of the script.
|
|
:param obj: an arbitrary object of user data.
|
|
:param auto_envvar_prefix: the prefix to use for automatic environment
|
|
variables. If this is `None` then reading
|
|
from environment variables is disabled. This
|
|
does not affect manually set environment
|
|
variables which are always read.
|
|
:param default_map: a dictionary (like object) with default values
|
|
for parameters.
|
|
:param terminal_width: the width of the terminal. The default is
|
|
inherit from parent context. If no context
|
|
defines the terminal width then auto
|
|
detection will be applied.
|
|
:param max_content_width: the maximum width for content rendered by
|
|
Click (this currently only affects help
|
|
pages). This defaults to 80 characters if
|
|
not overridden. In other words: even if the
|
|
terminal is larger than that, Click will not
|
|
format things wider than 80 characters by
|
|
default. In addition to that, formatters might
|
|
add some safety mapping on the right.
|
|
:param resilient_parsing: if this flag is enabled then Click will
|
|
parse without any interactivity or callback
|
|
invocation. Default values will also be
|
|
ignored. This is useful for implementing
|
|
things such as completion support.
|
|
:param allow_extra_args: if this is set to `True` then extra arguments
|
|
at the end will not raise an error and will be
|
|
kept on the context. The default is to inherit
|
|
from the command.
|
|
:param allow_interspersed_args: if this is set to `False` then options
|
|
and arguments cannot be mixed. The
|
|
default is to inherit from the command.
|
|
:param ignore_unknown_options: instructs click to ignore options it does
|
|
not know and keeps them for later
|
|
processing.
|
|
:param help_option_names: optionally a list of strings that define how
|
|
the default help parameter is named. The
|
|
default is ``['--help']``.
|
|
:param token_normalize_func: an optional function that is used to
|
|
normalize tokens (options, choices,
|
|
etc.). This for instance can be used to
|
|
implement case insensitive behavior.
|
|
:param color: controls if the terminal supports ANSI colors or not. The
|
|
default is autodetection. This is only needed if ANSI
|
|
codes are used in texts that Click prints which is by
|
|
default not the case. This for instance would affect
|
|
help output.
|
|
:param show_default: Show the default value for commands. If this
|
|
value is not set, it defaults to the value from the parent
|
|
context. ``Command.show_default`` overrides this default for the
|
|
specific command.
|
|
|
|
.. versionchanged:: 8.1
|
|
The ``show_default`` parameter is overridden by
|
|
``Command.show_default``, instead of the other way around.
|
|
|
|
.. versionchanged:: 8.0
|
|
The ``show_default`` parameter defaults to the value from the
|
|
parent context.
|
|
|
|
.. versionchanged:: 7.1
|
|
Added the ``show_default`` parameter.
|
|
|
|
.. versionchanged:: 4.0
|
|
Added the ``color``, ``ignore_unknown_options``, and
|
|
``max_content_width`` parameters.
|
|
|
|
.. versionchanged:: 3.0
|
|
Added the ``allow_extra_args`` and ``allow_interspersed_args``
|
|
parameters.
|
|
|
|
.. versionchanged:: 2.0
|
|
Added the ``resilient_parsing``, ``help_option_names``, and
|
|
``token_normalize_func`` parameters.
|
|
"""
|
|
|
|
#: The formatter class to create with :meth:`make_formatter`.
|
|
#:
|
|
#: .. versionadded:: 8.0
|
|
formatter_class: t.Type["HelpFormatter"] = HelpFormatter
|
|
|
|
def __init__(
|
|
self,
|
|
command: "Command",
|
|
parent: t.Optional["Context"] = None,
|
|
info_name: t.Optional[str] = None,
|
|
obj: t.Optional[t.Any] = None,
|
|
auto_envvar_prefix: t.Optional[str] = None,
|
|
default_map: t.Optional[t.MutableMapping[str, t.Any]] = None,
|
|
terminal_width: t.Optional[int] = None,
|
|
max_content_width: t.Optional[int] = None,
|
|
resilient_parsing: bool = False,
|
|
allow_extra_args: t.Optional[bool] = None,
|
|
allow_interspersed_args: t.Optional[bool] = None,
|
|
ignore_unknown_options: t.Optional[bool] = None,
|
|
help_option_names: t.Optional[t.List[str]] = None,
|
|
token_normalize_func: t.Optional[t.Callable[[str], str]] = None,
|
|
color: t.Optional[bool] = None,
|
|
show_default: t.Optional[bool] = None,
|
|
) -> None:
|
|
#: the parent context or `None` if none exists.
|
|
self.parent = parent
|
|
#: the :class:`Command` for this context.
|
|
self.command = command
|
|
#: the descriptive information name
|
|
self.info_name = info_name
|
|
#: Map of parameter names to their parsed values. Parameters
|
|
#: with ``expose_value=False`` are not stored.
|
|
self.params: t.Dict[str, t.Any] = {}
|
|
#: the leftover arguments.
|
|
self.args: t.List[str] = []
|
|
#: protected arguments. These are arguments that are prepended
|
|
#: to `args` when certain parsing scenarios are encountered but
|
|
#: must be never propagated to another arguments. This is used
|
|
#: to implement nested parsing.
|
|
self.protected_args: t.List[str] = []
|
|
#: the collected prefixes of the command's options.
|
|
self._opt_prefixes: t.Set[str] = set(parent._opt_prefixes) if parent else set()
|
|
|
|
if obj is None and parent is not None:
|
|
obj = parent.obj
|
|
|
|
#: the user object stored.
|
|
self.obj: t.Any = obj
|
|
self._meta: t.Dict[str, t.Any] = getattr(parent, "meta", {})
|
|
|
|
#: A dictionary (-like object) with defaults for parameters.
|
|
if (
|
|
default_map is None
|
|
and info_name is not None
|
|
and parent is not None
|
|
and parent.default_map is not None
|
|
):
|
|
default_map = parent.default_map.get(info_name)
|
|
|
|
self.default_map: t.Optional[t.MutableMapping[str, t.Any]] = default_map
|
|
|
|
#: This flag indicates if a subcommand is going to be executed. A
|
|
#: group callback can use this information to figure out if it's
|
|
#: being executed directly or because the execution flow passes
|
|
#: onwards to a subcommand. By default it's None, but it can be
|
|
#: the name of the subcommand to execute.
|
|
#:
|
|
#: If chaining is enabled this will be set to ``'*'`` in case
|
|
#: any commands are executed. It is however not possible to
|
|
#: figure out which ones. If you require this knowledge you
|
|
#: should use a :func:`result_callback`.
|
|
self.invoked_subcommand: t.Optional[str] = None
|
|
|
|
if terminal_width is None and parent is not None:
|
|
terminal_width = parent.terminal_width
|
|
|
|
#: The width of the terminal (None is autodetection).
|
|
self.terminal_width: t.Optional[int] = terminal_width
|
|
|
|
if max_content_width is None and parent is not None:
|
|
max_content_width = parent.max_content_width
|
|
|
|
#: The maximum width of formatted content (None implies a sensible
|
|
#: default which is 80 for most things).
|
|
self.max_content_width: t.Optional[int] = max_content_width
|
|
|
|
if allow_extra_args is None:
|
|
allow_extra_args = command.allow_extra_args
|
|
|
|
#: Indicates if the context allows extra args or if it should
|
|
#: fail on parsing.
|
|
#:
|
|
#: .. versionadded:: 3.0
|
|
self.allow_extra_args = allow_extra_args
|
|
|
|
if allow_interspersed_args is None:
|
|
allow_interspersed_args = command.allow_interspersed_args
|
|
|
|
#: Indicates if the context allows mixing of arguments and
|
|
#: options or not.
|
|
#:
|
|
#: .. versionadded:: 3.0
|
|
self.allow_interspersed_args: bool = allow_interspersed_args
|
|
|
|
if ignore_unknown_options is None:
|
|
ignore_unknown_options = command.ignore_unknown_options
|
|
|
|
#: Instructs click to ignore options that a command does not
|
|
#: understand and will store it on the context for later
|
|
#: processing. This is primarily useful for situations where you
|
|
#: want to call into external programs. Generally this pattern is
|
|
#: strongly discouraged because it's not possibly to losslessly
|
|
#: forward all arguments.
|
|
#:
|
|
#: .. versionadded:: 4.0
|
|
self.ignore_unknown_options: bool = ignore_unknown_options
|
|
|
|
if help_option_names is None:
|
|
if parent is not None:
|
|
help_option_names = parent.help_option_names
|
|
else:
|
|
help_option_names = ["--help"]
|
|
|
|
#: The names for the help options.
|
|
self.help_option_names: t.List[str] = help_option_names
|
|
|
|
if token_normalize_func is None and parent is not None:
|
|
token_normalize_func = parent.token_normalize_func
|
|
|
|
#: An optional normalization function for tokens. This is
|
|
#: options, choices, commands etc.
|
|
self.token_normalize_func: t.Optional[
|
|
t.Callable[[str], str]
|
|
] = token_normalize_func
|
|
|
|
#: Indicates if resilient parsing is enabled. In that case Click
|
|
#: will do its best to not cause any failures and default values
|
|
#: will be ignored. Useful for completion.
|
|
self.resilient_parsing: bool = resilient_parsing
|
|
|
|
# If there is no envvar prefix yet, but the parent has one and
|
|
# the command on this level has a name, we can expand the envvar
|
|
# prefix automatically.
|
|
if auto_envvar_prefix is None:
|
|
if (
|
|
parent is not None
|
|
and parent.auto_envvar_prefix is not None
|
|
and self.info_name is not None
|
|
):
|
|
auto_envvar_prefix = (
|
|
f"{parent.auto_envvar_prefix}_{self.info_name.upper()}"
|
|
)
|
|
else:
|
|
auto_envvar_prefix = auto_envvar_prefix.upper()
|
|
|
|
if auto_envvar_prefix is not None:
|
|
auto_envvar_prefix = auto_envvar_prefix.replace("-", "_")
|
|
|
|
self.auto_envvar_prefix: t.Optional[str] = auto_envvar_prefix
|
|
|
|
if color is None and parent is not None:
|
|
color = parent.color
|
|
|
|
#: Controls if styling output is wanted or not.
|
|
self.color: t.Optional[bool] = color
|
|
|
|
if show_default is None and parent is not None:
|
|
show_default = parent.show_default
|
|
|
|
#: Show option default values when formatting help text.
|
|
self.show_default: t.Optional[bool] = show_default
|
|
|
|
self._close_callbacks: t.List[t.Callable[[], t.Any]] = []
|
|
self._depth = 0
|
|
self._parameter_source: t.Dict[str, ParameterSource] = {}
|
|
self._exit_stack = ExitStack()
|
|
|
|
def to_info_dict(self) -> t.Dict[str, t.Any]:
|
|
"""Gather information that could be useful for a tool generating
|
|
user-facing documentation. This traverses the entire CLI
|
|
structure.
|
|
|
|
.. code-block:: python
|
|
|
|
with Context(cli) as ctx:
|
|
info = ctx.to_info_dict()
|
|
|
|
.. versionadded:: 8.0
|
|
"""
|
|
return {
|
|
"command": self.command.to_info_dict(self),
|
|
"info_name": self.info_name,
|
|
"allow_extra_args": self.allow_extra_args,
|
|
"allow_interspersed_args": self.allow_interspersed_args,
|
|
"ignore_unknown_options": self.ignore_unknown_options,
|
|
"auto_envvar_prefix": self.auto_envvar_prefix,
|
|
}
|
|
|
|
def __enter__(self) -> "Context":
|
|
self._depth += 1
|
|
push_context(self)
|
|
return self
|
|
|
|
def __exit__(
|
|
self,
|
|
exc_type: t.Optional[t.Type[BaseException]],
|
|
exc_value: t.Optional[BaseException],
|
|
tb: t.Optional[TracebackType],
|
|
) -> None:
|
|
self._depth -= 1
|
|
if self._depth == 0:
|
|
self.close()
|
|
pop_context()
|
|
|
|
@contextmanager
|
|
def scope(self, cleanup: bool = True) -> t.Iterator["Context"]:
|
|
"""This helper method can be used with the context object to promote
|
|
it to the current thread local (see :func:`get_current_context`).
|
|
The default behavior of this is to invoke the cleanup functions which
|
|
can be disabled by setting `cleanup` to `False`. The cleanup
|
|
functions are typically used for things such as closing file handles.
|
|
|
|
If the cleanup is intended the context object can also be directly
|
|
used as a context manager.
|
|
|
|
Example usage::
|
|
|
|
with ctx.scope():
|
|
assert get_current_context() is ctx
|
|
|
|
This is equivalent::
|
|
|
|
with ctx:
|
|
assert get_current_context() is ctx
|
|
|
|
.. versionadded:: 5.0
|
|
|
|
:param cleanup: controls if the cleanup functions should be run or
|
|
not. The default is to run these functions. In
|
|
some situations the context only wants to be
|
|
temporarily pushed in which case this can be disabled.
|
|
Nested pushes automatically defer the cleanup.
|
|
"""
|
|
if not cleanup:
|
|
self._depth += 1
|
|
try:
|
|
with self as rv:
|
|
yield rv
|
|
finally:
|
|
if not cleanup:
|
|
self._depth -= 1
|
|
|
|
@property
|
|
def meta(self) -> t.Dict[str, t.Any]:
|
|
"""This is a dictionary which is shared with all the contexts
|
|
that are nested. It exists so that click utilities can store some
|
|
state here if they need to. It is however the responsibility of
|
|
that code to manage this dictionary well.
|
|
|
|
The keys are supposed to be unique dotted strings. For instance
|
|
module paths are a good choice for it. What is stored in there is
|
|
irrelevant for the operation of click. However what is important is
|
|
that code that places data here adheres to the general semantics of
|
|
the system.
|
|
|
|
Example usage::
|
|
|
|
LANG_KEY = f'{__name__}.lang'
|
|
|
|
def set_language(value):
|
|
ctx = get_current_context()
|
|
ctx.meta[LANG_KEY] = value
|
|
|
|
def get_language():
|
|
return get_current_context().meta.get(LANG_KEY, 'en_US')
|
|
|
|
.. versionadded:: 5.0
|
|
"""
|
|
return self._meta
|
|
|
|
def make_formatter(self) -> HelpFormatter:
|
|
"""Creates the :class:`~click.HelpFormatter` for the help and
|
|
usage output.
|
|
|
|
To quickly customize the formatter class used without overriding
|
|
this method, set the :attr:`formatter_class` attribute.
|
|
|
|
.. versionchanged:: 8.0
|
|
Added the :attr:`formatter_class` attribute.
|
|
"""
|
|
return self.formatter_class(
|
|
width=self.terminal_width, max_width=self.max_content_width
|
|
)
|
|
|
|
def with_resource(self, context_manager: t.ContextManager[V]) -> V:
|
|
"""Register a resource as if it were used in a ``with``
|
|
statement. The resource will be cleaned up when the context is
|
|
popped.
|
|
|
|
Uses :meth:`contextlib.ExitStack.enter_context`. It calls the
|
|
resource's ``__enter__()`` method and returns the result. When
|
|
the context is popped, it closes the stack, which calls the
|
|
resource's ``__exit__()`` method.
|
|
|
|
To register a cleanup function for something that isn't a
|
|
context manager, use :meth:`call_on_close`. Or use something
|
|
from :mod:`contextlib` to turn it into a context manager first.
|
|
|
|
.. code-block:: python
|
|
|
|
@click.group()
|
|
@click.option("--name")
|
|
@click.pass_context
|
|
def cli(ctx):
|
|
ctx.obj = ctx.with_resource(connect_db(name))
|
|
|
|
:param context_manager: The context manager to enter.
|
|
:return: Whatever ``context_manager.__enter__()`` returns.
|
|
|
|
.. versionadded:: 8.0
|
|
"""
|
|
return self._exit_stack.enter_context(context_manager)
|
|
|
|
def call_on_close(self, f: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]:
|
|
"""Register a function to be called when the context tears down.
|
|
|
|
This can be used to close resources opened during the script
|
|
execution. Resources that support Python's context manager
|
|
protocol which would be used in a ``with`` statement should be
|
|
registered with :meth:`with_resource` instead.
|
|
|
|
:param f: The function to execute on teardown.
|
|
"""
|
|
return self._exit_stack.callback(f)
|
|
|
|
def close(self) -> None:
|
|
"""Invoke all close callbacks registered with
|
|
:meth:`call_on_close`, and exit all context managers entered
|
|
with :meth:`with_resource`.
|
|
"""
|
|
self._exit_stack.close()
|
|
# In case the context is reused, create a new exit stack.
|
|
self._exit_stack = ExitStack()
|
|
|
|
@property
|
|
def command_path(self) -> str:
|
|
"""The computed command path. This is used for the ``usage``
|
|
information on the help page. It's automatically created by
|
|
combining the info names of the chain of contexts to the root.
|
|
"""
|
|
rv = ""
|
|
if self.info_name is not None:
|
|
rv = self.info_name
|
|
if self.parent is not None:
|
|
parent_command_path = [self.parent.command_path]
|
|
|
|
if isinstance(self.parent.command, Command):
|
|
for param in self.parent.command.get_params(self):
|
|
parent_command_path.extend(param.get_usage_pieces(self))
|
|
|
|
rv = f"{' '.join(parent_command_path)} {rv}"
|
|
return rv.lstrip()
|
|
|
|
def find_root(self) -> "Context":
|
|
"""Finds the outermost context."""
|
|
node = self
|
|
while node.parent is not None:
|
|
node = node.parent
|
|
return node
|
|
|
|
def find_object(self, object_type: t.Type[V]) -> t.Optional[V]:
|
|
"""Finds the closest object of a given type."""
|
|
node: t.Optional["Context"] = self
|
|
|
|
while node is not None:
|
|
if isinstance(node.obj, object_type):
|
|
return node.obj
|
|
|
|
node = node.parent
|
|
|
|
return None
|
|
|
|
def ensure_object(self, object_type: t.Type[V]) -> V:
|
|
"""Like :meth:`find_object` but sets the innermost object to a
|
|
new instance of `object_type` if it does not exist.
|
|
"""
|
|
rv = self.find_object(object_type)
|
|
if rv is None:
|
|
self.obj = rv = object_type()
|
|
return rv
|
|
|
|
@t.overload
|
|
def lookup_default(
|
|
self, name: str, call: "te.Literal[True]" = True
|
|
) -> t.Optional[t.Any]:
|
|
...
|
|
|
|
@t.overload
|
|
def lookup_default(
|
|
self, name: str, call: "te.Literal[False]" = ...
|
|
) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
|
|
...
|
|
|
|
def lookup_default(self, name: str, call: bool = True) -> t.Optional[t.Any]:
|
|
"""Get the default for a parameter from :attr:`default_map`.
|
|
|
|
:param name: Name of the parameter.
|
|
:param call: If the default is a callable, call it. Disable to
|
|
return the callable instead.
|
|
|
|
.. versionchanged:: 8.0
|
|
Added the ``call`` parameter.
|
|
"""
|
|
if self.default_map is not None:
|
|
value = self.default_map.get(name)
|
|
|
|
if call and callable(value):
|
|
return value()
|
|
|
|
return value
|
|
|
|
return None
|
|
|
|
def fail(self, message: str) -> "te.NoReturn":
|
|
"""Aborts the execution of the program with a specific error
|
|
message.
|
|
|
|
:param message: the error message to fail with.
|
|
"""
|
|
raise UsageError(message, self)
|
|
|
|
def abort(self) -> "te.NoReturn":
|
|
"""Aborts the script."""
|
|
raise Abort()
|
|
|
|
def exit(self, code: int = 0) -> "te.NoReturn":
|
|
"""Exits the application with a given exit code."""
|
|
raise Exit(code)
|
|
|
|
def get_usage(self) -> str:
|
|
"""Helper method to get formatted usage string for the current
|
|
context and command.
|
|
"""
|
|
return self.command.get_usage(self)
|
|
|
|
def get_help(self) -> str:
|
|
"""Helper method to get formatted help page for the current
|
|
context and command.
|
|
"""
|
|
return self.command.get_help(self)
|
|
|
|
def _make_sub_context(self, command: "Command") -> "Context":
|
|
"""Create a new context of the same type as this context, but
|
|
for a new command.
|
|
|
|
:meta private:
|
|
"""
|
|
return type(self)(command, info_name=command.name, parent=self)
|
|
|
|
@t.overload
|
|
def invoke(
|
|
__self, # noqa: B902
|
|
__callback: "t.Callable[..., V]",
|
|
*args: t.Any,
|
|
**kwargs: t.Any,
|
|
) -> V:
|
|
...
|
|
|
|
@t.overload
|
|
def invoke(
|
|
__self, # noqa: B902
|
|
__callback: "Command",
|
|
*args: t.Any,
|
|
**kwargs: t.Any,
|
|
) -> t.Any:
|
|
...
|
|
|
|
def invoke(
|
|
__self, # noqa: B902
|
|
__callback: t.Union["Command", "t.Callable[..., V]"],
|
|
*args: t.Any,
|
|
**kwargs: t.Any,
|
|
) -> t.Union[t.Any, V]:
|
|
"""Invokes a command callback in exactly the way it expects. There
|
|
are two ways to invoke this method:
|
|
|
|
1. the first argument can be a callback and all other arguments and
|
|
keyword arguments are forwarded directly to the function.
|
|
2. the first argument is a click command object. In that case all
|
|
arguments are forwarded as well but proper click parameters
|
|
(options and click arguments) must be keyword arguments and Click
|
|
will fill in defaults.
|
|
|
|
Note that before Click 3.2 keyword arguments were not properly filled
|
|
in against the intention of this code and no context was created. For
|
|
more information about this change and why it was done in a bugfix
|
|
release see :ref:`upgrade-to-3.2`.
|
|
|
|
.. versionchanged:: 8.0
|
|
All ``kwargs`` are tracked in :attr:`params` so they will be
|
|
passed if :meth:`forward` is called at multiple levels.
|
|
"""
|
|
if isinstance(__callback, Command):
|
|
other_cmd = __callback
|
|
|
|
if other_cmd.callback is None:
|
|
raise TypeError(
|
|
"The given command does not have a callback that can be invoked."
|
|
)
|
|
else:
|
|
__callback = t.cast("t.Callable[..., V]", other_cmd.callback)
|
|
|
|
ctx = __self._make_sub_context(other_cmd)
|
|
|
|
for param in other_cmd.params:
|
|
if param.name not in kwargs and param.expose_value:
|
|
kwargs[param.name] = param.type_cast_value( # type: ignore
|
|
ctx, param.get_default(ctx)
|
|
)
|
|
|
|
# Track all kwargs as params, so that forward() will pass
|
|
# them on in subsequent calls.
|
|
ctx.params.update(kwargs)
|
|
else:
|
|
ctx = __self
|
|
|
|
with augment_usage_errors(__self):
|
|
with ctx:
|
|
return __callback(*args, **kwargs)
|
|
|
|
def forward(
|
|
__self, __cmd: "Command", *args: t.Any, **kwargs: t.Any # noqa: B902
|
|
) -> t.Any:
|
|
"""Similar to :meth:`invoke` but fills in default keyword
|
|
arguments from the current context if the other command expects
|
|
it. This cannot invoke callbacks directly, only other commands.
|
|
|
|
.. versionchanged:: 8.0
|
|
All ``kwargs`` are tracked in :attr:`params` so they will be
|
|
passed if ``forward`` is called at multiple levels.
|
|
"""
|
|
# Can only forward to other commands, not direct callbacks.
|
|
if not isinstance(__cmd, Command):
|
|
raise TypeError("Callback is not a command.")
|
|
|
|
for param in __self.params:
|
|
if param not in kwargs:
|
|
kwargs[param] = __self.params[param]
|
|
|
|
return __self.invoke(__cmd, *args, **kwargs)
|
|
|
|
def set_parameter_source(self, name: str, source: ParameterSource) -> None:
|
|
"""Set the source of a parameter. This indicates the location
|
|
from which the value of the parameter was obtained.
|
|
|
|
:param name: The name of the parameter.
|
|
:param source: A member of :class:`~click.core.ParameterSource`.
|
|
"""
|
|
self._parameter_source[name] = source
|
|
|
|
def get_parameter_source(self, name: str) -> t.Optional[ParameterSource]:
|
|
"""Get the source of a parameter. This indicates the location
|
|
from which the value of the parameter was obtained.
|
|
|
|
This can be useful for determining when a user specified a value
|
|
on the command line that is the same as the default value. It
|
|
will be :attr:`~click.core.ParameterSource.DEFAULT` only if the
|
|
value was actually taken from the default.
|
|
|
|
:param name: The name of the parameter.
|
|
:rtype: ParameterSource
|
|
|
|
.. versionchanged:: 8.0
|
|
Returns ``None`` if the parameter was not provided from any
|
|
source.
|
|
"""
|
|
return self._parameter_source.get(name)
|
|
|
|
|
|
class BaseCommand:
|
|
"""The base command implements the minimal API contract of commands.
|
|
Most code will never use this as it does not implement a lot of useful
|
|
functionality but it can act as the direct subclass of alternative
|
|
parsing methods that do not depend on the Click parser.
|
|
|
|
For instance, this can be used to bridge Click and other systems like
|
|
argparse or docopt.
|
|
|
|
Because base commands do not implement a lot of the API that other
|
|
parts of Click take for granted, they are not supported for all
|
|
operations. For instance, they cannot be used with the decorators
|
|
usually and they have no built-in callback system.
|
|
|
|
.. versionchanged:: 2.0
|
|
Added the `context_settings` parameter.
|
|
|
|
:param name: the name of the command to use unless a group overrides it.
|
|
:param context_settings: an optional dictionary with defaults that are
|
|
passed to the context object.
|
|
"""
|
|
|
|
#: The context class to create with :meth:`make_context`.
|
|
#:
|
|
#: .. versionadded:: 8.0
|
|
context_class: t.Type[Context] = Context
|
|
#: the default for the :attr:`Context.allow_extra_args` flag.
|
|
allow_extra_args = False
|
|
#: the default for the :attr:`Context.allow_interspersed_args` flag.
|
|
allow_interspersed_args = True
|
|
#: the default for the :attr:`Context.ignore_unknown_options` flag.
|
|
ignore_unknown_options = False
|
|
|
|
def __init__(
|
|
self,
|
|
name: t.Optional[str],
|
|
context_settings: t.Optional[t.MutableMapping[str, t.Any]] = None,
|
|
) -> None:
|
|
#: the name the command thinks it has. Upon registering a command
|
|
#: on a :class:`Group` the group will default the command name
|
|
#: with this information. You should instead use the
|
|
#: :class:`Context`\'s :attr:`~Context.info_name` attribute.
|
|
self.name = name
|
|
|
|
if context_settings is None:
|
|
context_settings = {}
|
|
|
|
#: an optional dictionary with defaults passed to the context.
|
|
self.context_settings: t.MutableMapping[str, t.Any] = context_settings
|
|
|
|
def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
|
|
"""Gather information that could be useful for a tool generating
|
|
user-facing documentation. This traverses the entire structure
|
|
below this command.
|
|
|
|
Use :meth:`click.Context.to_info_dict` to traverse the entire
|
|
CLI structure.
|
|
|
|
:param ctx: A :class:`Context` representing this command.
|
|
|
|
.. versionadded:: 8.0
|
|
"""
|
|
return {"name": self.name}
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<{self.__class__.__name__} {self.name}>"
|
|
|
|
def get_usage(self, ctx: Context) -> str:
|
|
raise NotImplementedError("Base commands cannot get usage")
|
|
|
|
def get_help(self, ctx: Context) -> str:
|
|
raise NotImplementedError("Base commands cannot get help")
|
|
|
|
def make_context(
|
|
self,
|
|
info_name: t.Optional[str],
|
|
args: t.List[str],
|
|
parent: t.Optional[Context] = None,
|
|
**extra: t.Any,
|
|
) -> Context:
|
|
"""This function when given an info name and arguments will kick
|
|
off the parsing and create a new :class:`Context`. It does not
|
|
invoke the actual command callback though.
|
|
|
|
To quickly customize the context class used without overriding
|
|
this method, set the :attr:`context_class` attribute.
|
|
|
|
:param info_name: the info name for this invocation. Generally this
|
|
is the most descriptive name for the script or
|
|
command. For the toplevel script it's usually
|
|
the name of the script, for commands below it's
|
|
the name of the command.
|
|
:param args: the arguments to parse as list of strings.
|
|
:param parent: the parent context if available.
|
|
:param extra: extra keyword arguments forwarded to the context
|
|
constructor.
|
|
|
|
.. versionchanged:: 8.0
|
|
Added the :attr:`context_class` attribute.
|
|
"""
|
|
for key, value in self.context_settings.items():
|
|
if key not in extra:
|
|
extra[key] = value
|
|
|
|
ctx = self.context_class(
|
|
self, info_name=info_name, parent=parent, **extra # type: ignore
|
|
)
|
|
|
|
with ctx.scope(cleanup=False):
|
|
self.parse_args(ctx, args)
|
|
return ctx
|
|
|
|
def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
|
|
"""Given a context and a list of arguments this creates the parser
|
|
and parses the arguments, then modifies the context as necessary.
|
|
This is automatically invoked by :meth:`make_context`.
|
|
"""
|
|
raise NotImplementedError("Base commands do not know how to parse arguments.")
|
|
|
|
def invoke(self, ctx: Context) -> t.Any:
|
|
"""Given a context, this invokes the command. The default
|
|
implementation is raising a not implemented error.
|
|
"""
|
|
raise NotImplementedError("Base commands are not invocable by default")
|
|
|
|
def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
|
|
"""Return a list of completions for the incomplete value. Looks
|
|
at the names of chained multi-commands.
|
|
|
|
Any command could be part of a chained multi-command, so sibling
|
|
commands are valid at any point during command completion. Other
|
|
command classes will return more completions.
|
|
|
|
:param ctx: Invocation context for this command.
|
|
:param incomplete: Value being completed. May be empty.
|
|
|
|
.. versionadded:: 8.0
|
|
"""
|
|
from click.shell_completion import CompletionItem
|
|
|
|
results: t.List["CompletionItem"] = []
|
|
|
|
while ctx.parent is not None:
|
|
ctx = ctx.parent
|
|
|
|
if isinstance(ctx.command, MultiCommand) and ctx.command.chain:
|
|
results.extend(
|
|
CompletionItem(name, help=command.get_short_help_str())
|
|
for name, command in _complete_visible_commands(ctx, incomplete)
|
|
if name not in ctx.protected_args
|
|
)
|
|
|
|
return results
|
|
|
|
@t.overload
|
|
def main(
|
|
self,
|
|
args: t.Optional[t.Sequence[str]] = None,
|
|
prog_name: t.Optional[str] = None,
|
|
complete_var: t.Optional[str] = None,
|
|
standalone_mode: "te.Literal[True]" = True,
|
|
**extra: t.Any,
|
|
) -> "te.NoReturn":
|
|
...
|
|
|
|
@t.overload
|
|
def main(
|
|
self,
|
|
args: t.Optional[t.Sequence[str]] = None,
|
|
prog_name: t.Optional[str] = None,
|
|
complete_var: t.Optional[str] = None,
|
|
standalone_mode: bool = ...,
|
|
**extra: t.Any,
|
|
) -> t.Any:
|
|
...
|
|
|
|
def main(
|
|
self,
|
|
args: t.Optional[t.Sequence[str]] = None,
|
|
prog_name: t.Optional[str] = None,
|
|
complete_var: t.Optional[str] = None,
|
|
standalone_mode: bool = True,
|
|
windows_expand_args: bool = True,
|
|
**extra: t.Any,
|
|
) -> t.Any:
|
|
"""This is the way to invoke a script with all the bells and
|
|
whistles as a command line application. This will always terminate
|
|
the application after a call. If this is not wanted, ``SystemExit``
|
|
needs to be caught.
|
|
|
|
This method is also available by directly calling the instance of
|
|
a :class:`Command`.
|
|
|
|
:param args: the arguments that should be used for parsing. If not
|
|
provided, ``sys.argv[1:]`` is used.
|
|
:param prog_name: the program name that should be used. By default
|
|
the program name is constructed by taking the file
|
|
name from ``sys.argv[0]``.
|
|
:param complete_var: the environment variable that controls the
|
|
bash completion support. The default is
|
|
``"_<prog_name>_COMPLETE"`` with prog_name in
|
|
uppercase.
|
|
:param standalone_mode: the default behavior is to invoke the script
|
|
in standalone mode. Click will then
|
|
handle exceptions and convert them into
|
|
error messages and the function will never
|
|
return but shut down the interpreter. If
|
|
this is set to `False` they will be
|
|
propagated to the caller and the return
|
|
value of this function is the return value
|
|
of :meth:`invoke`.
|
|
:param windows_expand_args: Expand glob patterns, user dir, and
|
|
env vars in command line args on Windows.
|
|
:param extra: extra keyword arguments are forwarded to the context
|
|
constructor. See :class:`Context` for more information.
|
|
|
|
.. versionchanged:: 8.0.1
|
|
Added the ``windows_expand_args`` parameter to allow
|
|
disabling command line arg expansion on Windows.
|
|
|
|
.. versionchanged:: 8.0
|
|
When taking arguments from ``sys.argv`` on Windows, glob
|
|
patterns, user dir, and env vars are expanded.
|
|
|
|
.. versionchanged:: 3.0
|
|
Added the ``standalone_mode`` parameter.
|
|
"""
|
|
if args is None:
|
|
args = sys.argv[1:]
|
|
|
|
if os.name == "nt" and windows_expand_args:
|
|
args = _expand_args(args)
|
|
else:
|
|
args = list(args)
|
|
|
|
if prog_name is None:
|
|
prog_name = _detect_program_name()
|
|
|
|
# Process shell completion requests and exit early.
|
|
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) as e:
|
|
echo(file=sys.stderr)
|
|
raise Abort() from e
|
|
except ClickException as e:
|
|
if not standalone_mode:
|
|
raise
|
|
e.show()
|
|
sys.exit(e.exit_code)
|
|
except OSError as e:
|
|
if e.errno == errno.EPIPE:
|
|
sys.stdout = t.cast(t.TextIO, PacifyFlushWrapper(sys.stdout))
|
|
sys.stderr = t.cast(t.TextIO, PacifyFlushWrapper(sys.stderr))
|
|
sys.exit(1)
|
|
else:
|
|
raise
|
|
except Exit as e:
|
|
if standalone_mode:
|
|
sys.exit(e.exit_code)
|
|
else:
|
|
# in non-standalone mode, return the exit code
|
|
# note that this is only reached if `self.invoke` above raises
|
|
# an Exit explicitly -- thus bypassing the check there which
|
|
# would return its result
|
|
# the results of non-standalone execution may therefore be
|
|
# somewhat ambiguous: if there are codepaths which lead to
|
|
# `ctx.exit(1)` and to `return 1`, the caller won't be able to
|
|
# tell the difference between the two
|
|
return e.exit_code
|
|
except Abort:
|
|
if not standalone_mode:
|
|
raise
|
|
echo(_("Aborted!"), file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
def _main_shell_completion(
|
|
self,
|
|
ctx_args: t.MutableMapping[str, t.Any],
|
|
prog_name: str,
|
|
complete_var: t.Optional[str] = None,
|
|
) -> None:
|
|
"""Check if the shell is asking for tab completion, process
|
|
that, then exit early. Called from :meth:`main` before the
|
|
program is invoked.
|
|
|
|
:param prog_name: Name of the executable in the shell.
|
|
:param complete_var: Name of the environment variable that holds
|
|
the completion instruction. Defaults to
|
|
``_{PROG_NAME}_COMPLETE``.
|
|
|
|
.. versionchanged:: 8.2.0
|
|
Dots (``.``) in ``prog_name`` are replaced with underscores (``_``).
|
|
"""
|
|
if complete_var is None:
|
|
complete_name = prog_name.replace("-", "_").replace(".", "_")
|
|
complete_var = f"_{complete_name}_COMPLETE".upper()
|
|
|
|
instruction = os.environ.get(complete_var)
|
|
|
|
if not instruction:
|
|
return
|
|
|
|
from .shell_completion import shell_complete
|
|
|
|
rv = shell_complete(self, ctx_args, prog_name, complete_var, instruction)
|
|
sys.exit(rv)
|
|
|
|
def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
|
|
"""Alias for :meth:`main`."""
|
|
return self.main(*args, **kwargs)
|
|
|
|
|
|
class Command(BaseCommand):
|
|
"""Commands are the basic building block of command line interfaces in
|
|
Click. A basic command handles command line parsing and might dispatch
|
|
more parsing to commands nested below it.
|
|
|
|
:param name: the name of the command to use unless a group overrides it.
|
|
:param context_settings: an optional dictionary with defaults that are
|
|
passed to the context object.
|
|
:param callback: the callback to invoke. This is optional.
|
|
:param params: the parameters to register with this command. This can
|
|
be either :class:`Option` or :class:`Argument` objects.
|
|
:param help: the help string to use for this command.
|
|
:param epilog: like the help string but it's printed at the end of the
|
|
help page after everything else.
|
|
:param short_help: the short help to use for this command. This is
|
|
shown on the command listing of the parent command.
|
|
:param add_help_option: by default each command registers a ``--help``
|
|
option. This can be disabled by this parameter.
|
|
:param no_args_is_help: this controls what happens if no arguments are
|
|
provided. This option is disabled by default.
|
|
If enabled this will add ``--help`` as argument
|
|
if no arguments are passed
|
|
:param hidden: hide this command from help outputs.
|
|
|
|
:param deprecated: issues a message indicating that
|
|
the command is deprecated.
|
|
|
|
.. versionchanged:: 8.1
|
|
``help``, ``epilog``, and ``short_help`` are stored unprocessed,
|
|
all formatting is done when outputting help text, not at init,
|
|
and is done even if not using the ``@command`` decorator.
|
|
|
|
.. versionchanged:: 8.0
|
|
Added a ``repr`` showing the command name.
|
|
|
|
.. versionchanged:: 7.1
|
|
Added the ``no_args_is_help`` parameter.
|
|
|
|
.. versionchanged:: 2.0
|
|
Added the ``context_settings`` parameter.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
name: t.Optional[str],
|
|
context_settings: t.Optional[t.MutableMapping[str, t.Any]] = None,
|
|
callback: t.Optional[t.Callable[..., t.Any]] = None,
|
|
params: t.Optional[t.List["Parameter"]] = None,
|
|
help: t.Optional[str] = None,
|
|
epilog: t.Optional[str] = None,
|
|
short_help: t.Optional[str] = None,
|
|
options_metavar: t.Optional[str] = "[OPTIONS]",
|
|
add_help_option: bool = True,
|
|
no_args_is_help: bool = False,
|
|
hidden: bool = False,
|
|
deprecated: bool = False,
|
|
) -> None:
|
|
super().__init__(name, context_settings)
|
|
#: the callback to execute when the command fires. This might be
|
|
#: `None` in which case nothing happens.
|
|
self.callback = callback
|
|
#: the list of parameters for this command in the order they
|
|
#: should show up in the help page and execute. Eager parameters
|
|
#: will automatically be handled before non eager ones.
|
|
self.params: t.List["Parameter"] = params or []
|
|
self.help = help
|
|
self.epilog = epilog
|
|
self.options_metavar = options_metavar
|
|
self.short_help = short_help
|
|
self.add_help_option = add_help_option
|
|
self.no_args_is_help = no_args_is_help
|
|
self.hidden = hidden
|
|
self.deprecated = deprecated
|
|
|
|
def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
|
|
info_dict = super().to_info_dict(ctx)
|
|
info_dict.update(
|
|
params=[param.to_info_dict() for param in self.get_params(ctx)],
|
|
help=self.help,
|
|
epilog=self.epilog,
|
|
short_help=self.short_help,
|
|
hidden=self.hidden,
|
|
deprecated=self.deprecated,
|
|
)
|
|
return info_dict
|
|
|
|
def get_usage(self, ctx: Context) -> str:
|
|
"""Formats the usage line into a string and returns it.
|
|
|
|
Calls :meth:`format_usage` internally.
|
|
"""
|
|
formatter = ctx.make_formatter()
|
|
self.format_usage(ctx, formatter)
|
|
return formatter.getvalue().rstrip("\n")
|
|
|
|
def get_params(self, ctx: Context) -> t.List["Parameter"]:
|
|
rv = self.params
|
|
help_option = self.get_help_option(ctx)
|
|
|
|
if help_option is not None:
|
|
rv = [*rv, help_option]
|
|
|
|
return rv
|
|
|
|
def format_usage(self, ctx: Context, formatter: HelpFormatter) -> None:
|
|
"""Writes the usage line into the formatter.
|
|
|
|
This is a low-level method called by :meth:`get_usage`.
|
|
"""
|
|
pieces = self.collect_usage_pieces(ctx)
|
|
formatter.write_usage(ctx.command_path, " ".join(pieces))
|
|
|
|
def collect_usage_pieces(self, ctx: Context) -> t.List[str]:
|
|
"""Returns all the pieces that go into the usage line and returns
|
|
it as a list of strings.
|
|
"""
|
|
rv = [self.options_metavar] if self.options_metavar else []
|
|
|
|
for param in self.get_params(ctx):
|
|
rv.extend(param.get_usage_pieces(ctx))
|
|
|
|
return rv
|
|
|
|
def get_help_option_names(self, ctx: Context) -> t.List[str]:
|
|
"""Returns the names for the help option."""
|
|
all_names = set(ctx.help_option_names)
|
|
for param in self.params:
|
|
all_names.difference_update(param.opts)
|
|
all_names.difference_update(param.secondary_opts)
|
|
return list(all_names)
|
|
|
|
def get_help_option(self, ctx: Context) -> t.Optional["Option"]:
|
|
"""Returns the help option object."""
|
|
help_options = self.get_help_option_names(ctx)
|
|
|
|
if not help_options or not self.add_help_option:
|
|
return None
|
|
|
|
def show_help(ctx: Context, param: "Parameter", value: str) -> None:
|
|
if value and not ctx.resilient_parsing:
|
|
echo(ctx.get_help(), color=ctx.color)
|
|
ctx.exit()
|
|
|
|
return Option(
|
|
help_options,
|
|
is_flag=True,
|
|
is_eager=True,
|
|
expose_value=False,
|
|
callback=show_help,
|
|
help=_("Show this message and exit."),
|
|
)
|
|
|
|
def make_parser(self, ctx: Context) -> OptionParser:
|
|
"""Creates the underlying option parser for this command."""
|
|
parser = OptionParser(ctx)
|
|
for param in self.get_params(ctx):
|
|
param.add_to_parser(parser, ctx)
|
|
return parser
|
|
|
|
def get_help(self, ctx: Context) -> str:
|
|
"""Formats the help into a string and returns it.
|
|
|
|
Calls :meth:`format_help` internally.
|
|
"""
|
|
formatter = ctx.make_formatter()
|
|
self.format_help(ctx, formatter)
|
|
return formatter.getvalue().rstrip("\n")
|
|
|
|
def get_short_help_str(self, limit: int = 45) -> str:
|
|
"""Gets short help for the command or makes it by shortening the
|
|
long help string.
|
|
"""
|
|
if self.short_help:
|
|
text = inspect.cleandoc(self.short_help)
|
|
elif self.help:
|
|
text = make_default_short_help(self.help, limit)
|
|
else:
|
|
text = ""
|
|
|
|
if self.deprecated:
|
|
text = _("(Deprecated) {text}").format(text=text)
|
|
|
|
return text.strip()
|
|
|
|
def format_help(self, ctx: Context, formatter: HelpFormatter) -> None:
|
|
"""Writes the help into the formatter if it exists.
|
|
|
|
This is a low-level method called by :meth:`get_help`.
|
|
|
|
This calls the following methods:
|
|
|
|
- :meth:`format_usage`
|
|
- :meth:`format_help_text`
|
|
- :meth:`format_options`
|
|
- :meth:`format_epilog`
|
|
"""
|
|
self.format_usage(ctx, formatter)
|
|
self.format_help_text(ctx, formatter)
|
|
self.format_options(ctx, formatter)
|
|
self.format_epilog(ctx, formatter)
|
|
|
|
def format_help_text(self, ctx: Context, formatter: HelpFormatter) -> None:
|
|
"""Writes the help text to the formatter if it exists."""
|
|
if self.help is not None:
|
|
# truncate the help text to the first form feed
|
|
text = inspect.cleandoc(self.help).partition("\f")[0]
|
|
else:
|
|
text = ""
|
|
|
|
if self.deprecated:
|
|
text = _("(Deprecated) {text}").format(text=text)
|
|
|
|
if text:
|
|
formatter.write_paragraph()
|
|
|
|
with formatter.indentation():
|
|
formatter.write_text(text)
|
|
|
|
def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
|
|
"""Writes all the options into the formatter if they exist."""
|
|
opts = []
|
|
for param in self.get_params(ctx):
|
|
rv = param.get_help_record(ctx)
|
|
if rv is not None:
|
|
opts.append(rv)
|
|
|
|
if opts:
|
|
with formatter.section(_("Options")):
|
|
formatter.write_dl(opts)
|
|
|
|
def format_epilog(self, ctx: Context, formatter: HelpFormatter) -> None:
|
|
"""Writes the epilog into the formatter if it exists."""
|
|
if self.epilog:
|
|
epilog = inspect.cleandoc(self.epilog)
|
|
formatter.write_paragraph()
|
|
|
|
with formatter.indentation():
|
|
formatter.write_text(epilog)
|
|
|
|
def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
|
|
if not args and self.no_args_is_help and not ctx.resilient_parsing:
|
|
echo(ctx.get_help(), color=ctx.color)
|
|
ctx.exit()
|
|
|
|
parser = self.make_parser(ctx)
|
|
opts, args, param_order = parser.parse_args(args=args)
|
|
|
|
for param in iter_params_for_processing(param_order, self.get_params(ctx)):
|
|
value, args = param.handle_parse_result(ctx, opts, args)
|
|
|
|
if args and not ctx.allow_extra_args and not ctx.resilient_parsing:
|
|
ctx.fail(
|
|
ngettext(
|
|
"Got unexpected extra argument ({args})",
|
|
"Got unexpected extra arguments ({args})",
|
|
len(args),
|
|
).format(args=" ".join(map(str, args)))
|
|
)
|
|
|
|
ctx.args = args
|
|
ctx._opt_prefixes.update(parser._opt_prefixes)
|
|
return args
|
|
|
|
def invoke(self, ctx: Context) -> t.Any:
|
|
"""Given a context, this invokes the attached callback (if it exists)
|
|
in the right way.
|
|
"""
|
|
if self.deprecated:
|
|
message = _(
|
|
"DeprecationWarning: The command {name!r} is deprecated."
|
|
).format(name=self.name)
|
|
echo(style(message, fg="red"), err=True)
|
|
|
|
if self.callback is not None:
|
|
return ctx.invoke(self.callback, **ctx.params)
|
|
|
|
def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
|
|
"""Return a list of completions for the incomplete value. Looks
|
|
at the names of options and chained multi-commands.
|
|
|
|
:param ctx: Invocation context for this command.
|
|
:param incomplete: Value being completed. May be empty.
|
|
|
|
.. versionadded:: 8.0
|
|
"""
|
|
from click.shell_completion import CompletionItem
|
|
|
|
results: t.List["CompletionItem"] = []
|
|
|
|
if incomplete and not incomplete[0].isalnum():
|
|
for param in self.get_params(ctx):
|
|
if (
|
|
not isinstance(param, Option)
|
|
or param.hidden
|
|
or (
|
|
not param.multiple
|
|
and ctx.get_parameter_source(param.name) # type: ignore
|
|
is ParameterSource.COMMANDLINE
|
|
)
|
|
):
|
|
continue
|
|
|
|
results.extend(
|
|
CompletionItem(name, help=param.help)
|
|
for name in [*param.opts, *param.secondary_opts]
|
|
if name.startswith(incomplete)
|
|
)
|
|
|
|
results.extend(super().shell_complete(ctx, incomplete))
|
|
return results
|
|
|
|
|
|
class MultiCommand(Command):
|
|
"""A multi command is the basic implementation of a command that
|
|
dispatches to subcommands. The most common version is the
|
|
:class:`Group`.
|
|
|
|
:param invoke_without_command: this controls how the multi command itself
|
|
is invoked. By default it's only invoked
|
|
if a subcommand is provided.
|
|
:param no_args_is_help: this controls what happens if no arguments are
|
|
provided. This option is enabled by default if
|
|
`invoke_without_command` is disabled or disabled
|
|
if it's enabled. If enabled this will add
|
|
``--help`` as argument if no arguments are
|
|
passed.
|
|
:param subcommand_metavar: the string that is used in the documentation
|
|
to indicate the subcommand place.
|
|
:param chain: if this is set to `True` chaining of multiple subcommands
|
|
is enabled. This restricts the form of commands in that
|
|
they cannot have optional arguments but it allows
|
|
multiple commands to be chained together.
|
|
:param result_callback: The result callback to attach to this multi
|
|
command. This can be set or changed later with the
|
|
:meth:`result_callback` decorator.
|
|
:param attrs: Other command arguments described in :class:`Command`.
|
|
"""
|
|
|
|
allow_extra_args = True
|
|
allow_interspersed_args = False
|
|
|
|
def __init__(
|
|
self,
|
|
name: t.Optional[str] = None,
|
|
invoke_without_command: bool = False,
|
|
no_args_is_help: t.Optional[bool] = None,
|
|
subcommand_metavar: t.Optional[str] = None,
|
|
chain: bool = False,
|
|
result_callback: t.Optional[t.Callable[..., t.Any]] = None,
|
|
**attrs: t.Any,
|
|
) -> None:
|
|
super().__init__(name, **attrs)
|
|
|
|
if no_args_is_help is None:
|
|
no_args_is_help = not invoke_without_command
|
|
|
|
self.no_args_is_help = no_args_is_help
|
|
self.invoke_without_command = invoke_without_command
|
|
|
|
if subcommand_metavar is None:
|
|
if chain:
|
|
subcommand_metavar = "COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]..."
|
|
else:
|
|
subcommand_metavar = "COMMAND [ARGS]..."
|
|
|
|
self.subcommand_metavar = subcommand_metavar
|
|
self.chain = chain
|
|
# The result callback that is stored. This can be set or
|
|
# overridden with the :func:`result_callback` decorator.
|
|
self._result_callback = result_callback
|
|
|
|
if self.chain:
|
|
for param in self.params:
|
|
if isinstance(param, Argument) and not param.required:
|
|
raise RuntimeError(
|
|
"Multi commands in chain mode cannot have"
|
|
" optional arguments."
|
|
)
|
|
|
|
def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
|
|
info_dict = super().to_info_dict(ctx)
|
|
commands = {}
|
|
|
|
for name in self.list_commands(ctx):
|
|
command = self.get_command(ctx, name)
|
|
|
|
if command is None:
|
|
continue
|
|
|
|
sub_ctx = ctx._make_sub_context(command)
|
|
|
|
with sub_ctx.scope(cleanup=False):
|
|
commands[name] = command.to_info_dict(sub_ctx)
|
|
|
|
info_dict.update(commands=commands, chain=self.chain)
|
|
return info_dict
|
|
|
|
def collect_usage_pieces(self, ctx: Context) -> t.List[str]:
|
|
rv = super().collect_usage_pieces(ctx)
|
|
rv.append(self.subcommand_metavar)
|
|
return rv
|
|
|
|
def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
|
|
super().format_options(ctx, formatter)
|
|
self.format_commands(ctx, formatter)
|
|
|
|
def result_callback(self, replace: bool = False) -> t.Callable[[F], F]:
|
|
"""Adds a result callback to the command. By default if a
|
|
result callback is already registered this will chain them but
|
|
this can be disabled with the `replace` parameter. The result
|
|
callback is invoked with the return value of the subcommand
|
|
(or the list of return values from all subcommands if chaining
|
|
is enabled) as well as the parameters as they would be passed
|
|
to the main callback.
|
|
|
|
Example::
|
|
|
|
@click.group()
|
|
@click.option('-i', '--input', default=23)
|
|
def cli(input):
|
|
return 42
|
|
|
|
@cli.result_callback()
|
|
def process_result(result, input):
|
|
return result + input
|
|
|
|
:param replace: if set to `True` an already existing result
|
|
callback will be removed.
|
|
|
|
.. versionchanged:: 8.0
|
|
Renamed from ``resultcallback``.
|
|
|
|
.. versionadded:: 3.0
|
|
"""
|
|
|
|
def decorator(f: F) -> F:
|
|
old_callback = self._result_callback
|
|
|
|
if old_callback is None or replace:
|
|
self._result_callback = f
|
|
return f
|
|
|
|
def function(__value, *args, **kwargs): # type: ignore
|
|
inner = old_callback(__value, *args, **kwargs)
|
|
return f(inner, *args, **kwargs)
|
|
|
|
self._result_callback = rv = update_wrapper(t.cast(F, function), f)
|
|
return rv
|
|
|
|
return decorator
|
|
|
|
def format_commands(self, ctx: Context, formatter: HelpFormatter) -> None:
|
|
"""Extra format methods for multi methods that adds all the commands
|
|
after the options.
|
|
"""
|
|
commands = []
|
|
for subcommand in self.list_commands(ctx):
|
|
cmd = self.get_command(ctx, subcommand)
|
|
# What is this, the tool lied about a command. Ignore it
|
|
if cmd is None:
|
|
continue
|
|
if cmd.hidden:
|
|
continue
|
|
|
|
commands.append((subcommand, cmd))
|
|
|
|
# allow for 3 times the default spacing
|
|
if len(commands):
|
|
limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
|
|
|
|
rows = []
|
|
for subcommand, cmd in commands:
|
|
help = cmd.get_short_help_str(limit)
|
|
rows.append((subcommand, help))
|
|
|
|
if rows:
|
|
with formatter.section(_("Commands")):
|
|
formatter.write_dl(rows)
|
|
|
|
def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
|
|
if not args and self.no_args_is_help and not ctx.resilient_parsing:
|
|
echo(ctx.get_help(), color=ctx.color)
|
|
ctx.exit()
|
|
|
|
rest = super().parse_args(ctx, args)
|
|
|
|
if self.chain:
|
|
ctx.protected_args = rest
|
|
ctx.args = []
|
|
elif rest:
|
|
ctx.protected_args, ctx.args = rest[:1], rest[1:]
|
|
|
|
return ctx.args
|
|
|
|
def invoke(self, ctx: Context) -> t.Any:
|
|
def _process_result(value: t.Any) -> t.Any:
|
|
if self._result_callback is not None:
|
|
value = ctx.invoke(self._result_callback, value, **ctx.params)
|
|
return value
|
|
|
|
if not ctx.protected_args:
|
|
if self.invoke_without_command:
|
|
# No subcommand was invoked, so the result callback is
|
|
# invoked with the group return value for regular
|
|
# groups, or an empty list for chained groups.
|
|
with ctx:
|
|
rv = super().invoke(ctx)
|
|
return _process_result([] if self.chain else rv)
|
|
ctx.fail(_("Missing command."))
|
|
|
|
# Fetch args back out
|
|
args = [*ctx.protected_args, *ctx.args]
|
|
ctx.args = []
|
|
ctx.protected_args = []
|
|
|
|
# If we're not in chain mode, we only allow the invocation of a
|
|
# single command but we also inform the current context about the
|
|
# name of the command to invoke.
|
|
if not self.chain:
|
|
# Make sure the context is entered so we do not clean up
|
|
# resources until the result processor has worked.
|
|
with ctx:
|
|
cmd_name, cmd, args = self.resolve_command(ctx, args)
|
|
assert cmd is not None
|
|
ctx.invoked_subcommand = cmd_name
|
|
super().invoke(ctx)
|
|
sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)
|
|
with sub_ctx:
|
|
return _process_result(sub_ctx.command.invoke(sub_ctx))
|
|
|
|
# In chain mode we create the contexts step by step, but after the
|
|
# base command has been invoked. Because at that point we do not
|
|
# know the subcommands yet, the invoked subcommand attribute is
|
|
# set to ``*`` to inform the command that subcommands are executed
|
|
# but nothing else.
|
|
with ctx:
|
|
ctx.invoked_subcommand = "*" if args else None
|
|
super().invoke(ctx)
|
|
|
|
# Otherwise we make every single context and invoke them in a
|
|
# chain. In that case the return value to the result processor
|
|
# is the list of all invoked subcommand's results.
|
|
contexts = []
|
|
while args:
|
|
cmd_name, cmd, args = self.resolve_command(ctx, args)
|
|
assert cmd is not None
|
|
sub_ctx = cmd.make_context(
|
|
cmd_name,
|
|
args,
|
|
parent=ctx,
|
|
allow_extra_args=True,
|
|
allow_interspersed_args=False,
|
|
)
|
|
contexts.append(sub_ctx)
|
|
args, sub_ctx.args = sub_ctx.args, []
|
|
|
|
rv = []
|
|
for sub_ctx in contexts:
|
|
with sub_ctx:
|
|
rv.append(sub_ctx.command.invoke(sub_ctx))
|
|
return _process_result(rv)
|
|
|
|
def resolve_command(
|
|
self, ctx: Context, args: t.List[str]
|
|
) -> t.Tuple[t.Optional[str], t.Optional[Command], t.List[str]]:
|
|
cmd_name = make_str(args[0])
|
|
original_cmd_name = cmd_name
|
|
|
|
# Get the command
|
|
cmd = self.get_command(ctx, cmd_name)
|
|
|
|
# If we can't find the command but there is a normalization
|
|
# function available, we try with that one.
|
|
if cmd is None and ctx.token_normalize_func is not None:
|
|
cmd_name = ctx.token_normalize_func(cmd_name)
|
|
cmd = self.get_command(ctx, cmd_name)
|
|
|
|
# If we don't find the command we want to show an error message
|
|
# to the user that it was not provided. However, there is
|
|
# something else we should do: if the first argument looks like
|
|
# an option we want to kick off parsing again for arguments to
|
|
# resolve things like --help which now should go to the main
|
|
# place.
|
|
if cmd is None and not ctx.resilient_parsing:
|
|
if split_opt(cmd_name)[0]:
|
|
self.parse_args(ctx, ctx.args)
|
|
ctx.fail(_("No such command {name!r}.").format(name=original_cmd_name))
|
|
return cmd_name if cmd else None, cmd, args[1:]
|
|
|
|
def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
|
|
"""Given a context and a command name, this returns a
|
|
:class:`Command` object if it exists or returns `None`.
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def list_commands(self, ctx: Context) -> t.List[str]:
|
|
"""Returns a list of subcommand names in the order they should
|
|
appear.
|
|
"""
|
|
return []
|
|
|
|
def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
|
|
"""Return a list of completions for the incomplete value. Looks
|
|
at the names of options, subcommands, and chained
|
|
multi-commands.
|
|
|
|
:param ctx: Invocation context for this command.
|
|
:param incomplete: Value being completed. May be empty.
|
|
|
|
.. versionadded:: 8.0
|
|
"""
|
|
from click.shell_completion import CompletionItem
|
|
|
|
results = [
|
|
CompletionItem(name, help=command.get_short_help_str())
|
|
for name, command in _complete_visible_commands(ctx, incomplete)
|
|
]
|
|
results.extend(super().shell_complete(ctx, incomplete))
|
|
return results
|
|
|
|
|
|
class Group(MultiCommand):
|
|
"""A group allows a command to have subcommands attached. This is
|
|
the most common way to implement nesting in Click.
|
|
|
|
:param name: The name of the group command.
|
|
:param commands: A dict mapping names to :class:`Command` objects.
|
|
Can also be a list of :class:`Command`, which will use
|
|
:attr:`Command.name` to create the dict.
|
|
:param attrs: Other command arguments described in
|
|
:class:`MultiCommand`, :class:`Command`, and
|
|
:class:`BaseCommand`.
|
|
|
|
.. versionchanged:: 8.0
|
|
The ``commands`` argument can be a list of command objects.
|
|
"""
|
|
|
|
#: If set, this is used by the group's :meth:`command` decorator
|
|
#: as the default :class:`Command` class. This is useful to make all
|
|
#: subcommands use a custom command class.
|
|
#:
|
|
#: .. versionadded:: 8.0
|
|
command_class: t.Optional[t.Type[Command]] = None
|
|
|
|
#: If set, this is used by the group's :meth:`group` decorator
|
|
#: as the default :class:`Group` class. This is useful to make all
|
|
#: subgroups use a custom group class.
|
|
#:
|
|
#: If set to the special value :class:`type` (literally
|
|
#: ``group_class = type``), this group's class will be used as the
|
|
#: default class. This makes a custom group class continue to make
|
|
#: custom groups.
|
|
#:
|
|
#: .. versionadded:: 8.0
|
|
group_class: t.Optional[t.Union[t.Type["Group"], t.Type[type]]] = None
|
|
# Literal[type] isn't valid, so use Type[type]
|
|
|
|
def __init__(
|
|
self,
|
|
name: t.Optional[str] = None,
|
|
commands: t.Optional[
|
|
t.Union[t.MutableMapping[str, Command], t.Sequence[Command]]
|
|
] = None,
|
|
**attrs: t.Any,
|
|
) -> None:
|
|
super().__init__(name, **attrs)
|
|
|
|
if commands is None:
|
|
commands = {}
|
|
elif isinstance(commands, abc.Sequence):
|
|
commands = {c.name: c for c in commands if c.name is not None}
|
|
|
|
#: The registered subcommands by their exported names.
|
|
self.commands: t.MutableMapping[str, Command] = commands
|
|
|
|
def add_command(self, cmd: Command, name: t.Optional[str] = None) -> None:
|
|
"""Registers another :class:`Command` with this group. If the name
|
|
is not provided, the name of the command is used.
|
|
"""
|
|
name = name or cmd.name
|
|
if name is None:
|
|
raise TypeError("Command has no name.")
|
|
_check_multicommand(self, name, cmd, register=True)
|
|
self.commands[name] = cmd
|
|
|
|
@t.overload
|
|
def command(self, __func: t.Callable[..., t.Any]) -> Command:
|
|
...
|
|
|
|
@t.overload
|
|
def command(
|
|
self, *args: t.Any, **kwargs: t.Any
|
|
) -> t.Callable[[t.Callable[..., t.Any]], Command]:
|
|
...
|
|
|
|
def command(
|
|
self, *args: t.Any, **kwargs: t.Any
|
|
) -> t.Union[t.Callable[[t.Callable[..., t.Any]], Command], Command]:
|
|
"""A shortcut decorator for declaring and attaching a command to
|
|
the group. This takes the same arguments as :func:`command` and
|
|
immediately registers the created command with this group by
|
|
calling :meth:`add_command`.
|
|
|
|
To customize the command class used, set the
|
|
:attr:`command_class` attribute.
|
|
|
|
.. versionchanged:: 8.1
|
|
This decorator can be applied without parentheses.
|
|
|
|
.. versionchanged:: 8.0
|
|
Added the :attr:`command_class` attribute.
|
|
"""
|
|
from .decorators import command
|
|
|
|
func: t.Optional[t.Callable[..., t.Any]] = None
|
|
|
|
if args and callable(args[0]):
|
|
assert (
|
|
len(args) == 1 and not kwargs
|
|
), "Use 'command(**kwargs)(callable)' to provide arguments."
|
|
(func,) = args
|
|
args = ()
|
|
|
|
if self.command_class and kwargs.get("cls") is None:
|
|
kwargs["cls"] = self.command_class
|
|
|
|
def decorator(f: t.Callable[..., t.Any]) -> Command:
|
|
cmd: Command = command(*args, **kwargs)(f)
|
|
self.add_command(cmd)
|
|
return cmd
|
|
|
|
if func is not None:
|
|
return decorator(func)
|
|
|
|
return decorator
|
|
|
|
@t.overload
|
|
def group(self, __func: t.Callable[..., t.Any]) -> "Group":
|
|
...
|
|
|
|
@t.overload
|
|
def group(
|
|
self, *args: t.Any, **kwargs: t.Any
|
|
) -> t.Callable[[t.Callable[..., t.Any]], "Group"]:
|
|
...
|
|
|
|
def group(
|
|
self, *args: t.Any, **kwargs: t.Any
|
|
) -> t.Union[t.Callable[[t.Callable[..., t.Any]], "Group"], "Group"]:
|
|
"""A shortcut decorator for declaring and attaching a group to
|
|
the group. This takes the same arguments as :func:`group` and
|
|
immediately registers the created group with this group by
|
|
calling :meth:`add_command`.
|
|
|
|
To customize the group class used, set the :attr:`group_class`
|
|
attribute.
|
|
|
|
.. versionchanged:: 8.1
|
|
This decorator can be applied without parentheses.
|
|
|
|
.. versionchanged:: 8.0
|
|
Added the :attr:`group_class` attribute.
|
|
"""
|
|
from .decorators import group
|
|
|
|
func: t.Optional[t.Callable[..., t.Any]] = None
|
|
|
|
if args and callable(args[0]):
|
|
assert (
|
|
len(args) == 1 and not kwargs
|
|
), "Use 'group(**kwargs)(callable)' to provide arguments."
|
|
(func,) = args
|
|
args = ()
|
|
|
|
if self.group_class is not None and kwargs.get("cls") is None:
|
|
if self.group_class is type:
|
|
kwargs["cls"] = type(self)
|
|
else:
|
|
kwargs["cls"] = self.group_class
|
|
|
|
def decorator(f: t.Callable[..., t.Any]) -> "Group":
|
|
cmd: Group = group(*args, **kwargs)(f)
|
|
self.add_command(cmd)
|
|
return cmd
|
|
|
|
if func is not None:
|
|
return decorator(func)
|
|
|
|
return decorator
|
|
|
|
def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
|
|
return self.commands.get(cmd_name)
|
|
|
|
def list_commands(self, ctx: Context) -> t.List[str]:
|
|
return sorted(self.commands)
|
|
|
|
|
|
class CommandCollection(MultiCommand):
|
|
"""A command collection is a multi command that merges multiple multi
|
|
commands together into one. This is a straightforward implementation
|
|
that accepts a list of different multi commands as sources and
|
|
provides all the commands for each of them.
|
|
|
|
See :class:`MultiCommand` and :class:`Command` for the description of
|
|
``name`` and ``attrs``.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
name: t.Optional[str] = None,
|
|
sources: t.Optional[t.List[MultiCommand]] = None,
|
|
**attrs: t.Any,
|
|
) -> None:
|
|
super().__init__(name, **attrs)
|
|
#: The list of registered multi commands.
|
|
self.sources: t.List[MultiCommand] = sources or []
|
|
|
|
def add_source(self, multi_cmd: MultiCommand) -> None:
|
|
"""Adds a new multi command to the chain dispatcher."""
|
|
self.sources.append(multi_cmd)
|
|
|
|
def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
|
|
for source in self.sources:
|
|
rv = source.get_command(ctx, cmd_name)
|
|
|
|
if rv is not None:
|
|
if self.chain:
|
|
_check_multicommand(self, cmd_name, rv)
|
|
|
|
return rv
|
|
|
|
return None
|
|
|
|
def list_commands(self, ctx: Context) -> t.List[str]:
|
|
rv: t.Set[str] = set()
|
|
|
|
for source in self.sources:
|
|
rv.update(source.list_commands(ctx))
|
|
|
|
return sorted(rv)
|
|
|
|
|
|
def _check_iter(value: t.Any) -> t.Iterator[t.Any]:
|
|
"""Check if the value is iterable but not a string. Raises a type
|
|
error, or return an iterator over the value.
|
|
"""
|
|
if isinstance(value, str):
|
|
raise TypeError
|
|
|
|
return iter(value)
|
|
|
|
|
|
class Parameter:
|
|
r"""A parameter to a command comes in two versions: they are either
|
|
:class:`Option`\s or :class:`Argument`\s. Other subclasses are currently
|
|
not supported by design as some of the internals for parsing are
|
|
intentionally not finalized.
|
|
|
|
Some settings are supported by both options and arguments.
|
|
|
|
:param param_decls: the parameter declarations for this option or
|
|
argument. This is a list of flags or argument
|
|
names.
|
|
:param type: the type that should be used. Either a :class:`ParamType`
|
|
or a Python type. The latter is converted into the former
|
|
automatically if supported.
|
|
:param required: controls if this is optional or not.
|
|
:param default: the default value if omitted. This can also be a callable,
|
|
in which case it's invoked when the default is needed
|
|
without any arguments.
|
|
:param callback: A function to further process or validate the value
|
|
after type conversion. It is called as ``f(ctx, param, value)``
|
|
and must return the value. It is called for all sources,
|
|
including prompts.
|
|
:param nargs: the number of arguments to match. If not ``1`` the return
|
|
value is a tuple instead of single value. The default for
|
|
nargs is ``1`` (except if the type is a tuple, then it's
|
|
the arity of the tuple). If ``nargs=-1``, all remaining
|
|
parameters are collected.
|
|
:param metavar: how the value is represented in the help page.
|
|
:param expose_value: if this is `True` then the value is passed onwards
|
|
to the command callback and stored on the context,
|
|
otherwise it's skipped.
|
|
:param is_eager: eager values are processed before non eager ones. This
|
|
should not be set for arguments or it will inverse the
|
|
order of processing.
|
|
:param envvar: a string or list of strings that are environment variables
|
|
that should be checked.
|
|
:param shell_complete: A function that returns custom shell
|
|
completions. Used instead of the param's type completion if
|
|
given. Takes ``ctx, param, incomplete`` and must return a list
|
|
of :class:`~click.shell_completion.CompletionItem` or a list of
|
|
strings.
|
|
|
|
.. versionchanged:: 8.0
|
|
``process_value`` validates required parameters and bounded
|
|
``nargs``, and invokes the parameter callback before returning
|
|
the value. This allows the callback to validate prompts.
|
|
``full_process_value`` is removed.
|
|
|
|
.. versionchanged:: 8.0
|
|
``autocompletion`` is renamed to ``shell_complete`` and has new
|
|
semantics described above. The old name is deprecated and will
|
|
be removed in 8.1, until then it will be wrapped to match the
|
|
new requirements.
|
|
|
|
.. versionchanged:: 8.0
|
|
For ``multiple=True, nargs>1``, the default must be a list of
|
|
tuples.
|
|
|
|
.. versionchanged:: 8.0
|
|
Setting a default is no longer required for ``nargs>1``, it will
|
|
default to ``None``. ``multiple=True`` or ``nargs=-1`` will
|
|
default to ``()``.
|
|
|
|
.. versionchanged:: 7.1
|
|
Empty environment variables are ignored rather than taking the
|
|
empty string value. This makes it possible for scripts to clear
|
|
variables if they can't unset them.
|
|
|
|
.. versionchanged:: 2.0
|
|
Changed signature for parameter callback to also be passed the
|
|
parameter. The old callback format will still work, but it will
|
|
raise a warning to give you a chance to migrate the code easier.
|
|
"""
|
|
|
|
param_type_name = "parameter"
|
|
|
|
def __init__(
|
|
self,
|
|
param_decls: t.Optional[t.Sequence[str]] = None,
|
|
type: t.Optional[t.Union[types.ParamType, t.Any]] = None,
|
|
required: bool = False,
|
|
default: t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]] = None,
|
|
callback: t.Optional[t.Callable[[Context, "Parameter", t.Any], t.Any]] = None,
|
|
nargs: t.Optional[int] = None,
|
|
multiple: bool = False,
|
|
metavar: t.Optional[str] = None,
|
|
expose_value: bool = True,
|
|
is_eager: bool = False,
|
|
envvar: t.Optional[t.Union[str, t.Sequence[str]]] = None,
|
|
shell_complete: t.Optional[
|
|
t.Callable[
|
|
[Context, "Parameter", str],
|
|
t.Union[t.List["CompletionItem"], t.List[str]],
|
|
]
|
|
] = None,
|
|
) -> None:
|
|
self.name: t.Optional[str]
|
|
self.opts: t.List[str]
|
|
self.secondary_opts: t.List[str]
|
|
self.name, self.opts, self.secondary_opts = self._parse_decls(
|
|
param_decls or (), expose_value
|
|
)
|
|
self.type: types.ParamType = types.convert_type(type, default)
|
|
|
|
# Default nargs to what the type tells us if we have that
|
|
# information available.
|
|
if nargs is None:
|
|
if self.type.is_composite:
|
|
nargs = self.type.arity
|
|
else:
|
|
nargs = 1
|
|
|
|
self.required = required
|
|
self.callback = callback
|
|
self.nargs = nargs
|
|
self.multiple = multiple
|
|
self.expose_value = expose_value
|
|
self.default = default
|
|
self.is_eager = is_eager
|
|
self.metavar = metavar
|
|
self.envvar = envvar
|
|
self._custom_shell_complete = shell_complete
|
|
|
|
if __debug__:
|
|
if self.type.is_composite and nargs != self.type.arity:
|
|
raise ValueError(
|
|
f"'nargs' must be {self.type.arity} (or None) for"
|
|
f" type {self.type!r}, but it was {nargs}."
|
|
)
|
|
|
|
# Skip no default or callable default.
|
|
check_default = default if not callable(default) else None
|
|
|
|
if check_default is not None:
|
|
if multiple:
|
|
try:
|
|
# Only check the first value against nargs.
|
|
check_default = next(_check_iter(check_default), None)
|
|
except TypeError:
|
|
raise ValueError(
|
|
"'default' must be a list when 'multiple' is true."
|
|
) from None
|
|
|
|
# Can be None for multiple with empty default.
|
|
if nargs != 1 and check_default is not None:
|
|
try:
|
|
_check_iter(check_default)
|
|
except TypeError:
|
|
if multiple:
|
|
message = (
|
|
"'default' must be a list of lists when 'multiple' is"
|
|
" true and 'nargs' != 1."
|
|
)
|
|
else:
|
|
message = "'default' must be a list when 'nargs' != 1."
|
|
|
|
raise ValueError(message) from None
|
|
|
|
if nargs > 1 and len(check_default) != nargs:
|
|
subject = "item length" if multiple else "length"
|
|
raise ValueError(
|
|
f"'default' {subject} must match nargs={nargs}."
|
|
)
|
|
|
|
def to_info_dict(self) -> t.Dict[str, t.Any]:
|
|
"""Gather information that could be useful for a tool generating
|
|
user-facing documentation.
|
|
|
|
Use :meth:`click.Context.to_info_dict` to traverse the entire
|
|
CLI structure.
|
|
|
|
.. versionadded:: 8.0
|
|
"""
|
|
return {
|
|
"name": self.name,
|
|
"param_type_name": self.param_type_name,
|
|
"opts": self.opts,
|
|
"secondary_opts": self.secondary_opts,
|
|
"type": self.type.to_info_dict(),
|
|
"required": self.required,
|
|
"nargs": self.nargs,
|
|
"multiple": self.multiple,
|
|
"default": self.default,
|
|
"envvar": self.envvar,
|
|
}
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<{self.__class__.__name__} {self.name}>"
|
|
|
|
def _parse_decls(
|
|
self, decls: t.Sequence[str], expose_value: bool
|
|
) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
|
|
raise NotImplementedError()
|
|
|
|
@property
|
|
def human_readable_name(self) -> str:
|
|
"""Returns the human readable name of this parameter. This is the
|
|
same as the name for options, but the metavar for arguments.
|
|
"""
|
|
return self.name # type: ignore
|
|
|
|
def make_metavar(self) -> str:
|
|
if self.metavar is not None:
|
|
return self.metavar
|
|
|
|
metavar = self.type.get_metavar(self)
|
|
|
|
if metavar is None:
|
|
metavar = self.type.name.upper()
|
|
|
|
if self.nargs != 1:
|
|
metavar += "..."
|
|
|
|
return metavar
|
|
|
|
@t.overload
|
|
def get_default(
|
|
self, ctx: Context, call: "te.Literal[True]" = True
|
|
) -> t.Optional[t.Any]:
|
|
...
|
|
|
|
@t.overload
|
|
def get_default(
|
|
self, ctx: Context, call: bool = ...
|
|
) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
|
|
...
|
|
|
|
def get_default(
|
|
self, ctx: Context, call: bool = True
|
|
) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
|
|
"""Get the default for the parameter. Tries
|
|
:meth:`Context.lookup_default` first, then the local default.
|
|
|
|
:param ctx: Current context.
|
|
:param call: If the default is a callable, call it. Disable to
|
|
return the callable instead.
|
|
|
|
.. versionchanged:: 8.0.2
|
|
Type casting is no longer performed when getting a default.
|
|
|
|
.. versionchanged:: 8.0.1
|
|
Type casting can fail in resilient parsing mode. Invalid
|
|
defaults will not prevent showing help text.
|
|
|
|
.. versionchanged:: 8.0
|
|
Looks at ``ctx.default_map`` first.
|
|
|
|
.. versionchanged:: 8.0
|
|
Added the ``call`` parameter.
|
|
"""
|
|
value = ctx.lookup_default(self.name, call=False) # type: ignore
|
|
|
|
if value is None:
|
|
value = self.default
|
|
|
|
if call and callable(value):
|
|
value = value()
|
|
|
|
return value
|
|
|
|
def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
|
|
raise NotImplementedError()
|
|
|
|
def consume_value(
|
|
self, ctx: Context, opts: t.Mapping[str, t.Any]
|
|
) -> t.Tuple[t.Any, ParameterSource]:
|
|
value = opts.get(self.name) # type: ignore
|
|
source = ParameterSource.COMMANDLINE
|
|
|
|
if value is None:
|
|
value = self.value_from_envvar(ctx)
|
|
source = ParameterSource.ENVIRONMENT
|
|
|
|
if value is None:
|
|
value = ctx.lookup_default(self.name) # type: ignore
|
|
source = ParameterSource.DEFAULT_MAP
|
|
|
|
if value is None:
|
|
value = self.get_default(ctx)
|
|
source = ParameterSource.DEFAULT
|
|
|
|
return value, source
|
|
|
|
def type_cast_value(self, ctx: Context, value: t.Any) -> t.Any:
|
|
"""Convert and validate a value against the option's
|
|
:attr:`type`, :attr:`multiple`, and :attr:`nargs`.
|
|
"""
|
|
if value is None:
|
|
return () if self.multiple or self.nargs == -1 else None
|
|
|
|
def check_iter(value: t.Any) -> t.Iterator[t.Any]:
|
|
try:
|
|
return _check_iter(value)
|
|
except TypeError:
|
|
# This should only happen when passing in args manually,
|
|
# the parser should construct an iterable when parsing
|
|
# the command line.
|
|
raise BadParameter(
|
|
_("Value must be an iterable."), ctx=ctx, param=self
|
|
) from None
|
|
|
|
if self.nargs == 1 or self.type.is_composite:
|
|
|
|
def convert(value: t.Any) -> t.Any:
|
|
return self.type(value, param=self, ctx=ctx)
|
|
|
|
elif self.nargs == -1:
|
|
|
|
def convert(value: t.Any) -> t.Any: # t.Tuple[t.Any, ...]
|
|
return tuple(self.type(x, self, ctx) for x in check_iter(value))
|
|
|
|
else: # nargs > 1
|
|
|
|
def convert(value: t.Any) -> t.Any: # t.Tuple[t.Any, ...]
|
|
value = tuple(check_iter(value))
|
|
|
|
if len(value) != self.nargs:
|
|
raise BadParameter(
|
|
ngettext(
|
|
"Takes {nargs} values but 1 was given.",
|
|
"Takes {nargs} values but {len} were given.",
|
|
len(value),
|
|
).format(nargs=self.nargs, len=len(value)),
|
|
ctx=ctx,
|
|
param=self,
|
|
)
|
|
|
|
return tuple(self.type(x, self, ctx) for x in value)
|
|
|
|
if self.multiple:
|
|
return tuple(convert(x) for x in check_iter(value))
|
|
|
|
return convert(value)
|
|
|
|
def value_is_missing(self, value: t.Any) -> bool:
|
|
if value is None:
|
|
return True
|
|
|
|
if (self.nargs != 1 or self.multiple) and value == ():
|
|
return True
|
|
|
|
return False
|
|
|
|
def process_value(self, ctx: Context, value: t.Any) -> t.Any:
|
|
value = self.type_cast_value(ctx, value)
|
|
|
|
if self.required and self.value_is_missing(value):
|
|
raise MissingParameter(ctx=ctx, param=self)
|
|
|
|
if self.callback is not None:
|
|
value = self.callback(ctx, self, value)
|
|
|
|
return value
|
|
|
|
def resolve_envvar_value(self, ctx: Context) -> t.Optional[str]:
|
|
if self.envvar is None:
|
|
return None
|
|
|
|
if isinstance(self.envvar, str):
|
|
rv = os.environ.get(self.envvar)
|
|
|
|
if rv:
|
|
return rv
|
|
else:
|
|
for envvar in self.envvar:
|
|
rv = os.environ.get(envvar)
|
|
|
|
if rv:
|
|
return rv
|
|
|
|
return None
|
|
|
|
def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]:
|
|
rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx)
|
|
|
|
if rv is not None and self.nargs != 1:
|
|
rv = self.type.split_envvar_value(rv)
|
|
|
|
return rv
|
|
|
|
def handle_parse_result(
|
|
self, ctx: Context, opts: t.Mapping[str, t.Any], args: t.List[str]
|
|
) -> t.Tuple[t.Any, t.List[str]]:
|
|
with augment_usage_errors(ctx, param=self):
|
|
value, source = self.consume_value(ctx, opts)
|
|
ctx.set_parameter_source(self.name, source) # type: ignore
|
|
|
|
try:
|
|
value = self.process_value(ctx, value)
|
|
except Exception:
|
|
if not ctx.resilient_parsing:
|
|
raise
|
|
|
|
value = None
|
|
|
|
if self.expose_value:
|
|
ctx.params[self.name] = value # type: ignore
|
|
|
|
return value, args
|
|
|
|
def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]:
|
|
pass
|
|
|
|
def get_usage_pieces(self, ctx: Context) -> t.List[str]:
|
|
return []
|
|
|
|
def get_error_hint(self, ctx: Context) -> str:
|
|
"""Get a stringified version of the param for use in error messages to
|
|
indicate which param caused the error.
|
|
"""
|
|
hint_list = self.opts or [self.human_readable_name]
|
|
return " / ".join(f"'{x}'" for x in hint_list)
|
|
|
|
def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
|
|
"""Return a list of completions for the incomplete value. If a
|
|
``shell_complete`` function was given during init, it is used.
|
|
Otherwise, the :attr:`type`
|
|
:meth:`~click.types.ParamType.shell_complete` function is used.
|
|
|
|
:param ctx: Invocation context for this command.
|
|
:param incomplete: Value being completed. May be empty.
|
|
|
|
.. versionadded:: 8.0
|
|
"""
|
|
if self._custom_shell_complete is not None:
|
|
results = self._custom_shell_complete(ctx, self, incomplete)
|
|
|
|
if results and isinstance(results[0], str):
|
|
from click.shell_completion import CompletionItem
|
|
|
|
results = [CompletionItem(c) for c in results]
|
|
|
|
return t.cast(t.List["CompletionItem"], results)
|
|
|
|
return self.type.shell_complete(ctx, self, incomplete)
|
|
|
|
|
|
class Option(Parameter):
|
|
"""Options are usually optional values on the command line and
|
|
have some extra features that arguments don't have.
|
|
|
|
All other parameters are passed onwards to the parameter constructor.
|
|
|
|
:param show_default: Show the default value for this option in its
|
|
help text. Values are not shown by default, unless
|
|
:attr:`Context.show_default` is ``True``. If this value is a
|
|
string, it shows that string in parentheses instead of the
|
|
actual value. This is particularly useful for dynamic options.
|
|
For single option boolean flags, the default remains hidden if
|
|
its value is ``False``.
|
|
:param show_envvar: Controls if an environment variable should be
|
|
shown on the help page. Normally, environment variables are not
|
|
shown.
|
|
:param prompt: If set to ``True`` or a non empty string then the
|
|
user will be prompted for input. If set to ``True`` the prompt
|
|
will be the option name capitalized.
|
|
:param confirmation_prompt: Prompt a second time to confirm the
|
|
value if it was prompted for. Can be set to a string instead of
|
|
``True`` to customize the message.
|
|
:param prompt_required: If set to ``False``, the user will be
|
|
prompted for input only when the option was specified as a flag
|
|
without a value.
|
|
:param hide_input: If this is ``True`` then the input on the prompt
|
|
will be hidden from the user. This is useful for password input.
|
|
:param is_flag: forces this option to act as a flag. The default is
|
|
auto detection.
|
|
:param flag_value: which value should be used for this flag if it's
|
|
enabled. This is set to a boolean automatically if
|
|
the option string contains a slash to mark two options.
|
|
:param multiple: if this is set to `True` then the argument is accepted
|
|
multiple times and recorded. This is similar to ``nargs``
|
|
in how it works but supports arbitrary number of
|
|
arguments.
|
|
:param count: this flag makes an option increment an integer.
|
|
:param allow_from_autoenv: if this is enabled then the value of this
|
|
parameter will be pulled from an environment
|
|
variable in case a prefix is defined on the
|
|
context.
|
|
:param help: the help string.
|
|
:param hidden: hide this option from help outputs.
|
|
:param attrs: Other command arguments described in :class:`Parameter`.
|
|
|
|
.. versionchanged:: 8.1.0
|
|
Help text indentation is cleaned here instead of only in the
|
|
``@option`` decorator.
|
|
|
|
.. versionchanged:: 8.1.0
|
|
The ``show_default`` parameter overrides
|
|
``Context.show_default``.
|
|
|
|
.. versionchanged:: 8.1.0
|
|
The default of a single option boolean flag is not shown if the
|
|
default value is ``False``.
|
|
|
|
.. versionchanged:: 8.0.1
|
|
``type`` is detected from ``flag_value`` if given.
|
|
"""
|
|
|
|
param_type_name = "option"
|
|
|
|
def __init__(
|
|
self,
|
|
param_decls: t.Optional[t.Sequence[str]] = None,
|
|
show_default: t.Union[bool, str, None] = None,
|
|
prompt: t.Union[bool, str] = False,
|
|
confirmation_prompt: t.Union[bool, str] = False,
|
|
prompt_required: bool = True,
|
|
hide_input: bool = False,
|
|
is_flag: t.Optional[bool] = None,
|
|
flag_value: t.Optional[t.Any] = None,
|
|
multiple: bool = False,
|
|
count: bool = False,
|
|
allow_from_autoenv: bool = True,
|
|
type: t.Optional[t.Union[types.ParamType, t.Any]] = None,
|
|
help: t.Optional[str] = None,
|
|
hidden: bool = False,
|
|
show_choices: bool = True,
|
|
show_envvar: bool = False,
|
|
**attrs: t.Any,
|
|
) -> None:
|
|
if help:
|
|
help = inspect.cleandoc(help)
|
|
|
|
default_is_missing = "default" not in attrs
|
|
super().__init__(param_decls, type=type, multiple=multiple, **attrs)
|
|
|
|
if prompt is True:
|
|
if self.name is None:
|
|
raise TypeError("'name' is required with 'prompt=True'.")
|
|
|
|
prompt_text: t.Optional[str] = self.name.replace("_", " ").capitalize()
|
|
elif prompt is False:
|
|
prompt_text = None
|
|
else:
|
|
prompt_text = prompt
|
|
|
|
self.prompt = prompt_text
|
|
self.confirmation_prompt = confirmation_prompt
|
|
self.prompt_required = prompt_required
|
|
self.hide_input = hide_input
|
|
self.hidden = hidden
|
|
|
|
# If prompt is enabled but not required, then the option can be
|
|
# used as a flag to indicate using prompt or flag_value.
|
|
self._flag_needs_value = self.prompt is not None and not self.prompt_required
|
|
|
|
if is_flag is None:
|
|
if flag_value is not None:
|
|
# Implicitly a flag because flag_value was set.
|
|
is_flag = True
|
|
elif self._flag_needs_value:
|
|
# Not a flag, but when used as a flag it shows a prompt.
|
|
is_flag = False
|
|
else:
|
|
# Implicitly a flag because flag options were given.
|
|
is_flag = bool(self.secondary_opts)
|
|
elif is_flag is False and not self._flag_needs_value:
|
|
# Not a flag, and prompt is not enabled, can be used as a
|
|
# flag if flag_value is set.
|
|
self._flag_needs_value = flag_value is not None
|
|
|
|
self.default: t.Union[t.Any, t.Callable[[], t.Any]]
|
|
|
|
if is_flag and default_is_missing and not self.required:
|
|
if multiple:
|
|
self.default = ()
|
|
else:
|
|
self.default = False
|
|
|
|
if flag_value is None:
|
|
flag_value = not self.default
|
|
|
|
self.type: types.ParamType
|
|
if is_flag and type is None:
|
|
# Re-guess the type from the flag value instead of the
|
|
# default.
|
|
self.type = types.convert_type(None, flag_value)
|
|
|
|
self.is_flag: bool = is_flag
|
|
self.is_bool_flag: bool = is_flag and isinstance(self.type, types.BoolParamType)
|
|
self.flag_value: t.Any = flag_value
|
|
|
|
# Counting
|
|
self.count = count
|
|
if count:
|
|
if type is None:
|
|
self.type = types.IntRange(min=0)
|
|
if default_is_missing:
|
|
self.default = 0
|
|
|
|
self.allow_from_autoenv = allow_from_autoenv
|
|
self.help = help
|
|
self.show_default = show_default
|
|
self.show_choices = show_choices
|
|
self.show_envvar = show_envvar
|
|
|
|
if __debug__:
|
|
if self.nargs == -1:
|
|
raise TypeError("nargs=-1 is not supported for options.")
|
|
|
|
if self.prompt and self.is_flag and not self.is_bool_flag:
|
|
raise TypeError("'prompt' is not valid for non-boolean flag.")
|
|
|
|
if not self.is_bool_flag and self.secondary_opts:
|
|
raise TypeError("Secondary flag is not valid for non-boolean flag.")
|
|
|
|
if self.is_bool_flag and self.hide_input and self.prompt is not None:
|
|
raise TypeError(
|
|
"'prompt' with 'hide_input' is not valid for boolean flag."
|
|
)
|
|
|
|
if self.count:
|
|
if self.multiple:
|
|
raise TypeError("'count' is not valid with 'multiple'.")
|
|
|
|
if self.is_flag:
|
|
raise TypeError("'count' is not valid with 'is_flag'.")
|
|
|
|
def to_info_dict(self) -> t.Dict[str, t.Any]:
|
|
info_dict = super().to_info_dict()
|
|
info_dict.update(
|
|
help=self.help,
|
|
prompt=self.prompt,
|
|
is_flag=self.is_flag,
|
|
flag_value=self.flag_value,
|
|
count=self.count,
|
|
hidden=self.hidden,
|
|
)
|
|
return info_dict
|
|
|
|
def _parse_decls(
|
|
self, decls: t.Sequence[str], expose_value: bool
|
|
) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
|
|
opts = []
|
|
secondary_opts = []
|
|
name = None
|
|
possible_names = []
|
|
|
|
for decl in decls:
|
|
if decl.isidentifier():
|
|
if name is not None:
|
|
raise TypeError(f"Name '{name}' defined twice")
|
|
name = decl
|
|
else:
|
|
split_char = ";" if decl[:1] == "/" else "/"
|
|
if split_char in decl:
|
|
first, second = decl.split(split_char, 1)
|
|
first = first.rstrip()
|
|
if first:
|
|
possible_names.append(split_opt(first))
|
|
opts.append(first)
|
|
second = second.lstrip()
|
|
if second:
|
|
secondary_opts.append(second.lstrip())
|
|
if first == second:
|
|
raise ValueError(
|
|
f"Boolean option {decl!r} cannot use the"
|
|
" same flag for true/false."
|
|
)
|
|
else:
|
|
possible_names.append(split_opt(decl))
|
|
opts.append(decl)
|
|
|
|
if name is None and possible_names:
|
|
possible_names.sort(key=lambda x: -len(x[0])) # group long options first
|
|
name = possible_names[0][1].replace("-", "_").lower()
|
|
if not name.isidentifier():
|
|
name = None
|
|
|
|
if name is None:
|
|
if not expose_value:
|
|
return None, opts, secondary_opts
|
|
raise TypeError("Could not determine name for option")
|
|
|
|
if not opts and not secondary_opts:
|
|
raise TypeError(
|
|
f"No options defined but a name was passed ({name})."
|
|
" Did you mean to declare an argument instead? Did"
|
|
f" you mean to pass '--{name}'?"
|
|
)
|
|
|
|
return name, opts, secondary_opts
|
|
|
|
def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
|
|
if self.multiple:
|
|
action = "append"
|
|
elif self.count:
|
|
action = "count"
|
|
else:
|
|
action = "store"
|
|
|
|
if self.is_flag:
|
|
action = f"{action}_const"
|
|
|
|
if self.is_bool_flag and self.secondary_opts:
|
|
parser.add_option(
|
|
obj=self, opts=self.opts, dest=self.name, action=action, const=True
|
|
)
|
|
parser.add_option(
|
|
obj=self,
|
|
opts=self.secondary_opts,
|
|
dest=self.name,
|
|
action=action,
|
|
const=False,
|
|
)
|
|
else:
|
|
parser.add_option(
|
|
obj=self,
|
|
opts=self.opts,
|
|
dest=self.name,
|
|
action=action,
|
|
const=self.flag_value,
|
|
)
|
|
else:
|
|
parser.add_option(
|
|
obj=self,
|
|
opts=self.opts,
|
|
dest=self.name,
|
|
action=action,
|
|
nargs=self.nargs,
|
|
)
|
|
|
|
def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]:
|
|
if self.hidden:
|
|
return None
|
|
|
|
any_prefix_is_slash = False
|
|
|
|
def _write_opts(opts: t.Sequence[str]) -> str:
|
|
nonlocal any_prefix_is_slash
|
|
|
|
rv, any_slashes = join_options(opts)
|
|
|
|
if any_slashes:
|
|
any_prefix_is_slash = True
|
|
|
|
if not self.is_flag and not self.count:
|
|
rv += f" {self.make_metavar()}"
|
|
|
|
return rv
|
|
|
|
rv = [_write_opts(self.opts)]
|
|
|
|
if self.secondary_opts:
|
|
rv.append(_write_opts(self.secondary_opts))
|
|
|
|
help = self.help or ""
|
|
extra = []
|
|
|
|
if self.show_envvar:
|
|
envvar = self.envvar
|
|
|
|
if envvar is None:
|
|
if (
|
|
self.allow_from_autoenv
|
|
and ctx.auto_envvar_prefix is not None
|
|
and self.name is not None
|
|
):
|
|
envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
|
|
|
|
if envvar is not None:
|
|
var_str = (
|
|
envvar
|
|
if isinstance(envvar, str)
|
|
else ", ".join(str(d) for d in envvar)
|
|
)
|
|
extra.append(_("env var: {var}").format(var=var_str))
|
|
|
|
# Temporarily enable resilient parsing to avoid type casting
|
|
# failing for the default. Might be possible to extend this to
|
|
# help formatting in general.
|
|
resilient = ctx.resilient_parsing
|
|
ctx.resilient_parsing = True
|
|
|
|
try:
|
|
default_value = self.get_default(ctx, call=False)
|
|
finally:
|
|
ctx.resilient_parsing = resilient
|
|
|
|
show_default = False
|
|
show_default_is_str = False
|
|
|
|
if self.show_default is not None:
|
|
if isinstance(self.show_default, str):
|
|
show_default_is_str = show_default = True
|
|
else:
|
|
show_default = self.show_default
|
|
elif ctx.show_default is not None:
|
|
show_default = ctx.show_default
|
|
|
|
if show_default_is_str or (show_default and (default_value is not None)):
|
|
if show_default_is_str:
|
|
default_string = f"({self.show_default})"
|
|
elif isinstance(default_value, (list, tuple)):
|
|
default_string = ", ".join(str(d) for d in default_value)
|
|
elif inspect.isfunction(default_value):
|
|
default_string = _("(dynamic)")
|
|
elif self.is_bool_flag and self.secondary_opts:
|
|
# For boolean flags that have distinct True/False opts,
|
|
# use the opt without prefix instead of the value.
|
|
default_string = split_opt(
|
|
(self.opts if self.default else self.secondary_opts)[0]
|
|
)[1]
|
|
elif self.is_bool_flag and not self.secondary_opts and not default_value:
|
|
default_string = ""
|
|
else:
|
|
default_string = str(default_value)
|
|
|
|
if default_string:
|
|
extra.append(_("default: {default}").format(default=default_string))
|
|
|
|
if (
|
|
isinstance(self.type, types._NumberRangeBase)
|
|
# skip count with default range type
|
|
and not (self.count and self.type.min == 0 and self.type.max is None)
|
|
):
|
|
range_str = self.type._describe_range()
|
|
|
|
if range_str:
|
|
extra.append(range_str)
|
|
|
|
if self.required:
|
|
extra.append(_("required"))
|
|
|
|
if extra:
|
|
extra_str = "; ".join(extra)
|
|
help = f"{help} [{extra_str}]" if help else f"[{extra_str}]"
|
|
|
|
return ("; " if any_prefix_is_slash else " / ").join(rv), help
|
|
|
|
@t.overload
|
|
def get_default(
|
|
self, ctx: Context, call: "te.Literal[True]" = True
|
|
) -> t.Optional[t.Any]:
|
|
...
|
|
|
|
@t.overload
|
|
def get_default(
|
|
self, ctx: Context, call: bool = ...
|
|
) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
|
|
...
|
|
|
|
def get_default(
|
|
self, ctx: Context, call: bool = True
|
|
) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
|
|
# If we're a non boolean flag our default is more complex because
|
|
# we need to look at all flags in the same group to figure out
|
|
# if we're the default one in which case we return the flag
|
|
# value as default.
|
|
if self.is_flag and not self.is_bool_flag:
|
|
for param in ctx.command.params:
|
|
if param.name == self.name and param.default:
|
|
return t.cast(Option, param).flag_value
|
|
|
|
return None
|
|
|
|
return super().get_default(ctx, call=call)
|
|
|
|
def prompt_for_value(self, ctx: Context) -> t.Any:
|
|
"""This is an alternative flow that can be activated in the full
|
|
value processing if a value does not exist. It will prompt the
|
|
user until a valid value exists and then returns the processed
|
|
value as result.
|
|
"""
|
|
assert self.prompt is not None
|
|
|
|
# Calculate the default before prompting anything to be stable.
|
|
default = self.get_default(ctx)
|
|
|
|
# If this is a prompt for a flag we need to handle this
|
|
# differently.
|
|
if self.is_bool_flag:
|
|
return confirm(self.prompt, default)
|
|
|
|
return prompt(
|
|
self.prompt,
|
|
default=default,
|
|
type=self.type,
|
|
hide_input=self.hide_input,
|
|
show_choices=self.show_choices,
|
|
confirmation_prompt=self.confirmation_prompt,
|
|
value_proc=lambda x: self.process_value(ctx, x),
|
|
)
|
|
|
|
def resolve_envvar_value(self, ctx: Context) -> t.Optional[str]:
|
|
rv = super().resolve_envvar_value(ctx)
|
|
|
|
if rv is not None:
|
|
return rv
|
|
|
|
if (
|
|
self.allow_from_autoenv
|
|
and ctx.auto_envvar_prefix is not None
|
|
and self.name is not None
|
|
):
|
|
envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
|
|
rv = os.environ.get(envvar)
|
|
|
|
if rv:
|
|
return rv
|
|
|
|
return None
|
|
|
|
def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]:
|
|
rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx)
|
|
|
|
if rv is None:
|
|
return None
|
|
|
|
value_depth = (self.nargs != 1) + bool(self.multiple)
|
|
|
|
if value_depth > 0:
|
|
rv = self.type.split_envvar_value(rv)
|
|
|
|
if self.multiple and self.nargs != 1:
|
|
rv = batch(rv, self.nargs)
|
|
|
|
return rv
|
|
|
|
def consume_value(
|
|
self, ctx: Context, opts: t.Mapping[str, "Parameter"]
|
|
) -> t.Tuple[t.Any, ParameterSource]:
|
|
value, source = super().consume_value(ctx, opts)
|
|
|
|
# The parser will emit a sentinel value if the option can be
|
|
# given as a flag without a value. This is different from None
|
|
# to distinguish from the flag not being given at all.
|
|
if value is _flag_needs_value:
|
|
if self.prompt is not None and not ctx.resilient_parsing:
|
|
value = self.prompt_for_value(ctx)
|
|
source = ParameterSource.PROMPT
|
|
else:
|
|
value = self.flag_value
|
|
source = ParameterSource.COMMANDLINE
|
|
|
|
elif (
|
|
self.multiple
|
|
and value is not None
|
|
and any(v is _flag_needs_value for v in value)
|
|
):
|
|
value = [self.flag_value if v is _flag_needs_value else v for v in value]
|
|
source = ParameterSource.COMMANDLINE
|
|
|
|
# The value wasn't set, or used the param's default, prompt if
|
|
# prompting is enabled.
|
|
elif (
|
|
source in {None, ParameterSource.DEFAULT}
|
|
and self.prompt is not None
|
|
and (self.required or self.prompt_required)
|
|
and not ctx.resilient_parsing
|
|
):
|
|
value = self.prompt_for_value(ctx)
|
|
source = ParameterSource.PROMPT
|
|
|
|
return value, source
|
|
|
|
|
|
class Argument(Parameter):
|
|
"""Arguments are positional parameters to a command. They generally
|
|
provide fewer features than options but can have infinite ``nargs``
|
|
and are required by default.
|
|
|
|
All parameters are passed onwards to the constructor of :class:`Parameter`.
|
|
"""
|
|
|
|
param_type_name = "argument"
|
|
|
|
def __init__(
|
|
self,
|
|
param_decls: t.Sequence[str],
|
|
required: t.Optional[bool] = None,
|
|
**attrs: t.Any,
|
|
) -> None:
|
|
if required is None:
|
|
if attrs.get("default") is not None:
|
|
required = False
|
|
else:
|
|
required = attrs.get("nargs", 1) > 0
|
|
|
|
if "multiple" in attrs:
|
|
raise TypeError("__init__() got an unexpected keyword argument 'multiple'.")
|
|
|
|
super().__init__(param_decls, required=required, **attrs)
|
|
|
|
if __debug__:
|
|
if self.default is not None and self.nargs == -1:
|
|
raise TypeError("'default' is not supported for nargs=-1.")
|
|
|
|
@property
|
|
def human_readable_name(self) -> str:
|
|
if self.metavar is not None:
|
|
return self.metavar
|
|
return self.name.upper() # type: ignore
|
|
|
|
def make_metavar(self) -> str:
|
|
if self.metavar is not None:
|
|
return self.metavar
|
|
var = self.type.get_metavar(self)
|
|
if not var:
|
|
var = self.name.upper() # type: ignore
|
|
if not self.required:
|
|
var = f"[{var}]"
|
|
if self.nargs != 1:
|
|
var += "..."
|
|
return var
|
|
|
|
def _parse_decls(
|
|
self, decls: t.Sequence[str], expose_value: bool
|
|
) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
|
|
if not decls:
|
|
if not expose_value:
|
|
return None, [], []
|
|
raise TypeError("Could not determine name for argument")
|
|
if len(decls) == 1:
|
|
name = arg = decls[0]
|
|
name = name.replace("-", "_").lower()
|
|
else:
|
|
raise TypeError(
|
|
"Arguments take exactly one parameter declaration, got"
|
|
f" {len(decls)}."
|
|
)
|
|
return name, [arg], []
|
|
|
|
def get_usage_pieces(self, ctx: Context) -> t.List[str]:
|
|
return [self.make_metavar()]
|
|
|
|
def get_error_hint(self, ctx: Context) -> str:
|
|
return f"'{self.make_metavar()}'"
|
|
|
|
def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
|
|
parser.add_argument(dest=self.name, nargs=self.nargs, obj=self)
|