click_extra package

Expose package-wide elements.

exception click_extra.Abort

Bases: RuntimeError

An internal signalling exception that signals Click to abort.

class click_extra.Argument(*args, help=None, **attrs)

Bases: _ParameterMixin, Argument

Wrap cloup.Argument, itself inheriting from click.Argument.

Inherits first from _ParameterMixin to allow future overrides of Click’s Parameter methods.

exception click_extra.BadArgumentUsage(message, ctx=None)

Bases: UsageError

Raised if an argument is generally supplied but the use of the argument was incorrect. This is for instance raised if the number of values for an argument is not correct.

Added in version 6.0.

exception click_extra.BadOptionUsage(option_name, message, ctx=None)

Bases: UsageError

Raised if an option is generally supplied but the use of the option was incorrect. This is for instance raised if the number of arguments for an option is not correct.

Added in version 4.0.

Parameters:

option_name (str) – the name of the option being used incorrectly.

exception click_extra.BadParameter(message, ctx=None, param=None, param_hint=None)

Bases: UsageError

An exception that formats out a standardized error message for a bad parameter. This is useful when thrown from a callback or type as Click will attach contextual information to it (for instance, which parameter it is).

Added in version 2.0.

Parameters:

• param (Parameter | None) – the parameter object that caused this error. This can be left out, and Click will attach this info itself if possible.

• param_hint (cabc.Sequence[str] | str | None) – a string that shows up as parameter name. This can be used as alternative to param in cases where custom validation should happen. If it is a string it’s used as such, if it’s a list then each item is quoted and separated.

format_message()

Return type:

str

class click_extra.Choice(choices, case_sensitive=True)

Bases: ParamType, Generic[ParamTypeValue]

The choice type allows a value to be checked against a fixed set of supported values.

You may pass any iterable value which will be converted to a tuple and thus will only be iterated once.

The resulting value will always be one of the originally passed choices. See normalize_choice() for more info on the mapping of strings to choices. See Choice for an example.

Parameters:

case_sensitive (bool) – Set to false to make choices case insensitive. Defaults to true.

Changed in version 8.2.0: Non-str choices are now supported. It can additionally be any iterable. Before you were not recommended to pass anything but a list or tuple.

Added in version 8.2.0: Choice normalization can be overridden via normalize_choice().

name: str = 'choice'

the descriptive name of this type

to_info_dict()

Gather information that could be useful for a tool generating user-facing documentation.

Use click.Context.to_info_dict() to traverse the entire CLI structure.

Added in version 8.0.

Return type:

dict[str, Any]

normalize_choice(choice, ctx)

Normalize a choice value, used to map a passed string to a choice. Each choice must have a unique normalized value.

By default uses Context.token_normalize_func() and if not case sensitive, convert it to a casefolded value.

Added in version 8.2.0.

Return type:

str

get_metavar(param, ctx)

Returns the metavar default for this param if it provides one.

Return type:

str | None

get_missing_message(param, ctx)

Message shown when no choice is passed.

Changed in version 8.2.0: Added ctx argument.

Return type:

str

convert(value, param, ctx)

For a given value from the parser, normalize it and find its matching normalized value in the list of choices. Then return the matched “original” choice.

Return type:

ParamTypeValue

get_invalid_choice_message(value, ctx)

Get the error message when the given choice is invalid.

Parameters:

value (t.Any) – The invalid value.

Added in version 8.2.

Return type:

str

shell_complete(ctx, param, incomplete)

Complete choices that start with the incomplete value.

Parameters:

• ctx (Context) – Invocation context for this command.

• param (Parameter) – The parameter that is requesting completion.

• incomplete (str) – Value being completed. May be empty.

Added in version 8.0.

Return type:

list[CompletionItem]

class click_extra.ChoiceSource(*values)

Bases: Enum

Source of choices for EnumChoice.

KEY = 'key'

NAME = 'name'

VALUE = 'value'

STR = 'str'

exception click_extra.ClickException(message)

Bases: Exception

An exception that Click can handle and show to the user.

exit_code = 1

The exit code for this exception.

format_message()

Return type:

str

show(file=None)

Return type:

None

class click_extra.Color

Bases: FrozenSpace

Colors accepted by Style and click.style().

black = 'black'

red = 'red'

green = 'green'

yellow = 'yellow'

blue = 'blue'

magenta = 'magenta'

cyan = 'cyan'

white = 'white'

reset = 'reset'

bright_black = 'bright_black'

bright_red = 'bright_red'

bright_green = 'bright_green'

bright_yellow = 'bright_yellow'

bright_blue = 'bright_blue'

bright_magenta = 'bright_magenta'

bright_cyan = 'bright_cyan'

bright_white = 'bright_white'

class click_extra.ColorOption(param_decls=None, is_flag=True, default=True, is_eager=True, expose_value=False, help='Strip out all colors and all ANSI codes from output.', **kwargs)

Bases: ExtraOption

A pre-configured option that is adding a --color/--no-color (aliased by --ansi/--no-ansi) to keep or strip colors and ANSI codes from CLI output.

This option is eager by default to allow for other eager options (like --version) to be rendered colorless.

Todo

Should we switch to --color=<auto|never|always> as GNU tools does?

Also see how the isatty property defaults with this option, and how it can be implemented in Python.

Todo

Support the TERM environment variable convention?

set_color(ctx, param, value)

Reconcile --color/--no-color/--ansi/--no-ansi with environment variables.

The reconciliation pass re-inspects the environment for any of the recognised colorization flags (NO_COLOR, FORCE_COLOR, CLICOLOR, …): when the user hasn’t explicitly passed --color / --no-color on the command line, the env vars take precedence. The final reconciled value lands on ctx.color (the Click-standard attribute that echo() reads). Renamed from disable_colors because the callback handles enable as well as disable: the previous name only described half the behavior.

Return type:

None

class click_extra.Command(*args, aliases=None, formatter_settings=None, **kwargs)

Bases: ConstraintMixin, OptionGroupMixin, Command

A click.Command supporting option groups and constraints.

Refer to superclasses for the documentation of all accepted parameters:

• ConstraintMixin

• OptionGroupMixin

• click.Command

Besides other things, this class also:

• adds a formatter_settings instance attribute.

Refer to click.Command for the documentation of all parameters.

Added in version 0.8.0.

Parameters:

• constraints – sequence of constraints bound to specific groups of parameters. Note that constraints applied to option groups are collected from the option groups themselves, so they don’t need to be included in this argument.

• show_constraints – whether to include a “Constraint” section in the command help. This is also available as a context setting having a lower priority than this attribute.

• args (Any) – positional arguments forwarded to the next class in the MRO

• kwargs (Any) – keyword arguments forwarded to the next class in the MRO

context_class

alias of Context

aliases: List[str]

HelpFormatter options that are merged with Context.formatter_settings (eventually overriding some values).

get_normalized_epilog()

Return type:

str

format_epilog(ctx, formatter)

Writes the epilog into the formatter if it exists.

Return type:

None

format_help_text(ctx, formatter)

Writes the help text to the formatter if it exists.

Return type:

None

format_aliases(ctx, formatter)

Return type:

None

format_help(ctx, formatter)

Writes the help into the formatter if it exists.

This is a low-level method called by get_help().

This calls the following methods:

• format_usage()

• format_help_text()

• format_options()

• format_epilog()

Return type:

None

class click_extra.CommandCollection(name=None, sources=None, **kwargs)

Bases: Group

A Group that looks up subcommands on other groups. If a command is not found on this group, each registered source is checked in order. Parameters on a source are not added to this group, and a source’s callback is not invoked when invoking its commands. In other words, this “flattens” commands in many groups into this one group.

Parameters:

• name (str | None) – The name of the group command.

• sources (list[Group] | None) – A list of Group objects to look up commands from.

• kwargs (Any) – Other arguments passed to Group.

Changed in version 8.2: This is a subclass of Group. Commands are looked up first on this group, then each of its sources.

sources: list[Group]

The list of registered groups.

add_source(group)

Add a group as a source of commands.

Return type:

None

get_command(ctx, cmd_name)

Given a context and a command name, this returns a Command object if it exists or returns None.

Return type:

Command | None

list_commands(ctx)

Returns a list of subcommand names in the order they should appear.

Return type:

list[str]

class click_extra.ConfigFormat(*values)

Bases: Enum

All configuration formats, associated to their support status.

The first element of the tuple is a sequence of file extensions associated to the format. Patterns are fed to wcmatch.glob for matching, and are influenced by the flags set on the ConfigOption instance.

The second element indicates whether the format is supported or not, depending on the availability of the required third-party packages. This evaluation is performed at runtime when this module is imported.

Caution

The order is important for both format members and file patterns. It defines the priority order in which formats are tried when multiple candidate files are found.

Todo

Add support for JWCC / hujson format?

TOML = (('*.toml',), True, 'TOML')

YAML = (('*.yaml', '*.yml'), True, 'YAML')

JSON = (('*.json',), True, 'JSON')

JSON5 = (('*.json5',), True, 'JSON5')

JSONC = (('*.jsonc',), True, 'JSONC')

HJSON = (('*.hjson',), True, 'Hjson')

INI = (('*.ini',), True, 'INI')

XML = (('*.xml',), True, 'XML')

PYPROJECT_TOML = (('pyproject.toml',), True, 'pyproject.toml')

property label: str

Human-friendly name of the format for display in messages.

property enabled: bool

Returns True if the format is supported, False otherwise.

property patterns: tuple[str]

Returns the default file patterns associated to the format.

class click_extra.ConfigOption(param_decls=None, metavar='CONFIG_PATH', type=UNPROCESSED, help='Location of the configuration file. Supports local path with glob patterns or remote URL.', is_eager=True, expose_value=False, file_format_patterns=None, file_pattern_flags=4104, roaming=True, force_posix=False, search_pattern_flags=285504, search_parents=False, stop_at=Sentinel.VCS, excluded_params=None, included_params=None, strict=False, config_schema=None, schema_strict=False, fallback_sections=(), config_validators=(), **kwargs)

Bases: ExtraOption, ParamStructure

A pre-configured option adding --config CONFIG_PATH.

Takes as input a path to a file or folder, a glob pattern, or an URL.

• is_eager is active by default so the callback gets the opportunity to set the default_map of the CLI before any other parameter is processed.

• default is set to the value returned by self.default_pattern(), which is a pattern combining the default configuration folder for the CLI (as returned by click.get_app_dir()) and all supported file formats.

  Attention

  Default search pattern must follow the syntax of wcmatch.glob.

• excluded_params are parameters which, if present in the configuration file, will be ignored and not applied to the CLI. Items are expected to be the fully-qualified ID of the parameter, as produced in the output of --show-params. Will default to the value of DEFAULT_EXCLUDED_PARAMS.

• included_params is the inverse of excluded_params: only the listed parameters will be loaded from the configuration file. Cannot be used together with excluded_params.

file_format_patterns: dict[ConfigFormat, tuple[str, ...]]

Mapping of ConfigFormat to their associated file patterns.

Can be a string or a sequence of strings. This defines which configuration file formats are supported, and which file patterns are used to search for them.

Note

All formats depending on third-party dependencies that are not installed will be ignored.

Attention

File patterns must follow the syntax of wcmatch.fnmatch.

file_pattern_flags

Flags provided to all calls of wcmatch.fnmatch.

Applies to the matching of file names against supported format patterns specified in file_format_patterns.

Important

The SPLIT flag is always forced, as our multi-pattern design relies on it.

force_posix

Configuration for default folder search.

roaming and force_posix are fed to click.get_app_dir() to determine the location of the default configuration folder.

search_pattern_flags

Flags provided to all calls of wcmatch.glob.

Applies to both the default pattern and any user-provided pattern.

Important

The BRACE flag is always forced, so that multi-format default patterns using {pat1,pat2,...} syntax expand correctly.

The NODIR flag is always forced, to optimize the search for files only.

search_parents

Indicates whether to walk back the tree of parent folders when searching for configuration files.

stop_at

Boundary for parent directory walking.

• None — walk up to filesystem root.

• VCS — stop at the nearest VCS root (.git or .hg) (default).

• A Path or str — stop at that directory.

included_params: frozenset[str] | None

strict

Defines the strictness of the configuration loading.

• If True, raise an error if the configuration file contain parameters not recognized by the CLI.

• If False, silently ignore unrecognized parameters.

config_schema

Optional schema for structured access to configuration values.

When set, the app’s configuration section is extracted from the parsed config file, normalized (hyphens replaced with underscores), flattened (nested dicts joined with _), and passed to this callable to produce a typed configuration object.

Supports:

• Dataclass types — detected via __dataclass_fields__. Keys are normalized, nested dicts are flattened, and the result is filtered to known fields before instantiation. This allows nested config sections (e.g. [tool.myapp.sub-section]) to map directly to flat dataclass fields (e.g. sub_section_key).

• Any callable dict → T — called directly with the raw dict. Works with Pydantic’s Model.model_validate, attrs, or custom factory functions. The caller is responsible for key normalization and flattening.

The resulting object is stored in ctx.meta[click_extra.context.TOOL_CONFIG] and can be retrieved via get_tool_config.

schema_strict

Strictness for schema validation (separate from strict).

• If True, raise ValueError when the config section contains keys that do not match any dataclass field (after normalization and flattening). Only applies when config_schema is a dataclass.

• If False, silently ignore unrecognized keys.

Note

This is distinct from strict, which controls whether merge_default_map rejects config keys not matching CLI parameters. schema_strict validates against dataclass fields instead.

fallback_sections: Sequence[str]

Legacy section names to try when the app’s own section is empty.

Useful when a CLI tool has been renamed: old configuration files that still use [tool.old-name] (TOML), old-name: (YAML), or {"old-name": …} (JSON) are recognized with a deprecation warning. Works with all configuration formats.

config_validators: tuple[ConfigValidator, ...]

Extension validators for sub-trees of the configuration file.

Each ConfigValidator targets a dotted extension_path relative to the app section. Validators run after click-extra’s built-in CLI-parameter strict check (during --validate-config) and after the schema callable produces the typed configuration object (during normal config loading).

The list is seeded with click-extra’s built-in validators (currently the one for [tool.<cli>.themes.<name>] tables, see click_extra.theme.validate_themes_config()); user-supplied validators are appended after them. App code that registers its own validator on the same extension_path simply runs alongside the built-in: both validators are called, both sets of errors surface.

property excluded_params: frozenset[str]

Generates the default list of fully-qualified IDs to exclude.

Danger

It is only called once to produce the default exclusion list if the user did not provided its own.

It was not implemented in the constructor but made as a property, to allow for a just-in-time call within the current context. Without this trick we could not have fetched the CLI name.

property file_pattern: str

Compile all file patterns from the supported formats.

Uses , (comma) notation to combine multiple patterns, suitable for wcmatch brace expansion ({pat1,pat2,...}).

Returns a single pattern string.

default_pattern()

Returns the default pattern used to search for the configuration file.

Defaults to <app_dir>/{*.toml,*.json,*.ini}. Where <app_dir> is produced by the click.get_app_dir() method. The result depends on OS and is influenced by the roaming and force_posix properties.

Multiple file format patterns are wrapped with {…} brace-expansion syntax so that wcmatch.glob correctly applies the directory prefix to every sub-pattern.

Todo

Use platformdirs for more advanced configuration folder detection?

Return type:

str

get_help_extra(ctx)

Replaces the default value of the configuration option.

Display a pretty path that is relative to the user’s home directory:

~/folder/my_cli/{*.toml,*.json,*.ini}

Instead of the full absolute path:

/home/user/folder/my_cli/{*.toml,*.json,*.ini}

Caution

This only applies when the GLOBTILDE flag is set in search_pattern_flags.

Return type:

OptionHelpExtra

parent_patterns(pattern)

Generate (root_dir, file_pattern) pairs for searching.

Each yielded pair can be passed directly to glob.iglob(file_pattern, root_dir=root_dir) so that every sub-pattern (whether from BRACE or SPLIT expansion) is correctly scoped to the same directory.

root_dir is None for entirely magic patterns that will be evaluated relative to the current working directory.

Stops when reaching the root folder, the stop_at boundary, or an inaccessible directory.

Return type:

Iterable[tuple[str | None, str]]

search_and_read_file(pattern)

Search filesystem or URL for files matching the pattern.

If pattern is an URL, download its content. A pattern is considered an URL only if it validates as one and starts with http:// or https://. All other patterns are considered glob patterns for local filesystem search.

Returns an iterator of the normalized location and its raw content, for each one matching the pattern. Only files are returned, directories are silently skipped.

This method returns the raw content of all matching patterns, without trying to parse them. If the content is empty, it is still returned as-is.

Also includes lookups into parents directories if self.search_parents is True.

Raises FileNotFoundError if no file was found after searching all locations.

Return type:

Iterable[tuple[Path | URL, str]]

parse_conf(content, formats)

Parse the content with the given formats.

Tries to parse the given raw content string with each of the given formats, in order. Yields the resulting data structure for each successful parse.

Attention

Formats whose parsing raises an exception or does not return a dict are considered a failure and are skipped.

This follows the parse, don’t validate principle.

Return type:

Iterable[dict[str, Any] | None]

read_and_parse_conf(pattern)

Search for a parseable configuration file.

Returns the location and data structure of the first configuration matching the pattern.

Only return the first match that:

• exists,

• is a file,

• is not empty,

• match file format patterns,

• can be parsed successfully, and

• produce a non-empty data structure.

Raises FileNotFoundError if no configuration file was found matching the criteria above.

Returns (None, None) if files were found but none could be parsed.

Return type:

tuple[Path | URL, dict[str, Any]] | tuple[None, None]

load_ini_config(content)

Utility method to parse INI configuration file.

Internal convention is to use a dot (., as set by self.SEP) in section IDs as a separator between levels. This is a workaround the limitation of INI format which doesn’t allow for sub-sections.

Returns a ready-to-use data structure.

Return type:

dict[str, Any]

merge_default_map(ctx, user_conf)

Save the user configuration into the context’s default_map.

Merge the user configuration into the pre-computed template structure, which will filter out all unrecognized options not supported by the command. Then cleans up blank values and update the context’s default_map.

Uses a ~collections.ChainMap so each config source keeps its own layer. The first layer wins on key lookup, which makes parameter-source precedence explicit and future-proofs for multi-file config loading.

Opaque sub-trees declared by the schema or by registered ConfigValidator instances are stripped from the conf before the CLI-parameter strict check, so user-controlled keys (e.g. mappings whose keys are data, not flag names) don’t trip strict=True.

Return type:

None

load_conf(ctx, param, path_pattern)

Fetch parameter values from a configuration file and set them as defaults.

User configuration is merged to the context’s default_map, like Click does.

By relying on Click’s default_map, we make sure that precedence is respected. Direct CLI parameters, environment variables or interactive prompts take precedence over any values from the config file.

Return type:

None

..hint::

Once loading is complete, the resolved file path and its full parsed content are stored in ctx.meta[click_extra.context.CONF_SOURCE] and ctx.meta[click_extra.context.CONF_FULL] respectively. This is the recommended way to identify which configuration file was loaded.

We intentionally do not add a custom ParameterSource.CONFIG_FILE enum member: ParameterSource is a closed enum in Click, and monkeypatching it would be fragile. Besides, config values end up in default_map, so Click already reports them as ParameterSource.DEFAULT_MAP, which is accurate.

class click_extra.ConfigValidator(extension_path, validator, description='')

Bases: object

Register an app-defined extension validator for one sub-tree of the configuration file.

Apps register validators via the config_validators= kwarg on ConfigOption (or the matching decorator) to extend click-extra’s built-in CLI-parameter strict check with custom validation logic. Each validator targets a single dotted extension_path relative to the app’s configuration section. Click-extra passes the matching sub-tree straight through to the registered validator: the strict check skips it, the schema machinery treats it as opaque, and the user’s logic owns the result. The validator runs both during --validate-config and during normal config loading.

Parameters:

• extension_path (str) – Dotted path of the sub-tree the validator owns, relative to the app’s section in the configuration file. For example, an app named my-cli with extension_path="managers" receives the contents of the [my-cli.managers] table.

• validator (Callable[[dict[str, Any]], None]) – Callable taking the sub-tree dict and raising ValidationError on failure. Must be a pure function: no side effects on the click context, no print statements. The caller decides how to surface the error.

• description (str) – Optional human-readable summary of what the validator checks. Surfaces in documentation generators that introspect the decorator (e.g. autodoc), and may be reused in --help text in a future release.

extension_path: str

validator: Callable[[dict[str, Any]], None]

description: str = ''

class click_extra.ConstraintMixin(*args, constraints=(), show_constraints=None, **kwargs)

Bases: object

Provides support for constraints.

Parameters:

• constraints (Sequence[BoundConstraintSpec | BoundConstraint]) – sequence of constraints bound to specific groups of parameters. Note that constraints applied to option groups are collected from the option groups themselves, so they don’t need to be included in this argument.

• show_constraints (bool | None) – whether to include a “Constraint” section in the command help. This is also available as a context setting having a lower priority than this attribute.

• args (Any) – positional arguments forwarded to the next class in the MRO

• kwargs (Any) – keyword arguments forwarded to the next class in the MRO

optgroup_constraints

Constraints applied to OptionGroup instances.

param_constraints: Tuple[BoundConstraint, ...]

Constraints registered using @constraint (or equivalent method).

all_constraints

All constraints applied to parameter/option groups of this command.

parse_args(ctx, args)

Return type:

List[str]

get_param_by_name(name)

Return type:

Parameter

get_params_by_name(names)

Return type:

Sequence[Parameter]

format_constraints(ctx, formatter)

Return type:

None

must_show_constraints(ctx)

Return type:

bool

class click_extra.Context(*ctx_args, align_option_groups=None, align_sections=None, show_subcommand_aliases=None, show_constraints=None, check_constraints_consistency=None, formatter_settings={}, **ctx_kwargs)

Bases: Context

A custom context for Cloup.

Look up click.Context for the list of all arguments.

Added in version 0.9.0: added the check_constraints_consistency parameter.

Added in version 0.8.0.

Parameters:

• ctx_args (Any) – arguments forwarded to click.Context.

• align_option_groups (bool | None) – if True, align the definition lists of all option groups of a command. You can override this by setting the corresponding argument of Command (but you probably shouldn’t: be consistent).

• align_sections (bool | None) – if True, align the definition lists of all subcommands of a group. You can override this by setting the corresponding argument of Group (but you probably shouldn’t: be consistent).

• show_subcommand_aliases (bool | None) – whether to show the aliases of subcommands in the help of a cloup.Group.

• show_constraints (bool | None) – whether to include a “Constraint” section in the command help (if at least one constraint is defined).

• check_constraints_consistency (bool | None) – enable additional checks for constraints which detects mistakes of the developer (see cloup.Constraint.check_consistency()).

• formatter_settings (Dict[str, Any]) – keyword arguments forwarded to HelpFormatter in make_formatter. This args are merged with those of the (eventual) parent context and then merged again (being overridden) by those of the command. Tip: use the static method HelpFormatter.settings() to create this dictionary, so that you can be guided by your IDE.

• ctx_kwargs (Any) – keyword arguments forwarded to click.Context.

formatter_class

alias of HelpFormatter

formatter_settings

Keyword arguments for the HelpFormatter. Obtained by merging the options of the parent context with the one passed to this context. Before creating the help formatter, these options are merged with the (eventual) options provided to the command (having higher priority).

get_formatter_settings()

Return type:

Dict[str, Any]

make_formatter()

Creates the HelpFormatter for the help and usage output.

To quickly customize the formatter class used without overriding this method, set the formatter_class attribute.

Changed in version 8.0: Added the formatter_class attribute.

Return type:

HelpFormatter

static settings(*, auto_envvar_prefix=_Missing.flag, default_map=_Missing.flag, terminal_width=_Missing.flag, max_content_width=_Missing.flag, resilient_parsing=_Missing.flag, allow_extra_args=_Missing.flag, allow_interspersed_args=_Missing.flag, ignore_unknown_options=_Missing.flag, help_option_names=_Missing.flag, token_normalize_func=_Missing.flag, color=_Missing.flag, show_default=_Missing.flag, align_option_groups=_Missing.flag, align_sections=_Missing.flag, show_subcommand_aliases=_Missing.flag, show_constraints=_Missing.flag, check_constraints_consistency=_Missing.flag, formatter_settings=_Missing.flag)

Utility method for creating a context_settings dictionary.

Parameters:

• auto_envvar_prefix (_Missing | str) – 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.

• default_map (_Missing | Dict[str, Any]) – a dictionary (like object) with default values for parameters.

• terminal_width (_Missing | int) – the width of the terminal. The default is inherited from parent context. If no context defines the terminal width then auto-detection will be applied.

• max_content_width (_Missing | int) – 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.

• resilient_parsing (_Missing | bool) – 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.

• allow_extra_args (_Missing | bool) – 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.

• allow_interspersed_args (_Missing | bool) – if this is set to False then options and arguments cannot be mixed. The default is to inherit from the command.

• ignore_unknown_options (_Missing | bool) – instructs click to ignore options it does not know and keeps them for later processing.

• help_option_names (_Missing | List[str]) – optionally a list of strings that define how the default help parameter is named. The default is ['--help'].

• token_normalize_func (_Missing | Callable[[str], str]) – an optional function that is used to normalize tokens (options, choices, etc.). This for instance can be used to implement case-insensitive behavior.

• color (_Missing | bool) – controls if the terminal supports ANSI colors or not. The default is auto-detection. 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.

• show_default (_Missing | bool) – Show defaults for all options. If not set, defaults to the value from a parent context. Overrides an option’s show_default argument.

• align_option_groups (_Missing | bool) – if True, align the definition lists of all option groups of a command. You can override this by setting the corresponding argument of Command (but you probably shouldn’t: be consistent).

• align_sections (_Missing | bool) – if True, align the definition lists of all subcommands of a group. You can override this by setting the corresponding argument of Group (but you probably shouldn’t: be consistent).

• show_subcommand_aliases (_Missing | bool) – whether to show the aliases of subcommands in the help of a cloup.Group.

• show_constraints (_Missing | bool) – whether to include a “Constraint” section in the command help (if at least one constraint is defined).

• check_constraints_consistency (_Missing | bool) – enable additional checks for constraints which detects mistakes of the developer (see cloup.Constraint.check_consistency()).

• formatter_settings (_Missing | Dict[str, Any]) – keyword arguments forwarded to HelpFormatter in make_formatter. This args are merged with those of the (eventual) parent context and then merged again (being overridden) by those of the command. Tip: use the static method HelpFormatter.settings() to create this dictionary, so that you can be guided by your IDE.

Return type:

Dict[str, Any]

class click_extra.DateTime(formats=None)

Bases: ParamType

The DateTime type converts date strings into datetime objects.

The format strings which are checked are configurable, but default to some common (non-timezone aware) ISO 8601 formats.

When specifying DateTime formats, you should only pass a list or a tuple. Other iterables, like generators, may lead to surprising results.

The format strings are processed using datetime.strptime, and this consequently defines the format strings which are allowed.

Parsing is tried using each format, in order, and the first format which parses successfully is used.

Parameters:

formats (Sequence[str] | None) – A list or tuple of date format strings, in the order in which they should be tried. Defaults to '%Y-%m-%d', '%Y-%m-%dT%H:%M:%S', '%Y-%m-%d %H:%M:%S'.

name: str = 'datetime'

the descriptive name of this type

formats: Sequence[str]

to_info_dict()

Gather information that could be useful for a tool generating user-facing documentation.

Use click.Context.to_info_dict() to traverse the entire CLI structure.

Added in version 8.0.

Return type:

dict[str, Any]

get_metavar(param, ctx)

Returns the metavar default for this param if it provides one.

Return type:

str | None

convert(value, param, ctx)

Convert the value to the correct type. This is not called if the value is None (the missing value).

This must accept string values from the command line, as well as values that are already the correct type. It may also convert other compatible types.

The param and ctx arguments may be None in certain situations, such as when converting prompt input.

If the value cannot be converted, call fail() with a descriptive message.

Parameters:

• value (t.Any) – The value to convert.

• param (Parameter | None) – The parameter that is using this type to convert its value. May be None.

• ctx (Context | None) – The current context that arrived at this value. May be None.

Return type:

t.Any

class click_extra.EnumChoice(choices, case_sensitive=False, choice_source=ChoiceSource.STR, show_aliases=False)

Bases: Choice

Choice type for Enum.

Allows to select which part of the members to use as choice strings, by setting the choice_source parameter to one of:

• ChoiceSource.KEY or ChoiceSource.NAME to use the key (i.e. the name property),

• ChoiceSource.VALUE to use the value,

• ChoiceSource.STR to use the str() string representation, or

• A custom callable that takes an Enum member and returns a string.

Default to ChoiceSource.STR, which makes you to only have to define the __str__() method on your Enum to produce beautiful choice strings.

Same as click.Choice, but takes an Enum as choices.

Also defaults to case-insensitive matching.

choices: tuple[str, ...]

The strings available as choice.

Hint

Contrary to the parent Choice class, we store choices directly as strings, not the Enum members themselves. That way there is no surprises when displaying them to the user.

This trick bypass Enum-specific code path in the Click library. Because, after all, a terminal environment only deals with strings: arguments, parameters, parsing, help messages, environment variables, etc.

get_choice_string(member)

Derivate the choice string from the given Enum’s member.

Return type:

str

normalize_choice(choice, ctx)

Expand the parent’s normalize_choice() to accept Enum members as input.

Parent method expects a string, but here we allow passing Enum members too.

Return type:

str

convert(value, param, ctx)

Convert the input value to the corresponding Enum member.

The parent’s convert() is going to return the choice string, which we then map back to the corresponding Enum member.

Return type:

Enum

class click_extra.ExtraCliRunner(charset='utf-8', env=None, echo_stdin=False, catch_exceptions=True)

Bases: CliRunner

Augment click.testing.CliRunner with extra features and bug fixes.

force_color: bool = False

Global class attribute to override the color parameter in invoke.

invoke(cli, *args, input=None, env=None, catch_exceptions=True, color=None, **extra)

Same as click.testing.CliRunner.invoke() with extra features.

• The first positional parameter is the CLI to invoke. The remaining positional parameters of the function are the CLI arguments. All other parameters are required to be named.

• The CLI arguments can be nested iterables of arbitrary depth. This is useful for argument composition of test cases with @pytest.mark.parametrize.

• Allow forcing of the color property at the class-level via force_color attribute.

• Adds a special case in the form of color="forced" parameter, which allows colored output to be kept, while forcing the initialization of Context.color = True. This is not allowed in current implementation of click.testing.CliRunner.invoke() because of colliding parameters.

• Strips all ANSI codes from results if color was explicirely set to False.

• Always prints a simulation of the CLI execution as the user would see it in its terminal. Including colors.

• Pretty-prints a formatted exception traceback if the command fails.

Parameters:

• cli (Command) – CLI to invoke.

• *args –

  can be nested iterables composed of str, pathlib.Path objects and None values. The nested structure will be flattened and None values will be filtered out. Then all elements will be casted to str. See args_cleanup() for details.

• input (str | bytes | IO | None) – same as click.testing.CliRunner.invoke().

• env (Mapping[str, str | None] | None) – same as click.testing.CliRunner.invoke().

• catch_exceptions (bool) – same as click.testing.CliRunner.invoke().

• color (bool | Literal['forced'] | None) – If a boolean, the parameter will be passed as-is to click.testing.CliRunner.isolation(). If "forced", the parameter will be passed as True to click.testing.CliRunner.isolation() and an extra color=True parameter will be passed to the invoked CLI.

• **extra –

  same as click.testing.CliRunner.invoke(), but colliding parameters are allowed and properly passed on to the invoked CLI.

Return type:

ExtraResult

class click_extra.ExtraCommand(*args, version_fields=None, config_schema=None, schema_strict=False, fallback_sections=(), config_validators=(), included_params=None, extra_option_at_end=True, populate_auto_envvars=True, extra_keywords=None, excluded_keywords=None, **kwargs)

Bases: ExtraHelpColorsMixin, Command

Like cloup.command, with sane defaults and extra help screen colorization.

List of extra parameters:

Parameters:

• version_fields (dict[str, Any] | None) – dictionary of ExtraVersionOption template field overrides forwarded to the version option. Accepts any field from ExtraVersionOption.template_fields (e.g. prog_name, version, git_branch). Lets you customize --version output from the command decorator without replacing the default params list.

• extra_keywords (HelpKeywords | None) – a HelpKeywords instance whose entries are merged into the auto-collected keyword set. Use this to inject additional strings for help screen highlighting.

• excluded_keywords (HelpKeywords | None) – a HelpKeywords instance whose entries are removed from the auto-collected keyword set. Use this to suppress highlighting of specific strings.

