click 8.3.2__tar.gz → 8.3.3__tar.gz

{click-8.3.2 → click-8.3.3}/CHANGES.rst

@@ -1,7 +1,48 @@
 .. currentmodule:: click
 
+Version 8.3.3
+-------------
+
+Released 2026-04-20
+
+-   Use :func:`shlex.split` to split pager and editor commands into ``argv``
+    lists for :class:`subprocess.Popen`, removing ``shell=True``.
+    :issue:`1026` :pr:`1477` :pr:`2775`
+-   Fix ``TypeError`` when rendering help for an option whose default value is
+    an object that doesn't support equality comparison with strings, such as
+    ``semver.Version``. :issue:`3298` :pr:`3299`
+-   Fix pager test pollution under parallel execution by using pytest's
+    ``tmp_path`` fixture instead of a shared temporary file path. :pr:`3238`
+-   Treat ``Sentinel.UNSET`` values in a ``default_map`` as absent, so they fall
+    through to the next default source instead of being used as the value.
+    :issue:`3224` :pr:`3240`
+-   Patch ``pdb.Pdb`` in ``CliRunner`` isolation so ``pdb.set_trace()``,
+    ``breakpoint()``, and debuggers subclassing ``pdb.Pdb`` (ipdb, pdbpp) can
+    interact with the real terminal instead of the captured I/O streams.
+    :issue:`654` :issue:`824` :issue:`843` :pr:`951` :pr:`3235`
+-   Add optional randomized parallel test execution using ``pytest-randomly`` and
+    ``pytest-xdist`` to detect test pollution and race conditions. :pr:`3151`
+-   Add contributor documentation for running stress tests, randomized
+    parallel tests, and Flask smoke tests. :pr:`3151` :pr:`3177`
+-   Show custom ``show_default`` string in prompts, matching the existing
+    help text behavior. :issue:`2836` :pr:`2837` :pr:`3165` :pr:`3262` :pr:`3280`
+    :pr:`3328`
+-   Fix ``default=True`` with boolean ``flag_value`` always returning the
+    ``flag_value`` instead of ``True``. The ``default=True`` to ``flag_value``
+    substitution now only applies to non-boolean flags, where ``True`` acts as a
+    sentinel meaning "activate this flag by default". For boolean flags,
+    ``default=True`` is returned as a literal value. :issue:`3111` :pr:`3239`
+-   Mark ``make_default_short_help`` as private API. :issue:`3189` :pr:`3250`
+-   ``CliRunner``'s redirected streams now expose the original file descriptor
+    via ``fileno()``, so that ``faulthandler``, ``subprocess``, and other
+    C-level consumers no longer crash with ``io.UnsupportedOperation``.
+    :issue:`2865`
+-   Change :class:`ParameterSource` to an :class:`~enum.IntEnum` and reorder
+    its members from most to least explicit, so values can be compared to
+    check whether a parameter was explicitly provided. :issue:`2879` :pr:`3248`
+
 Version 8.3.2
---------------
+-------------
 
 Released 2026-04-02
 
@@ -19,7 +60,7 @@ Released 2026-04-02
     ``default=True``. :issue:`3121` :pr:`3201` :pr:`3213` :pr:`3225`
 
 Version 8.3.1
---------------
+-------------
 
 Released 2025-11-15
 