• extra_option_at_end (bool) – reorders all parameters attached to the command, by moving all instances of ExtraOption at the end of the parameter list. The original order of the options is preserved among themselves.

• populate_auto_envvars (bool) – forces all parameters to have their auto-generated environment variables registered. This address the shortcoming of click which only evaluates them dynamiccaly. By forcing their registration, the auto-generated environment variables gets displayed in the help screen, fixing click#2483 issue. On Windows, environment variable names are case-insensitive, so we normalize them to uppercase.

By default, these Click context settings are applied:

• auto_envvar_prefix = self.name (Click feature)

  Auto-generate environment variables for all options, using the command ID as prefix. The prefix is normalized to be uppercased and all non-alphanumerics replaced by underscores.

• help_option_names = ("--help", "-h") (Click feature)

  Allow help screen to be invoked with either –help or -h options.

• show_default = True (Click feature)

  Show all default values in help screen.

Additionally, these Cloup context settings are set:

• align_option_groups = False (Cloup feature)

  Aligns option groups in help screen.

• show_constraints = True (Cloup feature)

  Show all constraints in help screen.

• show_subcommand_aliases = True (Cloup feature)

  Show all subcommand aliases in help screen.

Click Extra also adds its own context_settings:

• show_choices = None (Click Extra feature)

  If set to True or False, will force that value on all options, so we can globally show or hide choices when prompting a user for input. Only makes sense for options whose prompt property is set.

  Defaults to None, which will leave all options untouched, and let them decide of their own show_choices setting.

• show_envvar = None (Click Extra feature)

  If set to True or False, will force that value on all options, so we can globally enable or disable the display of environment variables in help screen.

  Defaults to None, which will leave all options untouched, and let them decide of their own show_envvar setting. The rationale being that discoverability of environment variables is enabled by the --show-params option, which is active by default on extra commands. So there is no need to surcharge the help screen.

  This addresses the click#2313 issue.

To override these defaults, you can pass your own settings with the context_settings parameter:

@command(
    context_settings={
        "show_default": False,
        ...
    }
)

context_class

alias of ExtraContext

main(args=None, prog_name=None, **kwargs)

Pre-invocation step that is instantiating the context, then call invoke() within it.

Caution

During context instantiation, each option’s callbacks are called. These might break the execution flow (like --help or --version).

Sets the default CLI’s prog_name to the command’s name if not provided, instead of relying on Click’s auto-detection via the _detect_program_name() method. This is to avoid the CLI being called python -m <module_name>, which is not very user-friendly.

Return type:

Any

make_context(info_name, args, parent=None, **extra)

Intercept the call to the original click.core.Command.make_context so we can keep a copy of the raw, pre-parsed arguments provided to the CLI.

The result are passed to our own ExtraContext constructor which is able to initialize the context’s meta property under our own click_extra.context.RAW_ARGS entry. This will be used in ShowParamsOption.print_params() to print the table of parameters fed to the CLI.

See also

This workaround is being discussed upstream in click#1279.

Return type:

Any

parse_args(ctx, args)

Like parent’s parse_args but with better error messages for single-dash multi-character tokens.

Return type:

list[str]

invoke(ctx)

Main execution of the command, just after the context has been instantiated in main().

Return type:

Any

class click_extra.ExtraContext(*args, meta=None, **kwargs)

Bases: Context

Like cloup._context.Context, but with the ability to populate the context’s meta property at instantiation.

Also defaults color to True for root contexts (i.e. without a parent), so help screens are always colorized — even when piped. Click’s own default is None (auto-detect via TTY), which strips colors in non-interactive contexts.

Parent-to-child color inheritance is handled by Click itself at Context.__init__ time, so no property override is needed.

Todo

Propose addition of meta keyword upstream to Click.

Like parent’s context but with an extra meta keyword-argument.

Also force color default to True if not provided by user and this context has no parent.

formatter_class

alias of HelpExtraFormatter

class click_extra.ExtraFormatter(fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)

Bases: Formatter

Click Extra’s default log formatter.

Initialize the formatter with specified format strings.

Initialize the formatter either with the specified format string, or a default as described above. Allow for specialized date formatting with the optional datefmt argument. If datefmt is omitted, you get an ISO8601-like (or RFC 3339-like) format.

Use a style parameter of ‘%’, ‘{’ or ‘$’ to specify that you want to use one of %-formatting, str.format() ({}) formatting or string.Template formatting in your format string.

Changed in version 3.2: Added the style parameter.

formatMessage(record)

Colorize the record’s log level name before calling the standard formatter.

Colors are sourced from a click_extra.theme.HelpExtraTheme, resolved per-invocation via click_extra.theme.get_current_theme().

Return type:

str

class click_extra.ExtraGroup(*args, help_command=True, **kwargs)

Bases: ExtraCommand, Group

Like cloup.Group, with sane defaults and extra help screen colorization.

Like ExtraCommand.__init__, but auto-injects a help subcommand.

Parameters:

help_command (bool) – when True (the default), a help subcommand is automatically registered. Set to False to suppress it, or register your own help subcommand to override it.

command_class

alias of ExtraCommand

group_class

alias of type

add_command(cmd, name=None, **kwargs)

Like cloup.Group.add_command, but replaces an auto-injected HelpCommand when the user registers their own help subcommand.

Return type:

None

invoke(ctx)

Inject _default_subcommands and _prepend_subcommands from config.

If the user has not provided any subcommands explicitly, and the loaded configuration contains a _default_subcommands list for this group, those subcommands are injected into ctx.protected_args so that Click’s normal Group.invoke() dispatches them.

_prepend_subcommands always prepends subcommands to the invocation, regardless of whether CLI subcommands were provided. Only works with chain=True groups.

Return type:

Any

class click_extra.ExtraOption(*args, group=None, **attrs)

Bases: Option

Dedicated to option implemented by click-extra itself.

Does nothing in particular for now but provides a way to identify Click Extra’s own options with certainty.

Note

Bracket fields (envvar, default, range, required) cannot be pre-styled in get_help_record() because Click’s text wrapper splits lines after the record is returned, which would break ANSI codes that span wrapped boundaries. Styling is instead applied post-wrapping in HelpExtraFormatter._style_bracket_fields(), which uses the structured data from Option.get_help_extra() to identify each field by its label.

class click_extra.ExtraStreamHandler(stream=None)

Bases: StreamHandler

A handler to output logs to the console.

Wraps logging.StreamHandler, but use click.echo() to support color printing.

Only <stderr> or <stdout> are allowed as output stream.

If stream is not specified, <stderr> is used by default

Initialize the handler.

If stream is not specified, sys.stderr is used.

property stream: IO[Any]

The stream to which logs are written.

A proxy of the parent logging.StreamHandler’s stream attribute.

Redefined here to enforce checks on the stream value.

emit(record)

Use click.echo() to print to the console.

Return type:

None

class click_extra.ExtraVersionOption(param_decls=None, message=None, module=None, module_name=None, module_file=None, module_version=None, package_name=None, package_version=None, exec_name=None, version=None, git_repo_path=None, git_branch=None, git_long_hash=None, git_short_hash=None, git_date=None, git_tag=None, git_tag_sha=None, prog_name=None, env_info=None, message_style=None, module_style=None, module_name_style=Style(fg='bright_white'), module_file_style=None, module_version_style=Style(fg='green'), package_name_style=Style(fg='bright_white'), package_version_style=Style(fg='green'), exec_name_style=Style(fg='bright_white'), version_style=Style(fg='green'), git_repo_path_style=Style(fg='bright_black'), git_branch_style=Style(fg='cyan'), git_long_hash_style=Style(fg='yellow'), git_short_hash_style=Style(fg='yellow'), git_date_style=Style(fg='bright_black'), git_tag_style=Style(fg='cyan'), git_tag_sha_style=Style(fg='yellow'), prog_name_style=Style(fg='bright_white'), env_info_style=Style(fg='bright_black'), is_flag=True, expose_value=False, is_eager=True, help='Show the version and exit.', **kwargs)

Bases: ExtraOption

Gather CLI metadata and prints a colored version string.

Note

This started as a copy of the standard @click.version_option() decorator, but is no longer a drop-in replacement. Hence the Extra prefix.

This address the following Click issues:

• click#2324, to allow its use with the declarative params= argument.

• click#2331, by distinguishing the module from the package.

• click#1756, by allowing path and Python version.

Preconfigured as a --version option flag.

Parameters:

• message (str | None) – the message template to print, in format string syntax. Defaults to {prog_name}, version {version}.

• module (str | None) – forces the value of {module}.

• module_name (str | None) – forces the value of {module_name}.

• module_file (str | None) – forces the value of {module_file}.

• module_version (str | None) – forces the value of {module_version}.

• package_name (str | None) – forces the value of {package_name}.

• package_version (str | None) – forces the value of {package_version}.

• exec_name (str | None) – forces the value of {exec_name}.

• version (str | None) – forces the value of {version}.

• git_repo_path (str | None) – forces the value of {git_repo_path}.

• git_branch (str | None) – forces the value of {git_branch}.

• git_long_hash (str | None) – forces the value of {git_long_hash}.

• git_short_hash (str | None) – forces the value of {git_short_hash}.

• git_date (str | None) – forces the value of {git_date}.

• git_tag (str | None) – forces the value of {git_tag}.

• git_tag_sha (str | None) – forces the value of {git_tag_sha}.

• prog_name (str | None) – forces the value of {prog_name}.

• env_info (dict[str, str] | None) – forces the value of {env_info}.

• message_style (Callable[[str], str] | None) – default style of the message.

• module_style (Callable[[str], str] | None) – style of {module}.

• module_name_style (Callable[[str], str] | None) – style of {module_name}.

• module_file_style (Callable[[str], str] | None) – style of {module_file}.

• module_version_style (Callable[[str], str] | None) – style of {module_version}.

• package_name_style (Callable[[str], str] | None) – style of {package_name}.

• package_version_style (Callable[[str], str] | None) – style of {package_version}.

• exec_name_style (Callable[[str], str] | None) – style of {exec_name}.

• version_style (Callable[[str], str] | None) – style of {version}.

• git_repo_path_style (Callable[[str], str] | None) – style of {git_repo_path}.

• git_branch_style (Callable[[str], str] | None) – style of {git_branch}.

• git_long_hash_style (Callable[[str], str] | None) – style of {git_long_hash}.

• git_short_hash_style (Callable[[str], str] | None) – style of {git_short_hash}.

• git_date_style (Callable[[str], str] | None) – style of {git_date}.

• git_tag_style (Callable[[str], str] | None) – style of {git_tag}.

• git_tag_sha_style (Callable[[str], str] | None) – style of {git_tag_sha}.

• prog_name_style (Callable[[str], str] | None) – style of {prog_name}.

• env_info_style (Callable[[str], str] | None) – style of {env_info}.

template_fields: tuple[str, ...] = ('module', 'module_name', 'module_file', 'module_version', 'package_name', 'package_version', 'exec_name', 'version', 'git_repo_path', 'git_branch', 'git_long_hash', 'git_short_hash', 'git_date', 'git_tag', 'git_tag_sha', 'prog_name', 'env_info')

List of field IDs recognized by the message template.

message: str = '{prog_name}, version {version}'

Default message template used to render the version string.

static cli_frame()

Returns the frame in which the CLI is implemented.

Inspects the execution stack frames to find the package in which the user’s CLI is implemented.

Returns the frame itself.

Return type:

FrameType

property module: ModuleType

Returns the module in which the CLI resides.

property module_name: str

Returns the full module name or ``__main__`.

property module_file: str | None

Returns the module’s file full path.

property module_version: str | None

Returns the string found in the local __version__ variable.

Hint

__version__ is an old pattern from early Python packaging. It is not a standard variable and is not defined in the packaging PEPs.

You should prefer using the package_version property below instead, which uses the standard library importlib.metadata API.

We’re still supporting it for backward compatibility with existing codebases, as Click removed it in version 8.2.0.

property package_name: str | None

Returns the package name.

property package_version: str | None

Returns the package version if installed.

property exec_name: str

User-friendly name of the executed CLI.

Returns the module name. But if the later is __main__, returns the package name.

If not packaged, the CLI is assumed to be a simple standalone script, and the returned name is the script’s file name (including its extension).

property version: str | None

Return the version of the CLI.

Returns the module version if a __version__ variable is set alongside the CLI in its module.

Else returns the package version if the CLI is implemented in a package, using importlib.metadata.version().

For development versions (containing .dev), automatically appends the Git short hash as a PEP 440 local version identifier, producing versions like 1.2.3.dev0+abc1234. This helps identify the exact commit a dev build was produced from. If Git is unavailable, the plain dev version is returned.

Versions that already contain a + (i.e., a pre-baked local version identifier, typically set at build time by CI pipelines) are returned as-is to avoid producing invalid double-suffixed versions like 1.2.3.dev0+abc1234+xyz5678.

property git_repo_path: Path | None

Find the Git repository root directory.

property git_branch: str | None

Returns the current Git branch name.

Checks for a pre-baked __git_branch__ dunder first, then falls back to git rev-parse --abbrev-ref HEAD.

property git_long_hash: str | None

Returns the full Git commit hash.

Checks for a pre-baked __git_long_hash__ dunder first, then falls back to git rev-parse HEAD.

property git_short_hash: str | None

Returns the short Git commit hash.

Checks for a pre-baked __git_short_hash__ dunder first, then falls back to git rev-parse --short HEAD.

Hint

The short hash is usually the first 7 characters of the full hash, but this is not guaranteed to be the case.

But it is at least guaranteed to be unique within the repository, and a minimum of 4 characters.

property git_date: str | None

Returns the commit date in ISO format: YYYY-MM-DD HH:MM:SS +ZZZZ.

Checks for a pre-baked __git_date__ dunder first, then falls back to git show -s --format=%ci HEAD.

property git_tag: str | None

Returns the Git tag pointing at HEAD, if any.

Checks for a pre-baked __git_tag__ dunder first, then falls back to git describe --tags --exact-match HEAD.

Returns None if HEAD is not at a tagged commit.

property git_tag_sha: str | None

Returns the commit SHA that the current tag points at.

Checks for a pre-baked __git_tag_sha__ dunder first, then falls back to git rev-list -1 on the tag returned by git_tag. Returns None if HEAD is not at a tag.

property prog_name: str | None

Return the name of the CLI, from Click’s point of view.

Get the info_name of the root command.

property env_info: dict[str, Any]

Various environment info.

Returns the data produced by boltons.ecoutils.get_profile().

colored_template(template=None)

Insert ANSI styles to a message template.

Accepts a custom template as parameter, otherwise uses the default message defined on the Option instance.

This step is necessary because we need to linearize the template to apply the ANSI codes on the string segments. This is a consequence of the nature of ANSI, directives which cannot be encapsulated within another (unlike markup tags like HTML).

Return type:

str

render_message(template=None)

Render the version string from the provided template.

Accepts a custom template as parameter, otherwise uses the default self.colored_template() produced by the instance.

Return type:

str

print_debug_message()

Render in debug logs all template fields in color.

Todo

Pretty print JSON output (easier to read in bug reports)?

Return type:

None

print_and_exit(ctx, param, value)

Print the version string and exits.

Also stores all version string elements in the Context’s meta dict.

Return type:

None

class click_extra.File(mode='r', encoding=None, errors='strict', lazy=None, atomic=False)

Bases: ParamType

Declares a parameter to be a file for reading or writing. The file is automatically closed once the context tears down (after the command finished working).

Files can be opened for reading or writing. The special value - indicates stdin or stdout depending on the mode.

By default, the file is opened for reading text data, but it can also be opened in binary mode or for writing. The encoding parameter can be used to force a specific encoding.

The lazy flag controls if the file should be opened immediately or upon first IO. The default is to be non-lazy for standard input and output streams as well as files opened for reading, lazy otherwise. When opening a file lazily for reading, it is still opened temporarily for validation, but will not be held open until first IO. lazy is mainly useful when opening for writing to avoid creating the file until it is needed.

Files can also be opened atomically in which case all writes go into a separate file in the same folder and upon completion the file will be moved over to the original location. This is useful if a file regularly read by other users is modified.

See File Arguments for more information.

Changed in version 2.0: Added the atomic parameter.

name: str = 'filename'

the descriptive name of this type

envvar_list_splitter: ClassVar[str] = ':'

if a list of this type is expected and the value is pulled from a string environment variable, this is what splits it up. None means any whitespace. For all parameters the general rule is that whitespace splits them up. The exception are paths and files which are split by os.path.pathsep by default (“:” on Unix and “;” on Windows).

to_info_dict()

Gather information that could be useful for a tool generating user-facing documentation.

Use click.Context.to_info_dict() to traverse the entire CLI structure.

Added in version 8.0.

Return type:

dict[str, Any]

resolve_lazy_flag(value)

Return type:

bool

convert(value, param, ctx)

Convert the value to the correct type. This is not called if the value is None (the missing value).

This must accept string values from the command line, as well as values that are already the correct type. It may also convert other compatible types.

The param and ctx arguments may be None in certain situations, such as when converting prompt input.

If the value cannot be converted, call fail() with a descriptive message.

Parameters:

• value (str | os.PathLike[str] | t.IO[t.Any]) – The value to convert.

• param (Parameter | None) – The parameter that is using this type to convert its value. May be None.

• ctx (Context | None) – The current context that arrived at this value. May be None.

Return type:

t.IO[t.Any]

shell_complete(ctx, param, incomplete)

Return a special completion marker that tells the completion system to use the shell to provide file path completions.

Parameters:

• ctx (Context) – Invocation context for this command.

• param (Parameter) – The parameter that is requesting completion.

• incomplete (str) – Value being completed. May be empty.

Added in version 8.0.

Return type:

list[CompletionItem]

exception click_extra.FileError(filename, hint=None)

Bases: ClickException

Raised if a file cannot be opened.

ui_filename: str

format_message()

Return type:

str

class click_extra.FloatRange(min=None, max=None, min_open=False, max_open=False, clamp=False)

Bases: _NumberRangeBase, FloatParamType

Restrict a click.FLOAT value to a range of accepted values. See Int and Float Ranges.

If min or max are not passed, any value is accepted in that direction. If min_open or max_open are enabled, the corresponding boundary is not included in the range.

If clamp is enabled, a value outside the range is clamped to the boundary instead of failing. This is not supported if either boundary is marked open.

Changed in version 8.0: Added the min_open and max_open parameters.

name: str = 'float range'

the descriptive name of this type

class click_extra.Group(*args, show_subcommand_aliases=None, commands=None, **kwargs)

Bases: SectionMixin, Command, Group

A click.Group that allows to organize its subcommands in multiple help sections and whose subcommands are, by default, of type cloup.Command.

Refer to superclasses for the documentation of all accepted parameters:

• SectionMixin

• Command

• click.Group

Apart from superclasses arguments, the following is the only additional parameter:

show_subcommand_aliases: Optional[bool] = None

whether to show subcommand aliases; aliases are shown by default and can be disabled using this argument or the homonym context setting.

Changed in version 0.14.0: this class now supports option groups and constraints.

Added in version 0.10.0: the “command aliases” feature, including the show_subcommand_aliases parameter/attribute.

Changed in version 0.8.0: this class now inherits from cloup.BaseCommand.

Parameters:

• align_sections – whether to align the columns of all subcommands’ help sections. This is also available as a context setting having a lower priority than this attribute. Given that this setting should be consistent across all you commands, you should probably use the context setting only.

• args (Any) – positional arguments forwarded to the next class in the MRO

• kwargs (Any) – keyword arguments forwarded to the next class in the MRO

SHOW_SUBCOMMAND_ALIASES: bool = False

show_subcommand_aliases

Whether to show subcommand aliases.

alias2name: Dict[str, str]

Dictionary mapping each alias to a command name.

add_multiple_commands(commands)

Return type:

None

add_command(cmd, name=None, section=None, fallback_to_default_section=True)

Add a subcommand to this Group.

Implementation note: fallback_to_default_section looks not very clean but, even if it’s not immediate to see (it wasn’t for me), I chose it over apparently cleaner options.

Parameters:

• cmd (Command)

• name (str | None)

• section (Section | None) – a Section instance. The command must not be in the section already.

• fallback_to_default_section (bool) – if section is None and this option is enabled, the command is added to the “default section”. If disabled, the command is not added to any section unless section is provided. This is useful for internal code and subclasses. Don’t disable it unless you know what you are doing.

Return type:

None

resolve_command_name(ctx, name)

Map a string supposed to be a command name or an alias to a normalized command name. If no match is found, it returns None.

Return type:

str | None

resolve_command(ctx, args)

Return type:

Tuple[str | None, Command | None, List[str]]

handle_bad_command_name(bad_name, valid_names, error)

This method is called when a command name cannot be resolved. Useful to implement the “Did you mean <x>?” feature.

Parameters:

• bad_name (str) – the command name that could not be resolved.

• valid_names (List[str]) – the list of valid command names, including aliases.

• error (UsageError) – the original error coming from Click.

Return type:

UsageError

Returns:

the original error or a new one.

must_show_subcommand_aliases(ctx)

Return type:

bool

format_subcommand_name(ctx, name, cmd)

Used to format the name of the subcommands. This method is useful when you combine this extension with other click extensions that override format_commands(). Most of these, like click-default-group, just add something to the name of the subcommands, which is exactly what this method allows you to do without overriding bigger methods.

Return type:

str

static format_subcommand_aliases(aliases, theme)

Return type:

str

command(name=None, *, aliases=None, cls=None, section=None, **kwargs)

Overloads:

• self, name (Optional[str]), aliases (Optional[Iterable[str]]), cls (None), section (Optional[Section]), context_settings (Optional[Dict[str, Any]]), formatter_settings (Optional[Dict[str, Any]]), help (Optional[str]), epilog (Optional[str]), short_help (Optional[str]), options_metavar (Optional[str]), add_help_option (bool), no_args_is_help (bool), hidden (bool), deprecated (bool), align_option_groups (Optional[bool]), show_constraints (Optional[bool]), params (Optional[List[click.Parameter]]) → Callable[[AnyCallable], click.Command]

• self, name (Optional[str]), aliases (Optional[Iterable[str]]), cls (Type[C]), section (Optional[Section]), context_settings (Optional[Dict[str, Any]]), help (Optional[str]), epilog (Optional[str]), short_help (Optional[str]), options_metavar (Optional[str]), add_help_option (bool), no_args_is_help (bool), hidden (bool), deprecated (bool), params (Optional[List[click.Parameter]]), kwargs (Any) → Callable[[AnyCallable], C]

Return a decorator that creates a new subcommand of this Group using the decorated function as callback.

It takes the same arguments of command() plus:

section: Optional[Section]

if provided, put the subcommand in this section.

Changed in version 0.10.0: all arguments but name are now keyword-only.

group(name=None, *, cls=None, aliases=None, section=None, **kwargs)

Overloads:

• self, name (Optional[str]), aliases (Optional[Iterable[str]]), cls (None), section (Optional[Section]), sections (Iterable[Section]), align_sections (Optional[bool]), invoke_without_command (bool), no_args_is_help (bool), context_settings (Optional[Dict[str, Any]]), formatter_settings (Dict[str, Any]), help (Optional[str]), epilog (Optional[str]), short_help (Optional[str]), options_metavar (Optional[str]), subcommand_metavar (Optional[str]), add_help_option (bool), chain (bool), hidden (bool), deprecated (bool), show_subcommand_aliases (bool) → Callable[[AnyCallable], click.Group]

• self, name (Optional[str]), aliases (Optional[Iterable[str]]), cls (Optional[Type[G]]), section (Optional[Section]), invoke_without_command (bool), no_args_is_help (bool), context_settings (Optional[Dict[str, Any]]), help (Optional[str]), epilog (Optional[str]), short_help (Optional[str]), options_metavar (Optional[str]), subcommand_metavar (Optional[str]), add_help_option (bool), chain (bool), hidden (bool), deprecated (bool), params (Optional[List[click.Parameter]]), kwargs (Any) → Callable[[AnyCallable], G]

Return a decorator that creates a new subcommand of this Group using the decorated function as callback.

It takes the same argument of group() plus:

section: Optional[Section]

if provided, put the subcommand in this section.

Changed in version 0.10.0: all arguments but name are now keyword-only.

class click_extra.HelpCommand(name, context_settings=None, callback=None, params=None, help=None, epilog=None, short_help=None, options_metavar='[OPTIONS]', add_help_option=True, no_args_is_help=False, hidden=False, deprecated=False)

Bases: ColorizedCommand

Synthetic subcommand that displays help for the parent group or a subcommand.

Auto-injected into every ExtraGroup. Supports nested resolution: mycli help subgroup subcmd shows the help for subcmd within subgroup.

invoke(ctx)

Resolve the command path and display its help.

Return type:

None

class click_extra.HelpExtraFormatter(*args, **kwargs)

Bases: HelpFormatter

Extends Cloup’s custom HelpFormatter to highlights options, choices, metavars and default values.

This is being discussed for upstream integration at:

• https://github.com/janluke/cloup/issues/97

• https://github.com/click-contrib/click-help-colors/issues/17

• https://github.com/janluke/cloup/issues/95

Forces theme to the active one for the current Click context.

Also transform Cloup’s standard HelpTheme to our own HelpExtraTheme.

Resolves the active theme via click_extra.theme.get_current_theme(), which reads the per-invocation pick from the Click context (set by ThemeOption) and falls back to the module-level default when no context is active.

theme: HelpExtraTheme

write_usage(prog, args='', prefix=None)

ANSI-aware override of cloup.HelpFormatter.write_usage().

Click’s click.formatting.wrap_text() measures line length with raw len(), counting every byte of the ANSI escape sequences embedded in initial_indent (the styled Usage: heading + invoked-command name). With 24-bit RGB themes (e.g. Solarized Dark, Dracula, Nord, Monokai), each styled token carries 17+ extra bytes of escape, which inflates the measured line beyond the width budget and causes premature wraps mid-token: [OPTIONS\n  ].

Cloup styles prefix and prog then delegates to click’s HelpFormatter.write_usage(), inheriting the bug. This override re-applies the same styling, then bypasses wrap_text whenever the visible content fits on a single line: the common case for short usage strings where wrapping is unnecessary. Lines that genuinely overflow the visible width fall back to click’s implementation: the wrap point may still be sub-optimal but the output stays syntactically valid.

See also

Upstream fix proposed at https://github.com/pallets/click/pull/3420, which makes click.formatting.TextWrapper ANSI-aware by counting visible width instead of raw bytes. Once that lands in a Click release, this override can be removed.

Todo

Drop this override once the minimum supported Click pins to the release that includes pallets/click#3420. The term_len-based visible-width check below becomes redundant once Click’s own wrapper counts visible width.

Return type:

None

keywords: HelpKeywords = HelpKeywords(cli_names=set(), subcommands=set(), command_aliases=set(), arguments=set(), long_options=set(), short_options=set(), choices=set(), choice_metavars=set(), metavars=set(), envvars=set(), defaults=set())

excluded_keywords: HelpKeywords | None = None

highlight_extra_keywords(help_text)

Highlight extra keywords in help screens based on the theme.

Uses the highlight() function for all keyword categories. Each category is processed as a batch of regex patterns with a single styling function, which handles overlapping matches and prevents double-styling.

Return type:

str

getvalue()

Wrap original Click.HelpFormatter.getvalue() to force extra-colorization on rendering.

Return type:

str

class click_extra.HelpExtraTheme(invoked_command=<function identity>, command_help=<function identity>, heading=<function identity>, constraint=<function identity>, section_help=<function identity>, col1=<function identity>, col2=<function identity>, alias=<function identity>, alias_secondary=None, epilog=<function identity>, critical=<function identity>, error=<function identity>, warning=<function identity>, info=<function identity>, debug=<function identity>, option=<function identity>, subcommand=<function identity>, choice=<function identity>, metavar=<function identity>, bracket=<function identity>, envvar=<function identity>, default=<function identity>, range_label=<function identity>, required=<function identity>, argument=<function identity>, deprecated=<function identity>, search=<function identity>, success=<function identity>, cross_ref_highlight=True, subheading=<function identity>)

Bases: HelpTheme

Extends cloup.HelpTheme with slots for log levels and the structural elements Click Extra highlights in help screens.

Each slot below documents what it colors. The built-in themes shipped in BUILTIN_THEMES provide the visual styling by setting the relevant slots; user-defined themes can be authored as plain mappings and loaded via from_dict().

critical()

Style applied to the CRITICAL level name in log records.

Example:

CRITICAL: Database connection lost.

Return type:

TypeVar(T)

error()

Style applied to the ERROR level name in log records.

Example:

ERROR: Configuration file not found.

Return type:

TypeVar(T)

warning()

Style applied to the WARNING level name in log records.

Example:

WARNING: Requested 16 jobs exceeds available CPU cores (8).

Return type:

TypeVar(T)

info()

Style applied to the INFO level name in log records.

Usually left at identity: INFO is the default verbosity and shouldn’t stand out from regular output.

Example:

INFO: Loaded 23 records.

Return type:

TypeVar(T)

debug()

Style applied to the DEBUG level name in log records.

Example:

DEBUG: Resolved /etc/myapp/config.toml.

Return type:

TypeVar(T)

option()

Style applied to option names (--config, -v, --ansi/--no-ansi) wherever they appear: synopsis column, free-form descriptions, and docstrings (when cross_ref_highlight is enabled).

Example:

--config CONFIG_PATH    Location of the configuration file.
-v, --verbose           Increase verbosity.

Return type:

TypeVar(T)

subcommand()

Style applied to subcommand names: in a group’s command list and wherever they are referenced in prose.

Example:

Commands:
  backup        Snapshot the data store.
  restore       Restore from a snapshot.
  show (ls)     Show the current state.

Return type:

TypeVar(T)

choice()

Style applied to each individual value inside a click.Choice metavar and to those values referenced in option descriptions.

Example:

--format [json|csv|xml]   Output format. Defaults to json.

Return type:

TypeVar(T)

metavar()

Style applied to type metavars (INTEGER, TEXT, PATH, FILE, …) that follow an option name in the synopsis column.

Example:

--output TEXT       Destination file.
--workers INTEGER   Worker count.

Return type:

TypeVar(T)

bracket()

Style applied to the literal bracket characters and label prefixes of trailing fields: [, ], default:, env var:, required, and the field separators between them.

Example:

--port INTEGER    [default: 8080; env var: PORT; required]

Return type:

TypeVar(T)

envvar()

Style applied to environment-variable values inside [env var: ...] bracket fields, and to envvar names mentioned in option descriptions.

Example:

--threshold INTEGER   Acceptable error rate.
                      [env var: THRESHOLD, TEST_THRESHOLD]

Return type:

TypeVar(T)

default()

Style applied to the default-value content inside [default: ...] bracket fields.

Example:

--output FILENAME    Destination file.  [default: out.csv]
--retries INTEGER    Retry budget.  [default: 5]

Return type:

TypeVar(T)

range_label()

Style applied to range expressions (0<=x<=9, x>=1024, 0<=x<100) that appear inside bracket fields for IntRange and FloatRange options.

Example:

--level INTEGER RANGE    Verbosity level.  [0<=x<=9]
--port INTEGER RANGE     Bind port.        [x>=1024]

Return type:

TypeVar(T)

required()

Style applied to the required label inside bracket fields on mandatory options.

Example:

--token TEXT    Authentication token.  [required]

Return type:

TypeVar(T)

argument()

Style applied to argument metavars (positional parameter names like MY_ARG, SCRIPT, [FILENAMES]...) in the synopsis column and when referenced in prose.

Example:

Usage: cp [OPTIONS] SRC DST
Usage: pack [OPTIONS] [FILES]... [OUTPUT]

Return type:

TypeVar(T)

deprecated()

Style applied to (DEPRECATED) / (Deprecated: reason) markers appended to options and commands.

Example:

--old-api    Legacy endpoint. (DEPRECATED: use --new-api instead)
--legacy     Kept for compatibility. (deprecated: will be removed in v9)

Return type:

TypeVar(T)

search()

Style applied to substring matches in <cli> help --search output, so users can spot where their query matched.

Example: running my-cli help --search retry highlights every occurrence of retry in the rendered help output, including --retries, RetryError, and prose mentions of “retry budget”.

Return type:

TypeVar(T)

success()

Style applied to success glyphs in pre-rendered UI elements (the ✓ in OK_GLYPH) and any text passed through this slot by downstream code.

Example:

✓ database migration completed
✓ 1,245 records imported

Return type:

TypeVar(T)

cross_ref_highlight: bool = True

Highlight options, choices, arguments, metavars and CLI names in free-form text (descriptions, docstrings).

When False, only structural elements are styled: bracket fields ([default: ...], [env var: ...], ranges, [required]), deprecated messages, and subcommand names in definition lists.

subheading()

Style for sub-section headings inside log output or inline help.

Distinct from heading (which styles the top-level help-screen section titles): subheading is intended for downstream code that wants a second styling level for its own narrative output.

Example:

◼ 3 mails sharing hash a1b2c3d4
◼ 7 mails sharing hash e5f6a7b8

See also

Used by mail-deduplicate to style ◼ N mails sharing hash … log lines.

Return type:

TypeVar(T)

with_(**kwargs)

Derives a new theme from the current one, with some styles overridden.

Returns the same instance if the provided styles are the same as the current.

Return type:

HelpExtraTheme

to_dict()

Serialize the theme to a plain dict suitable for TOML/JSON/YAML.

Each Style slot is emitted via Style.to_dict. Slots left at their default (identity or None) are omitted, so the output only carries what the theme actually overrides. Pair with from_dict() to round-trip.

Raises:

TypeError – when a slot holds an opaque IStyle callable that is not a Style (those cannot be serialized).

Return type:

dict[str, Any]

classmethod from_dict(data)

Build a theme from the plain dict produced by to_dict().

Each value is interpreted by field type: a mapping becomes a Style via Style.from_dict, while cross_ref_highlight is read as a plain bool. Unknown keys raise TypeError so typos surface immediately.

Return type:

HelpExtraTheme

cascade(base)

Layer this theme’s set slots on top of base.

Mirrors Style.cascade at the slot level: this theme’s non-default slots win, base fills the rest. Useful for layering a sparse override (typically parsed from a config file’s [tool.<cli>.themes.<name>] table) on top of a full built-in palette.

Raises:

TypeError – when base is not a HelpExtraTheme.

Return type:

HelpExtraTheme

class click_extra.HelpFormatter(indent_increment=2, width=None, max_width=None, col1_max_width=30, col2_min_width=35, col_spacing=2, row_sep=None, theme=HelpTheme(invoked_command=<function identity>, command_help=<function identity>, heading=<function identity>, constraint=<function identity>, section_help=<function identity>, col1=<function identity>, col2=<function identity>, alias=<function identity>, alias_secondary=None, epilog=<function identity>))

Bases: HelpFormatter

A custom help formatter. Features include:

• more attributes for controlling the output of the formatter

• a col1_width parameter in write_dl() that allows Cloup to align multiple definition lists without resorting to hacks

• a “linear layout” for definition lists that kicks in when the available terminal width is not enough for the standard 2-column layout (see argument col2_min_width)

• the first column width, when not explicitly given in write_dl is computed excluding the rows that exceed col1_max_width (called col_max in write_dl for compatibility with Click).

Changed in version 0.9.0: the row_sep parameter now:

• is set to None by default and row_sep="" corresponds to an empty line between rows

• must not ends with \n; the formatter writes a newline just after it (when it’s not None), so a newline at the end is always enforced

• accepts instances of SepGenerator and RowSepPolicy.

Added in version 0.8.0.

Parameters:

• indent_increment (int) – width of each indentation increment.

• width (int | None) – content line width, excluding the newline character; by default it’s initialized to min(terminal_width - 1, max_width) where max_width is another argument.

• max_width (int | None) – maximum content line width (equivalent to Context.max_content_width). Used to compute width when it is not provided, ignored otherwise.

• col1_max_width (int) – the maximum width of the first column of a definition list; as in Click, if the text of a row exceeds this threshold, the 2nd column is printed on a new line.

• col2_min_width (int) – the minimum width for the second column of a definition list; if the available space is less than this value, the formatter switches from the standard 2-column layout to the “linear layout” (that this decision is taken for each definition list). If you want to always use the linear layout, you can set this argument to a very high number (or math.inf). If you never want it (not recommended), you can set this argument to zero.

• col_spacing (int) – the number of spaces between the column boundaries of a definition list.

• row_sep (None | str | SepGenerator | RowSepPolicy) – an “extra” separator to insert between the rows of a definition list (in addition to the normal newline between definitions). If you want an empty line between rows, pass row_sep="". Read Row separators for more.

• theme (HelpTheme) – an HelpTheme instance specifying how to style the various elements of the help page.

width: int

static settings(*, width=_Missing.flag, max_width=_Missing.flag, indent_increment=_Missing.flag, col1_max_width=_Missing.flag, col2_min_width=_Missing.flag, col_spacing=_Missing.flag, row_sep=_Missing.flag, theme=_Missing.flag)

A utility method for creating a formatter_settings dictionary to pass as context settings or command attribute. This method exists for one only reason: it enables auto-complete for formatter options, thus improving the developer experience.

Parameters are described in HelpFormatter.

Return type:

Dict[str, Any]

property available_width: int

write(*strings)

Writes a unicode string into the internal buffer.

Return type:

None

write_usage(prog, args='', prefix=None)

Writes a usage line into the buffer.

Parameters:

• prog (str) – the program name.

• args (str) – whitespace separated list of arguments.

• prefix (str | None) – The prefix for the first line. Defaults to "Usage: ".

Return type:

None

write_aliases(aliases)

Return type:

None

write_command_help_text(cmd)

Return type:

None

write_heading(heading, newline=True)

Writes a heading into the buffer.

Return type:

None

write_many_sections(sections, aligned=True)

Return type:

None

write_aligned_sections(sections)

Write multiple aligned definition lists.

Return type:

None

write_section(s, col1_width=None)

Return type:

None

write_text(text, style=<function identity>)

Writes re-indented text into the buffer. This rewraps and preserves paragraphs.

Return type:

None

compute_col1_width(rows, max_width)

Return type:

int

write_dl(rows, col_max=None, col_spacing=None, col1_width=None)

Write a definition list into the buffer. This is how options and commands are usually formatted.

If there’s enough space, definition lists are rendered as a 2-column pseudo-table: if the first column text of a row doesn’t fit in the provided/computed col1_width, the 2nd column is printed on the following line.

If the available space for the 2nd column is below self.col2_min_width, the 2nd “column” is always printed below the 1st, indented with a minimum of 3 spaces (or one indent_increment if that’s greater than 3).

Parameters:

• rows (Sequence[Tuple[str, str | Callable[[int], str]]]) – a list of two item tuples for the terms and values.

• col_max (int | None) – the maximum width for the 1st column of a definition list; this argument is here to not break compatibility with Click; if provided, it overrides the attribute self.col1_max_width.

• col_spacing (int | None) – number of spaces between the first and second column; this argument is here to not break compatibility with Click; if provided, it overrides self.col_spacing.

• col1_width (int | None) – the width to use for the first column; if not provided, it’s computed as the length of the longest string under self.col1_max_width; useful when you need to align multiple definition lists.

Return type:

None

write_tabular_dl(rows, col1_width, col_spacing, col2_width)

Format a definition list as a 2-column “pseudo-table”. If the first column of a row exceeds col1_width, the 2nd column is written on the subsequent line. This is the standard way of formatting definition lists and it’s the default if there’s enough space.

Return type:

None

write_linear_dl(dl)

Format a definition list as a “linear list”. This is the default when the available width for the definitions (2nd column) is below self.col2_min_width.

Return type:

None

write_epilog(epilog)

Return type:

None

class click_extra.HelpKeywords(cli_names=<factory>, subcommands=<factory>, command_aliases=<factory>, arguments=<factory>, long_options=<factory>, short_options=<factory>, choices=<factory>, choice_metavars=<factory>, metavars=<factory>, envvars=<factory>, defaults=<factory>)

Bases: object

Structured collection of keywords extracted from a Click context for help screen highlighting.

Each field corresponds to a semantic category with its own styling.

cli_names: set[str]

subcommands: set[str]

command_aliases: set[str]

arguments: set[str]

long_options: set[str]

short_options: set[str]

choices: set[str]

choice_metavars: set[str]

metavars: set[str]

envvars: set[str]

defaults: set[str]

merge(other)

Merge another HelpKeywords into this one.

Each set field is updated with the corresponding set from other.

Return type:

None

subtract(other)

Remove keywords found in other from this instance.

Each set field is difference-updated with the corresponding set from other. Mirror of merge().

Return type:

None

class click_extra.HelpSection(heading, definitions, help=None, constraint=None)

Bases: object

A container for a help section data.

heading: str

Help section title.

definitions: Sequence[Tuple[str, str | Callable[[int], str]]]

Rows with 2 columns each. The 2nd element of each row can also be a function taking an integer (the available width for the 2nd column) and returning a string.

help: str | None = None

(Optional) long description of the section.

constraint: str | None = None

(Optional) option group constraint description.

class click_extra.HelpTheme(invoked_command=<function identity>, command_help=<function identity>, heading=<function identity>, constraint=<function identity>, section_help=<function identity>, col1=<function identity>, col2=<function identity>, alias=<function identity>, alias_secondary=None, epilog=<function identity>)

Bases: object

A collection of styles for several elements of the help page.

A “style” is just a function or a callable that takes a string and returns a styled version of it. This means you can use your favorite styling/color library (like rich, colorful etc). Nonetheless, given that Click has some basic styling functionality built-in, Cloup provides the Style class, which is a wrapper of the click.style function.

Parameters:

• invoked_command (Callable[[str], str]) – Style of the invoked command name (in Usage).

• command_help (Callable[[str], str]) – Style of the invoked command description (below Usage).

• heading (Callable[[str], str]) – Style of help section headings.

• constraint (Callable[[str], str]) – Style of an option group constraint description.

• section_help (Callable[[str], str]) – Style of the help text of a section (the optional paragraph below the heading).

• col1 (Callable[[str], str]) – Style of the first column of a definition list (options and command names).

• col2 (Callable[[str], str]) – Style of the second column of a definition list (help text).

• epilog (Callable[[str], str]) – Style of the epilog.

• alias (Callable[[str], str]) – Style of subcommand aliases in a definition lists.

• alias_secondary (Callable[[str], str] | None) – Style of separator and eventual parenthesis/brackets in subcommand alias lists. If not provided, the alias style will be used.

invoked_command()

Style of the invoked command name (in Usage).

Return type:

TypeVar(T)

command_help()

Style of the invoked command description (below Usage).

Return type:

TypeVar(T)

heading()

Style of help section headings.

Return type:

TypeVar(T)

constraint()

Style of an option group constraint description.

Return type:

TypeVar(T)

section_help()

Style of the help text of a section (the optional paragraph below the heading).

Return type:

TypeVar(T)

col1()

Style of the first column of a definition list (options and command names).

Return type:

TypeVar(T)

col2()

Style of the second column of a definition list (help text).

Return type:

TypeVar(T)

alias()

Style of subcommand aliases in a definition lists.

Return type:

TypeVar(T)

alias_secondary: Callable[[str], str] | None = None

Style of separator and eventual parenthesis/brackets in subcommand alias lists. If not provided, the alias style will be used.

epilog()

Style of the epilog.

Return type:

TypeVar(T)

with_(invoked_command=None, command_help=None, heading=None, constraint=None, section_help=None, col1=None, col2=None, alias=None, alias_secondary=_Missing.flag, epilog=None)

Return type:

HelpTheme

static dark()

A theme assuming a dark terminal background color.

Return type:

HelpTheme

static light()

A theme assuming a light terminal background color.

Return type:

HelpTheme

class click_extra.IntRange(min=None, max=None, min_open=False, max_open=False, clamp=False)

Bases: _NumberRangeBase, IntParamType

Restrict an click.INT value to a range of accepted values. See Int and Float Ranges.

If min or max are not passed, any value is accepted in that direction. If min_open or max_open are enabled, the corresponding boundary is not included in the range.

If clamp is enabled, a value outside the range is clamped to the boundary instead of failing.

Changed in version 8.0: Added the min_open and max_open parameters.

name: str = 'integer range'

the descriptive name of this type

class click_extra.JobsOption(param_decls=None, default=1, expose_value=False, show_default=True, type=<class 'int'>, help='Number of parallel jobs. Defaults to one less than available CPUs.', **kwargs)

Bases: ExtraOption

A pre-configured --jobs option to control parallel execution.

Defaults to one fewer than the number of available CPU cores, leaving one core free for the main process and system tasks.

The resolved value is stored in ctx.meta[click_extra.context.JOBS].

Warning

This option is a placeholder for future parallel execution utilities. It does not drive any concurrency by itself: downstream code must read ctx.meta[click_extra.context.JOBS] and act on it.

validate_jobs(ctx, param, value)

Validate job count and store the effective value in context metadata.

Clamps values below 1 to 1 and warns when the requested count exceeds available CPU cores.

Return type:

None

class click_extra.LazyGroup(*args, lazy_subcommands=None, **kwargs)

Bases: ExtraGroup

An ExtraGroup that supports lazy loading of subcommands.

Hint

This implementation is based on the snippet from Click’s documentation: Defining the lazy group.

It has been extended to work with Click Extra’s config_option in click_extra#1332 issue.

lazy_subcommands maps command names to their import paths.

Tip

lazy_subcommands is a map of the form:

{"<command-name>": "<module-name>.<command-object-name>"}

Example:

{"mycmd": "my_cli.commands.mycmd"}

list_commands(ctx)

List all commands, including not-yet-loaded lazy subcommands.

Return type:

list[str]

get_command(ctx, cmd_name)

Get a command by name, loading lazily if necessary.

Todo

Allow passing extra parameters to the self.lazy_subcommands so we can register commands with custom settings like Cloup’s section or fallback_to_default_section:

• section: Optional[Section] = None,

• fallback_to_default_section: bool = True,

See: https://github.com/janluke/cloup/blob/master/cloup/_sections.py#L169

Return type:

Command | None

class click_extra.LogLevel(*values)

Bases: IntEnum

Mapping of canonical log level names to their integer level.

That’s our own version of logging._nameToLevel, but:

• sorted from lowest to highest verbosity,

• excludes the following levels:

  • NOTSET, which is considered internal

  • WARN, which is obsolete

  • FATAL, which shouldn’t be used and has been replaced by CRITICAL

CRITICAL = 50

ERROR = 40

WARNING = 30

INFO = 20

DEBUG = 10

exception click_extra.MissingParameter(message=None, ctx=None, param=None, param_hint=None, param_type=None)

Bases: BadParameter

Raised if click required an option or argument but it was not provided when invoking the script.

Added in version 4.0.

Parameters:

param_type (str | None) – a string that indicates the type of the parameter. The default is to inherit the parameter type from the given param. Valid values are 'parameter', 'option' or 'argument'.

format_message()

Return type:

str

class click_extra.NoConfigOption(param_decls=None, type=UNPROCESSED, help='Ignore all configuration files and only use command line parameters and environment variables.', is_flag=True, flag_value=Sentinel.NO_CONFIG, is_eager=True, expose_value=False, **kwargs)

Bases: ExtraOption

A pre-configured option adding --no-config.

This option is supposed to be used alongside the --config option (ConfigOption) to allow users to explicitly disable the use of any configuration file.

This is especially useful to debug side-effects caused by autodetection of configuration files.

See also

An alternative implementation of this class would be to create a custom click.ParamType instead of a custom Option subclass. Here is for example.

check_sibling_config_option(ctx, param, value)

Ensure that this option is used alongside a ConfigOption instance.

Return type:

None

exception click_extra.NoSuchOption(option_name, message=None, possibilities=None, ctx=None)

Bases: UsageError

Raised if click attempted to handle an option that does not exist.

Added in version 4.0.

format_message()

Return type:

str

class click_extra.Option(*args, group=None, **attrs)

Bases: _ParameterMixin, Option

Wrap cloup.Option, itself inheriting from click.Option.

Inherits first from _ParameterMixin to allow future overrides of Click’s Parameter methods.

class click_extra.OptionGroup(title, help=None, constraint=None, hidden=False)

Bases: object

Contains the information of an option group and identifies it. Note that, as far as the clients of this library are concerned, an OptionGroups acts as a “marker” for options, not as a container for related options. When you call @optgroup.option(...) you are not adding an option to a container, you are just adding an option marked with this option group.

Added in version 0.8.0: The hidden parameter.

property options: Sequence[Option]

get_help_records(ctx)

Return type:

List[Tuple[str, str]]

option(*param_decls, **attrs)

Refer to cloup.option().

Return type:

Callable[[TypeVar(F, bound= Callable[..., Any])], TypeVar(F, bound= Callable[..., Any])]

class click_extra.OptionGroupMixin(*args, align_option_groups=None, **kwargs)

Bases: object

Implements support for:

• option groups

• the “Positional arguments” help section; this section is shown only if at least one of your arguments has non-empty help.

Important

In order to check the constraints defined on the option groups, a command must inherits from cloup.ConstraintMixin too!

Added in version 0.14.0: added the “Positional arguments” help section.

Changed in version 0.8.0: this mixin now relies on cloup.HelpFormatter to align help sections. If a click.HelpFormatter is used with a TypeError is raised.

Changed in version 0.8.0: removed format_option_group. Added get_default_option_group and make_option_group_help_section.

Added in version 0.5.0.

Parameters:

• align_option_groups (bool | None) – whether to align the columns of all option groups’ help sections. This is also available as a context setting having a lower priority than this attribute. Given that this setting should be consistent across all you commands, you should probably use the context setting only.

• args (Any) – positional arguments forwarded to the next class in the MRO

• kwargs (Any) – keyword arguments forwarded to the next class in the MRO

option_groups

List of all option groups, except the “default option group”.

ungrouped_options

List of options not explicitly assigned to an user-defined option group. These options will be included in the “default option group”. Note: this list does not include options added automatically by Click based on context settings, like the --help option; use the get_ungrouped_options() method if you need the real full list (which needs a Context object).

get_ungrouped_options(ctx)

Return options not explicitly assigned to an option group (eventually including the --help option), i.e. options that will be part of the “default option group”.

Return type:

Sequence[Option]

get_argument_help_record(arg, ctx)

Return type:

Tuple[str, str]

get_arguments_help_section(ctx)

Return type:

HelpSection | None

make_option_group_help_section(group, ctx)

Return a HelpSection for an OptionGroup, i.e. an object containing the title, the optional description and the options’ definitions for this option group.

Added in version 0.8.0.

Return type:

HelpSection

must_align_option_groups(ctx, default=True)

Return True if the help sections of all options groups should have their columns aligned.

Added in version 0.8.0.

Return type:

bool

get_default_option_group(ctx, is_the_only_visible_option_group=False)

Return an OptionGroup instance for the options not explicitly assigned to an option group, eventually including the --help option.

Added in version 0.8.0.

Return type:

OptionGroup

format_params(ctx, formatter)

Return type:

None

class click_extra.ParamStructure(*args, excluded_params=None, included_params=None, **kwargs)

Bases: object

Utilities to introspect CLI options and commands structure.

Structures are represented by a tree-like dict.

Access to a node is available using a serialized path string composed of the keys to descend to that node, separated by a dot ..

Todo

Evaluates the possibility of replacing all key-based access to the tree-like structure by a Box object, as it provides lots of utilities to merge its content.

Allow a list of paramerers to be blocked from the parameter structure.

Items of excluded_params are expected to be the fully-qualified ID of the parameter. Which is the dot-separated ID that is prefixed by the CLI name, featured in the first column of the table.

included_params is the inverse: only the listed parameters will be allowed. Cannot be used together with excluded_params.

SEP: str = '.'

Use a dot . as a separator between levels of the tree-like parameter structure.

excluded_params: frozenset[str]

included_params: frozenset[str] | None

static init_tree_dict(*path, leaf=None)

Utility method to recursively create a nested dict structure whose keys are provided by path list and at the end is populated by a copy of leaf.

Return type:

Any

static get_tree_value(tree_dict, *path)

Get in the tree_dict the value located at the path.

Raises KeyError if no item is found at the provided path.

Return type:

Any

flatten_tree_dict(tree_dict, parent_key=None)

Recursively traverse the tree-like dict and produce a flat dict whose keys are path and values are the leaf’s content.

Return type:

dict[str, Any]

walk_params()

Generates an unfiltered list of all CLI parameters.

Everything is included, from top-level groups to subcommands, and from options to arguments.

Return type:

Iterator[tuple[tuple[str, ...], Parameter]]

Returns a 2-elements tuple:

• the first being a tuple of keys leading to the parameter

• the second being the parameter object itself

TYPE_MAP: ClassVar[dict[type[ParamType], type[str | int | float | bool | list]]] = {<class 'click.types.BoolParamType'>: <class 'bool'>, <class 'click.types.Choice'>: <class 'str'>, <class 'click.types.DateTime'>: <class 'str'>, <class 'click.types.File'>: <class 'str'>, <class 'click.types.FloatParamType'>: <class 'float'>, <class 'click.types.FloatRange'>: <class 'float'>, <class 'click.types.IntParamType'>: <class 'int'>, <class 'click.types.IntRange'>: <class 'int'>, <class 'click.types.Path'>: <class 'str'>, <class 'click.types.StringParamType'>: <class 'str'>, <class 'click.types.Tuple'>: <class 'list'>, <class 'click.types.UUIDParameterType'>: <class 'str'>, <class 'click.types.UnprocessedParamType'>: <class 'str'>}

Map Click types to their Python equivalent.

Keys are subclasses of click.types.ParamType. Values are expected to be simple builtins Python types.

This mapping can be seen as a reverse of the click.types.convert_type() method.

static get_param_type(param)

Get the Python type of a Click parameter.

Returns str for unrecognised custom types, since command-line parameters are strings by default.

See the list of custom types provided by Click.

Return type:

type[str | int | float | bool | list]

build_param_trees()

Build the parameters tree structure and cache it.

This removes parameters whose fully-qualified IDs are in the excluded_params blocklist.

If included_params was provided, it is resolved into excluded_params here, where all parameter IDs are available.

Return type:

None

property params_template: dict[str, Any]

Returns a tree-like dictionary whose keys shadows the CLI options and subcommands and values are None.

Perfect to serve as a template for configuration files.

property params_objects: dict[str, Any]

Returns a tree-like dictionary whose keys shadows the CLI options and subcommands and values are parameter objects.

Perfect to parse configuration files and user-provided parameters.

class click_extra.ParamType

Bases: object

Represents the type of a parameter. Validates and converts values from the command line or Python into the correct type.

To implement a custom type, subclass and implement at least the following:

• The name class attribute must be set.

• Calling an instance of the type with None must return None. This is already implemented by default.

• convert() must convert string values to the correct type.

• convert() must accept values that are already the correct type.

• It must be able to convert a value if the ctx and param arguments are None. This can occur when converting prompt input.

is_composite: ClassVar[bool] = False

arity: ClassVar[int] = 1

name: str

the descriptive name of this type

envvar_list_splitter: ClassVar[str | None] = None

if a list of this type is expected and the value is pulled from a string environment variable, this is what splits it up. None means any whitespace. For all parameters the general rule is that whitespace splits them up. The exception are paths and files which are split by os.path.pathsep by default (“:” on Unix and “;” on Windows).

to_info_dict()

Gather information that could be useful for a tool generating user-facing documentation.

Use click.Context.to_info_dict() to traverse the entire CLI structure.

Added in version 8.0.

Return type:

dict[str, Any]

get_metavar(param, ctx)

Returns the metavar default for this param if it provides one.

Return type:

str | None

get_missing_message(param, ctx)

Optionally might return extra information about a missing parameter.

Added in version 2.0.

Return type:

str | None

convert(value, param, ctx)

Convert the value to the correct type. This is not called if the value is None (the missing value).

This must accept string values from the command line, as well as values that are already the correct type. It may also convert other compatible types.

The param and ctx arguments may be None in certain situations, such as when converting prompt input.

If the value cannot be converted, call fail() with a descriptive message.

Parameters:

• value (t.Any) – The value to convert.

• param (Parameter | None) – The parameter that is using this type to convert its value. May be None.

• ctx (Context | None) – The current context that arrived at this value. May be None.

Return type:

t.Any

split_envvar_value(rv)

Given a value from an environment variable this splits it up into small chunks depending on the defined envvar list splitter.

If the splitter is set to None, which means that whitespace splits, then leading and trailing whitespace is ignored. Otherwise, leading and trailing splitters usually lead to empty items being included.

Return type:

Sequence[str]

fail(message, param=None, ctx=None)

Helper method to fail with an invalid value message.

Return type:

t.NoReturn

shell_complete(ctx, param, incomplete)

Return a list of CompletionItem objects for the incomplete value. Most types do not provide completions, but some do, and this allows custom types to provide custom completions as well.

Parameters:

• ctx (Context) – Invocation context for this command.

• param (Parameter) – The parameter that is requesting completion.

• incomplete (str) – Value being completed. May be empty.

Added in version 8.0.

Return type:

list[CompletionItem]

class click_extra.Parameter(param_decls=None, type=None, required=False, default=Sentinel.UNSET, callback=None, nargs=None, multiple=False, metavar=None, expose_value=True, is_eager=False, envvar=None, shell_complete=None, deprecated=False)

Bases: object

A parameter to a command comes in two versions: they are either Options or Arguments. 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.

Parameters:

• param_decls (cabc.Sequence[str] | None) – the parameter declarations for this option or argument. This is a list of flags or argument names.

• type (types.ParamType | t.Any | None) – the type that should be used. Either a ParamType or a Python type. The latter is converted into the former automatically if supported.

• required (bool) – controls if this is optional or not.

• default (t.Any | t.Callable[[], t.Any] | None) – 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.

• callback (t.Callable[[Context, Parameter, t.Any], t.Any] | None) – 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.

• nargs (int | None) – 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.

• metavar (str | None) – how the value is represented in the help page.

• expose_value (bool) – if this is True then the value is passed onwards to the command callback and stored on the context, otherwise it’s skipped.

• is_eager (bool) – eager values are processed before non eager ones. This should not be set for arguments or it will inverse the order of processing.

• envvar (str | cabc.Sequence[str] | None) – environment variable(s) that are used to provide a default value for this parameter. This can be a string or a sequence of strings. If a sequence is given, only the first non-empty environment variable is used for the parameter.

• shell_complete (t.Callable[[Context, Parameter, str], list[CompletionItem] | list[str]] | None) – 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 CompletionItem or a list of strings.

• deprecated (bool | str) – If True or non-empty string, issues a message indicating that the argument is deprecated and highlights its deprecation in –help. The message can be customized by using a string as the value. A deprecated parameter cannot be required, a ValueError will be raised otherwise.

Changed in version 8.2.0: Introduction of deprecated.

Changed in version 8.2: Adding duplicate parameter names to a Command will result in a UserWarning being shown.

Changed in version 8.2: Adding duplicate parameter names to a Command will result in a UserWarning being shown.

Changed in version 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.

Changed in version 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.

Changed in version 8.0: For multiple=True, nargs>1, the default must be a list of tuples.

Changed in version 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 ().

Changed in version 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.

Changed in version 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'

name: str | None

opts: list[str]

secondary_opts: list[str]

type: ParamType

default: Any | Callable[[], Any] | None

to_info_dict()

Gather information that could be useful for a tool generating user-facing documentation.

Use click.Context.to_info_dict() to traverse the entire CLI structure.

Changed in version 8.3.0: Returns None for the default if it was not set.

Added in version 8.0.

Return type:

dict[str, Any]

property human_readable_name: str

Returns the human readable name of this parameter. This is the same as the name for options, but the metavar for arguments.

make_metavar(ctx)

Return type:

str

get_default(ctx, call=True)

Overloads:

• self, ctx (Context), call (t.Literal[True]) → t.Any | None

• self, ctx (Context), call (bool) → t.Any | t.Callable[[], t.Any] | None

Get the default for the parameter. Tries Context.lookup_default() first, then the local default.

Parameters:

• ctx (Context) – Current context.

• call (bool) – If the default is a callable, call it. Disable to return the callable instead.

Changed in version 8.0.2: Type casting is no longer performed when getting a default.

Changed in version 8.0.1: Type casting can fail in resilient parsing mode. Invalid defaults will not prevent showing help text.

Changed in version 8.0: Looks at ctx.default_map first.

Changed in version 8.0: Added the call parameter.

add_to_parser(parser, ctx)

Return type:

None

type_cast_value(ctx, value)

Convert and validate a value against the parameter’s type, multiple, and nargs.

Return type:

Any

get_help_record(ctx)

Return type:

tuple[str, str] | None

get_usage_pieces(ctx)

Return type:

list[str]

get_error_hint(ctx)

Get a stringified version of the param for use in error messages to indicate which param caused the error.

Return type:

str

shell_complete(ctx, incomplete)

Return a list of completions for the incomplete value. If a shell_complete function was given during init, it is used. Otherwise, the type shell_complete() function is used.

Parameters:

• ctx (Context) – Invocation context for this command.

• incomplete (str) – Value being completed. May be empty.

Added in version 8.0.

Return type:

list[CompletionItem]

class click_extra.ParameterSource(*values)

Bases: IntEnum

This is an IntEnum that indicates the source of a parameter’s value.

Use click.Context.get_parameter_source() to get the source for a parameter by name.

Members are ordered from most explicit to least explicit source. This allows comparison to check if a value was explicitly provided:

source = ctx.get_parameter_source("port")
if source < click.ParameterSource.DEFAULT_MAP:
    ...  # value was explicitly set

Changed in version 8.3.3: Use IntEnum and reorder members from most to least explicit. Supports comparison operators.

Changed in version 8.0: Use Enum and drop the validate method.

Changed in version 8.0: Added the PROMPT value.

PROMPT = 1

Used a prompt to confirm a default or provide a value.

COMMANDLINE = 2

The value was provided by the command line args.

ENVIRONMENT = 3

The value was provided with an environment variable.

DEFAULT_MAP = 4

Used a default provided by Context.default_map.

DEFAULT = 5

Used the default specified by the parameter.

class click_extra.Path(exists=False, file_okay=True, dir_okay=True, writable=False, readable=True, resolve_path=False, allow_dash=False, path_type=None, executable=False)

Bases: ParamType

The Path type is similar to the File type, but returns the filename instead of an open file. Various checks can be enabled to validate the type of file and permissions.

Parameters:

• exists (bool) – The file or directory needs to exist for the value to be valid. If this is not set to True, and the file does not exist, then all further checks are silently skipped.

• file_okay (bool) – Allow a file as a value.

• dir_okay (bool) – Allow a directory as a value.

• readable (bool) – if true, a readable check is performed.

• writable (bool) – if true, a writable check is performed.

• executable (bool) – if true, an executable check is performed.

• resolve_path (bool) – Make the value absolute and resolve any symlinks. A ~ is not expanded, as this is supposed to be done by the shell only.

• allow_dash (bool) – Allow a single dash as a value, which indicates a standard stream (but does not open it). Use open_file() to handle opening this value.

• path_type (type[Any] | None) – Convert the incoming path value to this type. If None, keep Python’s default, which is str. Useful to convert to pathlib.Path.

Changed in version 8.1: Added the executable parameter.

Changed in version 8.0: Allow passing path_type=pathlib.Path.

Changed in version 6.0: Added the allow_dash parameter.

envvar_list_splitter: ClassVar[str] = ':'

if a list of this type is expected and the value is pulled from a string environment variable, this is what splits it up. None means any whitespace. For all parameters the general rule is that whitespace splits them up. The exception are paths and files which are split by os.path.pathsep by default (“:” on Unix and “;” on Windows).

name: str

the descriptive name of this type

to_info_dict()

Gather information that could be useful for a tool generating user-facing documentation.

Use click.Context.to_info_dict() to traverse the entire CLI structure.

Added in version 8.0.

Return type:

dict[str, Any]

coerce_path_result(value)

Return type:

str | bytes | PathLike[str]

convert(value, param, ctx)

Convert the value to the correct type. This is not called if the value is None (the missing value).

This must accept string values from the command line, as well as values that are already the correct type. It may also convert other compatible types.

The param and ctx arguments may be None in certain situations, such as when converting prompt input.

If the value cannot be converted, call fail() with a descriptive message.

Parameters:

• value (str | os.PathLike[str]) – The value to convert.

• param (Parameter | None) – The parameter that is using this type to convert its value. May be None.

• ctx (Context | None) – The current context that arrived at this value. May be None.

Return type:

str | bytes | os.PathLike[str]

shell_complete(ctx, param, incomplete)

Return a special completion marker that tells the completion system to use the shell to provide path completions for only directories or any paths.

Parameters:

• ctx (Context) – Invocation context for this command.

• param (Parameter) – The parameter that is requesting completion.

• incomplete (str) – Value being completed. May be empty.

Added in version 8.0.

Return type:

list[CompletionItem]

class click_extra.Section(title, commands=(), is_sorted=False)

Bases: object

A group of (sub)commands to show in the same help section of a MultiCommand. You can use sections with any Command that inherits from SectionMixin.

Changed in version 0.6.0: removed the deprecated old name GroupSection.

Changed in version 0.5.0: introduced the new name Section and deprecated the old GroupSection.

Parameters:

• title (str)

• commands (Iterable[Command] | Dict[str, Command]) – sequence of commands or dict of commands keyed by name

• is_sorted (bool) – if True, list_commands() returns the commands in lexicographic order

commands: OrderedDict[str, Command]

classmethod sorted(title, commands=())

Return type:

Section

add_command(cmd, name=None)

Return type:

None

list_commands()

Return type:

List[Tuple[str, Command]]

class click_extra.SectionMixin(*args, commands=None, sections=(), align_sections=None, **kwargs)

Bases: object

Adds to a click.MultiCommand the possibility of organizing its subcommands into multiple help sections.

Sections can be specified in the following ways:

1. passing a list of Section objects to the constructor setting the argument sections

2. using add_section() to add a single section

3. using add_command() with the argument section set

Commands not assigned to any user-defined section are added to the “default section”, whose title is “Commands” or “Other commands” depending on whether it is the only section or not. The default section is the last shown section in the help and its commands are listed in lexicographic order.

Changed in version 0.8.0: this mixin now relies on cloup.HelpFormatter to align help sections. If a click.HelpFormatter is used with a TypeError is raised.

Changed in version 0.8.0: removed format_section. Added make_commands_help_section.

Added in version 0.5.0.

Parameters:

• align_sections (bool | None) – whether to align the columns of all subcommands’ help sections. This is also available as a context setting having a lower priority than this attribute. Given that this setting should be consistent across all you commands, you should probably use the context setting only.

• args (Any) – positional arguments forwarded to the next class in the MRO

• kwargs (Any) – keyword arguments forwarded to the next class in the MRO

add_section(section)

Add a Section to this group. You can add the same section object only a single time.

Return type:

None

See Also:

section()

section(title, *commands, **attrs)

Create a new Section, adds it to this group and returns it.

Return type:

Section

add_command(cmd, name=None, section=None, fallback_to_default_section=True)

Add a subcommand to this Group.

Implementation note: fallback_to_default_section looks not very clean but, even if it’s not immediate to see (it wasn’t for me), I chose it over apparently cleaner options.

Parameters:

• cmd (Command)

• name (str | None)

• section (Section | None) – a Section instance. The command must not be in the section already.

• fallback_to_default_section (bool) – if section is None and this option is enabled, the command is added to the “default section”. If disabled, the command is not added to any section unless section is provided. This is useful for internal code and subclasses. Don’t disable it unless you know what you are doing.

Return type:

None

list_sections(ctx, include_default_section=True)

Return the list of all sections in the “correct order”.

If include_default_section=True and the default section is non-empty, it will be included at the end of the list.

Return type:

List[Section]

format_subcommand_name(ctx, name, cmd)

Used to format the name of the subcommands. This method is useful when you combine this extension with other click extensions that override format_commands(). Most of these, like click-default-group, just add something to the name of the subcommands, which is exactly what this method allows you to do without overriding bigger methods.

Return type:

str

make_commands_help_section(ctx, section)

Return type:

HelpSection | None

must_align_sections(ctx, default=True)

Return type:

bool

format_commands(ctx, formatter)

Return type:

None

class click_extra.ShowParamsOption(param_decls=None, is_flag=True, expose_value=False, is_eager=True, help='Show all CLI parameters, their provenance, defaults and value, then exit.', **kwargs)

Bases: ExtraOption, ParamStructure

A pre-configured option adding a --show-params option.

Between configuration files, default values and environment variables, it might be hard to guess under which set of parameters the CLI will be executed. This option print information about the parameters that will be fed to the CLI.

TABLE_HEADERS = ('ID', 'Spec.', 'Class', 'Param type', 'Python type', 'Hidden', 'Exposed', 'Allowed in conf?', 'Env. vars.', 'Default', 'Value', 'Source')

Hard-coded list of table headers.

excluded_params: frozenset[str]

Deactivates the blocking of any parameter.

included_params: frozenset[str] | None

No allowlist filter; show all parameters.

print_params(ctx, param, value)

Introspects current CLI and list its parameters and metadata.

Important

Click doesn’t keep a list of all parsed arguments and their origin. So we need to emulate here what’s happening during CLI invocation.

Unfortunately we cannot even do that because the raw, pre-parsed arguments are not available anywhere within Click’s internals.

Our workaround consist in leveraging our custom ExtraCommand/ExtraGroup classes, in which we are attaching a click_extra.raw_args metadata entry to the context.

Return type:

None

class click_extra.SortByOption(*header_defs, param_decls=None, default=None, expose_value=False, cell_key=None, help='Sort table by this column. Repeat to set priority.', **kwargs)

Bases: ExtraOption

A --sort-by option whose choices are derived from column definitions.

Stores the selected column IDs in ctx.meta[click_extra.context.SORT_BY] and replaces ctx.print_table with print_sorted_table() so that table output is automatically sorted. The option accepts multiple=True, so users can repeat --sort-by to define a multi-column sort priority.

@command
@table_format_option
@sort_by_option(
    ("Package ID", "package_id"),
    ("Name", "package_name"),
    ("Manager", "manager_id"),
    ("Version", None),
)
@pass_context
def my_cmd(ctx):
    ctx.print_table(header_defs, rows)

init_sort(ctx, param, sort_columns)

Store sort columns and override ctx.print_table with sorted variant.

Return type:

None

class click_extra.Style(fg=None, bg=None, bold=None, dim=None, underline=None, overline=None, italic=None, blink=None, reverse=None, strikethrough=None, text_transform=None)

Bases: Style

cloup.Style with extra ergonomics.

See the module docstring for the full list of additions. The runtime contract (calling the instance to apply styling, equality, hashing, with_()) is otherwise identical to cloup.Style.

fg: str | tuple[int, int, int] | int | None = None

Foreground color: named ANSI string, #rrggbb hex, RGB tuple, or palette index.

bg: str | tuple[int, int, int] | int | None = None

Background color: named ANSI string, #rrggbb hex, RGB tuple, or palette index.

cascade(base)

Return a copy with None fields filled in from base.

The instance’s own non-None values always win: cascade only fills gaps. Useful for theme inheritance: derived.cascade(parent) keeps derived’s overrides and inherits the rest from parent.

Return type:

Style

to_dict()

Serialize to a plain dict with only the set fields.

RGB tuples are emitted as #rrggbb strings so the result round-trips through TOML/JSON/YAML untouched. Pair with from_dict() to rebuild a Style.

Return type:

dict[str, Any]

classmethod from_dict(data)

Build a Style from the plain dict produced by to_dict().

Validates that every key in data names a known Style field and raises TypeError otherwise. Pair with to_dict() to round-trip through TOML/JSON/YAML.

Return type:

Style

to_css()

Render the style as a semicolon-separated CSS declaration list.

Style(fg="#f1fa8c", bold=True).to_css() returns "color: #f1fa8c; font-weight: bold". Suitable for inline style="..." attributes on HTML spans.

Return type:

str

classmethod from_ansi(escape)

Parse one or more consecutive ANSI SGR escapes into a Style.

Supports the standard 8/16-color codes (30–37, 40–47, 90–97, 100–107), the 38;5;n / 48;5;n 256-color extension, and the 38;2;r;g;b / 48;2;r;g;b 24-bit extension. Reset codes (0) are ignored. Multiple back-to-back escapes (as click emits when combining colors with attributes: \x1b[31m\x1b[1m) are merged into a single Style.

Return type:

Style

contrast_ratio(other)

Return the WCAG 2.x contrast ratio between this fg and other’s fg.

Result is in [1, 21]: 1 = identical colors (no contrast), 21 = maximum contrast (black on white). WCAG AA requires 4.5+ for normal text, 3.0+ for large text; AAA wants 7.0+ and 4.5+ respectively.

Return type:

float

class click_extra.TableFormat(*values)

Bases: Enum

Enumeration of supported table formats.

Hard-coded to be in alphabetical order. Content of this enum is checked in unit tests.

Warning

The youtrack format is missing in action from any official JetBrains documentation. It will be removed in python-tabulate v0.11.

ALIGNED = 'aligned'

ASCIIDOC = 'asciidoc'

COLON_GRID = 'colon-grid'

CSV = 'csv'

CSV_EXCEL = 'csv-excel'

CSV_EXCEL_TAB = 'csv-excel-tab'

CSV_UNIX = 'csv-unix'

DOUBLE_GRID = 'double-grid'

DOUBLE_OUTLINE = 'double-outline'

FANCY_GRID = 'fancy-grid'

FANCY_OUTLINE = 'fancy-outline'

GITHUB = 'github'

GRID = 'grid'

HEAVY_GRID = 'heavy-grid'

HEAVY_OUTLINE = 'heavy-outline'

HJSON = 'hjson'

HTML = 'html'

JIRA = 'jira'

JSON = 'json'

JSON5 = 'json5'

JSONC = 'jsonc'

LATEX = 'latex'

LATEX_BOOKTABS = 'latex-booktabs'

LATEX_LONGTABLE = 'latex-longtable'

LATEX_RAW = 'latex-raw'

MEDIAWIKI = 'mediawiki'

MIXED_GRID = 'mixed-grid'

MIXED_OUTLINE = 'mixed-outline'

MOINMOIN = 'moinmoin'

ORGTBL = 'orgtbl'

OUTLINE = 'outline'

PIPE = 'pipe'

PLAIN = 'plain'

PRESTO = 'presto'

PRETTY = 'pretty'

PSQL = 'psql'

ROUNDED_GRID = 'rounded-grid'

ROUNDED_OUTLINE = 'rounded-outline'

RST = 'rst'

SIMPLE = 'simple'

SIMPLE_GRID = 'simple-grid'

SIMPLE_OUTLINE = 'simple-outline'

TEXTILE = 'textile'

TOML = 'toml'

TSV = 'tsv'

UNSAFEHTML = 'unsafehtml'

VERTICAL = 'vertical'

XML = 'xml'

YAML = 'yaml'

YOUTRACK = 'youtrack'

property is_markup: bool

Whether this format is a markup rendering.

Markup formats have ANSI color codes stripped from their output by default. Use the --color flag to preserve them.

class click_extra.TableFormatOption(param_decls=None, type=EnumChoice('aligned', 'asciidoc', 'colon-grid', 'csv', 'csv-excel', 'csv-excel-tab', 'csv-unix', 'double-grid', 'double-outline', 'fancy-grid', 'fancy-outline', 'github', 'grid', 'heavy-grid', 'heavy-outline', 'hjson', 'html', 'jira', 'json', 'json5', 'jsonc', 'latex', 'latex-booktabs', 'latex-longtable', 'latex-raw', 'mediawiki', 'mixed-grid', 'mixed-outline', 'moinmoin', 'orgtbl', 'outline', 'pipe', 'plain', 'presto', 'pretty', 'psql', 'rounded-grid', 'rounded-outline', 'rst', 'simple', 'simple-grid', 'simple-outline', 'textile', 'toml', 'tsv', 'unsafehtml', 'vertical', 'xml', 'yaml', 'youtrack'), default=TableFormat.ROUNDED_OUTLINE, expose_value=False, is_eager=True, help='Rendering style of tables.', **kwargs)

Bases: ExtraOption

A pre-configured option that is adding a --table-format flag to select the rendering style of a table.

The selected table format ID is made available in the context in ctx.meta[click_extra.context.TABLE_FORMAT], and two helper methods are added to the context: - ctx.render_table(table_data, headers, **kwargs): renders and returns

the table as a string,

• ctx.print_table(table_data, headers, **kwargs): renders and prints the table to the console.

Where: - table_data is a 2-dimensional iterable of iterables for rows and cells values, - headers is a list of string to be used as column headers, - **kwargs are any extra keyword arguments supported by the underlying table

formatting function.

init_formatter(ctx, param, table_format)

Save in the context: table_format, render_table & print_table.

Return type:

None

class click_extra.TelemetryOption(param_decls=None, default=False, expose_value=False, envvar=None, show_envvar=True, help='Collect telemetry and usage data.', **kwargs)

Bases: ExtraOption

A pre-configured --telemetry/--no-telemetry option flag.

Respects the proposed DO_NOT_TRACK environment variable as a unified standard to opt-out of telemetry for TUI/console apps.

The DO_NOT_TRACK convention takes precedence over the user-defined environment variables and the auto-generated values.

The resolved value is stored in ctx.meta[click_extra.context.TELEMETRY], aligning with every other Click Extra option’s per-invocation context-meta storage pattern.

See also

• A knowledge base of telemetry disabling configuration options.

• And another list of environment variable to disable telemetry in desktop apps.

set_telemetry(ctx, param, value)

Store the resolved telemetry opt-in flag on the context’s meta dict.

Reads via click_extra.context.get(ctx, click_extra.context.TELEMETRY). Renamed from save_telemetry to align with the set_<key> convention used by every other ctx.meta-writing callback.

Return type:

None

class click_extra.ThemeOption(param_decls=None, default='dark', is_eager=True, expose_value=False, help='Color theme used for help screens.', **kwargs)

Bases: ExtraOption

A pre-configured option that adds --theme to select the help-screen palette.

Accepts any name registered in theme_registry or in the per-invocation overrides loaded by ConfigOption from [tool.<cli>.themes.<name>]. Validation goes through ThemeChoice, which reads the live registry at parse time, so config-defined themes appear as valid choices and in the --help metavar without any further wiring.

The resolved HelpExtraTheme lands on the Click context under click_extra.context.THEME and applies for the duration of the current invocation only.

set_theme(ctx, param, value)

Resolve the chosen theme name and store it on the Click context.

ThemeChoice has already validated value against the live registry by the time this fires, so the lookup is unconditional.

Return type:

None

class click_extra.TimerOption(param_decls=None, default=False, expose_value=False, is_eager=True, help='Measure and print elapsed execution time.', **kwargs)

Bases: ExtraOption

A pre-configured option that is adding a --time/--no-time flag to print elapsed time at the end of CLI execution.

The start time is made available in the context in ctx.meta[click_extra.context.START_TIME].

print_timer()

Compute and print elapsed execution time.

Always prints, even when a sibling eager option (--version, --show-params, --show-config…) short-circuited the command body via ctx.exit(). That makes --time a usable probe for the cost of Click Extra’s own machinery (option parsing, config loading, eager callbacks), not just user command bodies.

Return type:

None

init_timer(ctx, param, value)

Set up the execution-timer machinery for the current invocation.

Captures time.perf_counter() as the start time, stores it on ctx.meta under click_extra.context.START_TIME, and queues print_timer() as a context-close callback so the elapsed duration is printed even when a sibling eager option (--version, --show-params…) short-circuits the command body.

Renamed from register_timer_on_close to align with the init_<system> convention shared with init_formatter and init_sort.

Return type:

None

class click_extra.Tuple(types)

Bases: CompositeParamType

The default behavior of Click is to apply a type on a value directly. This works well in most cases, except for when nargs is set to a fixed count and different types should be used for different items. In this case the Tuple type can be used. This type can only be used if nargs is set to a fixed number.

For more information see Multi Value Options as Tuples.

This can be selected by using a Python tuple literal as a type.

Parameters:

types (Sequence[type[Any] | ParamType]) – a list of types that should be used for the tuple items.

types: Sequence[ParamType]

to_info_dict()

Gather information that could be useful for a tool generating user-facing documentation.

Use click.Context.to_info_dict() to traverse the entire CLI structure.

Added in version 8.0.

Return type:

dict[str, Any]

property name: str

property arity: int

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating-point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int(‘0b100’, base=0) 4

convert(value, param, ctx)

Convert the value to the correct type. This is not called if the value is None (the missing value).

This must accept string values from the command line, as well as values that are already the correct type. It may also convert other compatible types.

The param and ctx arguments may be None in certain situations, such as when converting prompt input.

If the value cannot be converted, call fail() with a descriptive message.

Parameters:

• value (t.Any) – The value to convert.

• param (Parameter | None) – The parameter that is using this type to convert its value. May be None.

• ctx (Context | None) – The current context that arrived at this value. May be None.

Return type:

t.Any

exception click_extra.UsageError(message, ctx=None)

Bases: ClickException

An internal exception that signals a usage error. This typically aborts any further handling.

Parameters:

• message (str) – the error message to display.

• ctx (Context | None) – optionally the context that caused this error. Click will fill in the context automatically in some situations.

exit_code = 2

The exit code for this exception.

cmd: Command | None

show(file=None)

Return type:

None

class click_extra.ValidateConfigOption(param_decls=None, type=<click.types.Path object>, is_eager=True, expose_value=False, help='Validate the configuration file and exit.', **kwargs)

Bases: ExtraOption

A pre-configured option adding --validate-config CONFIG_PATH.

Loads the config file at the given path, validates it against the CLI’s parameter structure in strict mode, reports results, and exits.

validate_config(ctx, param, value)

Load, parse, and validate the configuration file, then exit.

Validation runs three checks in order, every one of them under the same ValidationError shape so the reported path is always rooted at the configuration file:

1. CLI-parameter strict check on the non-opaque part of the document.

2. Schema processing, if a config_schema is configured: catches type errors and unknown keys inside the dataclass-described section.

3. Each registered ConfigValidator runs against its declared opaque sub-tree.

Every detected error is emitted before exiting, so a single --validate-config run surfaces the full list of fixes the user needs to apply.

Return type:

None

exception click_extra.ValidationError(path, message, code=None)

Bases: Exception

Raised when a configuration file fails validation.

A single, structured exception type that uniformly carries the dotted path of the offending key, a human-readable message, and an optional code for programmatic handling. Used by click-extra’s built-in strict-mode check and by every user-registered ConfigValidator, so downstream apps and --validate-config see the same error shape regardless of who detected the problem.

Parameters:

• path (str) – Dotted path to the offending key, relative to the configuration file root (e.g. "my-cli.managers.winget.cli_searchpath"). An empty string means the error applies to the document as a whole.

• message (str) – Human-readable description of the failure. Should be a single sentence, no trailing punctuation, no path repeated.

• code (str | None) – Optional machine-readable error code (e.g. "unknown_field") for callers that want to dispatch on error type without parsing the message string.

class click_extra.VerboseOption(param_decls=None, count=True, **kwargs)

Bases: ExtraVerbosity

--verbose/-v` option to increase the log level of ExtraVerbosity by a number of steps.

If -v is passed to a CLI, then it will increase the verbosity level by one step. The option can be provided multiple times by the user. So if -vv (or -v -v) is passed, the verbosity will be increase by 2 levels.

The default base-level from which we start incrementing is sourced from VerbosityOption.default. So with --verbosity’s default set to WARNING:

• -v will increase the level to INFO,

• -vv will increase the level to DEBUG,

• any number of repetition above that point will be set to the maximum level, so for -vvvvv for example will be capped at DEBUG.

Set up a verbosity-altering option.

Parameters:

default_logger – If a logging.Logger object is provided, that’s the instance to which we will set the level to. If the parameter is a string and is found in the global registry, we will use it as the logger’s ID. Otherwise, we will create a new logger with new_extra_logger() Default to the global root logger.

get_base_level(ctx)

Returns the default base-level from which the option will start incrementing.

We try first to get the default level from any instance of VerbosityOption defined on the current command. If none is found, it’s because the --verbose option is used standalone. In which case we defaults to DEFAULT_LEVEL.

Return type:

LogLevel

get_help_record(ctx)

Dynamiccaly generates the default help message.

We need that patch because get_base_level() depends on the context, so we cannot hard-code the help message as VerboseOption.__init__() default.

Return type:

tuple[str, str] | None

set_level(ctx, param, value)

Translate the number of steps to the target log level.

The value passed to --verbose/-v will be saved in ctx.meta[click_extra.context.VERBOSE].

Return type:

None

class click_extra.VerbosityOption(param_decls=None, default_logger='root', default=LogLevel.WARNING, metavar='LEVEL', type=EnumChoice('CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG'), help='Either CRITICAL, ERROR, WARNING, INFO, DEBUG.', **kwargs)

Bases: ExtraVerbosity

--verbosity LEVEL option to set the the log level of ExtraVerbosity.

Set up a verbosity-altering option.

Parameters:

default_logger (Logger | str) – If a logging.Logger object is provided, that’s the instance to which we will set the level to. If the parameter is a string and is found in the global registry, we will use it as the logger’s ID. Otherwise, we will create a new logger with new_extra_logger() Default to the global root logger.

set_level(ctx, param, value)

The value passed to --verbosity will be saved in ctx.meta[click_extra.context.VERBOSITY].

Return type:

None

click_extra.argument(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.clear()

Clears the terminal screen. This will have the effect of clearing the whole visible space of the terminal and moving the cursor to the top left. This does not do anything if not connected to a terminal.

Added in version 2.0.

Return type:

None

click_extra.color_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.command(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.config_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.confirm(text, default=False, abort=False, prompt_suffix=': ', show_default=True, err=False)

Prompts for confirmation (yes/no question).

If the user aborts the input by sending a interrupt signal this function will catch it and raise a Abort exception.

Parameters:

• text (str) – the question to ask.

• default (bool | None) – The default value to use when no input is given. If None, repeat until input is given.

• abort (bool) – if this is set to True a negative answer aborts the exception by raising Abort.

• prompt_suffix (str) – a suffix that should be added to the prompt.

• show_default (bool) – shows or hides the default value in the prompt.

• err (bool) – if set to true the file defaults to stderr instead of stdout, the same as with echo.

Changed in version 8.3.1: A space is no longer appended to the prompt.

Changed in version 8.0: Repeat until input is given if default is None.

Added in version 4.0: Added the err parameter.

Return type:

bool

click_extra.confirmation_option(*param_decls, **kwargs)

Add a --yes option which shows a prompt before continuing if not passed. If the prompt is declined, the program will exit.

Parameters:

• param_decls (str) – One or more option names. Defaults to the single value "--yes".

• kwargs (Any) – Extra arguments are passed to option().

Return type:

Callable[[TypeVar(FC, bound= _AnyCallable | Command)], TypeVar(FC, bound= _AnyCallable | Command)]

click_extra.constrained_params(constr, *param_adders)

Return a decorator that adds the given parameters and applies a constraint to them. Equivalent to:

@param_adders[0]
...
@param_adders[-1]
@constraint(constr, <param names>)

This decorator saves you to manually (re)type the parameter names. It can also be used inside @option_group.

Instead of using this decorator, you can also call the constraint itself:

@constr(*param_adders)

but remember that:

• Python 3.9 is the first that allows arbitrary expressions on the right of @;

• using a long conditional/composite constraint as decorator may be less readable.

In these cases, you may consider using @constrained_params.

Added in version 0.9.0.

Parameters:

• constr (Constraint) – an instance of Constraint

• param_adders (Callable[[Callable[..., Any]], Callable[..., Any]]) – function decorators, each attaching a single parameter to the decorated function.

Return type:

Callable[[TypeVar(F, bound= Callable[..., Any])], TypeVar(F, bound= Callable[..., Any])]

click_extra.constraint(constr, params)

Register a constraint on a list of parameters specified by (destination) name (e.g. the default name of --input-file is input_file).

Return type:

Callable[[TypeVar(F, bound= Callable[..., Any])], TypeVar(F, bound= Callable[..., Any])]

click_extra.dir_path(*, path_type=<class 'pathlib.Path'>, exists=False, readable=True, writable=False, executable=False, resolve_path=False, allow_dash=False)

Shortcut for click.Path with file_okay=False, path_type=pathlib.Path.

Return type:

Path

click_extra.echo(message=None, file=None, nl=True, err=False, color=None)

Print a message and newline to stdout or a file. This should be used instead of print() because it provides better support for different data, files, and environments.

Compared to print(), this does the following:

• Ensures that the output encoding is not misconfigured on Linux.

• Supports Unicode in the Windows console.

• Supports writing to binary outputs, and supports writing bytes to text outputs.

• Supports colors and styles on Windows.

• Removes ANSI color and style codes if the output does not look like an interactive terminal.

• Always flushes the output.

Parameters:

• message (Any | None) – The string or bytes to output. Other objects are converted to strings.

• file (IO[Any] | None) – The file to write to. Defaults to stdout.

• err (bool) – Write to stderr instead of stdout.

• nl (bool) – Print a newline after the message. Enabled by default.

• color (bool | None) – Force showing or hiding colors and other styles. By default Click will remove color if the output does not look like an interactive terminal.

Changed in version 6.0: Support Unicode output on the Windows console. Click does not modify sys.stdout, so sys.stdout.write() and print() will still not support Unicode.

Changed in version 4.0: Added the color parameter.

Added in version 3.0: Added the err parameter.

Changed in version 2.0: Support colors on Windows if colorama is installed.

Return type:

None

click_extra.echo_via_pager(text_or_generator, color=None)

This function takes a text and shows it via an environment specific pager on stdout.

Changed in version 3.0: Added the color flag.

Parameters:

• text_or_generator (Iterable[str] | Callable[[], Iterable[str]] | str) – the text to page, or alternatively, a generator emitting the text to page.

• color (bool | None) – controls if the pager supports ANSI colors or not. The default is autodetection.

Return type:

None

click_extra.edit(text=None, editor=None, env=None, require_save=True, extension='.txt', filename=None)

Overloads:

• text (bytes | bytearray), editor (str | None), env (cabc.Mapping[str, str] | None), require_save (bool), extension (str) → bytes | None

• text (str), editor (str | None), env (cabc.Mapping[str, str] | None), require_save (bool), extension (str) → str | None

• text (None), editor (str | None), env (cabc.Mapping[str, str] | None), require_save (bool), extension (str), filename (str | cabc.Iterable[str] | None) → None

Edits the given text in the defined editor. If an editor is given (should be the full path to the executable but the regular operating system search path is used for finding the executable) it overrides the detected editor. Optionally, some environment variables can be used. If the editor is closed without changes, None is returned. In case a file is edited directly the return value is always None and require_save and extension are ignored.

If the editor cannot be opened a UsageError is raised.

Note for Windows: to simplify cross-platform usage, the newlines are automatically converted from POSIX to Windows and vice versa. As such, the message here will have \n as newline markers.

Parameters:

• text (str | bytes | bytearray | None) – the text to edit.

• editor (str | None) – optionally the editor to use. Defaults to automatic detection.

• env (Mapping[str, str] | None) – environment variables to forward to the editor.

• require_save (bool) – if this is true, then not saving in the editor will make the return value become None.

• extension (str) – the extension to tell the editor about. This defaults to .txt but changing this might change syntax highlighting.

• filename (str | Iterable[str] | None) – if provided it will edit this file instead of the provided text contents. It will not use a temporary file as an indirection in that case. If the editor supports editing multiple files at once, a sequence of files may be passed as well. Invoke click.file once per file instead if multiple files cannot be managed at once or editing the files serially is desired.

Changed in version 8.2.0: filename now accepts any Iterable[str] in addition to a str if the editor supports editing multiple files at once.

click_extra.extraBasicConfig(*, filename=None, filemode='a', format='{levelname}: {message}', datefmt=None, style='{', level=None, stream=None, handlers=None, force=False, encoding=None, errors='backslashreplace', stream_handler_class=<class 'click_extra.logging.ExtraStreamHandler'>, file_handler_class=<class 'logging.FileHandler'>, formatter_class=<class 'click_extra.logging.ExtraFormatter'>)

Configure the global root logger.

This function is a wrapper around Python standard library’s logging.basicConfig(), but with additional parameters and tweaked defaults.

It sets up the global root logger, and optionally adds a file or stream handler to it.

Differences in default values:

Argument	extraBasicConfig() default	logging.basicConfig() default
style	{	%
format	{levelname}: {message}	%(levelname)s:%(name)s:%(message)s

This function takes the same parameters as logging.basicConfig(), but require them to be all passed as explicit keywords arguments.

Parameters:

• filename (str | None) – Specifies that a logging.FileHandler be created, using the specified filename, rather than an ExtraStreamHandler.

• filemode (str) –

  If filename is specified, open the file in this mode.

  Defaults to a.

• format (str | None) –

  Use the specified format string for the handler.

  Defaults to {levelname}: {message}.

• datefmt (str | None) – Use the specified date/time format, as accepted by time.strftime().

• style (Literal['%', '{', '$']) –

  If format is specified, use this style for the format string:

  • % for printf-style,

  • { for str.format(),

  • $ for string.Template.

  Defaults to {.

• level (int | str | None) – Set the root logger level to the specified level.

• stream (IO[Any] | None) – Use the specified stream to initialize the ExtraStreamHandler. Note that this argument is incompatible with filename - if both are present, a ValueError is raised.

• handlers (Iterable[Handler] | None) – If specified, this should be an iterable of already created handlers to add to the root logger. Any handlers which don’t already have a formatter set will be assigned the default formatter created in this function. Note that this argument is incompatible with filename or stream - if both are present, a ValueError is raised.

• force (bool) – If this argument is specified as True, any existing handlers attached to the root logger are removed and closed, before carrying out the configuration as specified by the other arguments.

• encoding (str | None) – Name of the encoding used to decode or encode the file. To be specified along with filename, and passed to logging.FileHandler for opening the output file.

• errors (str | None) – Optional string that specifies how encoding and decoding errors are to be handled by the logging.FileHandler. Defaults to backslashreplace. Note that if None is specified, it will be passed as such to open().

Return type:

None

Important

Always keep the signature of this function, the default values of its parameters and its documentation in sync with the one from Python’s standard library.

These new arguments are available for better configurability:

Parameters:

• stream_handler_class (type[Handler]) – A logging.Handler class that will be used in logging.basicConfig() to create a default stream-based handler. Defaults to ExtraStreamHandler.

• file_handler_class (type[Handler]) – A logging.Handler class that will be used in logging.basicConfig() to create a default file-based handler. Defaults to FileHandler.

• formatter_class (type[Formatter]) – A logging.Formatter class of the formatter that will be used in logging.basicConfig() to setup the default formatter. Defaults to ExtraFormatter.

Note

I don’t like the camel-cased name of this function and would have called it extra_basic_config(), but it’s kept this way for consistency with Python’s standard library.

click_extra.file_path(*, path_type=<class 'pathlib.Path'>, exists=False, readable=True, writable=False, executable=False, resolve_path=False, allow_dash=False)

Shortcut for click.Path with dir_okay=False, path_type=pathlib.Path.

Return type:

Path

click_extra.flatten_config_keys(conf, sep='_', opaque_keys=frozenset({}), _prefix='')

Flatten nested dicts into a single level by joining keys with a separator.

Useful for mapping nested configuration structures (e.g. TOML sub-tables) to flat Python dataclass fields. After normalization with normalize_config_keys, the flattened keys match dataclass field names directly:

>>> from click_extra.config import flatten_config_keys, normalize_config_keys
>>> raw = {"dependency-graph": {"all-groups": True, "output": "deps.mmd"}}
>>> flatten_config_keys(normalize_config_keys(raw))
{'dependency_graph_all_groups': True, 'dependency_graph_output': 'deps.mmd'}

Parameters:

• conf (dict[str, Any]) – Nested dictionary to flatten.

• sep (str) – Separator used to join parent and child keys. Defaults to "_" which produces valid Python identifiers when combined with normalize_config_keys.

• opaque_keys (frozenset[str]) – Fully-qualified key names where flattening stops. When the accumulated key matches an entry in this set, the dict value is kept as-is instead of being recursively flattened. This is useful for fields typed as dict[str, X] where the dict keys are data (e.g. GitHub Actions matrix axis names), not config structure.

• _prefix (str) – Internal parameter for tracking the accumulated key path during recursion. Callers should not set this.

Return type:

dict[str, Any]

click_extra.format_filename(filename, shorten=False)

Format a filename as a string for display. Ensures the filename can be displayed by replacing any invalid bytes or surrogate escapes in the name with the replacement character �.

Invalid bytes or surrogate escapes will raise an error when written to a stream with errors="strict". This will typically happen with stdout when the locale is something like en_GB.UTF-8.

Many scenarios are safe to write surrogates though, due to PEP 538 and PEP 540, including:

• Writing to stderr, which uses errors="backslashreplace".

• The system has LANG=C.UTF-8, C, or POSIX. Python opens stdout and stderr with errors="surrogateescape".

• None of LANG/LC_* are set. Python assumes LANG=C.UTF-8.

• Python is started in UTF-8 mode with PYTHONUTF8=1 or -X utf8. Python opens stdout and stderr with errors="surrogateescape".

Parameters:

• filename (str | bytes | PathLike[str] | PathLike[bytes]) – formats a filename for UI display. This will also convert the filename into unicode without failing.

• shorten (bool) – this optionally shortens the filename to strip of the path that leads up to it.

Return type:

str

click_extra.format_param_row(param, ctx, path, is_structured)

Format the common parameter table cells.

Returns a tuple of 8 cells in column order: ID, Spec., Class, Param type, Python type, Hidden, Env. vars., Default.

For structured formats (JSON, YAML, etc.), cells are native Python values. For visual formats, cells are themed strings matching help-screen styling.

Return type:

tuple

click_extra.get_app_dir(app_name, roaming=True, force_posix=False)

Returns the config folder for the application. The default behavior is to return whatever is most appropriate for the operating system.

To give you an idea, for an app called "Foo Bar", something like the following folders could be returned:

Mac OS X:

~/Library/Application Support/Foo Bar

Mac OS X (POSIX):

~/.foo-bar

Unix:

~/.config/foo-bar

Unix (POSIX):

~/.foo-bar

Windows (roaming):

C:\Users\<user>\AppData\Roaming\Foo Bar

Windows (not roaming):

C:\Users\<user>\AppData\Local\Foo Bar

Added in version 2.0.

Parameters:

• app_name (str) – the application name. This should be properly capitalized and can contain whitespace.

• roaming (bool) – controls if the folder should be roaming or not on Windows. Has no effect otherwise.

• force_posix (bool) – if this is set to True then on any POSIX system the folder will be stored in the home folder with a leading dot instead of the XDG config home or darwin’s application support folder.

Return type:

str

click_extra.get_binary_stream(name)

Returns a system stream for byte processing.

Parameters:

name (Literal['stdin', 'stdout', 'stderr']) – the name of the stream to open. Valid names are 'stdin', 'stdout' and 'stderr'

Return type:

BinaryIO

click_extra.get_current_context(silent=False)

Overloads:

• → Context

• silent (bool) → Optional[Context]

Equivalent to click.get_current_context() but casts the returned click.Context object to cloup.Context (which is safe when using cloup commands classes and decorators).

click_extra.get_current_theme()

Return the theme active for the current CLI invocation.

Resolution order:

1. The theme stored on the active Click context under click_extra.context.THEME (set by ThemeOption from --theme).

2. The process-wide fallback returned by get_default_theme() (the dark default, or whatever click_extra.wrap.patch_click() set at process start).

Falling back through the active context (instead of reading a module attribute) keeps --theme scoped to the invocation that received it, so a second invocation in the same process starts from the default again.

Return type:

HelpExtraTheme

click_extra.get_default_theme()

Return the process-wide fallback theme.

Read by get_current_theme() when no Click context is active or when the active context has no theme set. The default is the built-in dark palette; click_extra.wrap.patch_click() overrides it via set_default_theme() for the duration of a patched session.

Resolved through a function rather than a module attribute so callers always observe the current value: capturing default_theme as a default function parameter (the previous pattern) would freeze whatever was set at import time.

Return type:

HelpExtraTheme

click_extra.get_param_spec(param, ctx)

Extract the option-spec string (like -v, --verbose) from a parameter.

Temporarily unhides hidden options so their help record can be produced.

Note

The hidden property is only supported by Option, not Argument.

Todo

Submit a PR to Click to separate production of param spec and help record. That way we can always produce the param spec even if the parameter is hidden. See: https://github.com/kdeldycke/click-extra/issues/689

Return type:

str | None

click_extra.get_text_stream(name, encoding=None, errors='strict')

Returns a system stream for text processing. This usually returns a wrapped stream around a binary stream returned from get_binary_stream() but it also can take shortcuts for already correctly configured streams.

Parameters:

• name (Literal['stdin', 'stdout', 'stderr']) – the name of the stream to open. Valid names are 'stdin', 'stdout' and 'stderr'

• encoding (str | None) – overrides the detected default encoding.

• errors (str | None) – overrides the default error mode.

Return type:

TextIO

click_extra.get_tool_config(ctx=None)

Retrieve the typed tool configuration from the context.

Returns the object stored under click_extra.context.TOOL_CONFIG by ConfigOption when a config_schema is set, or None if no schema was configured or no configuration was loaded.

Parameters:

ctx (Context | None) – Click context. Defaults to the current context.

Return type:

Any

click_extra.getchar(echo=False)

Fetches a single character from the terminal and returns it. This will always return a unicode character and under certain rare circumstances this might return more than one character. The situations which more than one character is returned is when for whatever reason multiple characters end up in the terminal buffer or standard input was not actually a terminal.

Note that this will always read from the terminal, even if something is piped into the standard input.

Note for Windows: in rare cases when typing non-ASCII characters, this function might wait for a second character and then return both at once. This is because certain Unicode characters look like special-key markers.

Added in version 2.0.

Parameters:

echo (bool) – if set to True, the character read will also show up on the terminal. The default is to not show it.

Return type:

str

click_extra.group(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.help_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.jobs_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.launch(url, wait=False, locate=False)

This function launches the given URL (or filename) in the default viewer application for this file type. If this is an executable, it might launch the executable in a new session. The return value is the exit code of the launched application. Usually, 0 indicates success.

Examples:

click.launch('https://click.palletsprojects.com/')
click.launch('/my/downloaded/file', locate=True)

Added in version 2.0.

Parameters:

• url (str) – URL or filename of the thing to launch.

• wait (bool) – Wait for the program to exit before returning. This only works if the launched program blocks. In particular, xdg-open on Linux does not block.

• locate (bool) – if this is set to True then instead of launching the application associated with the URL it will attempt to launch a file manager with the file located. This might have weird effects if the URL does not point to the filesystem.

Return type:

int

click_extra.lazy_group(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.make_pass_decorator(object_type, ensure=False)

Given an object type this creates a decorator that will work similar to pass_obj() but instead of passing the object of the current context, it will find the innermost context of type object_type().

This generates a decorator that works roughly like this:

from functools import update_wrapper

def decorator(f):
    @pass_context
    def new_func(ctx, *args, **kwargs):
        obj = ctx.find_object(object_type)
        return ctx.invoke(f, obj, *args, **kwargs)
    return update_wrapper(new_func, f)
return decorator

Parameters:

• object_type (type[T]) – the type of the object to pass.

• ensure (bool) – if set to True, a new object will be created and remembered on the context if it’s not there yet.

Return type:

t.Callable[[t.Callable[te.Concatenate[T, P], R]], t.Callable[P, R]]

click_extra.new_extra_logger(name='root', *, propagate=False, force=True, **kwargs)

Setup a logger in the style of Click Extra.

By default, this helper will:

• Fetch the logger registered under the name parameter, or creates a new one with that name if it doesn’t exist,

• Set the logger’s propagate attribute to False,

• Force removal of any existing handlers and formatters attached to the logger,

• Attach a new ExtraStreamHandler with ExtraFormatter,

• Return the logger object.

This function is a wrapper around extraBasicConfig() and takes the same keywords arguments.

Parameters:

• name (str) – ID of the logger to setup. If None, Python’s root logger will be used. If a logger with the provided name is not found in the global registry, a new logger with that name will be created.

• propagate (bool) – Sets the logger’s propagate attribute. Defaults to False.

• force (bool) – Same as the force parameter from logging.basicConfig() and extraBasicConfig(). Defaults to True.

• kwargs – Any other keyword parameters supported by logging.basicConfig() and extraBasicConfig().

Return type:

Logger

click_extra.no_config_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.normalize_config_keys(conf, opaque_keys=frozenset({}), _prefix='')

Normalize configuration keys to valid Python identifiers.

Recursively replaces hyphens with underscores in all dict keys, using the same str.replace("-", "_") transform that Click applies internally when deriving parameter names from option declarations (e.g. --foo-bar becomes foo_bar). Click does not expose this as a public function, so we replicate the one-liner here.

Handles the convention mismatch between configuration formats (TOML, YAML, JSON all commonly use kebab-case) and Python identifiers. Works with all configuration formats supported by ConfigOption.

Parameters:

• opaque_keys (frozenset[str]) – Fully-qualified key names (using "_" as separator) where recursion stops. The key itself is still normalized, but its dict value is kept as-is. Used in tandem with flatten_config_keys’s opaque_keys to protect data dicts (e.g. GitHub Actions matrix axes) from normalization.

• _prefix (str) – Internal parameter for tracking the accumulated key path during recursion. Callers should not set this.

Todo

Propose upstream to Click to extract the inline name.replace("-", "_") into a private _normalize_param_name helper, so downstream projects like Click Extra can reuse it instead of duplicating the transform.

Return type:

dict[str, Any]

click_extra.open_file(filename, mode='r', encoding=None, errors='strict', lazy=False, atomic=False)

Open a file, with extra behavior to handle '-' to indicate a standard stream, lazy open on write, and atomic write. Similar to the behavior of the File param type.

If '-' is given to open stdout or stdin, the stream is wrapped so that using it in a context manager will not close it. This makes it possible to use the function without accidentally closing a standard stream:

with open_file(filename) as f:
    ...

Parameters:

• filename (str | PathLike[str]) – The name or Path of the file to open, or '-' for stdin/stdout.

• mode (str) – The mode in which to open the file.

• encoding (str | None) – The encoding to decode or encode a file opened in text mode.

• errors (str | None) – The error handling mode.

• lazy (bool) – Wait to open the file until it is accessed. For read mode, the file is temporarily opened to raise access errors early, then closed until it is read again.

• atomic (bool) – Write to a temporary file and replace the given file on close.

Added in version 3.0.

Return type:

IO[Any]

click_extra.option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.option_group(title, *args, **kwargs)

Overloads:

• title (str), help (str), options (Decorator), constraint (Optional[Constraint]), hidden (bool) → Callable[[F], F]

• title (str), options (Decorator), help (Optional[str]), constraint (Optional[Constraint]), hidden (bool) → Callable[[F], F]

Return a decorator that annotates a function with an option group.

The help argument is an optional description and can be provided either as keyword argument or as 2nd positional argument after the name of the group:

# help as keyword argument
@option_group(name, *options, help=None, ...)

# help as 2nd positional argument
@option_group(name, help, *options, ...)

Changed in version 0.9.0: in order to support the decorator cloup.constrained_params(), @option_group now allows each input decorators to add multiple options.

Parameters:

• title (str) – title of the help section describing the option group.

• help – an optional description shown below the name; can be provided as keyword argument or 2nd positional argument.

• options – an arbitrary number of decorators like click.option, which attach one or multiple options to the decorated command function.

• constraint – an optional instance of Constraint (see Constraints for more info); a description of the constraint will be shown between squared brackets aside the option group title (or below it if too long).

• hidden – if True, the option group and all its options are hidden from the help page (all contained options will have their hidden attribute set to True).

click_extra.pass_context(f)

Marks a callback as wanting to receive the current context object as first argument. Equivalent to click.pass_context() but assumes the current context is of type cloup.Context.

Return type:

Callable[[ParamSpec(P, bound= None)], TypeVar(R)]

click_extra.pass_obj(f)

Similar to pass_context(), but only pass the object on the context onwards (Context.obj). This is useful if that object represents the state of a nested system.

Return type:

t.Callable[P, R]

click_extra.password_option(*param_decls, **kwargs)

Add a --password option which prompts for a password, hiding input and asking to enter the value again for confirmation.

Parameters:

• param_decls (str) – One or more option names. Defaults to the single value "--password".

• kwargs (Any) – Extra arguments are passed to option().

Return type:

Callable[[TypeVar(FC, bound= _AnyCallable | Command)], TypeVar(FC, bound= _AnyCallable | Command)]

click_extra.path(*, path_type=<class 'pathlib.Path'>, exists=False, file_okay=True, dir_okay=True, readable=True, writable=False, executable=False, resolve_path=False, allow_dash=False)

Shortcut for click.Path with path_type=pathlib.Path.

Return type:

Path

click_extra.pause(info=None, err=False)

This command stops execution and waits for the user to press any key to continue. This is similar to the Windows batch “pause” command. If the program is not run through a terminal, this command will instead do nothing.

Added in version 2.0.

Added in version 4.0: Added the err parameter.

Parameters:

• info (str | None) – The message to print before pausing. Defaults to "Press any key to continue...".

• err (bool) – if set to message goes to stderr instead of stdout, the same as with echo.

Return type:

None

click_extra.print_data(data, table_format, *, default=None, root_element='records', package='click-extra', **kwargs)

Serialize arbitrary Python data and print it to the console.

Wraps serialize_data() with user-friendly error handling for missing optional dependencies.

Parameters:

• data (Any) – Arbitrary data to serialize.

• table_format (TableFormat) – Target serialization format.

• default (Callable | None) – Fallback serializer for custom types. Defaults to str().

• root_element (str) – Root element name for XML output.

• package (str) – Package name for install instructions in error messages.

• kwargs – Extra keyword arguments forwarded to the underlying serializer.

Return type:

None

click_extra.print_sorted_table(header_defs, table_data, sort_columns=None, table_format=None, *, cell_key=None, **kwargs)

Sort and print a table using named column definitions.

header_defs is an ordered sequence of (label, column_id) tuples. Columns with column_id=None are not selectable for sorting but still participate in tie-breaking.

Parameters:

• header_defs (Sequence[tuple[str, str | None]]) – Column definitions as (label, column_id) pairs.

• table_data (Sequence[Sequence[str | None]]) – Rows of cell values.

• sort_columns (Sequence[str] | None) – Column IDs to sort by, in priority order. Falls back to natural header order.

• table_format (TableFormat | None) – Rendering format.

• cell_key (Callable[[str | None], Any] | None) – Per-cell comparison key. Defaults to ANSI-stripped, case-folded string comparison.

Return type:

None

click_extra.print_table(table_data, headers=None, table_format=None, sort_key=None, **kwargs)

Render a table and print it to the console.

For markup formats, ANSI color codes are stripped from cell values before rendering unless --color is explicitly set.

Parameters:

sort_key (Callable[[Sequence[str | None]], Any] | None) – Optional callable passed to sorted() as the key argument. When provided, rows are sorted before rendering.

Return type:

None

click_extra.progressbar(iterable=None, length=None, label=None, hidden=False, show_eta=True, show_percent=None, show_pos=False, item_show_func=None, fill_char='#', empty_char='-', bar_template='%(label)s  [%(bar)s]  %(info)s', info_sep='  ', width=36, file=None, color=None, update_min_steps=1)

Overloads:

• length (int), label (str | None), hidden (bool), show_eta (bool), show_percent (bool | None), show_pos (bool), fill_char (str), empty_char (str), bar_template (str), info_sep (str), width (int), file (t.TextIO | None), color (bool | None), update_min_steps (int) → ProgressBar[int]

• iterable (cabc.Iterable[V] | None), length (int | None), label (str | None), hidden (bool), show_eta (bool), show_percent (bool | None), show_pos (bool), item_show_func (t.Callable[[V | None], str | None] | None), fill_char (str), empty_char (str), bar_template (str), info_sep (str), width (int), file (t.TextIO | None), color (bool | None), update_min_steps (int) → ProgressBar[V]

This function creates an iterable context manager that can be used to iterate over something while showing a progress bar. It will either iterate over the iterable or length items (that are counted up). While iteration happens, this function will print a rendered progress bar to the given file (defaults to stdout) and will attempt to calculate remaining time and more. By default, this progress bar will not be rendered if the file is not a terminal.

The context manager creates the progress bar. When the context manager is entered the progress bar is already created. With every iteration over the progress bar, the iterable passed to the bar is advanced and the bar is updated. When the context manager exits, a newline is printed and the progress bar is finalized on screen.

Note: The progress bar is currently designed for use cases where the total progress can be expected to take at least several seconds. Because of this, the ProgressBar class object won’t display progress that is considered too fast, and progress where the time between steps is less than a second.

No printing must happen or the progress bar will be unintentionally destroyed.

Example usage:

with progressbar(items) as bar:
    for item in bar:
        do_something_with(item)

Alternatively, if no iterable is specified, one can manually update the progress bar through the update() method instead of directly iterating over the progress bar. The update method accepts the number of steps to increment the bar with:

with progressbar(length=chunks.total_bytes) as bar:
    for chunk in chunks:
        process_chunk(chunk)
        bar.update(chunks.bytes)

The update() method also takes an optional value specifying the current_item at the new position. This is useful when used together with item_show_func to customize the output for each manual step:

with click.progressbar(
    length=total_size,
    label='Unzipping archive',
    item_show_func=lambda a: a.filename
) as bar:
    for archive in zip_file:
        archive.extract()
        bar.update(archive.size, archive)

Parameters:

• iterable (cabc.Iterable[V] | None) – an iterable to iterate over. If not provided the length is required.

• length (int | None) – the number of items to iterate over. By default the progressbar will attempt to ask the iterator about its length, which might or might not work. If an iterable is also provided this parameter can be used to override the length. If an iterable is not provided the progress bar will iterate over a range of that length.

• label (str | None) – the label to show next to the progress bar.

• hidden (bool) – hide the progressbar. Defaults to False. When no tty is detected, it will only print the progressbar label. Setting this to False also disables that.

• show_eta (bool) – enables or disables the estimated time display. This is automatically disabled if the length cannot be determined.

• show_percent (bool | None) – enables or disables the percentage display. The default is True if the iterable has a length or False if not.

• show_pos (bool) – enables or disables the absolute position display. The default is False.

• item_show_func (t.Callable[[V | None], str | None] | None) – A function called with the current item which can return a string to show next to the progress bar. If the function returns None nothing is shown. The current item can be None, such as when entering and exiting the bar.

• fill_char (str) – the character to use to show the filled part of the progress bar.

• empty_char (str) – the character to use to show the non-filled part of the progress bar.

• bar_template (str) – the format string to use as template for the bar. The parameters in it are label for the label, bar for the progress bar and info for the info section.

• info_sep (str) – the separator between multiple info items (eta etc.)

• width (int) – the width of the progress bar in characters, 0 means full terminal width

• file (t.TextIO | None) – The file to write to. If this is not a terminal then only the label is printed.

• color (bool | None) – controls if the terminal supports ANSI colors or not. The default is autodetection. This is only needed if ANSI codes are included anywhere in the progress bar output which is not the case by default.

• update_min_steps (int) – Render only when this many updates have completed. This allows tuning for very fast iterators.

Added in version 8.2: The hidden argument.

Changed in version 8.0: Output is shown even if execution time is less than 0.5 seconds.

Changed in version 8.0: item_show_func shows the current item, not the previous one.

Changed in version 8.0: Labels are echoed if the output is not a TTY. Reverts a change in 7.0 that removed all output.

Added in version 8.0: The update_min_steps parameter.

Added in version 4.0: The color parameter and update method.

Added in version 2.0.

click_extra.prompt(text, default=None, hide_input=False, confirmation_prompt=False, type=None, value_proc=None, prompt_suffix=': ', show_default=True, err=False, show_choices=True)

Prompts a user for input. This is a convenience function that can be used to prompt a user for input later.

If the user aborts the input by sending an interrupt signal, this function will catch it and raise a Abort exception.

Parameters:

• text (str) – the text to show for the prompt.

• default (Any | None) – the default value to use if no input happens. If this is not given it will prompt until it’s aborted.

• hide_input (bool) – if this is set to true then the input value will be hidden.

• confirmation_prompt (bool | str) – Prompt a second time to confirm the value. Can be set to a string instead of True to customize the message.

• type (ParamType | Any | None) – the type to use to check the value against.

• value_proc (Callable[[str], Any] | None) – if this parameter is provided it’s a function that is invoked instead of the type conversion to convert a value.

• prompt_suffix (str) – a suffix that should be added to the prompt.

• show_default (bool | str) – shows or hides the default value in the prompt. If this value is a string, it shows that string in parentheses instead of the actual value.

• err (bool) – if set to true the file defaults to stderr instead of stdout, the same as with echo.

• show_choices (bool) – Show or hide choices if the passed type is a Choice. For example if type is a Choice of either day or week, show_choices is true and text is “Group by” then the prompt will be “Group by (day, week): “.

Changed in version 8.3.3: show_default can be a string to show a custom value instead of the actual default, matching the help text behavior.

Changed in version 8.3.1: A space is no longer appended to the prompt.

Added in version 8.0: confirmation_prompt can be a custom string.

Added in version 7.0: Added the show_choices parameter.

Added in version 6.0: Added unicode support for cmd.exe on Windows.

Added in version 4.0: Added the err parameter.

Return type:

Any

click_extra.register_theme(name, theme)

Register a named theme in the module-level theme_registry.

Parameters:

• name (str) – Lowercase identifier used as the --theme choice value.

• theme (HelpExtraTheme) – A HelpExtraTheme instance.

Return type:

None

click_extra.render_table(table_data, headers=None, table_format=None, sort_key=None, **kwargs)

Render a table and return it as a string.

Parameters:

sort_key (Callable[[Sequence[str | None]], Any] | None) – Optional callable passed to sorted() as the key argument. When provided, rows are sorted before rendering.

Return type:

str

click_extra.search_params(params, klass, include_subclasses=True, unique=True)

Search a particular class of parameter in a list and return them.

Parameters:

• params (Iterable[Parameter]) – list of parameter instances to search in.

• klass (type[Parameter]) – the class of the parameters to look for.

• include_subclasses (bool) – if True, includes in the results all parameters subclassing the provided klass. If False, only matches parameters which are strictly instances of klass. Defaults to True.

• unique (bool) – if True, raise an error if more than one parameter of the provided klass is found. Defaults to True.

Return type:

list[Parameter] | Parameter | None

click_extra.secho(message=None, file=None, nl=True, err=False, color=None, **styles)

This function combines echo() and style() into one call. As such the following two calls are the same:

click.secho('Hello World!', fg='green')
click.echo(click.style('Hello World!', fg='green'))

All keyword arguments are forwarded to the underlying functions depending on which one they go with.

Non-string types will be converted to str. However, bytes are passed directly to echo() without applying style. If you want to style bytes that represent text, call bytes.decode() first.

Changed in version 8.0: A non-string message is converted to a string. Bytes are passed through without style applied.

Added in version 2.0.

Return type:

None

click_extra.serialize_data(data, table_format, *, default=None, root_element='records', **kwargs)

Serialize arbitrary Python data to a structured format.

Unlike render_table() which expects tabular rows and headers, this function accepts any JSON-compatible data structure (dicts, lists, nested combinations) and serializes it to the requested format.

Only formats in SERIALIZATION_FORMATS are supported.

Parameters:

• data (Any) – Arbitrary data to serialize (dicts, lists, scalars).

• table_format (TableFormat) – Target serialization format.

• default (Callable | None) – Fallback serializer for types not natively supported. Defaults to str(), so Path and similar types are stringified automatically. Set to a custom callable for different behavior.

• root_element (str) – Root element name for XML output.

• kwargs – Extra keyword arguments forwarded to the underlying serializer (e.g. sort_keys, indent for JSON).

Raises:

ValueError – If the format is not a serialization format.

Return type:

str

click_extra.set_default_theme(theme)

Override the process-wide fallback theme.

ThemeOption writes its picked theme to ctx.meta rather than calling this helper, so per-invocation choices do not leak across invocations sharing the same process. Use this only for genuinely process-wide overrides — click_extra.wrap.patch_click() is the canonical caller.

Return type:

None

click_extra.show_params_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.style(text, fg=None, bg=None, bold=None, dim=None, underline=None, overline=None, italic=None, blink=None, reverse=None, strikethrough=None, reset=True)

Styles a text with ANSI styles and returns the new string. By default the styling is self contained which means that at the end of the string a reset code is issued. This can be prevented by passing reset=False.

Examples:

click.echo(click.style('Hello World!', fg='green'))
click.echo(click.style('ATTENTION!', blink=True))
click.echo(click.style('Some things', reverse=True, fg='cyan'))
click.echo(click.style('More colors', fg=(255, 12, 128), bg=117))

Supported color names:

• black (might be a gray)

• red

• green

• yellow (might be an orange)

• blue

• magenta

• cyan

• white (might be light gray)

• bright_black

• bright_red

• bright_green

• bright_yellow

• bright_blue

• bright_magenta

• bright_cyan

• bright_white

• reset (reset the color code only)

If the terminal supports it, color may also be specified as:

• An integer in the interval [0, 255]. The terminal must support 8-bit/256-color mode.

• An RGB tuple of three integers in [0, 255]. The terminal must support 24-bit/true-color mode.

See https://en.wikipedia.org/wiki/ANSI_color and https://gist.github.com/XVilka/8346728 for more information.

Parameters:

• text (Any) – the string to style with ansi codes.

• fg (int | tuple[int, int, int] | str | None) – if provided this will become the foreground color.

• bg (int | tuple[int, int, int] | str | None) – if provided this will become the background color.

• bold (bool | None) – if provided this will enable or disable bold mode.

• dim (bool | None) – if provided this will enable or disable dim mode. This is badly supported.

• underline (bool | None) – if provided this will enable or disable underline.

• overline (bool | None) – if provided this will enable or disable overline.

• italic (bool | None) – if provided this will enable or disable italic.

• blink (bool | None) – if provided this will enable or disable blinking.

• reverse (bool | None) – if provided this will enable or disable inverse rendering (foreground becomes background and the other way round).

• strikethrough (bool | None) – if provided this will enable or disable striking through text.

• reset (bool) – by default a reset-all code is added at the end of the string which means that styles do not carry over. This can be disabled to compose styles.

Changed in version 8.0: A non-string message is converted to a string.

Changed in version 8.0: Added support for 256 and RGB color codes.

Changed in version 8.0: Added the strikethrough, italic, and overline parameters.

Changed in version 7.0: Added support for bright colors.

Added in version 2.0.

Return type:

str

click_extra.table_format_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.telemetry_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.theme_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.timer_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.unstyle(text)

Removes ANSI styling information from a string. Usually it’s not necessary to use this function as Click’s echo function will automatically remove styling if necessary.

Added in version 2.0.

Parameters:

text (str) – the text to remove style information from.

Return type:

str

click_extra.validate_config_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.verbose_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.verbosity_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.version_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.wrap_text(text, width=78, initial_indent='', subsequent_indent='', preserve_paragraphs=False)

A helper function that intelligently wraps text. By default, it assumes that it operates on a single paragraph of text but if the preserve_paragraphs parameter is provided it will intelligently handle paragraphs (defined by two empty lines).

If paragraphs are handled, a paragraph can be prefixed with an empty line containing the \b character (\x08) to indicate that no rewrapping should happen in that block.

Parameters:

• text (str) – the text that should be rewrapped.

• width (int) – the maximum width for the text.

• initial_indent (str) – the initial indent that should be placed on the first line as a string.

• subsequent_indent (str) – the indent string that should be placed on each consecutive line.

• preserve_paragraphs (bool) – if this flag is set then the wrapping will intelligently handle paragraphs.

Return type:

str

Subpackages

• click_extra.sphinx package
  • EXEC_DIRECTIVES_OPT_IN
  • setup()
  • Submodules
  • click_extra.sphinx.alerts module
    • GITHUB_ALERT_PATTERN
    • QUOTE_PREFIX_PATTERN
    • CODE_FENCE_PATTERN
    • INDENTED_CODE_BLOCK_PATTERN
    • Alert
      • Alert.alert_type
      • Alert.indent
      • Alert.depth
      • Alert.has_nested
      • Alert.opening_line_index
    • FenceState
      • FenceState.char
      • FenceState.length
      • FenceState.indent
      • FenceState.is_code_block
    • ParserState
      • ParserState.result
      • ParserState.alert_stack
      • ParserState.fence_stack
      • ParserState.prev_line_blank
      • ParserState.modified
      • ParserState.just_opened_fence_directive
      • ParserState.in_code_block()
      • ParserState.current_depth()
    • check_colon_fence()
    • count_quote_depth()
    • process_fence()
    • close_alerts_to_depth()
    • mark_parent_nested()
    • open_alert()
    • process_quoted_line()
    • replace_github_alerts()
    • convert_github_alerts()
  • click_extra.sphinx.click module
    • RST_INDENT
    • TerminatedEchoingStdin
    • patch_subprocess()
    • ClickRunner
      • ClickRunner.isolation()
      • ClickRunner.invoke()
      • ClickRunner.execute_source()
      • ClickRunner.run_cli()
    • ClickDirective
      • ClickDirective.has_content
      • ClickDirective.required_arguments
      • ClickDirective.optional_arguments
      • ClickDirective.final_argument_whitespace
      • ClickDirective.option_spec
      • ClickDirective.default_language
      • ClickDirective.show_source_by_default
      • ClickDirective.show_results_by_default
      • ClickDirective.runner_method
      • ClickDirective.runner_attr
      • ClickDirective.runner_factory
      • ClickDirective.runner
      • ClickDirective.language
      • ClickDirective.code_block_options()
      • ClickDirective.show_source
      • ClickDirective.show_results
      • ClickDirective.is_myst_syntax
      • ClickDirective.render_code_block()
      • ClickDirective.run()
    • SourceDirective
      • SourceDirective.default_language
      • SourceDirective.show_source_by_default
      • SourceDirective.show_results_by_default
      • SourceDirective.runner_method
    • RunDirective
      • RunDirective.default_language
      • RunDirective.show_source_by_default
      • RunDirective.show_results_by_default
      • RunDirective.runner_method
    • DeprecatedExampleDirective
      • DeprecatedExampleDirective.run()
    • ClickDomain
      • ClickDomain.name
      • ClickDomain.label
      • ClickDomain.directives
    • cleanup_runner()

Submodules

click_extra.cli module

Click Extra CLI with pre-baking utilities.

click_extra.colorize module

Helpers and utilities to apply ANSI coloring to terminal content.

Note

_nearest_256 (24-bit RGB to 256-color quantization) lives here rather than in pygments.py because both cli.py and pygments.py need it, and pygments.py is gated behind the optional pygments extra. Placing it in colorize.py (which has no optional dependencies) keeps the function available to the CLI regardless of whether Pygments is installed.

click_extra.colorize.color_envvars = {'CLICOLOR': True, 'CLICOLORS': True, 'CLICOLORS_FORCE': True, 'CLICOLOR_FORCE': True, 'COLOR': True, 'COLORS': True, 'FORCE_COLOR': True, 'FORCE_COLORS': True, 'LLM': False, 'NOCOLOR': False, 'NOCOLORS': False, 'NO_COLOR': False, 'NO_COLORS': False}

List of environment variables recognized as flags to switch color rendering on or off.

The key is the name of the variable and the boolean value the value to pass to --color option flag when encountered.

Source:

• https://github.com/pallets/click/issues/558

• https://github.com/pallets/click/issues/1090

• https://github.com/pallets/click/issues/1498

• https://github.com/pallets/click/issues/3022

• https://blog.codemine.be/posts/2026/20260222-be-quiet/

class click_extra.colorize.ColorOption(param_decls=None, is_flag=True, default=True, is_eager=True, expose_value=False, help='Strip out all colors and all ANSI codes from output.', **kwargs)

Bases: ExtraOption

A pre-configured option that is adding a --color/--no-color (aliased by --ansi/--no-ansi) to keep or strip colors and ANSI codes from CLI output.

This option is eager by default to allow for other eager options (like --version) to be rendered colorless.

Todo

Should we switch to --color=<auto|never|always> as GNU tools does?

Also see how the isatty property defaults with this option, and how it can be implemented in Python.

Todo

Support the TERM environment variable convention?

set_color(ctx, param, value)

Reconcile --color/--no-color/--ansi/--no-ansi with environment variables.

The reconciliation pass re-inspects the environment for any of the recognised colorization flags (NO_COLOR, FORCE_COLOR, CLICOLOR, …): when the user hasn’t explicitly passed --color / --no-color on the command line, the env vars take precedence. The final reconciled value lands on ctx.color (the Click-standard attribute that echo() reads). Renamed from disable_colors because the callback handles enable as well as disable: the previous name only described half the behavior.

Return type:

None

class click_extra.colorize.HelpKeywords(cli_names=<factory>, subcommands=<factory>, command_aliases=<factory>, arguments=<factory>, long_options=<factory>, short_options=<factory>, choices=<factory>, choice_metavars=<factory>, metavars=<factory>, envvars=<factory>, defaults=<factory>)

Bases: object

Structured collection of keywords extracted from a Click context for help screen highlighting.

Each field corresponds to a semantic category with its own styling.

cli_names: set[str]

subcommands: set[str]

command_aliases: set[str]

arguments: set[str]

long_options: set[str]

short_options: set[str]

choices: set[str]

choice_metavars: set[str]

metavars: set[str]

envvars: set[str]

defaults: set[str]

merge(other)

Merge another HelpKeywords into this one.

Each set field is updated with the corresponding set from other.

Return type:

None

subtract(other)

Remove keywords found in other from this instance.

Each set field is difference-updated with the corresponding set from other. Mirror of merge().

Return type:

None

class click_extra.colorize.ExtraHelpColorsMixin

Bases: object

Adds extra-keywords highlighting to Click commands.

This mixin for click.Command-like classes intercepts the top-level helper- generation method to initialize the formatter with dynamic settings. This is implemented at this stage so we have access to the global context.

extra_keywords: HelpKeywords | None = None

Extra keywords to merge into the auto-collected set. Consumers can set this attribute on a command instance to inject additional keywords for help screen highlighting (e.g. placeholder option names like --<manager-id> that appear in prose but are not real parameters).

excluded_keywords: HelpKeywords | None = None

Keywords to remove from the auto-collected set. Mirror of extra_keywords: any string listed here will not be highlighted even if it was collected from the Click context.

collect_keywords(ctx)

Parse click context to collect option names, choices and metavar keywords.

Override this method to customize keyword collection. Call super() and mutate the returned HelpKeywords to extend the default set.

Return type:

HelpKeywords

get_help(ctx)

Replace default formatter by our own.

Return type:

str

format_help(ctx, formatter)

Feed our custom formatter instance with the keywords to highlight.

Return type:

None

class click_extra.colorize.HelpExtraFormatter(*args, **kwargs)

Bases: HelpFormatter

Extends Cloup’s custom HelpFormatter to highlights options, choices, metavars and default values.

This is being discussed for upstream integration at:

• https://github.com/janluke/cloup/issues/97

• https://github.com/click-contrib/click-help-colors/issues/17

• https://github.com/janluke/cloup/issues/95

Forces theme to the active one for the current Click context.

Also transform Cloup’s standard HelpTheme to our own HelpExtraTheme.

Resolves the active theme via click_extra.theme.get_current_theme(), which reads the per-invocation pick from the Click context (set by ThemeOption) and falls back to the module-level default when no context is active.

theme: HelpExtraTheme

write_usage(prog, args='', prefix=None)

ANSI-aware override of cloup.HelpFormatter.write_usage().

Click’s click.formatting.wrap_text() measures line length with raw len(), counting every byte of the ANSI escape sequences embedded in initial_indent (the styled Usage: heading + invoked-command name). With 24-bit RGB themes (e.g. Solarized Dark, Dracula, Nord, Monokai), each styled token carries 17+ extra bytes of escape, which inflates the measured line beyond the width budget and causes premature wraps mid-token: [OPTIONS\n  ].

Cloup styles prefix and prog then delegates to click’s HelpFormatter.write_usage(), inheriting the bug. This override re-applies the same styling, then bypasses wrap_text whenever the visible content fits on a single line: the common case for short usage strings where wrapping is unnecessary. Lines that genuinely overflow the visible width fall back to click’s implementation: the wrap point may still be sub-optimal but the output stays syntactically valid.

See also

Upstream fix proposed at https://github.com/pallets/click/pull/3420, which makes click.formatting.TextWrapper ANSI-aware by counting visible width instead of raw bytes. Once that lands in a Click release, this override can be removed.

Todo

Drop this override once the minimum supported Click pins to the release that includes pallets/click#3420. The term_len-based visible-width check below becomes redundant once Click’s own wrapper counts visible width.

Return type:

None

keywords: HelpKeywords = HelpKeywords(cli_names=set(), subcommands=set(), command_aliases=set(), arguments=set(), long_options=set(), short_options=set(), choices=set(), choice_metavars=set(), metavars=set(), envvars=set(), defaults=set())

excluded_keywords: HelpKeywords | None = None

highlight_extra_keywords(help_text)

Highlight extra keywords in help screens based on the theme.

Uses the highlight() function for all keyword categories. Each category is processed as a batch of regex patterns with a single styling function, which handles overlapping matches and prevents double-styling.

Return type:

str

getvalue()

Wrap original Click.HelpFormatter.getvalue() to force extra-colorization on rendering.

Return type:

str

click_extra.colorize.highlight(content, patterns, styling_func, ignore_case=False)

Highlights parts of the content that matches patterns.

Takes care of overlapping parts within the content, so that the styling function is applied only once to each contiguous range of matching characters.

Todo

Support case-foldeing, so we can have the Straße string matching the Strasse content.

This could be tricky as it messes with string length and characters index, which our logic relies on.

Danger

Roundtrip through lower-casing/upper-casing is a can of worms, because some characters change length when their case is changed:

• Unicode roundtrip-unsafe characters

• Unicode codepoints expanding or contracting on case changes

Return type:

str

click_extra.commands module

Wraps vanilla Click and Cloup commands with extra features.

Our flavor of commands, groups and context are all subclasses of their vanilla counterparts, but are pre-configured with good and common defaults. You can still leverage the mixins in here to build up your own custom variants.

click_extra.commands.default_extra_params()

Default additional options added to @command and @group.

Caution

The order of options has been carefully crafted to handle subtle edge-cases and avoid leaky states in unittests.

You can still override this hard-coded order for easthetic reasons and it should be fine. Your end-users are unlikely to be affected by these sneaky bugs, as the CLI context is going to be naturraly reset after each invocation (which is not the case in unitests).

1. --time / --no-time

   Hint

   --time is placed at the top of all other eager options so all other options’ processing time can be measured.

2. --config CONFIG_PATH

   Hint

   --config is at the top so it can have a direct influence on the default behavior and value of the other options.

3. --no-config

4. --validate-config CONFIG_PATH

5. --color, --ansi / --no-color, --no-ansi

6. --theme

7. --show-params

8. --table-format FORMAT

9. --verbosity LEVEL

10. -v, --verbose

11. --version

12. -h, --help

    Attention

    This is the option produced by the @click.decorators.help_option decorator.

    It is not explicitly referenced in the implementation of this function.

    That’s because it’s going to be added by Click itself, at the end of the list of options. By letting Click handle this, we ensure that the help option will take into account the help_option_names setting.

Important

Sensitivity to order still remains to be proven. With the code of Click Extra and its dependencies moving fast, there is a non-zero chance that all the options are now sound enough to be re-ordered in a more natural way.

Todo

For bullet-proof handling of edge-cases, we should probably add an indirection layer to have the processing order of options (the one below) different from the presentation order of options in the help screen.

This is probably something that has been requested in issue #544.

Return type:

list[Option]

class click_extra.commands.ExtraCommand(*args, version_fields=None, config_schema=None, schema_strict=False, fallback_sections=(), config_validators=(), included_params=None, extra_option_at_end=True, populate_auto_envvars=True, extra_keywords=None, excluded_keywords=None, **kwargs)

Bases: ExtraHelpColorsMixin, Command

Like cloup.command, with sane defaults and extra help screen colorization.

List of extra parameters:

Parameters:

• version_fields (dict[str, Any] | None) – dictionary of ExtraVersionOption template field overrides forwarded to the version option. Accepts any field from ExtraVersionOption.template_fields (e.g. prog_name, version, git_branch). Lets you customize --version output from the command decorator without replacing the default params list.

• extra_keywords (HelpKeywords | None) – a HelpKeywords instance whose entries are merged into the auto-collected keyword set. Use this to inject additional strings for help screen highlighting.

• excluded_keywords (HelpKeywords | None) – a HelpKeywords instance whose entries are removed from the auto-collected keyword set. Use this to suppress highlighting of specific strings.

• extra_option_at_end (bool) – reorders all parameters attached to the command, by moving all instances of ExtraOption at the end of the parameter list. The original order of the options is preserved among themselves.

• populate_auto_envvars (bool) – forces all parameters to have their auto-generated environment variables registered. This address the shortcoming of click which only evaluates them dynamiccaly. By forcing their registration, the auto-generated environment variables gets displayed in the help screen, fixing click#2483 issue. On Windows, environment variable names are case-insensitive, so we normalize them to uppercase.

By default, these Click context settings are applied:

• auto_envvar_prefix = self.name (Click feature)

  Auto-generate environment variables for all options, using the command ID as prefix. The prefix is normalized to be uppercased and all non-alphanumerics replaced by underscores.

• help_option_names = ("--help", "-h") (Click feature)

  Allow help screen to be invoked with either –help or -h options.

• show_default = True (Click feature)

  Show all default values in help screen.

Additionally, these Cloup context settings are set:

• align_option_groups = False (Cloup feature)

  Aligns option groups in help screen.

• show_constraints = True (Cloup feature)

  Show all constraints in help screen.

• show_subcommand_aliases = True (Cloup feature)

  Show all subcommand aliases in help screen.

Click Extra also adds its own context_settings:

• show_choices = None (Click Extra feature)

  If set to True or False, will force that value on all options, so we can globally show or hide choices when prompting a user for input. Only makes sense for options whose prompt property is set.

  Defaults to None, which will leave all options untouched, and let them decide of their own show_choices setting.

• show_envvar = None (Click Extra feature)

  If set to True or False, will force that value on all options, so we can globally enable or disable the display of environment variables in help screen.

  Defaults to None, which will leave all options untouched, and let them decide of their own show_envvar setting. The rationale being that discoverability of environment variables is enabled by the --show-params option, which is active by default on extra commands. So there is no need to surcharge the help screen.

  This addresses the click#2313 issue.

To override these defaults, you can pass your own settings with the context_settings parameter:

@command(
    context_settings={
        "show_default": False,
        ...
    }
)

context_class

alias of ExtraContext

main(args=None, prog_name=None, **kwargs)

Pre-invocation step that is instantiating the context, then call invoke() within it.

Caution

During context instantiation, each option’s callbacks are called. These might break the execution flow (like --help or --version).

Sets the default CLI’s prog_name to the command’s name if not provided, instead of relying on Click’s auto-detection via the _detect_program_name() method. This is to avoid the CLI being called python -m <module_name>, which is not very user-friendly.

Return type:

Any

make_context(info_name, args, parent=None, **extra)

Intercept the call to the original click.core.Command.make_context so we can keep a copy of the raw, pre-parsed arguments provided to the CLI.

The result are passed to our own ExtraContext constructor which is able to initialize the context’s meta property under our own click_extra.context.RAW_ARGS entry. This will be used in ShowParamsOption.print_params() to print the table of parameters fed to the CLI.

See also

This workaround is being discussed upstream in click#1279.

Return type:

Any

parse_args(ctx, args)

Like parent’s parse_args but with better error messages for single-dash multi-character tokens.

Return type:

list[str]

invoke(ctx)

Main execution of the command, just after the context has been instantiated in main().

Return type:

Any

class click_extra.commands.ColorizedCommand(name, context_settings=None, callback=None, params=None, help=None, epilog=None, short_help=None, options_metavar='[OPTIONS]', add_help_option=True, no_args_is_help=False, hidden=False, deprecated=False)

Bases: ExtraHelpColorsMixin, Command

Click Command with help colorization but no extra params.

Mixes in ExtraHelpColorsMixin for keyword highlighting and uses ExtraContext for the colorized formatter, without inheriting from ExtraCommand (which would inject default_extra_params).

Use this as a base for lightweight subcommands (like help) or for monkey-patching third-party CLIs (via patch_click()).

context_class

alias of ExtraContext

class click_extra.commands.ColorizedGroup(name=None, commands=None, invoke_without_command=False, no_args_is_help=None, subcommand_metavar=None, chain=False, result_callback=None, **kwargs)

Bases: ExtraHelpColorsMixin, Group

Click Group with help colorization but no extra params.

Same as ColorizedCommand but for groups.

context_class

alias of ExtraContext

class click_extra.commands.HelpCommand(name, context_settings=None, callback=None, params=None, help=None, epilog=None, short_help=None, options_metavar='[OPTIONS]', add_help_option=True, no_args_is_help=False, hidden=False, deprecated=False)

Bases: ColorizedCommand

Synthetic subcommand that displays help for the parent group or a subcommand.

Auto-injected into every ExtraGroup. Supports nested resolution: mycli help subgroup subcmd shows the help for subcmd within subgroup.

invoke(ctx)

Resolve the command path and display its help.

Return type:

None

class click_extra.commands.ExtraGroup(*args, help_command=True, **kwargs)

Bases: ExtraCommand, Group

Like cloup.Group, with sane defaults and extra help screen colorization.

Like ExtraCommand.__init__, but auto-injects a help subcommand.

Parameters:

help_command (bool) – when True (the default), a help subcommand is automatically registered. Set to False to suppress it, or register your own help subcommand to override it.

command_class

Makes commands of an ExtraGroup be instances of ExtraCommand.

That way all subcommands created from an ExtraGroup benefits from the same defaults and extra help screen colorization.

See: https://click.palletsprojects.com/en/stable/api/#click.Group.command_class

alias of ExtraCommand

group_class

Let ExtraGroup produce sub-groups that are also of ExtraGroup type.

See: https://click.palletsprojects.com/en/stable/api/#click.Group.group_class

alias of type

add_command(cmd, name=None, **kwargs)

Like cloup.Group.add_command, but replaces an auto-injected HelpCommand when the user registers their own help subcommand.

Return type:

None

invoke(ctx)

Inject _default_subcommands and _prepend_subcommands from config.

If the user has not provided any subcommands explicitly, and the loaded configuration contains a _default_subcommands list for this group, those subcommands are injected into ctx.protected_args so that Click’s normal Group.invoke() dispatches them.

_prepend_subcommands always prepends subcommands to the invocation, regardless of whether CLI subcommands were provided. Only works with chain=True groups.

Return type:

Any

class click_extra.commands.LazyGroup(*args, lazy_subcommands=None, **kwargs)

Bases: ExtraGroup

An ExtraGroup that supports lazy loading of subcommands.

Hint

This implementation is based on the snippet from Click’s documentation: Defining the lazy group.

It has been extended to work with Click Extra’s config_option in click_extra#1332 issue.

lazy_subcommands maps command names to their import paths.

Tip

lazy_subcommands is a map of the form:

{"<command-name>": "<module-name>.<command-object-name>"}

Example:

{"mycmd": "my_cli.commands.mycmd"}

list_commands(ctx)

List all commands, including not-yet-loaded lazy subcommands.

Return type:

list[str]

get_command(ctx, cmd_name)

Get a command by name, loading lazily if necessary.

Todo

Allow passing extra parameters to the self.lazy_subcommands so we can register commands with custom settings like Cloup’s section or fallback_to_default_section:

• section: Optional[Section] = None,

• fallback_to_default_section: bool = True,

See: https://github.com/janluke/cloup/blob/master/cloup/_sections.py#L169

Return type:

Command | None

click_extra.config module

Utilities to load parameters and options from a configuration file.

Hint

Why config?

That whole namespace is using the common config short-name to designate configuration files.

Not conf, not cfg, not configuration, not settings. Just config.

A quick survey of existing practices, and poll to my friends informed me that config is more explicit and less likely to be misunderstood.

After all, is there a chance for it to be misunderstood, in the context of a CLI, for something else? Confirm? Conference? Conflict Confuse?…

So yes, config is good enough.

Todo

Add a --dump-config or --export-config option to write down the current configuration (or a template) into a file or <stdout>.

Help message would be: you can use this option with other options or environment variables to have them set in the generated configuration.

Dotted keys in configuration files (e.g. "subcommand.option": value) are automatically expanded into nested dicts before merging, so users can freely mix flat dot-notation and nested structures in any supported format.

click_extra.config.VCS_DIRS = ('.git', '.hg', '.svn', '.bzr', 'CVS', '.darcs')

VCS directory names used to identify version control system roots.

Includes: - .git — Git - .hg — Mercurial - .svn — Subversion - .bzr — Bazaar - CVS — CVS (note: uppercase, no leading dot) - .darcs — Darcs

class click_extra.config.ConfigFormat(*values)

Bases: Enum

All configuration formats, associated to their support status.

The first element of the tuple is a sequence of file extensions associated to the format. Patterns are fed to wcmatch.glob for matching, and are influenced by the flags set on the ConfigOption instance.

The second element indicates whether the format is supported or not, depending on the availability of the required third-party packages. This evaluation is performed at runtime when this module is imported.

Caution

The order is important for both format members and file patterns. It defines the priority order in which formats are tried when multiple candidate files are found.

Todo

Add support for JWCC / hujson format?

TOML = (('*.toml',), True, 'TOML')

YAML = (('*.yaml', '*.yml'), True, 'YAML')

JSON = (('*.json',), True, 'JSON')

JSON5 = (('*.json5',), True, 'JSON5')

JSONC = (('*.jsonc',), True, 'JSONC')

HJSON = (('*.hjson',), True, 'Hjson')

INI = (('*.ini',), True, 'INI')

XML = (('*.xml',), True, 'XML')

PYPROJECT_TOML = (('pyproject.toml',), True, 'pyproject.toml')

property label: str

Human-friendly name of the format for display in messages.

property enabled: bool

Returns True if the format is supported, False otherwise.

property patterns: tuple[str]

Returns the default file patterns associated to the format.

click_extra.config.CONFIG_OPTION_NAME = 'config'

Hardcoded name of the configuration option.

This name is going to be shared by both the --config and --no-config options below, so they can compete with each other to either set a path pattern or disable the use of any configuration file at all.

click_extra.config.DEFAULT_EXCLUDED_PARAMS = ('config', 'help', 'show_params', 'version')

Default parameter IDs to exclude from the configuration file.

Defaults to:

• --config option, which cannot be used to recursively load another configuration file.

• --help, as it makes no sense to have the configurable file always forces a CLI to show the help and exit.

• --show-params flag, which is like --help and stops the CLI execution.

• --version, which is not a configurable option per-se.

click_extra.config.DEFAULT_SUBCOMMANDS_KEY = '_default_subcommands'

Reserved configuration key for specifying default subcommands.

When a group is invoked without explicit subcommands on the CLI, the subcommands listed under this key execute automatically in order. CLI always wins: if the user names subcommands explicitly, the config is ignored.

Example TOML configuration:

[my-cli]
_default_subcommands = ["backup", "sync"]

[my-cli.backup]
path = "/home"

click_extra.config.PREPEND_SUBCOMMANDS_KEY = '_prepend_subcommands'

Reserved configuration key for prepending subcommands to every invocation.

Unlike _default_subcommands which only fires when no subcommands are given on the CLI, _prepend_subcommands always prepends the listed subcommands. This is useful for always injecting a debug subcommand on a dev machine, for example.

Only works with chain=True groups (non-chained groups resolve exactly one subcommand, so prepending would break the user’s intended command).

Example TOML configuration:

[my-cli]
_prepend_subcommands = ["debug"]

click_extra.config.EXTENSION_METADATA_KEY = 'click_extra.extension'

Dataclass field metadata flag marking a field as an extension point.

Schema authors set metadata={EXTENSION_METADATA_KEY: True} on a field when its sub-tree should pass through click-extra’s CLI-parameter strict check and be validated by app-specific logic instead. Equivalent to typing the field as dict[str, X]: both forms are recognized by _collect_opaque_paths_from_schema() (the internal pipeline still calls these paths “opaque” since they’re skipped by the normalize/flatten/strict machinery). The metadata form is useful when the underlying Python type is something other than a dict (for example, a nested dataclass that nonetheless represents user-extensible content).

click_extra.config.THEMES_CONFIG_KEY: str = 'themes'

Sub-key under [tool.<cli>] where user-defined themes live in config.

Used by ConfigOption to find [tool.<cli>.themes.<name>] tables, build them via HelpExtraTheme.from_dict, and stash the result on ctx.meta[click_extra.context.THEME_OVERRIDES]. The constant is the single source of truth shared by _builtin_config_validators(), ConfigOption._apply_theme_overrides(), and click_extra.theme.themes_from_config().

exception click_extra.config.ValidationError(path, message, code=None)

Bases: Exception

Raised when a configuration file fails validation.

A single, structured exception type that uniformly carries the dotted path of the offending key, a human-readable message, and an optional code for programmatic handling. Used by click-extra’s built-in strict-mode check and by every user-registered ConfigValidator, so downstream apps and --validate-config see the same error shape regardless of who detected the problem.

Parameters:

• path (str) – Dotted path to the offending key, relative to the configuration file root (e.g. "my-cli.managers.winget.cli_searchpath"). An empty string means the error applies to the document as a whole.

• message (str) – Human-readable description of the failure. Should be a single sentence, no trailing punctuation, no path repeated.

• code (str | None) – Optional machine-readable error code (e.g. "unknown_field") for callers that want to dispatch on error type without parsing the message string.

class click_extra.config.ConfigValidator(extension_path, validator, description='')

Bases: object

Register an app-defined extension validator for one sub-tree of the configuration file.

Apps register validators via the config_validators= kwarg on ConfigOption (or the matching decorator) to extend click-extra’s built-in CLI-parameter strict check with custom validation logic. Each validator targets a single dotted extension_path relative to the app’s configuration section. Click-extra passes the matching sub-tree straight through to the registered validator: the strict check skips it, the schema machinery treats it as opaque, and the user’s logic owns the result. The validator runs both during --validate-config and during normal config loading.

Parameters:

• extension_path (str) – Dotted path of the sub-tree the validator owns, relative to the app’s section in the configuration file. For example, an app named my-cli with extension_path="managers" receives the contents of the [my-cli.managers] table.

• validator (Callable[[dict[str, Any]], None]) – Callable taking the sub-tree dict and raising ValidationError on failure. Must be a pure function: no side effects on the click context, no print statements. The caller decides how to surface the error.

• description (str) – Optional human-readable summary of what the validator checks. Surfaces in documentation generators that introspect the decorator (e.g. autodoc), and may be reused in --help text in a future release.

extension_path: str

validator: Callable[[dict[str, Any]], None]

description: str = ''

click_extra.config.normalize_config_keys(conf, opaque_keys=frozenset({}), _prefix='')

Normalize configuration keys to valid Python identifiers.

Recursively replaces hyphens with underscores in all dict keys, using the same str.replace("-", "_") transform that Click applies internally when deriving parameter names from option declarations (e.g. --foo-bar becomes foo_bar). Click does not expose this as a public function, so we replicate the one-liner here.

Handles the convention mismatch between configuration formats (TOML, YAML, JSON all commonly use kebab-case) and Python identifiers. Works with all configuration formats supported by ConfigOption.

Parameters:

• opaque_keys (frozenset[str]) – Fully-qualified key names (using "_" as separator) where recursion stops. The key itself is still normalized, but its dict value is kept as-is. Used in tandem with flatten_config_keys’s opaque_keys to protect data dicts (e.g. GitHub Actions matrix axes) from normalization.

• _prefix (str) – Internal parameter for tracking the accumulated key path during recursion. Callers should not set this.

Todo

Propose upstream to Click to extract the inline name.replace("-", "_") into a private _normalize_param_name helper, so downstream projects like Click Extra can reuse it instead of duplicating the transform.

Return type:

dict[str, Any]

click_extra.config.flatten_config_keys(conf, sep='_', opaque_keys=frozenset({}), _prefix='')

Flatten nested dicts into a single level by joining keys with a separator.

Useful for mapping nested configuration structures (e.g. TOML sub-tables) to flat Python dataclass fields. After normalization with normalize_config_keys, the flattened keys match dataclass field names directly:

>>> from click_extra.config import flatten_config_keys, normalize_config_keys
>>> raw = {"dependency-graph": {"all-groups": True, "output": "deps.mmd"}}
>>> flatten_config_keys(normalize_config_keys(raw))
{'dependency_graph_all_groups': True, 'dependency_graph_output': 'deps.mmd'}

Parameters:

• conf (dict[str, Any]) – Nested dictionary to flatten.

• sep (str) – Separator used to join parent and child keys. Defaults to "_" which produces valid Python identifiers when combined with normalize_config_keys.

• opaque_keys (frozenset[str]) – Fully-qualified key names where flattening stops. When the accumulated key matches an entry in this set, the dict value is kept as-is instead of being recursively flattened. This is useful for fields typed as dict[str, X] where the dict keys are data (e.g. GitHub Actions matrix axis names), not config structure.

• _prefix (str) – Internal parameter for tracking the accumulated key path during recursion. Callers should not set this.

Return type:

dict[str, Any]

click_extra.config.get_tool_config(ctx=None)

Retrieve the typed tool configuration from the context.

Returns the object stored under click_extra.context.TOOL_CONFIG by ConfigOption when a config_schema is set, or None if no schema was configured or no configuration was loaded.

Parameters:

ctx (Context | None) – Click context. Defaults to the current context.

Return type:

Any

class click_extra.config.Sentinel(*values)

Bases: Enum

Enum used to define sentinel values.

Note

This reuse the same pattern as Click._utils.Sentinel.

See also

PEP 661 - Sentinel Values.

NO_CONFIG = <object object>

VCS = <object object>

click_extra.config.NO_CONFIG = Sentinel.NO_CONFIG

Sentinel used to indicate that no configuration file must be used at all.

click_extra.config.VCS = Sentinel.VCS

Sentinel used to stop parent directory walking at the nearest VCS root.

class click_extra.config.ConfigOption(param_decls=None, metavar='CONFIG_PATH', type=UNPROCESSED, help='Location of the configuration file. Supports local path with glob patterns or remote URL.', is_eager=True, expose_value=False, file_format_patterns=None, file_pattern_flags=4104, roaming=True, force_posix=False, search_pattern_flags=285504, search_parents=False, stop_at=Sentinel.VCS, excluded_params=None, included_params=None, strict=False, config_schema=None, schema_strict=False, fallback_sections=(), config_validators=(), **kwargs)

Bases: ExtraOption, ParamStructure

A pre-configured option adding --config CONFIG_PATH.

Takes as input a path to a file or folder, a glob pattern, or an URL.

• is_eager is active by default so the callback gets the opportunity to set the default_map of the CLI before any other parameter is processed.

• default is set to the value returned by self.default_pattern(), which is a pattern combining the default configuration folder for the CLI (as returned by click.get_app_dir()) and all supported file formats.

  Attention

  Default search pattern must follow the syntax of wcmatch.glob.

• excluded_params are parameters which, if present in the configuration file, will be ignored and not applied to the CLI. Items are expected to be the fully-qualified ID of the parameter, as produced in the output of --show-params. Will default to the value of DEFAULT_EXCLUDED_PARAMS.

• included_params is the inverse of excluded_params: only the listed parameters will be loaded from the configuration file. Cannot be used together with excluded_params.

file_format_patterns: dict[ConfigFormat, tuple[str, ...]]

Mapping of ConfigFormat to their associated file patterns.

Can be a string or a sequence of strings. This defines which configuration file formats are supported, and which file patterns are used to search for them.

Note

All formats depending on third-party dependencies that are not installed will be ignored.

Attention

File patterns must follow the syntax of wcmatch.fnmatch.

file_pattern_flags

Flags provided to all calls of wcmatch.fnmatch.

Applies to the matching of file names against supported format patterns specified in file_format_patterns.

Important

The SPLIT flag is always forced, as our multi-pattern design relies on it.

force_posix

Configuration for default folder search.

roaming and force_posix are fed to click.get_app_dir() to determine the location of the default configuration folder.

search_pattern_flags

Flags provided to all calls of wcmatch.glob.

Applies to both the default pattern and any user-provided pattern.

Important

The BRACE flag is always forced, so that multi-format default patterns using {pat1,pat2,...} syntax expand correctly.

The NODIR flag is always forced, to optimize the search for files only.

search_parents

Indicates whether to walk back the tree of parent folders when searching for configuration files.

stop_at

Boundary for parent directory walking.

• None — walk up to filesystem root.

• VCS — stop at the nearest VCS root (.git or .hg) (default).

• A Path or str — stop at that directory.

included_params: frozenset[str] | None

strict

Defines the strictness of the configuration loading.

• If True, raise an error if the configuration file contain parameters not recognized by the CLI.

• If False, silently ignore unrecognized parameters.

config_schema

Optional schema for structured access to configuration values.

When set, the app’s configuration section is extracted from the parsed config file, normalized (hyphens replaced with underscores), flattened (nested dicts joined with _), and passed to this callable to produce a typed configuration object.

Supports:

• Dataclass types — detected via __dataclass_fields__. Keys are normalized, nested dicts are flattened, and the result is filtered to known fields before instantiation. This allows nested config sections (e.g. [tool.myapp.sub-section]) to map directly to flat dataclass fields (e.g. sub_section_key).

• Any callable dict → T — called directly with the raw dict. Works with Pydantic’s Model.model_validate, attrs, or custom factory functions. The caller is responsible for key normalization and flattening.

The resulting object is stored in ctx.meta[click_extra.context.TOOL_CONFIG] and can be retrieved via get_tool_config.

schema_strict

Strictness for schema validation (separate from strict).

• If True, raise ValueError when the config section contains keys that do not match any dataclass field (after normalization and flattening). Only applies when config_schema is a dataclass.

• If False, silently ignore unrecognized keys.

Note

This is distinct from strict, which controls whether merge_default_map rejects config keys not matching CLI parameters. schema_strict validates against dataclass fields instead.

fallback_sections: Sequence[str]

Legacy section names to try when the app’s own section is empty.

Useful when a CLI tool has been renamed: old configuration files that still use [tool.old-name] (TOML), old-name: (YAML), or {"old-name": …} (JSON) are recognized with a deprecation warning. Works with all configuration formats.

config_validators: tuple[ConfigValidator, ...]

Extension validators for sub-trees of the configuration file.

Each ConfigValidator targets a dotted extension_path relative to the app section. Validators run after click-extra’s built-in CLI-parameter strict check (during --validate-config) and after the schema callable produces the typed configuration object (during normal config loading).

The list is seeded with click-extra’s built-in validators (currently the one for [tool.<cli>.themes.<name>] tables, see click_extra.theme.validate_themes_config()); user-supplied validators are appended after them. App code that registers its own validator on the same extension_path simply runs alongside the built-in: both validators are called, both sets of errors surface.

property excluded_params: frozenset[str]

Generates the default list of fully-qualified IDs to exclude.

Danger

It is only called once to produce the default exclusion list if the user did not provided its own.

It was not implemented in the constructor but made as a property, to allow for a just-in-time call within the current context. Without this trick we could not have fetched the CLI name.

property file_pattern: str

Compile all file patterns from the supported formats.

Uses , (comma) notation to combine multiple patterns, suitable for wcmatch brace expansion ({pat1,pat2,...}).

Returns a single pattern string.

default_pattern()

Returns the default pattern used to search for the configuration file.

Defaults to <app_dir>/{*.toml,*.json,*.ini}. Where <app_dir> is produced by the click.get_app_dir() method. The result depends on OS and is influenced by the roaming and force_posix properties.

Multiple file format patterns are wrapped with {…} brace-expansion syntax so that wcmatch.glob correctly applies the directory prefix to every sub-pattern.

Todo

Use platformdirs for more advanced configuration folder detection?

Return type:

str

get_help_extra(ctx)

Replaces the default value of the configuration option.

Display a pretty path that is relative to the user’s home directory:

~/folder/my_cli/{*.toml,*.json,*.ini}

Instead of the full absolute path:

/home/user/folder/my_cli/{*.toml,*.json,*.ini}

Caution

This only applies when the GLOBTILDE flag is set in search_pattern_flags.

Return type:

OptionHelpExtra

parent_patterns(pattern)

Generate (root_dir, file_pattern) pairs for searching.

Each yielded pair can be passed directly to glob.iglob(file_pattern, root_dir=root_dir) so that every sub-pattern (whether from BRACE or SPLIT expansion) is correctly scoped to the same directory.

root_dir is None for entirely magic patterns that will be evaluated relative to the current working directory.

Stops when reaching the root folder, the stop_at boundary, or an inaccessible directory.

Return type:

Iterable[tuple[str | None, str]]

search_and_read_file(pattern)

Search filesystem or URL for files matching the pattern.

If pattern is an URL, download its content. A pattern is considered an URL only if it validates as one and starts with http:// or https://. All other patterns are considered glob patterns for local filesystem search.

Returns an iterator of the normalized location and its raw content, for each one matching the pattern. Only files are returned, directories are silently skipped.

This method returns the raw content of all matching patterns, without trying to parse them. If the content is empty, it is still returned as-is.

Also includes lookups into parents directories if self.search_parents is True.

Raises FileNotFoundError if no file was found after searching all locations.

Return type:

Iterable[tuple[Path | URL, str]]

parse_conf(content, formats)

Parse the content with the given formats.

Tries to parse the given raw content string with each of the given formats, in order. Yields the resulting data structure for each successful parse.

Attention

Formats whose parsing raises an exception or does not return a dict are considered a failure and are skipped.

This follows the parse, don’t validate principle.

Return type:

Iterable[dict[str, Any] | None]

read_and_parse_conf(pattern)

Search for a parseable configuration file.

Returns the location and data structure of the first configuration matching the pattern.

Only return the first match that:

• exists,

• is a file,

• is not empty,

• match file format patterns,

• can be parsed successfully, and

• produce a non-empty data structure.

Raises FileNotFoundError if no configuration file was found matching the criteria above.

Returns (None, None) if files were found but none could be parsed.

Return type:

tuple[Path | URL, dict[str, Any]] | tuple[None, None]

load_ini_config(content)

Utility method to parse INI configuration file.

Internal convention is to use a dot (., as set by self.SEP) in section IDs as a separator between levels. This is a workaround the limitation of INI format which doesn’t allow for sub-sections.

Returns a ready-to-use data structure.

Return type:

dict[str, Any]

merge_default_map(ctx, user_conf)

Save the user configuration into the context’s default_map.

Merge the user configuration into the pre-computed template structure, which will filter out all unrecognized options not supported by the command. Then cleans up blank values and update the context’s default_map.

Uses a ~collections.ChainMap so each config source keeps its own layer. The first layer wins on key lookup, which makes parameter-source precedence explicit and future-proofs for multi-file config loading.

Opaque sub-trees declared by the schema or by registered ConfigValidator instances are stripped from the conf before the CLI-parameter strict check, so user-controlled keys (e.g. mappings whose keys are data, not flag names) don’t trip strict=True.

Return type:

None

load_conf(ctx, param, path_pattern)

Fetch parameter values from a configuration file and set them as defaults.

User configuration is merged to the context’s default_map, like Click does.

By relying on Click’s default_map, we make sure that precedence is respected. Direct CLI parameters, environment variables or interactive prompts take precedence over any values from the config file.

Return type:

None

..hint::

Once loading is complete, the resolved file path and its full parsed content are stored in ctx.meta[click_extra.context.CONF_SOURCE] and ctx.meta[click_extra.context.CONF_FULL] respectively. This is the recommended way to identify which configuration file was loaded.

We intentionally do not add a custom ParameterSource.CONFIG_FILE enum member: ParameterSource is a closed enum in Click, and monkeypatching it would be fragile. Besides, config values end up in default_map, so Click already reports them as ParameterSource.DEFAULT_MAP, which is accurate.

class click_extra.config.NoConfigOption(param_decls=None, type=UNPROCESSED, help='Ignore all configuration files and only use command line parameters and environment variables.', is_flag=True, flag_value=Sentinel.NO_CONFIG, is_eager=True, expose_value=False, **kwargs)

Bases: ExtraOption

A pre-configured option adding --no-config.

This option is supposed to be used alongside the --config option (ConfigOption) to allow users to explicitly disable the use of any configuration file.

This is especially useful to debug side-effects caused by autodetection of configuration files.

See also

An alternative implementation of this class would be to create a custom click.ParamType instead of a custom Option subclass. Here is for example.

check_sibling_config_option(ctx, param, value)

Ensure that this option is used alongside a ConfigOption instance.

Return type:

None

class click_extra.config.ValidateConfigOption(param_decls=None, type=<click.types.Path object>, is_eager=True, expose_value=False, help='Validate the configuration file and exit.', **kwargs)

Bases: ExtraOption

A pre-configured option adding --validate-config CONFIG_PATH.

Loads the config file at the given path, validates it against the CLI’s parameter structure in strict mode, reports results, and exits.

validate_config(ctx, param, value)

Load, parse, and validate the configuration file, then exit.

Validation runs three checks in order, every one of them under the same ValidationError shape so the reported path is always rooted at the configuration file:

1. CLI-parameter strict check on the non-opaque part of the document.

2. Schema processing, if a config_schema is configured: catches type errors and unknown keys inside the dataclass-described section.

3. Each registered ConfigValidator runs against its declared opaque sub-tree.

Every detected error is emitted before exiting, so a single --validate-config run surfaces the full list of fixes the user needs to apply.

Return type:

None

click_extra.decorators module

Decorators for group, commands and options.

click_extra.decorators.allow_missing_parenthesis(dec_factory)

Allow to use decorators with or without parenthesis.

As proposed in Cloup issue #127.

click_extra.decorators.decorator_factory(dec, *new_args, **new_defaults)

Clone decorator with a set of new defaults.

Used to create our own collection of decorators for our custom options, based on Cloup’s.

Attention

The cls argument passed to the factory is used as the reference class from which the produced decorator’s cls argument must inherit.

The idea is to ensure that, for example, the @command decorator re-implemented by Click Extra is always a subclass of ExtraCommand, even when the user overrides the cls argument. That way it can always rely on the additional properties and methods defined in the Click Extra framework, where we have extended Cloup and Click so much that we want to prevent surprising side effects.

click_extra.decorators.command(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.group(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.argument(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.help_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.version_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.lazy_group(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.color_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.config_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.jobs_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.no_config_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.validate_config_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.show_params_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.table_format_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.telemetry_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.theme_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.timer_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.verbose_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.decorators.verbosity_option(*args, **kwargs)

Returns a new decorator instantiated with custom defaults.

These defaults values are merged with the user’s own arguments.

A special case is made for the params argument, to allow it to be callable. This limits the issue of the mutable options being shared between commands.

This decorator can be used with or without arguments.

click_extra.envvar module

Implements environment variable utilities.

click_extra.envvar.merge_envvar_ids(*envvar_ids)

Merge and deduplicate environment variables.

Multiple parameters are accepted and can be single strings or arbitrary-nested iterables of strings. None values are ignored.

Variable names are deduplicated while preserving their initial order.

Caution

On Windows, environment variable names are case-insensitive, so we normalize them to uppercase as the standard library does.

Returns a tuple of strings. The result is ready to be used as the envvar parameter for Click’s options or arguments.

Return type:

tuple[str, ...]

click_extra.envvar.clean_envvar_id(envvar_id)

Utility to produce a user-friendly environment variable name from a string.

Separates all contiguous alphanumeric string segments, eliminate empty strings, join them with an underscore and uppercase the result.

Attention

We do not rely too much on this utility to try to reproduce the current behavior of Click, which is is not consistent regarding case-handling of environment variable.

Return type:

str

click_extra.envvar.param_auto_envvar_id(param, ctx)

Compute the auto-generated environment variable of an option or argument.

Returns the auto envvar as it is exactly computed within Click’s internals, i.e. click.core.Parameter.resolve_envvar_value() and click.core.Option.resolve_envvar_value().

Return type:

str | None

click_extra.envvar.param_envvar_ids(param, ctx)

Returns the deduplicated, ordered list of environment variables for an option or argument, including the auto-generated one.

The auto-generated environment variable is added at the end of the list, so that user-defined envvars takes precedence. This respects the current implementation of click.core.Option.resolve_envvar_value().

Caution

On Windows, environment variable names are case-insensitive, so we normalize them to uppercase as the standard library does.

Return type:

tuple[str, ...]

click_extra.envvar.env_copy(extend=None)

Returns a copy of the current environment variables and eventually extend it.

Mimics Python’s original implementation by returning None if no extend content are provided.

Environment variables are expected to be a dict of str:str.

Return type:

Mapping[str, str | None] | None

click_extra.logging module

Logging utilities.

class click_extra.logging.LogLevel(*values)

Bases: IntEnum

Mapping of canonical log level names to their integer level.

That’s our own version of logging._nameToLevel, but:

• sorted from lowest to highest verbosity,

• excludes the following levels:

  • NOTSET, which is considered internal

  • WARN, which is obsolete

  • FATAL, which shouldn’t be used and has been replaced by CRITICAL

CRITICAL = 50

ERROR = 40

WARNING = 30

INFO = 20

DEBUG = 10

click_extra.logging.DEFAULT_LEVEL: LogLevel = LogLevel.WARNING

WARNING is the default level we expect any loggers to starts their lives at.

WARNING has been chosen as it is the level at which the default Python’s global root logger is set up.

This value is also used as the default level for VerbosityOption .

class click_extra.logging.ExtraStreamHandler(stream=None)

Bases: StreamHandler

A handler to output logs to the console.

Wraps logging.StreamHandler, but use click.echo() to support color printing.

Only <stderr> or <stdout> are allowed as output stream.

If stream is not specified, <stderr> is used by default

Initialize the handler.

If stream is not specified, sys.stderr is used.

property stream: IO[Any]

The stream to which logs are written.

A proxy of the parent logging.StreamHandler’s stream attribute.

Redefined here to enforce checks on the stream value.

emit(record)

Use click.echo() to print to the console.

Return type:

None

class click_extra.logging.ExtraFormatter(fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)

Bases: Formatter

Click Extra’s default log formatter.

Initialize the formatter with specified format strings.

Initialize the formatter either with the specified format string, or a default as described above. Allow for specialized date formatting with the optional datefmt argument. If datefmt is omitted, you get an ISO8601-like (or RFC 3339-like) format.

Use a style parameter of ‘%’, ‘{’ or ‘$’ to specify that you want to use one of %-formatting, str.format() ({}) formatting or string.Template formatting in your format string.

Changed in version 3.2: Added the style parameter.

formatMessage(record)

Colorize the record’s log level name before calling the standard formatter.

Colors are sourced from a click_extra.theme.HelpExtraTheme, resolved per-invocation via click_extra.theme.get_current_theme().

Return type:

str

click_extra.logging.extraBasicConfig(*, filename=None, filemode='a', format='{levelname}: {message}', datefmt=None, style='{', level=None, stream=None, handlers=None, force=False, encoding=None, errors='backslashreplace', stream_handler_class=<class 'click_extra.logging.ExtraStreamHandler'>, file_handler_class=<class 'logging.FileHandler'>, formatter_class=<class 'click_extra.logging.ExtraFormatter'>)

Configure the global root logger.

This function is a wrapper around Python standard library’s logging.basicConfig(), but with additional parameters and tweaked defaults.

It sets up the global root logger, and optionally adds a file or stream handler to it.

Differences in default values:

Argument	extraBasicConfig() default	logging.basicConfig() default
style	{	%
format	{levelname}: {message}	%(levelname)s:%(name)s:%(message)s

This function takes the same parameters as logging.basicConfig(), but require them to be all passed as explicit keywords arguments.

Parameters:

• filename (str | None) – Specifies that a logging.FileHandler be created, using the specified filename, rather than an ExtraStreamHandler.

• filemode (str) –

  If filename is specified, open the file in this mode.

  Defaults to a.

• format (str | None) –

  Use the specified format string for the handler.

  Defaults to {levelname}: {message}.

• datefmt (str | None) – Use the specified date/time format, as accepted by time.strftime().

• style (Literal['%', '{', '$']) –

  If format is specified, use this style for the format string:

  • % for printf-style,

  • { for str.format(),

  • $ for string.Template.

  Defaults to {.

• level (int | str | None) – Set the root logger level to the specified level.

• stream (IO[Any] | None) – Use the specified stream to initialize the ExtraStreamHandler. Note that this argument is incompatible with filename - if both are present, a ValueError is raised.

• handlers (Iterable[Handler] | None) – If specified, this should be an iterable of already created handlers to add to the root logger. Any handlers which don’t already have a formatter set will be assigned the default formatter created in this function. Note that this argument is incompatible with filename or stream - if both are present, a ValueError is raised.

• force (bool) – If this argument is specified as True, any existing handlers attached to the root logger are removed and closed, before carrying out the configuration as specified by the other arguments.

• encoding (str | None) – Name of the encoding used to decode or encode the file. To be specified along with filename, and passed to logging.FileHandler for opening the output file.

• errors (str | None) – Optional string that specifies how encoding and decoding errors are to be handled by the logging.FileHandler. Defaults to backslashreplace. Note that if None is specified, it will be passed as such to open().

Return type:

None

Important

Always keep the signature of this function, the default values of its parameters and its documentation in sync with the one from Python’s standard library.

These new arguments are available for better configurability:

Parameters:

• stream_handler_class (type[Handler]) – A logging.Handler class that will be used in logging.basicConfig() to create a default stream-based handler. Defaults to ExtraStreamHandler.

• file_handler_class (type[Handler]) – A logging.Handler class that will be used in logging.basicConfig() to create a default file-based handler. Defaults to FileHandler.

• formatter_class (type[Formatter]) – A logging.Formatter class of the formatter that will be used in logging.basicConfig() to setup the default formatter. Defaults to ExtraFormatter.

Note

I don’t like the camel-cased name of this function and would have called it extra_basic_config(), but it’s kept this way for consistency with Python’s standard library.

click_extra.logging.new_extra_logger(name='root', *, propagate=False, force=True, **kwargs)

Setup a logger in the style of Click Extra.

By default, this helper will:

• Fetch the logger registered under the name parameter, or creates a new one with that name if it doesn’t exist,

• Set the logger’s propagate attribute to False,

• Force removal of any existing handlers and formatters attached to the logger,

• Attach a new ExtraStreamHandler with ExtraFormatter,

• Return the logger object.

This function is a wrapper around extraBasicConfig() and takes the same keywords arguments.

Parameters:

• name (str) – ID of the logger to setup. If None, Python’s root logger will be used. If a logger with the provided name is not found in the global registry, a new logger with that name will be created.

• propagate (bool) – Sets the logger’s propagate attribute. Defaults to False.

• force (bool) – Same as the force parameter from logging.basicConfig() and extraBasicConfig(). Defaults to True.

• kwargs – Any other keyword parameters supported by logging.basicConfig() and extraBasicConfig().

Return type:

Logger

class click_extra.logging.ExtraVerbosity(param_decls=None, default_logger='root', expose_value=False, is_eager=True, **kwargs)

Bases: ExtraOption

A base class implementing all the common helpers to manipulated logger’s verbosity.

Sets the level of the provided logger. If no logger is provided, sets the level of the global root logger.

Important

The internal click_extra logger will be aligned to the level set through this class.

Caution

This class is not intended to be used as-is. It is an internal place to reconcile the verbosity level selected by the competing logger options implemented below:

• --verbosity

• --verbose/-v

Set up a verbosity-altering option.

Parameters:

default_logger (Logger | str) – If a logging.Logger object is provided, that’s the instance to which we will set the level to. If the parameter is a string and is found in the global registry, we will use it as the logger’s ID. Otherwise, we will create a new logger with new_extra_logger() Default to the global root logger.

property all_loggers: Generator[Logger, None, None]

Returns the list of logger IDs affected by the verbosity option.

Will returns click_extra internal logger first, then the option’s logger_name.

reset_loggers()

Forces all loggers managed by the option to be reset to DEFAULT_LEVEL.

Important

Loggers are reset in reverse order to ensure the internal logger is changed last. That way the internal click_extra logger can report its ongoing logger-altering operations while using the logging facilities itself.

Danger

Resetting loggers is extremely important for unittests. Because they’re global, loggers have tendency to leak and pollute their state between multiple test calls.

Return type:

None

set_level(ctx, param, level)

Set level of all loggers configured on the option.

All verbosity-related options are attached to this callback, so that’s where we reconcile the multiple values provided by different options. In case of a conflict, the highest versbosity level always takes precedence.

The final reconciled level chosen for the logger will be saved in ctx.meta[click_extra.context.VERBOSITY_LEVEL]. This context entry served as a kind of global state shared by all verbosity-related options.

Return type:

None

logger_name: str

The ID of the logger to set the level to.

This will be provided to logging.getLogger() to fetch the logger object, and as such, can be a dot-separated string to build hierarchical loggers.

class click_extra.logging.VerbosityOption(param_decls=None, default_logger='root', default=LogLevel.WARNING, metavar='LEVEL', type=EnumChoice('CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG'), help='Either CRITICAL, ERROR, WARNING, INFO, DEBUG.', **kwargs)

Bases: ExtraVerbosity

--verbosity LEVEL option to set the the log level of ExtraVerbosity.

Set up a verbosity-altering option.

Parameters:

default_logger (Logger | str) – If a logging.Logger object is provided, that’s the instance to which we will set the level to. If the parameter is a string and is found in the global registry, we will use it as the logger’s ID. Otherwise, we will create a new logger with new_extra_logger() Default to the global root logger.

set_level(ctx, param, value)

The value passed to --verbosity will be saved in ctx.meta[click_extra.context.VERBOSITY].

Return type:

None

class click_extra.logging.VerboseOption(param_decls=None, count=True, **kwargs)

Bases: ExtraVerbosity

--verbose/-v` option to increase the log level of ExtraVerbosity by a number of steps.

If -v is passed to a CLI, then it will increase the verbosity level by one step. The option can be provided multiple times by the user. So if -vv (or -v -v) is passed, the verbosity will be increase by 2 levels.

The default base-level from which we start incrementing is sourced from VerbosityOption.default. So with --verbosity’s default set to WARNING:

• -v will increase the level to INFO,

• -vv will increase the level to DEBUG,

• any number of repetition above that point will be set to the maximum level, so for -vvvvv for example will be capped at DEBUG.

Set up a verbosity-altering option.

Parameters:

default_logger – If a logging.Logger object is provided, that’s the instance to which we will set the level to. If the parameter is a string and is found in the global registry, we will use it as the logger’s ID. Otherwise, we will create a new logger with new_extra_logger() Default to the global root logger.

get_base_level(ctx)

Returns the default base-level from which the option will start incrementing.

We try first to get the default level from any instance of VerbosityOption defined on the current command. If none is found, it’s because the --verbose option is used standalone. In which case we defaults to DEFAULT_LEVEL.

Return type:

LogLevel

get_help_record(ctx)

Dynamiccaly generates the default help message.

We need that patch because get_base_level() depends on the context, so we cannot hard-code the help message as VerboseOption.__init__() default.

Return type:

tuple[str, str] | None

set_level(ctx, param, value)

Translate the number of steps to the target log level.

The value passed to --verbose/-v will be saved in ctx.meta[click_extra.context.VERBOSE].

Return type:

None

click_extra.parameters module

Our own flavor of Option, Argument and parameters.

click_extra.parameters.search_params(params, klass, include_subclasses=True, unique=True)

Search a particular class of parameter in a list and return them.

Parameters:

• params (Iterable[Parameter]) – list of parameter instances to search in.

• klass (type[Parameter]) – the class of the parameters to look for.

• include_subclasses (bool) – if True, includes in the results all parameters subclassing the provided klass. If False, only matches parameters which are strictly instances of klass. Defaults to True.

• unique (bool) – if True, raise an error if more than one parameter of the provided klass is found. Defaults to True.

Return type:

list[Parameter] | Parameter | None

class click_extra.parameters.Argument(*args, help=None, **attrs)

Bases: _ParameterMixin, Argument

Wrap cloup.Argument, itself inheriting from click.Argument.

Inherits first from _ParameterMixin to allow future overrides of Click’s Parameter methods.

class click_extra.parameters.Option(*args, group=None, **attrs)

Bases: _ParameterMixin, Option

Wrap cloup.Option, itself inheriting from click.Option.

Inherits first from _ParameterMixin to allow future overrides of Click’s Parameter methods.

class click_extra.parameters.ExtraOption(*args, group=None, **attrs)

Bases: Option

Dedicated to option implemented by click-extra itself.

Does nothing in particular for now but provides a way to identify Click Extra’s own options with certainty.

Note

Bracket fields (envvar, default, range, required) cannot be pre-styled in get_help_record() because Click’s text wrapper splits lines after the record is returned, which would break ANSI codes that span wrapped boundaries. Styling is instead applied post-wrapping in HelpExtraFormatter._style_bracket_fields(), which uses the structured data from Option.get_help_extra() to identify each field by its label.

class click_extra.parameters.ParamStructure(*args, excluded_params=None, included_params=None, **kwargs)

Bases: object

Utilities to introspect CLI options and commands structure.

Structures are represented by a tree-like dict.

Access to a node is available using a serialized path string composed of the keys to descend to that node, separated by a dot ..

Todo

Evaluates the possibility of replacing all key-based access to the tree-like structure by a Box object, as it provides lots of utilities to merge its content.

Allow a list of paramerers to be blocked from the parameter structure.

Items of excluded_params are expected to be the fully-qualified ID of the parameter. Which is the dot-separated ID that is prefixed by the CLI name, featured in the first column of the table.

included_params is the inverse: only the listed parameters will be allowed. Cannot be used together with excluded_params.

SEP: str = '.'

Use a dot . as a separator between levels of the tree-like parameter structure.

excluded_params: frozenset[str]

included_params: frozenset[str] | None

static init_tree_dict(*path, leaf=None)

Utility method to recursively create a nested dict structure whose keys are provided by path list and at the end is populated by a copy of leaf.

Return type:

Any

static get_tree_value(tree_dict, *path)

Get in the tree_dict the value located at the path.

Raises KeyError if no item is found at the provided path.

Return type:

Any

flatten_tree_dict(tree_dict, parent_key=None)

Recursively traverse the tree-like dict and produce a flat dict whose keys are path and values are the leaf’s content.

Return type:

dict[str, Any]

walk_params()

Generates an unfiltered list of all CLI parameters.

Everything is included, from top-level groups to subcommands, and from options to arguments.

Return type:

Iterator[tuple[tuple[str, ...], Parameter]]

Returns a 2-elements tuple:

• the first being a tuple of keys leading to the parameter

• the second being the parameter object itself

TYPE_MAP: ClassVar[dict[type[ParamType], type[str | int | float | bool | list]]] = {<class 'click.types.BoolParamType'>: <class 'bool'>, <class 'click.types.Choice'>: <class 'str'>, <class 'click.types.DateTime'>: <class 'str'>, <class 'click.types.File'>: <class 'str'>, <class 'click.types.FloatParamType'>: <class 'float'>, <class 'click.types.FloatRange'>: <class 'float'>, <class 'click.types.IntParamType'>: <class 'int'>, <class 'click.types.IntRange'>: <class 'int'>, <class 'click.types.Path'>: <class 'str'>, <class 'click.types.StringParamType'>: <class 'str'>, <class 'click.types.Tuple'>: <class 'list'>, <class 'click.types.UUIDParameterType'>: <class 'str'>, <class 'click.types.UnprocessedParamType'>: <class 'str'>}

Map Click types to their Python equivalent.

Keys are subclasses of click.types.ParamType. Values are expected to be simple builtins Python types.

This mapping can be seen as a reverse of the click.types.convert_type() method.

static get_param_type(param)

Get the Python type of a Click parameter.

Returns str for unrecognised custom types, since command-line parameters are strings by default.

See the list of custom types provided by Click.

Return type:

type[str | int | float | bool | list]

build_param_trees()

Build the parameters tree structure and cache it.

This removes parameters whose fully-qualified IDs are in the excluded_params blocklist.

If included_params was provided, it is resolved into excluded_params here, where all parameter IDs are available.

Return type:

None

property params_template: dict[str, Any]

Returns a tree-like dictionary whose keys shadows the CLI options and subcommands and values are None.

Perfect to serve as a template for configuration files.

property params_objects: dict[str, Any]

Returns a tree-like dictionary whose keys shadows the CLI options and subcommands and values are parameter objects.

Perfect to parse configuration files and user-provided parameters.

click_extra.parameters.get_param_spec(param, ctx)

Extract the option-spec string (like -v, --verbose) from a parameter.

Temporarily unhides hidden options so their help record can be produced.

Note

The hidden property is only supported by Option, not Argument.

Todo

Submit a PR to Click to separate production of param spec and help record. That way we can always produce the param spec even if the parameter is hidden. See: https://github.com/kdeldycke/click-extra/issues/689

Return type:

str | None

click_extra.parameters.format_param_row(param, ctx, path, is_structured)

Format the common parameter table cells.

Returns a tuple of 8 cells in column order: ID, Spec., Class, Param type, Python type, Hidden, Env. vars., Default.

For structured formats (JSON, YAML, etc.), cells are native Python values. For visual formats, cells are themed strings matching help-screen styling.

Return type:

tuple

class click_extra.parameters.ShowParamsOption(param_decls=None, is_flag=True, expose_value=False, is_eager=True, help='Show all CLI parameters, their provenance, defaults and value, then exit.', **kwargs)

Bases: ExtraOption, ParamStructure

A pre-configured option adding a --show-params option.

Between configuration files, default values and environment variables, it might be hard to guess under which set of parameters the CLI will be executed. This option print information about the parameters that will be fed to the CLI.

TABLE_HEADERS = ('ID', 'Spec.', 'Class', 'Param type', 'Python type', 'Hidden', 'Exposed', 'Allowed in conf?', 'Env. vars.', 'Default', 'Value', 'Source')

Hard-coded list of table headers.

excluded_params: frozenset[str]

Deactivates the blocking of any parameter.

included_params: frozenset[str] | None

No allowlist filter; show all parameters.

print_params(ctx, param, value)

Introspects current CLI and list its parameters and metadata.

Important

Click doesn’t keep a list of all parsed arguments and their origin. So we need to emulate here what’s happening during CLI invocation.

Unfortunately we cannot even do that because the raw, pre-parsed arguments are not available anywhere within Click’s internals.

Our workaround consist in leveraging our custom ExtraCommand/ExtraGroup classes, in which we are attaching a click_extra.raw_args metadata entry to the context.

Return type:

None

click_extra.pygments module

Pygments lexers, filters, and formatters for ANSI escape sequences.

Parses ANSI SGR escape sequences (ECMA-48 / ISO 6429) from terminal output and renders them as colored HTML with CSS classes. Supports the standard 8/16 named colors, the 256-color indexed palette, and 24-bit RGB.

SGR text attributes: bold, faint, italic, underline, blink, reverse video, strikethrough, and overline.

OSC 8 hyperlinks are rendered as HTML <a> tags. Other OSC sequences are silently stripped.

Note

24-bit RGB colors (SGR 38;2;r;g;b and 48;2;r;g;b) are preserved by default and rendered by AnsiHtmlFormatter as inline style="color: #rrggbb" / style="background-color: #rrggbb" spans (CSS classes cannot enumerate 16.7M colors). Other token components (bold, named colors, palette indices) keep their CSS-class rendering. Pass true_color=False to AnsiColorLexer, AnsiFilter, or any session lexer (via get_lexer_by_name(..., true_color=False)) to opt into quantization to the nearest entry in the 256-color palette instead.

click_extra.pygments.Ansi = ('Ansi',)

Unified token namespace for ANSI styling.

Compound tokens from the lexer (like Token.Ansi.Bold.Red) and individual style components (like Token.Ansi.Red) share this single namespace. The formatter decomposes compound tokens into individual CSS classes at render time.

click_extra.pygments.DEFAULT_TOKEN_TYPE = ('Generic', 'Output')

Default Pygments token type to render with ANSI support.

Defaults to Generic.Output tokens, as this is the token type used by all REPL-like and terminal session lexers.

class click_extra.pygments.AnsiColorLexer(*args, **kwargs)

Bases: Lexer

Lexer for text containing ANSI escape sequences.

Parses Select Graphic Rendition (SGR) codes and emits compound Token.Ansi.* tokens representing the active styling state. OSC 8 hyperlinks emit Token.AnsiLinkStart / Token.AnsiLinkEnd structural tokens. All other escape sequences are silently stripped.

Supported SGR codes:

• Text attributes: bold (1), faint (2), italic (3), underline (4), blink (5), reverse video (7), strikethrough (9), overline (53), and their resets.

• Named colors: standard (30-37, 40-47) and bright (90-97, 100-107).

• 256-color indexed palette (38;5;n, 48;5;n).

• 24-bit RGB (38;2;r;g;b, 48;2;r;g;b), quantized to the nearest 256-color entry.

Supported OSC sequences:

• OSC 8 hyperlinks: rendered as <a> tags by AnsiHtmlFormatter. Only URLs with safe schemes (http, https, mailto, ftp, ftps) are emitted; others are stripped.

Initialize the lexer.

Parameters:

true_color – Default True. 24-bit RGB sequences are preserved as Token.Ansi.FG_{rrggbb} / Token.Ansi.BG_{rrggbb} tokens, which AnsiHtmlFormatter renders as inline style="color: #rrggbb" / style="background-color: #rrggbb" attributes (CSS classes cannot enumerate 16.7M colors). Pass False to quantize 24-bit RGB to the nearest entry in the 256-color palette and emit Token.Ansi.C{n} / Token.Ansi.BGC{n} tokens that map to CSS classes via the style dict.

name = 'ANSI Color'

Full name of the lexer, in human-readable form

aliases = ('ansi-color', 'ansi', 'ansi-terminal')

A list of short, unique identifiers that can be used to look up the lexer from a list, e.g., using get_lexer_by_name().

get_tokens_unprocessed(text)

Parse ANSI escape sequences from text and yield styled tokens.

SGR sequences update the styling state. OSC 8 hyperlinks emit structural Token.AnsiLinkStart / Token.AnsiLinkEnd tokens. All other escape sequences are consumed and stripped.

Return type:

Iterator[tuple[int, _TokenType, str]]

class click_extra.pygments.AnsiFilter(**options)

Bases: Filter

Custom filter transforming a particular kind of token (Generic.Output by default) into ANSI tokens.

Initialize an AnsiColorLexer and configure the token_type to be colorized.

Parameters:

true_color – Forwarded to the inner AnsiColorLexer to control whether 24-bit RGB sequences are preserved as FG_/BG_ hex tokens for inline-style rendering (default True) or quantized to the 256-color palette. See AnsiColorLexer for details.

Note

Only one token_type is supported. All Pygments session lexers (ShellSessionBaseLexer and the manually-maintained list in collect_session_lexers) emit terminal output exclusively as Generic.Output. No upstream issue or PR proposes splitting output into additional token types (like Generic.Error for stderr). If that changes, this filter would need to accept a set of token types instead of a single one. See pygments#1148 and pygments#2499 for the closest related discussions.

filter(lexer, stream)

Transform each token of token_type type into a stream of ANSI tokens.

Return type:

Iterator[tuple[_TokenType, str]]

click_extra.pygments.collect_session_lexers()

Retrieve all lexers producing shell-like sessions in Pygments.

This function contains a manually-maintained list of lexers, to which we dynamically add lexers inheriting from ShellSessionBaseLexer.

Hint

To help maintain this list, there is a test that will fail if a new REPL/terminal-like lexer is added to Pygments but not referenced here.

Return type:

Iterator[type[Lexer]]

click_extra.pygments.LEXER_MAP: dict[type[Lexer], type[Lexer]] = {<class 'pygments.lexers.algebra.GAPConsoleLexer'>: <class 'pygments.lexer.AnsiGAPConsoleLexer'>, <class 'pygments.lexers.dylan.DylanConsoleLexer'>: <class 'pygments.lexer.AnsiDylanConsoleLexer'>, <class 'pygments.lexers.erlang.ElixirConsoleLexer'>: <class 'pygments.lexer.AnsiElixirConsoleLexer'>, <class 'pygments.lexers.erlang.ErlangShellLexer'>: <class 'pygments.lexer.AnsiErlangShellLexer'>, <class 'pygments.lexers.julia.JuliaConsoleLexer'>: <class 'pygments.lexer.AnsiJuliaConsoleLexer'>, <class 'pygments.lexers.matlab.MatlabSessionLexer'>: <class 'pygments.lexer.AnsiMatlabSessionLexer'>, <class 'pygments.lexers.php.PsyshConsoleLexer'>: <class 'pygments.lexer.AnsiPsyshConsoleLexer'>, <class 'pygments.lexers.python.PythonConsoleLexer'>: <class 'pygments.lexer.AnsiPythonConsoleLexer'>, <class 'pygments.lexers.r.RConsoleLexer'>: <class 'pygments.lexer.AnsiRConsoleLexer'>, <class 'pygments.lexers.ruby.RubyConsoleLexer'>: <class 'pygments.lexer.AnsiRubyConsoleLexer'>, <class 'pygments.lexers.shell.BashSessionLexer'>: <class 'pygments.lexer.AnsiBashSessionLexer'>, <class 'pygments.lexers.shell.MSDOSSessionLexer'>: <class 'pygments.lexer.AnsiMSDOSSessionLexer'>, <class 'pygments.lexers.shell.PowerShellSessionLexer'>: <class 'pygments.lexer.AnsiPowerShellSessionLexer'>, <class 'pygments.lexers.shell.TcshSessionLexer'>: <class 'pygments.lexer.AnsiTcshSessionLexer'>, <class 'pygments.lexers.special.OutputLexer'>: <class 'pygments.lexer.AnsiOutputLexer'>, <class 'pygments.lexers.sql.PostgresConsoleLexer'>: <class 'pygments.lexer.AnsiPostgresConsoleLexer'>, <class 'pygments.lexers.sql.SqliteConsoleLexer'>: <class 'pygments.lexer.AnsiSqliteConsoleLexer'>}

Map original session lexers to their ANSI-capable variants.

click_extra.pygments.EXTRA_ANSI_CSS: dict[str, str] = {'Blink': 'animation: ansi-blink 1s step-end infinite', 'Bold': 'font-weight: bold', 'Faint': 'opacity: 0.5', 'Italic': 'font-style: italic', 'Overline': 'text-decoration: overline', 'Reverse': 'filter: invert(1)', 'Strikethrough': 'text-decoration: line-through', 'Underline': 'text-decoration: underline'}

All SGR text attribute CSS declarations.

Maps Token.Ansi component names to CSS declarations. These are kept out of the Pygments style dict (_ANSI_STYLES) to prevent Furo’s dark-mode CSS generator from injecting color: #D0D0D0 fallbacks that conflict with foreground color tokens.

Used by AnsiHtmlFormatter.get_token_style_defs to inject CSS rules that both standalone pygmentize and Furo’s dark-mode CSS generator pick up.

class click_extra.pygments.AnsiHtmlFormatter(**kwargs)

Bases: HtmlFormatter

HTML formatter with ANSI color and hyperlink support.

Extends Pygments’ HtmlFormatter to handle compound Token.Ansi.* tokens by decomposing them into individual CSS classes, augments the base style with ANSI color definitions for the 256-color indexed palette, and renders OSC 8 hyperlinks as HTML <a> tags.

Intercept the style argument to augment it with ANSI color support.

Creates a new style instance that inherits from the one provided by the user, but updates its styles attribute with ANSI token definitions from _ANSI_STYLES.

name = 'ANSI HTML'

Full name for the formatter, in human-readable form.

aliases: ClassVar[list[str]] = ['ansi-html']

A list of short, unique identifiers that can be used to lookup the formatter from a list, e.g. using get_formatter_by_name().

format_unencoded(tokensource, outfile)

Render tokens to HTML, converting OSC 8 link and 24-bit RGB markers to tags.

Replaces Token.AnsiLinkStart / Token.AnsiLinkEnd with Unicode Private Use Area markers, strips FG_/BG_ 24-bit RGB components from compound tokens and replaces them with PUA markers carrying the hex value, delegates to Pygments’ HTML rendering, then post-processes the output to swap markers for <a> and inline-styled <span> tags.

Return type:

None

get_token_style_defs(arg=None)

Extend Pygments’ token CSS with rules for SGR attributes it cannot express.

Pygments’ style strings support bold, italic, and underline, but have no keywords for faint, blink, reverse, strikethrough, or overline. This override appends dedicated CSS rules from EXTRA_ANSI_CSS after the standard Pygments token CSS output.

Overriding get_token_style_defs (rather than get_style_defs) ensures that Furo’s dark-mode CSS generator, which calls this method directly, also picks up the extra rules.

click_extra.pytest module

Pytest fixtures and marks to help testing Click CLIs.

click_extra.pytest.extra_runner()

Runner fixture for click.testing.ExtraCliRunner.

click_extra.pytest.invoke(extra_runner)

Invoke fixture shorthand for click.testing.ExtraCliRunner.invoke.

click_extra.pytest.command_decorators(no_commands=False, no_groups=False, no_click=False, no_cloup=False, no_extra=False, with_parenthesis=True, with_types=False)

Returns collection of Pytest parameters to test all command-like decorators.

Returns:

• click.command

• click.command()

• cloup.command

• cloup.command()

• click_extra.command

• click_extra.command()

• click.group

• click.group()

• cloup.group

• cloup.group()

• click_extra.group

• click_extra.group()

Return type:

tuple[ParameterSet, ...]

click_extra.pytest.option_decorators(no_options=False, no_arguments=False, no_click=False, no_cloup=False, no_extra=False, with_parenthesis=True, with_types=False)

Returns collection of Pytest parameters to test all parameter-like decorators.

Returns:

• click.option

• click.option()

• cloup.option

• cloup.option()

• click_extra.option

• click_extra.option()

• click.argument

• click.argument()

• cloup.argument

• cloup.argument()

• click_extra.argument

• click_extra.argument()

Return type:

tuple[ParameterSet, ...]

click_extra.pytest.create_config(tmp_path)

A generic fixture to produce a temporary configuration file.

click_extra.pytest.assert_output_regex(request)

An assert-like utility for Pytest to compare CLI output against the regex.

Designed for the regexes defined above.

click_extra.table module

Collection of table rendering utilities.

class click_extra.table.TableFormat(*values)

Bases: Enum

Enumeration of supported table formats.

Hard-coded to be in alphabetical order. Content of this enum is checked in unit tests.

Warning

The youtrack format is missing in action from any official JetBrains documentation. It will be removed in python-tabulate v0.11.

ALIGNED = 'aligned'

ASCIIDOC = 'asciidoc'

COLON_GRID = 'colon-grid'

CSV = 'csv'

CSV_EXCEL = 'csv-excel'

CSV_EXCEL_TAB = 'csv-excel-tab'

CSV_UNIX = 'csv-unix'

DOUBLE_GRID = 'double-grid'

DOUBLE_OUTLINE = 'double-outline'

FANCY_GRID = 'fancy-grid'

FANCY_OUTLINE = 'fancy-outline'

GITHUB = 'github'

GRID = 'grid'

HEAVY_GRID = 'heavy-grid'

HEAVY_OUTLINE = 'heavy-outline'

HJSON = 'hjson'

HTML = 'html'

JIRA = 'jira'

JSON = 'json'

JSON5 = 'json5'

JSONC = 'jsonc'

LATEX = 'latex'

LATEX_BOOKTABS = 'latex-booktabs'

LATEX_LONGTABLE = 'latex-longtable'

LATEX_RAW = 'latex-raw'

MEDIAWIKI = 'mediawiki'

MIXED_GRID = 'mixed-grid'

MIXED_OUTLINE = 'mixed-outline'

MOINMOIN = 'moinmoin'

ORGTBL = 'orgtbl'

OUTLINE = 'outline'

PIPE = 'pipe'

PLAIN = 'plain'

PRESTO = 'presto'

PRETTY = 'pretty'

PSQL = 'psql'

ROUNDED_GRID = 'rounded-grid'

ROUNDED_OUTLINE = 'rounded-outline'

RST = 'rst'

SIMPLE = 'simple'

SIMPLE_GRID = 'simple-grid'

SIMPLE_OUTLINE = 'simple-outline'

TEXTILE = 'textile'

TOML = 'toml'

TSV = 'tsv'

UNSAFEHTML = 'unsafehtml'

VERTICAL = 'vertical'

XML = 'xml'

YAML = 'yaml'

YOUTRACK = 'youtrack'

property is_markup: bool

Whether this format is a markup rendering.

Markup formats have ANSI color codes stripped from their output by default. Use the --color flag to preserve them.

click_extra.table.MARKUP_FORMATS = frozenset({TableFormat.ASCIIDOC, TableFormat.CSV, TableFormat.CSV_EXCEL, TableFormat.CSV_EXCEL_TAB, TableFormat.CSV_UNIX, TableFormat.GITHUB, TableFormat.HJSON, TableFormat.HTML, TableFormat.JIRA, TableFormat.JSON, TableFormat.JSON5, TableFormat.JSONC, TableFormat.LATEX, TableFormat.LATEX_BOOKTABS, TableFormat.LATEX_LONGTABLE, TableFormat.LATEX_RAW, TableFormat.MEDIAWIKI, TableFormat.MOINMOIN, TableFormat.ORGTBL, TableFormat.PIPE, TableFormat.RST, TableFormat.TEXTILE, TableFormat.TOML, TableFormat.TSV, TableFormat.UNSAFEHTML, TableFormat.XML, TableFormat.YAML, TableFormat.YOUTRACK})

Subset of table formats that are considered as markup rendering.

click_extra.table.DEFAULT_FORMAT = TableFormat.ROUNDED_OUTLINE

Default table format, if none is specified.

click_extra.table.RECORD_KEY = 'record'

Key used for each record in structured formats that require named containers (TOML [[record]], XML <record>).

click_extra.table.XML_ROOT_KEY = 'records'

Root element name for XML table output.

click_extra.table.SERIALIZATION_FORMATS = frozenset({TableFormat.HJSON, TableFormat.JSON, TableFormat.JSON5, TableFormat.JSONC, TableFormat.TOML, TableFormat.XML, TableFormat.YAML})

Structured serialization formats whose renderers escape raw ESC bytes, making post-render strip_ansi() ineffective.

click_extra.table.render_table(table_data, headers=None, table_format=None, sort_key=None, **kwargs)

Render a table and return it as a string.

Parameters:

sort_key (Callable[[Sequence[str | None]], Any] | None) – Optional callable passed to sorted() as the key argument. When provided, rows are sorted before rendering.

Return type:

str

click_extra.table.print_table(table_data, headers=None, table_format=None, sort_key=None, **kwargs)

Render a table and print it to the console.

For markup formats, ANSI color codes are stripped from cell values before rendering unless --color is explicitly set.

Parameters:

sort_key (Callable[[Sequence[str | None]], Any] | None) – Optional callable passed to sorted() as the key argument. When provided, rows are sorted before rendering.

Return type:

None

click_extra.table.serialize_data(data, table_format, *, default=None, root_element='records', **kwargs)

Serialize arbitrary Python data to a structured format.

Unlike render_table() which expects tabular rows and headers, this function accepts any JSON-compatible data structure (dicts, lists, nested combinations) and serializes it to the requested format.

Only formats in SERIALIZATION_FORMATS are supported.

Parameters:

• data (Any) – Arbitrary data to serialize (dicts, lists, scalars).

• table_format (TableFormat) – Target serialization format.

• default (Callable | None) – Fallback serializer for types not natively supported. Defaults to str(), so Path and similar types are stringified automatically. Set to a custom callable for different behavior.

• root_element (str) – Root element name for XML output.

• kwargs – Extra keyword arguments forwarded to the underlying serializer (e.g. sort_keys, indent for JSON).

Raises:

ValueError – If the format is not a serialization format.

Return type:

str

click_extra.table.print_data(data, table_format, *, default=None, root_element='records', package='click-extra', **kwargs)

Serialize arbitrary Python data and print it to the console.

Wraps serialize_data() with user-friendly error handling for missing optional dependencies.

Parameters:

• data (Any) – Arbitrary data to serialize.

• table_format (TableFormat) – Target serialization format.

• default (Callable | None) – Fallback serializer for custom types. Defaults to str().

• root_element (str) – Root element name for XML output.

• package (str) – Package name for install instructions in error messages.

• kwargs – Extra keyword arguments forwarded to the underlying serializer.

Return type:

None

class click_extra.table.TableFormatOption(param_decls=None, type=EnumChoice('aligned', 'asciidoc', 'colon-grid', 'csv', 'csv-excel', 'csv-excel-tab', 'csv-unix', 'double-grid', 'double-outline', 'fancy-grid', 'fancy-outline', 'github', 'grid', 'heavy-grid', 'heavy-outline', 'hjson', 'html', 'jira', 'json', 'json5', 'jsonc', 'latex', 'latex-booktabs', 'latex-longtable', 'latex-raw', 'mediawiki', 'mixed-grid', 'mixed-outline', 'moinmoin', 'orgtbl', 'outline', 'pipe', 'plain', 'presto', 'pretty', 'psql', 'rounded-grid', 'rounded-outline', 'rst', 'simple', 'simple-grid', 'simple-outline', 'textile', 'toml', 'tsv', 'unsafehtml', 'vertical', 'xml', 'yaml', 'youtrack'), default=TableFormat.ROUNDED_OUTLINE, expose_value=False, is_eager=True, help='Rendering style of tables.', **kwargs)

Bases: ExtraOption

A pre-configured option that is adding a --table-format flag to select the rendering style of a table.

The selected table format ID is made available in the context in ctx.meta[click_extra.context.TABLE_FORMAT], and two helper methods are added to the context: - ctx.render_table(table_data, headers, **kwargs): renders and returns

the table as a string,

• ctx.print_table(table_data, headers, **kwargs): renders and prints the table to the console.

Where: - table_data is a 2-dimensional iterable of iterables for rows and cells values, - headers is a list of string to be used as column headers, - **kwargs are any extra keyword arguments supported by the underlying table

formatting function.

init_formatter(ctx, param, table_format)

Save in the context: table_format, render_table & print_table.

Return type:

None

click_extra.table.print_sorted_table(header_defs, table_data, sort_columns=None, table_format=None, *, cell_key=None, **kwargs)

Sort and print a table using named column definitions.

header_defs is an ordered sequence of (label, column_id) tuples. Columns with column_id=None are not selectable for sorting but still participate in tie-breaking.

Parameters:

• header_defs (Sequence[tuple[str, str | None]]) – Column definitions as (label, column_id) pairs.

• table_data (Sequence[Sequence[str | None]]) – Rows of cell values.

• sort_columns (Sequence[str] | None) – Column IDs to sort by, in priority order. Falls back to natural header order.

• table_format (TableFormat | None) – Rendering format.

• cell_key (Callable[[str | None], Any] | None) – Per-cell comparison key. Defaults to ANSI-stripped, case-folded string comparison.

Return type:

None

class click_extra.table.SortByOption(*header_defs, param_decls=None, default=None, expose_value=False, cell_key=None, help='Sort table by this column. Repeat to set priority.', **kwargs)

Bases: ExtraOption

A --sort-by option whose choices are derived from column definitions.

Stores the selected column IDs in ctx.meta[click_extra.context.SORT_BY] and replaces ctx.print_table with print_sorted_table() so that table output is automatically sorted. The option accepts multiple=True, so users can repeat --sort-by to define a multi-column sort priority.

@command
@table_format_option
@sort_by_option(
    ("Package ID", "package_id"),
    ("Name", "package_name"),
    ("Manager", "manager_id"),
    ("Version", None),
)
@pass_context
def my_cmd(ctx):
    ctx.print_table(header_defs, rows)

init_sort(ctx, param, sort_columns)

Store sort columns and override ctx.print_table with sorted variant.

Return type:

None

click_extra.telemetry module

Telemetry utilities.

class click_extra.telemetry.TelemetryOption(param_decls=None, default=False, expose_value=False, envvar=None, show_envvar=True, help='Collect telemetry and usage data.', **kwargs)

Bases: ExtraOption

A pre-configured --telemetry/--no-telemetry option flag.

Respects the proposed DO_NOT_TRACK environment variable as a unified standard to opt-out of telemetry for TUI/console apps.

The DO_NOT_TRACK convention takes precedence over the user-defined environment variables and the auto-generated values.

The resolved value is stored in ctx.meta[click_extra.context.TELEMETRY], aligning with every other Click Extra option’s per-invocation context-meta storage pattern.

See also

• A knowledge base of telemetry disabling configuration options.

• And another list of environment variable to disable telemetry in desktop apps.

set_telemetry(ctx, param, value)

Store the resolved telemetry opt-in flag on the context’s meta dict.

Reads via click_extra.context.get(ctx, click_extra.context.TELEMETRY). Renamed from save_telemetry to align with the set_<key> convention used by every other ctx.meta-writing callback.

Return type:

None

click_extra.testing module

CLI testing and simulation of their execution.

click_extra.testing.PROMPT = '$ '

Prompt used to simulate the CLI execution.

Hint

Use ASCII characters to avoid issues with Windows terminals.

click_extra.testing.INDENT = '  '

Constants for rendering of CLI execution.

click_extra.testing.args_cleanup(*args)

Flatten recursive iterables, remove all None, and cast each element to strings.

Helps serialize pathlib.Path and other objects.

It also allows for nested iterables and None values as CLI arguments for convenience. We just need to flatten and filters them out.

Return type:

tuple[str, ...]

click_extra.testing.format_cli_prompt(cmd_args, extra_env=None)

Simulate the console prompt used to invoke the CLI.

Return type:

str

click_extra.testing.render_cli_run(args, result, env=None)

Generates the full simulation of CLI execution, including output.

Mostly used to print debug traces to user or in test results.

Return type:

str

click_extra.testing.print_cli_run(args, result, env=None)

Prints the full simulation of CLI execution, including output.

Return type:

None

click_extra.testing.INVOKE_ARGS = {'args', 'catch_exceptions', 'cli', 'color', 'env', 'input', 'self'}

Parameter IDs of click.testing.CliRunner.invoke().

We need to collect them to help us identify which extra parameters passed to invoke() collides with its original signature.

Warning

This has been reported upstream to Click project but has been rejected and not considered an issue worth fixing.

class click_extra.testing.ExtraResult(runner, stdout_bytes, stderr_bytes, output_bytes, return_value, exit_code, exception, exc_info=None)

Bases: Result

A Result subclass with automatic traceback formatting.

Enhances __repr__ so that pytest assertion failures show the full traceback instead of just the exception type.

property formatted_exception: str | None

Full formatted traceback, or None if no exception occurred.

class click_extra.testing.ExtraCliRunner(charset='utf-8', env=None, echo_stdin=False, catch_exceptions=True)

Bases: CliRunner

Augment click.testing.CliRunner with extra features and bug fixes.

force_color: bool = False

Global class attribute to override the color parameter in invoke.

invoke(cli, *args, input=None, env=None, catch_exceptions=True, color=None, **extra)

Same as click.testing.CliRunner.invoke() with extra features.

• The first positional parameter is the CLI to invoke. The remaining positional parameters of the function are the CLI arguments. All other parameters are required to be named.

• The CLI arguments can be nested iterables of arbitrary depth. This is useful for argument composition of test cases with @pytest.mark.parametrize.

• Allow forcing of the color property at the class-level via force_color attribute.

• Adds a special case in the form of color="forced" parameter, which allows colored output to be kept, while forcing the initialization of Context.color = True. This is not allowed in current implementation of click.testing.CliRunner.invoke() because of colliding parameters.

• Strips all ANSI codes from results if color was explicirely set to False.

• Always prints a simulation of the CLI execution as the user would see it in its terminal. Including colors.

• Pretty-prints a formatted exception traceback if the command fails.

Parameters:

• cli (Command) – CLI to invoke.

• *args –

  can be nested iterables composed of str, pathlib.Path objects and None values. The nested structure will be flattened and None values will be filtered out. Then all elements will be casted to str. See args_cleanup() for details.

• input (str | bytes | IO | None) – same as click.testing.CliRunner.invoke().

• env (Mapping[str, str | None] | None) – same as click.testing.CliRunner.invoke().

• catch_exceptions (bool) – same as click.testing.CliRunner.invoke().

• color (bool | Literal['forced'] | None) – If a boolean, the parameter will be passed as-is to click.testing.CliRunner.isolation(). If "forced", the parameter will be passed as True to click.testing.CliRunner.isolation() and an extra color=True parameter will be passed to the invoked CLI.

• **extra –

  same as click.testing.CliRunner.invoke(), but colliding parameters are allowed and properly passed on to the invoked CLI.

Return type:

ExtraResult

click_extra.testing.unescape_regex(text)

De-obfuscate a regex for better readability.

This is like the reverse of re.escape().

Return type:

str

exception click_extra.testing.RegexLineMismatch(regex_line, content_line, line_number)

Bases: AssertionError

Raised when a regex line does not match the corresponding content line.

click_extra.testing.REGEX_NEWLINE = '\\n'

Newline representation in the regexes above.

click_extra.testing.regex_fullmatch_line_by_line(regex, content)

Check that the content matches the given regex.

If the regex does not fully match the content, raise an AssertionError, with a message showing the first mismatching line.

This is useful when comparing large walls of text, such as CLI output.

Return type:

None

click_extra.timer module

Command execution time measurement.

class click_extra.timer.TimerOption(param_decls=None, default=False, expose_value=False, is_eager=True, help='Measure and print elapsed execution time.', **kwargs)

Bases: ExtraOption

A pre-configured option that is adding a --time/--no-time flag to print elapsed time at the end of CLI execution.

The start time is made available in the context in ctx.meta[click_extra.context.START_TIME].

print_timer()

Compute and print elapsed execution time.

Always prints, even when a sibling eager option (--version, --show-params, --show-config…) short-circuited the command body via ctx.exit(). That makes --time a usable probe for the cost of Click Extra’s own machinery (option parsing, config loading, eager callbacks), not just user command bodies.

Return type:

None

init_timer(ctx, param, value)

Set up the execution-timer machinery for the current invocation.

Captures time.perf_counter() as the start time, stores it on ctx.meta under click_extra.context.START_TIME, and queues print_timer() as a context-close callback so the elapsed duration is printed even when a sibling eager option (--version, --show-params…) short-circuits the command body.

Renamed from register_timer_on_close to align with the init_<system> convention shared with init_formatter and init_sort.

Return type:

None

click_extra.types module

class click_extra.types.ChoiceSource(*values)

Bases: Enum

Source of choices for EnumChoice.

KEY = 'key'

NAME = 'name'

VALUE = 'value'

STR = 'str'

class click_extra.types.EnumChoice(choices, case_sensitive=False, choice_source=ChoiceSource.STR, show_aliases=False)

Bases: Choice

Choice type for Enum.

Allows to select which part of the members to use as choice strings, by setting the choice_source parameter to one of:

• ChoiceSource.KEY or ChoiceSource.NAME to use the key (i.e. the name property),

• ChoiceSource.VALUE to use the value,

• ChoiceSource.STR to use the str() string representation, or

• A custom callable that takes an Enum member and returns a string.

Default to ChoiceSource.STR, which makes you to only have to define the __str__() method on your Enum to produce beautiful choice strings.

Same as click.Choice, but takes an Enum as choices.

Also defaults to case-insensitive matching.

choices: tuple[str, ...]

The strings available as choice.

Hint

Contrary to the parent Choice class, we store choices directly as strings, not the Enum members themselves. That way there is no surprises when displaying them to the user.

This trick bypass Enum-specific code path in the Click library. Because, after all, a terminal environment only deals with strings: arguments, parameters, parsing, help messages, environment variables, etc.

get_choice_string(member)

Derivate the choice string from the given Enum’s member.

Return type:

str

normalize_choice(choice, ctx)

Expand the parent’s normalize_choice() to accept Enum members as input.

Parent method expects a string, but here we allow passing Enum members too.

Return type:

str

convert(value, param, ctx)

Convert the input value to the corresponding Enum member.

The parent’s convert() is going to return the choice string, which we then map back to the corresponding Enum member.

Return type:

Enum

click_extra.version module

Gather CLI metadata and print them.

Pre-baking is inspired by shadow-rs, which injects build-time constants (BRANCH, SHORT_COMMIT, COMMIT_HASH, COMMIT_DATE, TAG, …) into Rust binaries at compile time.

Todo

shadow-rs also provides constants not yet covered here: BUILD_TIME, BUILD_TIME_2822, BUILD_TIME_3339, BUILD_OS, BUILD_TARGET, BUILD_TARGET_ARCH. Some overlap with data already in {env_info} (Python version, OS, architecture). Others like BUILD_TIME could be added as new template fields.

click_extra.version.GIT_FIELDS: dict[str, tuple[str, ...]] = {'git_branch': ('rev-parse', '--abbrev-ref', 'HEAD'), 'git_date': ('show', '-s', '--format=%ci', 'HEAD'), 'git_long_hash': ('rev-parse', 'HEAD'), 'git_short_hash': ('rev-parse', '--short', 'HEAD'), 'git_tag': ('describe', '--tags', '--exact-match', 'HEAD')}

Git fields that can be pre-baked, mapped to their git subcommand args.

git_tag_sha is excluded because its resolution depends on git_tag (it runs git rev-list -1 <tag>), so it cannot be expressed as a static argument tuple.

click_extra.version.run_git(*args, cwd=None)

Run a git command and return its stripped output, or None.

cwd defaults to the current working directory when not provided.

Return type:

str | None

click_extra.version.prebake_version(file_path, local_version)

Pre-bake a __version__ string with a PEP 440 local version identifier.

Reads file_path, finds the __version__ assignment via ast, and — if the version contains .dev and does not already contain + — appends +<local_version>.

This is the compile-time complement to the runtime ExtraVersionOption.version property: Nuitka/PyInstaller binaries cannot run git at runtime, so the hash must be baked into __version__ in the source file before compilation.

Returns the new version string on success, or None if no change was made (release version, already pre-baked, or no __version__ found).

Return type:

str | None

click_extra.version.prebake_dunder(file_path, name, value)

Replace an empty dunder variable’s value in a Python source file.

Reads file_path, finds a top-level name = "" assignment via ast, and — if the current value is an empty string — replaces it with value.

Placeholders must use empty strings (__field__ = "", not None). The AST matcher only recognizes string literals, and the empty string serves as a falsy sentinel that stays type-consistent with baked values (always str).

This is the generic counterpart to prebake_version(): where prebake_version appends a PEP 440 local identifier to __version__, this function does a full replacement of any dunder variable that starts empty. Typical use case: injecting a release commit SHA into __git_tag_sha__ = "" at build time.

Returns the new value on success, or None if no change was made (variable not found, or already has a non-empty value).

Return type:

str | None

click_extra.version.discover_package_init_files()

Discover __init__.py files from [project.scripts].

Reads the pyproject.toml in the current working directory, extracts [project.scripts] entry points, and returns the unique __init__.py paths for each top-level package.

Only returns paths that exist on disk. Returns an empty list if pyproject.toml is missing or has no [project.scripts].

Return type:

list[Path]

class click_extra.version.ExtraVersionOption(param_decls=None, message=None, module=None, module_name=None, module_file=None, module_version=None, package_name=None, package_version=None, exec_name=None, version=None, git_repo_path=None, git_branch=None, git_long_hash=None, git_short_hash=None, git_date=None, git_tag=None, git_tag_sha=None, prog_name=None, env_info=None, message_style=None, module_style=None, module_name_style=Style(fg='bright_white'), module_file_style=None, module_version_style=Style(fg='green'), package_name_style=Style(fg='bright_white'), package_version_style=Style(fg='green'), exec_name_style=Style(fg='bright_white'), version_style=Style(fg='green'), git_repo_path_style=Style(fg='bright_black'), git_branch_style=Style(fg='cyan'), git_long_hash_style=Style(fg='yellow'), git_short_hash_style=Style(fg='yellow'), git_date_style=Style(fg='bright_black'), git_tag_style=Style(fg='cyan'), git_tag_sha_style=Style(fg='yellow'), prog_name_style=Style(fg='bright_white'), env_info_style=Style(fg='bright_black'), is_flag=True, expose_value=False, is_eager=True, help='Show the version and exit.', **kwargs)

Bases: ExtraOption

Gather CLI metadata and prints a colored version string.

Note

This started as a copy of the standard @click.version_option() decorator, but is no longer a drop-in replacement. Hence the Extra prefix.

This address the following Click issues:

• click#2324, to allow its use with the declarative params= argument.

• click#2331, by distinguishing the module from the package.

• click#1756, by allowing path and Python version.

Preconfigured as a --version option flag.

Parameters:

• message (str | None) – the message template to print, in format string syntax. Defaults to {prog_name}, version {version}.

• module (str | None) – forces the value of {module}.

• module_name (str | None) – forces the value of {module_name}.

• module_file (str | None) – forces the value of {module_file}.

• module_version (str | None) – forces the value of {module_version}.

• package_name (str | None) – forces the value of {package_name}.

• package_version (str | None) – forces the value of {package_version}.

• exec_name (str | None) – forces the value of {exec_name}.

• version (str | None) – forces the value of {version}.

• git_repo_path (str | None) – forces the value of {git_repo_path}.

• git_branch (str | None) – forces the value of {git_branch}.

• git_long_hash (str | None) – forces the value of {git_long_hash}.

• git_short_hash (str | None) – forces the value of {git_short_hash}.

• git_date (str | None) – forces the value of {git_date}.

• git_tag (str | None) – forces the value of {git_tag}.

• git_tag_sha (str | None) – forces the value of {git_tag_sha}.

• prog_name (str | None) – forces the value of {prog_name}.

• env_info (dict[str, str] | None) – forces the value of {env_info}.

• message_style (Callable[[str], str] | None) – default style of the message.

• module_style (Callable[[str], str] | None) – style of {module}.

• module_name_style (Callable[[str], str] | None) – style of {module_name}.

• module_file_style (Callable[[str], str] | None) – style of {module_file}.

• module_version_style (Callable[[str], str] | None) – style of {module_version}.

• package_name_style (Callable[[str], str] | None) – style of {package_name}.

• package_version_style (Callable[[str], str] | None) – style of {package_version}.

• exec_name_style (Callable[[str], str] | None) – style of {exec_name}.

• version_style (Callable[[str], str] | None) – style of {version}.

• git_repo_path_style (Callable[[str], str] | None) – style of {git_repo_path}.

• git_branch_style (Callable[[str], str] | None) – style of {git_branch}.

• git_long_hash_style (Callable[[str], str] | None) – style of {git_long_hash}.

• git_short_hash_style (Callable[[str], str] | None) – style of {git_short_hash}.

• git_date_style (Callable[[str], str] | None) – style of {git_date}.

• git_tag_style (Callable[[str], str] | None) – style of {git_tag}.

• git_tag_sha_style (Callable[[str], str] | None) – style of {git_tag_sha}.

• prog_name_style (Callable[[str], str] | None) – style of {prog_name}.

• env_info_style (Callable[[str], str] | None) – style of {env_info}.

template_fields: tuple[str, ...] = ('module', 'module_name', 'module_file', 'module_version', 'package_name', 'package_version', 'exec_name', 'version', 'git_repo_path', 'git_branch', 'git_long_hash', 'git_short_hash', 'git_date', 'git_tag', 'git_tag_sha', 'prog_name', 'env_info')

List of field IDs recognized by the message template.

message: str = '{prog_name}, version {version}'

Default message template used to render the version string.

static cli_frame()

Returns the frame in which the CLI is implemented.

Inspects the execution stack frames to find the package in which the user’s CLI is implemented.

Returns the frame itself.

Return type:

FrameType

property module: ModuleType

Returns the module in which the CLI resides.

property module_name: str

Returns the full module name or ``__main__`.

property module_file: str | None

Returns the module’s file full path.

property module_version: str | None

Returns the string found in the local __version__ variable.

Hint

__version__ is an old pattern from early Python packaging. It is not a standard variable and is not defined in the packaging PEPs.

You should prefer using the package_version property below instead, which uses the standard library importlib.metadata API.

We’re still supporting it for backward compatibility with existing codebases, as Click removed it in version 8.2.0.

property package_name: str | None

Returns the package name.

property package_version: str | None

Returns the package version if installed.

property exec_name: str

User-friendly name of the executed CLI.

Returns the module name. But if the later is __main__, returns the package name.

If not packaged, the CLI is assumed to be a simple standalone script, and the returned name is the script’s file name (including its extension).

property version: str | None

Return the version of the CLI.

Returns the module version if a __version__ variable is set alongside the CLI in its module.

Else returns the package version if the CLI is implemented in a package, using importlib.metadata.version().

For development versions (containing .dev), automatically appends the Git short hash as a PEP 440 local version identifier, producing versions like 1.2.3.dev0+abc1234. This helps identify the exact commit a dev build was produced from. If Git is unavailable, the plain dev version is returned.

Versions that already contain a + (i.e., a pre-baked local version identifier, typically set at build time by CI pipelines) are returned as-is to avoid producing invalid double-suffixed versions like 1.2.3.dev0+abc1234+xyz5678.

property git_repo_path: Path | None

Find the Git repository root directory.

property git_branch: str | None

Returns the current Git branch name.

Checks for a pre-baked __git_branch__ dunder first, then falls back to git rev-parse --abbrev-ref HEAD.

property git_long_hash: str | None

Returns the full Git commit hash.

Checks for a pre-baked __git_long_hash__ dunder first, then falls back to git rev-parse HEAD.

property git_short_hash: str | None

Returns the short Git commit hash.

Checks for a pre-baked __git_short_hash__ dunder first, then falls back to git rev-parse --short HEAD.

Hint

The short hash is usually the first 7 characters of the full hash, but this is not guaranteed to be the case.

But it is at least guaranteed to be unique within the repository, and a minimum of 4 characters.

property git_date: str | None

Returns the commit date in ISO format: YYYY-MM-DD HH:MM:SS +ZZZZ.

Checks for a pre-baked __git_date__ dunder first, then falls back to git show -s --format=%ci HEAD.

property git_tag: str | None

Returns the Git tag pointing at HEAD, if any.

Checks for a pre-baked __git_tag__ dunder first, then falls back to git describe --tags --exact-match HEAD.

Returns None if HEAD is not at a tagged commit.

property git_tag_sha: str | None

Returns the commit SHA that the current tag points at.

Checks for a pre-baked __git_tag_sha__ dunder first, then falls back to git rev-list -1 on the tag returned by git_tag. Returns None if HEAD is not at a tag.

property prog_name: str | None

Return the name of the CLI, from Click’s point of view.

Get the info_name of the root command.

property env_info: dict[str, Any]

Various environment info.

Returns the data produced by boltons.ecoutils.get_profile().

colored_template(template=None)

Insert ANSI styles to a message template.

Accepts a custom template as parameter, otherwise uses the default message defined on the Option instance.

This step is necessary because we need to linearize the template to apply the ANSI codes on the string segments. This is a consequence of the nature of ANSI, directives which cannot be encapsulated within another (unlike markup tags like HTML).

Return type:

str

render_message(template=None)

Render the version string from the provided template.

Accepts a custom template as parameter, otherwise uses the default self.colored_template() produced by the instance.

Return type:

str

print_debug_message()

Render in debug logs all template fields in color.

Todo

Pretty print JSON output (easier to read in bug reports)?

Return type:

None

print_and_exit(ctx, param, value)

Print the version string and exits.

Also stores all version string elements in the Context’s meta dict.

Return type:

None