{click-8.3.2 → click-8.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: click
-Version: 8.3.2
+Version: 8.3.3
 Summary: Composable command line interface toolkit
 Maintainer-email: Pallets <contact@palletsprojects.com>
 Requires-Python: >=3.10

click-8.3.2/docs/arguments.rst → click-8.3.3/docs/arguments.md

@@ -1,28 +1,31 @@
-.. _arguments:
+(arguments)=
 
-Arguments
-=========
+# Arguments
 
-.. currentmodule:: click
+```{currentmodule} click
+```
 
 Arguments are:
 
-*   Are positional in nature.
-*   Similar to a limited version of :ref:`options <options>` that can take an arbitrary number of inputs
-*   :ref:`Documented manually <documenting-arguments>`.
+* Are positional in nature.
+* Similar to a limited version of {ref}`options <options>` that
+  can take an arbitrary number of inputs
+* {ref}`Documented manually <documenting-arguments>`.
 
 Useful and often used kwargs are:
 
-*   ``default``: Passes a default.
-*   ``nargs``: Sets the number of arguments. Set to -1 to take an arbitrary number.
+* `default`: Passes a default.
+* `nargs`: Sets the number of arguments. Set to -1 to take an arbitrary number.
 
-Basic Arguments
----------------
+## Basic Arguments
 
-A minimal :class:`click.Argument` solely takes one string argument: the name of the argument. This will assume the argument is required, has no default, and is of the type ``str``.
+A minimal {class}`click.Argument` solely takes one string argument:
+the name of the argument. This will assume the argument is required,
+has no default, and is of the type `str`.
 
 Example:
 
+```{eval-rst}
 .. click:example::
 
     @click.command()
@@ -36,19 +39,31 @@ And from the command line:
 .. click:run::
 
     invoke(touch, args=['foo.txt'])
+```
 
+An argument may be assigned a {ref}`parameter type <parameter-types>`.
+If no type is provided, the type of the default value is used. If no
+default value is provided, the type is assumed to be {data}`STRING`.
 
-An argument may be assigned a :ref:`parameter type <parameter-types>`. If no type is provided, the type of the default value is used. If no default value is provided, the type is assumed to be :data:`STRING`.
+```{admonition} Note on Required Arguments
+:class: note
 
-.. admonition:: Note on Required Arguments
+   It is possible to make an argument required by setting
+   `required=True`. It is not recommended since we think command line
+   tools should gracefully degrade into becoming no ops. We think this
+   because command line tools are often invoked with wildcard inputs
+   and they should not error out if the wildcard is empty.
+```
 
-   It is possible to make an argument required by setting ``required=True``.  It is not recommended since we think command line tools should gracefully degrade into becoming no ops.  We think this because command line tools are often invoked with wildcard inputs and they should not error out if the wildcard is empty.
+## Multiple Arguments
 
-Multiple Arguments
------------------------------------
-
-To set the number of argument use the ``nargs`` kwarg. It can be set to any positive integer and -1. Setting it to -1, makes the number of arguments arbitrary (which is called variadic) and can only be used once. The arguments are then packed as a tuple and passed to the function.
+To set the number of argument use the `nargs` kwarg. It can be set to
+any positive integer and -1. Setting it to -1, makes the number of
+arguments arbitrary (which is called variadic) and can only be used
+once. The arguments are then packed as a tuple and passed to the
+function.
 
+```{eval-rst}
 .. click:example::
 
     @click.command()
@@ -64,18 +79,26 @@ And from the command line:
 .. click:run::
 
     invoke(copy, args=['foo.txt', 'usr/david/foo.txt', 'usr/mitsuko/foo.txt'])
+```
 
-.. admonition:: Note on Handling Files
+```{admonition} Note on Handling Files
+:class: note
 
-    This is not how you should handle files and files paths. This merely used as a simple example. See :ref:`handling-files` to learn more about how to handle files in parameters.
+   This is not how you should handle files and files paths. This
+   merely used as a simple example. See {ref}`handling-files` to learn
+   more about how to handle files in parameters.
+```
 
-Argument Escape Sequences
----------------------------
+## Argument Escape Sequences
 
-If you want to process arguments that look like options, like a file named ``-foo.txt`` or ``--foo.txt`` , you must pass the ``--`` separator first. After you pass the ``--``, you may only pass arguments. This is a common feature for POSIX command line tools.
+If you want to process arguments that look like options, like a file
+named `-foo.txt` or `--foo.txt`, you must pass the `--` separator
+first. After you pass the `--`, you may only pass arguments. This is a
+common feature for POSIX command line tools.
 
 Example usage:
 
+```{eval-rst}
 .. click:example::
 
     @click.command()
@@ -90,9 +113,12 @@ And from the command line:
 .. click:run::
 
     invoke(touch, ['--', '-foo.txt', 'bar.txt'])
+```
 
-If you don't like the ``--`` marker, you can set ignore_unknown_options to True to avoid checking unknown options:
+If you don't like the `--` marker, you can set
+`ignore_unknown_options` to `True` to avoid checking unknown options:
 
+```{eval-rst}
 .. click:example::
 
     @click.command(context_settings={"ignore_unknown_options": True})
@@ -107,17 +133,18 @@ And from the command line:
 .. click:run::
 
     invoke(touch, ['-foo.txt', 'bar.txt'])
+```
 
+(environment-variables)=
 
-.. _environment-variables:
-
-Environment Variables
----------------------
+## Environment Variables
 
-Arguments can use environment variables. To do so, pass the name(s) of the environment variable(s) via `envvar` in ``click.argument``.
+Arguments can use environment variables. To do so, pass the name(s) of
+the environment variable(s) via `envvar` in `click.argument`.
 
 Checking one environment variable:
 
+```{eval-rst}
 .. click:example::
 
     @click.command()
@@ -156,3 +183,4 @@ And from the command line:
         with open('hello.txt', 'w') as f:
             f.write('Hello World from second variable!')
         invoke(echo, env={'SRC_2': 'hello.txt'})
+```

click-8.3.3/docs/click-concepts.md

@@ -0,0 +1,68 @@
+# Click Concepts
+
+This section covers concepts about Click's design.
+
+```{contents}
+---
+depth: 1
+local: true
+---
+```
+
+(callback-evaluation-order)=
+
+## Callback Evaluation Order
+
+Click works a bit differently than some other command line parsers in that
+it attempts to reconcile the order of arguments as defined by the
+programmer with the order of arguments as defined by the user before
+invoking any callbacks.
+
+This is an important concept to understand when porting complex
+patterns to Click from optparse or other systems.  A parameter
+callback invocation in optparse happens as part of the parsing step,
+whereas a callback invocation in Click happens after the parsing.
+
+The main difference is that in optparse, callbacks are invoked with the raw
+value as it happens, whereas a callback in Click is invoked after the
+value has been fully converted.
+
+Generally, the order of invocation is driven by the order in which the user
+provides the arguments to the script; if there is an option called `--foo`
+and an option called `--bar` and the user calls it as `--bar --foo`, then
+the callback for `bar` will fire before the one for `foo`.
+
+There are three exceptions to this rule which are important to know:
+
+Eagerness:
+>    An option can be set to be "eager".  All eager parameters are
+>    evaluated before all non-eager parameters, but again in the order as
+>    they were provided on the command line by the user.
+
+>    This is important for parameters that execute and exit like `--help`
+>    and `--version`.  Both are eager parameters, but whatever parameter
+>    comes first on the command line will win and exit the program.
+
+Repeated parameters:
+>    If an option or argument is split up on the command line into multiple
+>    places because it is repeated -- for instance, `--exclude foo --include
+>    baz --exclude bar` -- the callback will fire based on the position of
+>    the first option.  In this case, the callback will fire for
+>    `exclude` and it will be passed both options (`foo` and
+>    `bar`), then the callback for `include` will fire with `baz`
+>    only.
+
+>    Note that even if a parameter does not allow multiple versions, Click
+>    will still accept the position of the first, but it will ignore every
+>    value except the last.  The reason for this is to allow composability
+>    through shell aliases that set defaults.
+
+Missing parameters:
+>    If a parameter is not defined on the command line, the callback will
+>    still fire.  This is different from how it works in optparse where
+>    undefined values do not fire the callback.  Missing parameters fire
+>    their callbacks at the very end which makes it possible for them to
+>    default to values from a parameter that came before.
+
+Most of the time you do not need to be concerned about any of this,
+but it is important to know how it works for some advanced cases.

click-8.3.2/docs/commands-and-groups.rst → click-8.3.3/docs/commands-and-groups.md

@@ -1,22 +1,29 @@
-Basic Commands, Groups, Context
-================================
+# Basic Commands, Groups, Context
 
-.. currentmodule:: click
+```{currentmodule} click
+```
 
-Commands and Groups are the building blocks for Click applications. :class:`Command` wraps a function to make it into a cli command. :class:`Group` wraps Commands and Groups to make them into applications. :class:`Context` is how groups and commands communicate.
+Commands and Groups are the building blocks for Click applications.
+{class}`Command` wraps a function to make it into a cli command. {class}`Group`
+wraps Commands and Groups to make them into applications. {class}`Context` is
+how groups and commands communicate.
 
-.. contents::
-   :depth: 2
-   :local:
+```{contents}
+---
+depth: 2
+local: true
+---
+```
 
-Commands
---------------------
+## Commands
+
+### Basic Command Example
 
-Basic Command Example
-^^^^^^^^^^^^^^^^^^^^^^^
 A simple command decorator takes no arguments.
 
+```{eval-rst}
 .. click:example::
+
     @click.command()
     @click.option('--count', default=1)
     def hello(count):
@@ -25,12 +32,16 @@ A simple command decorator takes no arguments.
 
 .. click:run::
     invoke(hello, args=['--count', '2',])
+```
+
+### Renaming Commands
 
-Renaming Commands
-^^^^^^^^^^^^^^^^^^^
-By default the command is the function name with underscores replaced by dashes. To change this pass the  desired name into the first positional argument.
+By default the command is the function name with underscores replaced by dashes.
+To change this pass the  desired name into the first positional argument.
 
+```{eval-rst}
 .. click:example::
+
     @click.command('say-hello')
     @click.option('--count', default=1)
     def hello(count):
@@ -39,12 +50,15 @@ By default the command is the function name with underscores replaced by dashes.
 
 .. click:run::
     invoke(hello, args=['--count', '2',])
+```
+
+### Deprecating Commands
 
-Deprecating Commands
-^^^^^^^^^^^^^^^^^^^^^^
-To mark a command as deprecated pass in ``deprecated=True``
+To mark a command as deprecated pass in `deprecated=True`
 
+```{eval-rst}
 .. click:example::
+
     @click.command('say-hello', deprecated=True)
     @click.option('--count', default=1)
     def hello(count):
@@ -53,15 +67,19 @@ To mark a command as deprecated pass in ``deprecated=True``
 
 .. click:run::
     invoke(hello, args=['--count', '2',])
+```
 
-Groups
-------------
+## Groups
 
-Basic Group Example
-^^^^^^^^^^^^^^^^^^^^^
-A group wraps one or more commands. After being wrapped, the commands are nested under that group. You can see that on the help pages and in the execution. By default, invoking the group with no command shows the help page.
+### Basic Group Example
 
+A group wraps one or more commands. After being wrapped, the commands are nested
+under that group. You can see that on the help pages and in the execution. By
+default, invoking the group with no command shows the help page.
+
+```{eval-rst}
 .. click:example::
+
     @click.group()
     def greeting():
         click.echo('Starting greeting ...')
@@ -84,14 +102,19 @@ At the command level:
 
     invoke(greeting, args=['say-hello'])
     invoke(greeting, args=['say-hello', '--help'])
+```
+
+As you can see from the above example, the function wrapped by the group
+decorator executes unless it is interrupted (for example by calling the help).
 
-As you can see from the above example, the function wrapped by the group decorator executes unless it is interrupted (for example by calling the help).
+### Renaming Groups
 
-Renaming Groups
-^^^^^^^^^^^^^^^^^
-To have a name other than the decorated function name as the group name, pass it in as the first positional argument.
+To have a name other than the decorated function name as the group name, pass it
+in as the first positional argument.
 
+```{eval-rst}
 .. click:example::
+
     @click.group('greet-someone')
     def greeting():
         click.echo('Starting greeting ...')
@@ -105,12 +128,17 @@ To have a name other than the decorated function name as the group name, pass it
 .. click:run::
 
     invoke(greeting, args=['say-hello'])
+```
 
-Group Invocation Without Command
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Group Invocation Without Command
 
-By default, if a group is passed without a command, the group is not invoked and a command automatically passes ``--help``. To change this, pass ``invoke_without_command=True`` to the group. The context object also includes information about whether or not the group invocation would go to a command nested under it.
+By default, if a group is passed without a command, the group is not invoked and
+a command automatically passes `--help`. To change this, pass
+`invoke_without_command=True` to the group. The context object also includes
+information about whether or not the group invocation would go to a command
+nested under it.
 
+```{eval-rst}
 .. click:example::
 
     @click.group(invoke_without_command=True)
@@ -129,14 +157,15 @@ By default, if a group is passed without a command, the group is not invoked and
 
     invoke(cli, prog_name='tool', args=[])
     invoke(cli, prog_name='tool', args=['sync'])
+```
 
+### Group Separation
 
+Command {ref}`parameters` attached to a command belong only to that command.
 
-Group Separation
-^^^^^^^^^^^^^^^^^^^
-Command :ref:`parameters` attached to a command belong only to that command.
-
+```{eval-rst}
 .. click:example::
+
     @click.group()
     def greeting():
         pass
@@ -158,19 +187,27 @@ Command :ref:`parameters` attached to a command belong only to that command.
     invoke(greeting, args=['hello', '--count', '2'])
     invoke(greeting, args=['goodbye', '--count', '2'])
     invoke(greeting)
+```
 
-Additionally parameters for a given group belong only to that group and not to the commands under it. What this means is that options and arguments for a specific command have to be specified *after* the command name itself, but *before* any other command names.
+Additionally parameters for a given group belong only to that group and not to
+the commands under it. What this means is that options and arguments for a
+specific command have to be specified *after* the command name itself, but
+*before* any other command names.
 
-This behavior is observable with the ``--help`` option. Suppose we have a group called ``tool`` containing a command called ``sub``.
+This behavior is observable with the `--help` option. Suppose we have a group
+called `tool` containing a command called `sub`.
 
-- ``tool --help`` returns the help for the whole program (listing subcommands).
-- ``tool sub --help`` returns the help for the ``sub`` subcommand.
-- But ``tool --help sub`` treats ``--help`` as an argument for the main program. Click then invokes the callback for ``--help``, which prints the help and aborts the program before click can process the subcommand.
+- `tool --help` returns the help for the whole program (listing subcommands).
+- `tool sub --help` returns the help for the `sub` subcommand.
+- But `tool --help sub` treats `--help` as an argument for the main program.
+  Click then invokes the callback for `--help`, which prints the help and aborts
+  the program before click can process the subcommand.
 
-Arbitrary Nesting
-^^^^^^^^^^^^^^^^^^^
-:class:`Commands <Command>` are attached to a :class:`Group`. Multiple groups can be attached to another group. Groups containing multiple groups can be attached to a group, and so on. To invoke a command nested under multiple groups, all the groups under which it is nested must be invoked.
+### Arbitrary Nesting
 
+{class}`Commands <Command>` are attached to a {class}`Group`. Multiple groups can be attached to another group. Groups containing multiple groups can be attached to a group, and so on. To invoke a command nested under multiple groups, all the groups under which it is nested must be invoked.
+
+```{eval-rst}
 .. click:example::
 
     @click.group()
@@ -193,11 +230,16 @@ Arbitrary Nesting
 .. click:run::
 
     invoke(cli, args=['session', 'initdb'])
+```
+
+### Lazily Attaching Commands
 
-Lazily Attaching Commands
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Most examples so far have attached the commands to a group immediately, but commands may be registered later. This could be used to split commands into multiple Python modules. Regardless of how they are attached, the commands are invoked identically.
+Most examples so far have attached the commands to a group immediately, but
+commands may be registered later. This could be used to split commands into
+multiple Python modules. Regardless of how they are attached, the commands are
+invoked identically.
 
+```{eval-rst}
 .. click:example::
 
     @click.group()
@@ -218,18 +260,23 @@ Most examples so far have attached the commands to a group immediately, but comm
 
     invoke(cli, args=['initdb'])
     invoke(cli, args=['dropdb'])
+```
+
+## Context Object
+The {class}`Context` object is how commands and groups communicate.
 
-Context Object
--------------------
-The :class:`Context` object is how commands and groups communicate.
+### Auto Envvar Prefix
 
-Auto Envvar Prefix
-^^^^^^^^^^^^^^^^^^^^
-Automatically built environment variables are supported for options only. To enable this feature, the ``auto_envvar_prefix`` parameter needs to be passed to the script that is invoked.  Each command and parameter is then added as an uppercase underscore-separated variable.  If you have a subcommand
-called ``run`` taking an option called ``reload`` and the prefix is ``WEB``, then the variable is ``WEB_RUN_RELOAD``.
+Automatically built environment variables are supported for options only. To
+enable this feature, the `auto_envvar_prefix` parameter needs to be passed to
+the script that is invoked.  Each command and parameter is then added as an
+uppercase underscore-separated variable.  If you have a subcommand
+called `run` taking an option called `reload` and the prefix is `WEB`, then the
+variable is `WEB_RUN_RELOAD`.
 
 Example usage:
 
+```{eval-rst}
 .. click:example::
 
     @click.command()
@@ -246,13 +293,15 @@ And from the command line:
 
     invoke(greet, env={'GREETER_USERNAME': 'john'},
            auto_envvar_prefix='GREETER')
+```
 
-When using ``auto_envvar_prefix`` with command groups, the command name
+When using `auto_envvar_prefix` with command groups, the command name
 needs to be included in the environment variable, between the prefix and
-the parameter name, *i.e.* ``PREFIX_COMMAND_VARIABLE``. If you have a
-subcommand called ``run-server`` taking an option called ``host`` and
-the prefix is ``WEB``, then the variable is ``WEB_RUN_SERVER_HOST``.
+the parameter name, *i.e.* `PREFIX_COMMAND_VARIABLE`. If you have a
+subcommand called `run-server` taking an option called `host` and
+the prefix is `WEB`, then the variable is `WEB_RUN_SERVER_HOST`.
 
+```{eval-rst}
 .. click:example::
 
    @click.group()
@@ -273,31 +322,35 @@ the prefix is ``WEB``, then the variable is ``WEB_RUN_SERVER_HOST``.
    invoke(cli, args=['greet',],
           env={'GREETER_GREET_USERNAME': 'John', 'GREETER_DEBUG': 'false'},
           auto_envvar_prefix='GREETER')
+```
 
-Global Context Access
-^^^^^^^^^^^^^^^^^^^^^^
+### Global Context Access
 
-.. versionadded:: 5.0
+```{versionadded} 5.0
+```
 
 Starting with Click 5.0 it is possible to access the current context from
 anywhere within the same thread through the use of the
-:func:`get_current_context` function which returns it.  This is primarily
+{func}`get_current_context` function which returns it.  This is primarily
 useful for accessing the context bound object as well as some flags that
 are stored on it to customize the runtime behavior.  For instance the
-:func:`echo` function does this to infer the default value of the `color`
+{func}`echo` function does this to infer the default value of the `color`
 flag.
 
-Example usage::
+Example usage:
 
+```python
     def get_current_command_name():
         return click.get_current_context().info_name
+```
 
 It should be noted that this only works within the current thread.  If you
 spawn additional threads then those threads will not have the ability to
 refer to the current context.  If you want to give another thread the
 ability to refer to this context you need to use the context within the
-thread as a context manager::
+thread as a context manager:
 
+```python
     def spawn_thread(ctx, func):
         def wrapper():
             with ctx:
@@ -305,6 +358,7 @@ thread as a context manager::
         t = threading.Thread(target=wrapper)
         t.start()
         return t
+```
 
 Now the thread function can access the context like the main thread would
 do.  However if you do use this for threading you need to be very careful
@@ -313,16 +367,45 @@ allowed to read from the context, but not to perform any modifications on
 it.
 
 
-Detecting the Source of a Parameter
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Parameter Source Priority
+
+When a parameter's value is resolved, Click checks several sources
+in the following order of precedence:
+
+1.  **Prompt** (`PROMPT`): interactively provided by the user at a prompt.
+2.  **Command line** (`COMMANDLINE`): provided as a CLI argument or option.
+3.  **Environment variable** (`ENVIRONMENT`): read from an environment variable.
+4.  **Default map** (`DEFAULT_MAP`): looked up from {attr}`Context.default_map`.
+5.  **Default** (`DEFAULT`): the default value defined on the parameter.
+
+{class}`~click.core.ParameterSource` members are ordered from most
+explicit to least explicit. Because it is an {class}`~enum.IntEnum`,
+you can use comparison operators to check how explicitly a value was
+provided:
+
+```python
+source = ctx.get_parameter_source("port")
+
+# True if the value was explicitly set (command line, prompt, or env var).
+if source < click.ParameterSource.DEFAULT_MAP:
+    ...
+
+# True if the value came from any kind of default.
+if source >= click.ParameterSource.DEFAULT_MAP:
+    ...
+```
+
+
+### Detecting the Source of a Parameter
 
 In some situations it's helpful to understand whether or not an option
 or parameter came from the command line, the environment, the default
-value, or :attr:`Context.default_map`. The
-:meth:`Context.get_parameter_source` method can be used to find this
-out. It will return a member of the :class:`~click.core.ParameterSource`
+value, or {attr}`Context.default_map`. The
+{meth}`Context.get_parameter_source` method can be used to find this
+out. It will return a member of the {class}`~click.core.ParameterSource`
 enum.
 
+```{eval-rst}
 .. click:example::
 
     @click.command()
@@ -340,3 +423,4 @@ enum.
     println()
     invoke(cli, prog_name='cli', args=[])
     println()
+```