U
|
ß=®d¦½ ã @ sH d dl Z d dlZd dlZd dlZd dlZd dlZd dlmZ d dl m
|
Z
|
d dl m Z d dl m Z d dlmZ d dlmZ d dlmZ d d lmZ d
|
d lmZ d
|
d lmZ d
|
d lmZ d
|
dlmZ d
|
dlmZ d
|
dlmZ d
|
dlm Z d
|
dl m Z d
|
dl m Z d
|
dl m!Z! d
|
dl m"Z" d
|
dl#m$Z$ d
|
dl#m%Z% d
|
dl#m&Z& d
|
dl'm(Z( d
|
dl'm)Z) d
|
dl'm*Z* d
|
d l+m,Z, d
|
d l+m-Z- d
|
d l+m.Z. d
|
d l+m/Z/ d
|
d l+m0Z0 d
|
d!l+m1Z1 ej2rÀd dl3Z4d
|
d"l5m6Z6 ej7d#ej8d$ej9f d%Z:e 7d&¡Z;d'e<ej=ej>e<d(f d)d*d+Z?dNd-e<d(e@dd.d/d0ZAejBe; eCejDej>e;d$f d1d2d3ZEe
|
dOd'ejFd4 ej=d d5d6d7ZGejHd4 ejHd4 ejDd4 d8d9d:ZIG d;d< d<e jJZKG d=d' d'ZLG d>d? d?ZMG d@d( d(eMZNG dAd- d-eNZOG dBdC dCeOZPG dDdE dEeOZQej9ej=ej9 dFdGdHZRG dId4 d4ZSG dJdK dKeSZTG dLdM dMeSZUdS )Pé N)Úabc)Úcontextmanager)Ú ExitStack)Úupdate_wrapper)Úgettext)Úngettext)Úrepeat)Ú TracebackTypeé )Útypes©ÚAbort)Ú BadParameter)ÚClickException©ÚExit)ÚMissingParameter©Ú
|
UsageError)Ú HelpFormatter)Ú join_options)Ú pop_context)Ú push_context©Ú_flag_needs_value)Ú OptionParser)Ú split_opt)Úconfirm)Úprompt)Ústyle)Ú_detect_program_name)Ú _expand_args)Úecho)Úmake_default_short_help)Úmake_str)ÚPacifyFlushWrapper©ÚCompletionItemÚF.)ÚboundÚVÚContextÚCommand©ÚctxÚ
|
incompleteÚreturnc c sP t t| j¡}| | ¡D ]2}| |¡r| | |¡}|dk r|js||fV qdS )zÓList all the subcommands of a group that start with the
|
incomplete value and aren't hidden.
|
|
:param ctx: Invocation context for the group.
|
:param incomplete: Value being completed. May be empty.
|
N)ÚtÚcastÚ MultiCommandÚcommandÚ list_commandsÚ
|
startswithÚ get_commandÚhidden)r. r/ ZmultiÚnamer4 © r: úAd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\click/core.pyÚ_complete_visible_commands0 s
|
r< Fr3 )Ú base_commandÚcmd_nameÚcmdÚregisterr0 c C sh | j rt|tsd S |r d}nd}t| d| jd|d|dt|j dt| j d| jd d S )
|
NzdIt is not possible to add multi commands as children to another multi command that is in chain mode.zdFound a multi command as subcommand to a multi command that is in chain mode. This is not supported.z
|
. Command z is set to chain and zA was added as a subcommand but it in itself is a multi command. (z is a z within a chained z named z).)ÚchainÚ
|
isinstancer3 Ú RuntimeErrorr9 ÚtypeÚ__name__)r= r> r? r@ Úhintr: r: r; Ú_check_multicommandC s ÿÿ<ÿrG )ÚiterableÚ
|
batch_sizer0 c C s t ttt| | S ©N)ÚlistÚzipr Úiter)rH rI r: r: r; Úbatch[ s rN Ú Parameter)r. Úparamr0 c
|
c s z
|
dV W n~ t k
|
rV } z.|jdkr,| |_|dk rD|jdkrD||_ W 5 d}~X Y n4 tk
|
r } z|jdkrv| |_ W 5 d}~X Y nX dS )z>Context manager that attaches extra information to exceptions.N)r r. rP r )r. rP Úer: r: r; Úaugment_usage_errors_ s
|
|
|
rR )Úinvocation_orderÚdeclaration_orderr0 c s* dt jttf d fdd }t||dS )zÏGiven a sequence of parameters in the order as should be considered
|
for processing and an iterable of parameters that exist, this returns
|
a list in the correct order as they should be processed.
|
rO )Úitemr0 c s8 z | ¡}W n tk
|
r* td}Y nX | j |fS )NÚinf)ÚindexÚ
|
ValueErrorÚfloatÚis_eager)rU Úidx©rS r: r; Úsort_key{ s
|
z,iter_params_for_processing.<locals>.sort_key©Úkey)r1 ÚTupleÚboolrY Úsorted)rS rT r] r: r\ r; Úiter_params_for_processingr s rc c @ s8 e Zd ZdZe ¡ Ze ¡ Ze ¡ Ze ¡ Z e ¡ Z
|
dS )ÚParameterSourcea\ This is an :class:`~enum.Enum` that indicates the source of a
|
parameter's value.
|
|
Use :meth:`click.Context.get_parameter_source` to get the
|
source for a parameter by name.
|
|
.. versionchanged:: 8.0
|
Use :class:`~enum.Enum` and drop the ``validate`` method.
|
|
.. versionchanged:: 8.0
|
Added the ``PROMPT`` value.
|
N) rE Ú
|
__module__Ú __qualname__Ú__doc__ÚenumÚautoÚ COMMANDLINEÚ ENVIRONMENTÚDEFAULTÚ DEFAULT_MAPÚPROMPTr: r: r: r; rd s rd c @ s~ e Zd ZU dZeZejd ed< dTdej d ej e
|
ej ej ej e
|
ej ej e
|
ej f ej e ej e eej e ej e ej e ej eje
|
ej eje
|
ge
|
f ej e ej e dddd Zeje
|
ej f d
|
d d Zd d
|
d dZej eje ej e ej e ddddZedUeejd dddZeeje
|
ej f d
|
ddZ ed
|
ddZ ej e e ddd Z ejd ej f ejd ej f d d d Z!dd
|
d!d"Z"ee
|
d
|
d#d$Z#d d
|
d%d&Z$eje ej e d'd(d)Z%eje e d'd*d+Z&ej'dVe
|
d,ej ej d-d.d/Z(ej'dWe
|
d0ej ej)ej ejg ej f f d-d1d/Z(dXe
|
eej ej d-d2d/Z(e
|
d3d4d5d6Z*d3d
|
d7d8Z+dYe d3d:d;d<Z,e
|
d
|
d=d>Z-e
|
d
|
d?d@Z.dd dAdBdCZ/ej'dDej ej e dEdFdGZ0ej'dej ej ej dEdHdGZ0ej)dI ej ej ej)ej e f dEdJdGZ0dej ej ej dKdLdMZ1e
|
e2ddNdOdPZ3e
|
ej e2 dQdRdSZ4dS )Zr+ að The context is a special internal object that holds state relevant
|
for the script execution at every single level. It's normally invisible
|
to commands unless they opt-in to getting access to it.
|
|
The context is useful as it can pass internal objects around and can
|
control special execution features such as reading data from
|
environment variables.
|
|
A context can be used as context manager in which case it will call
|
:meth:`close` on teardown.
|
|
:param command: the command class for this context.
|
:param parent: the parent context.
|
:param info_name: the info name for this invocation. Generally this
|
is the most descriptive name for the script or
|
command. For the toplevel script it is usually
|
the name of the script, for commands below it it's
|
the name of the script.
|
:param obj: an arbitrary object of user data.
|
:param auto_envvar_prefix: the prefix to use for automatic environment
|
variables. If this is `None` then reading
|
from environment variables is disabled. This
|
does not affect manually set environment
|
variables which are always read.
|
:param default_map: a dictionary (like object) with default values
|
for parameters.
|
:param terminal_width: the width of the terminal. The default is
|
inherit from parent context. If no context
|
defines the terminal width then auto
|
detection will be applied.
|
:param max_content_width: the maximum width for content rendered by
|
Click (this currently only affects help
|
pages). This defaults to 80 characters if
|
not overridden. In other words: even if the
|
terminal is larger than that, Click will not
|
format things wider than 80 characters by
|
default. In addition to that, formatters might
|
add some safety mapping on the right.
|
:param resilient_parsing: if this flag is enabled then Click will
|
parse without any interactivity or callback
|
invocation. Default values will also be
|
ignored. This is useful for implementing
|
things such as completion support.
|
:param allow_extra_args: if this is set to `True` then extra arguments
|
at the end will not raise an error and will be
|
kept on the context. The default is to inherit
|
from the command.
|
:param allow_interspersed_args: if this is set to `False` then options
|
and arguments cannot be mixed. The
|
default is to inherit from the command.
|
:param ignore_unknown_options: instructs click to ignore options it does
|
not know and keeps them for later
|
processing.
|
:param help_option_names: optionally a list of strings that define how
|
the default help parameter is named. The
|
default is ``['--help']``.
|
:param token_normalize_func: an optional function that is used to
|
normalize tokens (options, choices,
|
etc.). This for instance can be used to
|
implement case insensitive behavior.
|
:param color: controls if the terminal supports ANSI colors or not. The
|
default is autodetection. This is only needed if ANSI
|
codes are used in texts that Click prints which is by
|
default not the case. This for instance would affect
|
help output.
|
:param show_default: Show the default value for commands. If this
|
value is not set, it defaults to the value from the parent
|
context. ``Command.show_default`` overrides this default for the
|
specific command.
|
|
.. versionchanged:: 8.1
|
The ``show_default`` parameter is overridden by
|
``Command.show_default``, instead of the other way around.
|
|
.. versionchanged:: 8.0
|
The ``show_default`` parameter defaults to the value from the
|
parent context.
|
|
.. versionchanged:: 7.1
|
Added the ``show_default`` parameter.
|
|
.. versionchanged:: 4.0
|
Added the ``color``, ``ignore_unknown_options``, and
|
``max_content_width`` parameters.
|
|
.. versionchanged:: 3.0
|
Added the ``allow_extra_args`` and ``allow_interspersed_args``
|
parameters.
|
|
.. versionchanged:: 2.0
|
Added the ``resilient_parsing``, ``help_option_names``, and
|
``token_normalize_func`` parameters.
|
r Úformatter_classNFr, )r4 ÚparentÚ info_nameÚobjÚauto_envvar_prefixÚ default_mapÚterminal_widthÚmax_content_widthÚresilient_parsingÚallow_extra_argsÚallow_interspersed_argsÚignore_unknown_optionsÚhelp_option_namesÚtoken_normalize_funcÚcolorÚ show_defaultr0 c C s( || _ || _|| _i | _g | _g | _|r2t|jnt | _|d krP|d k rP|j}|| _t |di | _
|
|d kr|d k r|d k r|j d k r|j |¡}|| _ d | _ |d kr´|d k r´|j}|| _|d krÐ|d k rÐ|j}|| _|
|
d krä|j}
|
|
|
| _| d krø|j} | | _| d kr|j} | | _| d kr6|d k r0|j} ndg} | | _|d krV|d k rV|j}|| _| | _|d kr¦|d k r®|jd k r®| jd k r®|j d| j ¡ }n| ¡ }|d k rÄ| dd¡}|| _|d krä|d k rä|j}|| _|d kr|d k r|j}|| _g | _d| _ i | _ t | _ d S )NÚmetaz--helpÚ_ú-r ) rp r4 rq ÚparamsÚargsÚprotected_argsÚsetÚ _opt_prefixesrr ÚgetattrÚ_metart ÚgetÚinvoked_subcommandru rv rx ry rz r{ r| rw rs ÚupperÚreplacer} r~ Z_close_callbacksÚ_depthÚ_parameter_sourcer Ú _exit_stack)Úselfr4 rp rq rr rs rt ru rv rw rx ry rz r{ r| r} r~ r: r: r; Ú__init__ s ÿþýü
|
|
|
|
þ
|
ÿþýÿ
|
zContext.__init__©r0 c C s$ | j | ¡| j| j| j| j| jdS )a* Gather information that could be useful for a tool generating
|
user-facing documentation. This traverses the entire CLI
|
structure.
|
|
.. code-block:: python
|
|
with Context(cli) as ctx:
|
info = ctx.to_info_dict()
|
|
.. versionadded:: 8.0
|
)r4 rq rx ry rz rs )r4 Ú to_info_dictrq rx ry rz rs ©r r: r: r; r ° s
|
úzContext.to_info_dictc C s | j d7 _ t| | S ©Nr
|
)r r r r: r: r; Ú __enter__Å s zContext.__enter__)Úexc_typeÚ exc_valueÚtbr0 c C s* | j d8 _ | j dkr | ¡ t d S ©Nr
|
r )r Úcloser )r r r r r: r: r; Ú__exit__Ê s
|
zContext.__exit__T)Úcleanupr0 c c sF |s| j d7 _ z| }|V W 5 Q R X W 5 |s@| j d8 _ X dS )aI This helper method can be used with the context object to promote
|
it to the current thread local (see :func:`get_current_context`).
|
The default behavior of this is to invoke the cleanup functions which
|
can be disabled by setting `cleanup` to `False`. The cleanup
|
functions are typically used for things such as closing file handles.
|
|
If the cleanup is intended the context object can also be directly
|
used as a context manager.
|
|
Example usage::
|
|
with ctx.scope():
|
assert get_current_context() is ctx
|
|
This is equivalent::
|
|
with ctx:
|
assert get_current_context() is ctx
|
|
.. versionadded:: 5.0
|
|
:param cleanup: controls if the cleanup functions should be run or
|
not. The default is to run these functions. In
|
some situations the context only wants to be
|
temporarily pushed in which case this can be disabled.
|
Nested pushes automatically defer the cleanup.
|
r
|
N)r )r r Úrvr: r: r; ÚscopeÕ s z Context.scopec C s | j S )a This is a dictionary which is shared with all the contexts
|
that are nested. It exists so that click utilities can store some
|
state here if they need to. It is however the responsibility of
|
that code to manage this dictionary well.
|
|
The keys are supposed to be unique dotted strings. For instance
|
module paths are a good choice for it. What is stored in there is
|
irrelevant for the operation of click. However what is important is
|
that code that places data here adheres to the general semantics of
|
the system.
|
|
Example usage::
|
|
LANG_KEY = f'{__name__}.lang'
|
|
def set_language(value):
|
ctx = get_current_context()
|
ctx.meta[LANG_KEY] = value
|
|
def get_language():
|
return get_current_context().meta.get(LANG_KEY, 'en_US')
|
|
.. versionadded:: 5.0
|
)r r r: r: r; r û s z Context.metac C s | j | j| jdS )a= Creates the :class:`~click.HelpFormatter` for the help and
|
usage output.
|
|
To quickly customize the formatter class used without overriding
|
this method, set the :attr:`formatter_class` attribute.
|
|
.. versionchanged:: 8.0
|
Added the :attr:`formatter_class` attribute.
|
)ÚwidthÚ max_width)ro ru rv r r: r: r; Úmake_formatter s
|
ÿzContext.make_formatter)Úcontext_managerr0 c C s | j |¡S )aÙ Register a resource as if it were used in a ``with``
|
statement. The resource will be cleaned up when the context is
|
popped.
|
|
Uses :meth:`contextlib.ExitStack.enter_context`. It calls the
|
resource's ``__enter__()`` method and returns the result. When
|
the context is popped, it closes the stack, which calls the
|
resource's ``__exit__()`` method.
|
|
To register a cleanup function for something that isn't a
|
context manager, use :meth:`call_on_close`. Or use something
|
from :mod:`contextlib` to turn it into a context manager first.
|
|
.. code-block:: python
|
|
@click.group()
|
@click.option("--name")
|
@click.pass_context
|
def cli(ctx):
|
ctx.obj = ctx.with_resource(connect_db(name))
|
|
:param context_manager: The context manager to enter.
|
:return: Whatever ``context_manager.__enter__()`` returns.
|
|
.. versionadded:: 8.0
|
)r Ú enter_context)r r£ r: r: r; Ú with_resource% s zContext.with_resource.©Úfr0 c C s | j |¡S )a
Register a function to be called when the context tears down.
|
|
This can be used to close resources opened during the script
|
execution. Resources that support Python's context manager
|
protocol which would be used in a ``with`` statement should be
|
registered with :meth:`with_resource` instead.
|
|
:param f: The function to execute on teardown.
|
)r Úcallback)r r§ r: r: r; Ú call_on_closeB s
|
zContext.call_on_closec C s | j ¡ t | _ dS )zInvoke all close callbacks registered with
|
:meth:`call_on_close`, and exit all context managers entered
|
with :meth:`with_resource`.
|
N)r r r r r: r: r; r N s
|
z Context.closec C sv d}| j dk r| j }| jdk rn| jjg}t| jjtrZ| jj | ¡D ]}| | | ¡¡ qDd |¡ d| }|
|
¡ S )zÏThe computed command path. This is used for the ``usage``
|
information on the help page. It's automatically created by
|
combining the info names of the chain of contexts to the root.
|
Ú Nú ) rq rp Ú command_pathrB r4 r, Ú
|
get_paramsÚextendÚget_usage_piecesÚjoinÚlstrip)r r Zparent_command_pathrP r: r: r; r¬ W s
|
|
|
zContext.command_pathc C s | }|j dk r|j }q|S )z Finds the outermost context.N©rp )r Únoder: r: r; Ú find_rootj s
|
zContext.find_root)Ú object_typer0 c C s* | }|dk r&t |j|r |jS |j}qdS )z)Finds the closest object of a given type.N)rB rr rp )r rµ r³ r: r: r; Ú find_objectq s zContext.find_objectc C s" | |¡}|dkr | | _}|S )zLike :meth:`find_object` but sets the innermost object to a
|
new instance of `object_type` if it does not exist.
|
N)r¶ rr )r rµ r r: r: r; Ú ensure_object} s
|
zContext.ensure_objectúte.Literal[True])r9 Úcallr0 c C s d S rJ r: ©r r9 r¹ r: r: r; Úlookup_default s zContext.lookup_defaultzte.Literal[False]c C s d S rJ r: rº r: r: r; r» s c C s0 | j dk r,| j |¡}|r(t|r(| S |S dS )a* Get the default for a parameter from :attr:`default_map`.
|
|
:param name: Name of the parameter.
|
:param call: If the default is a callable, call it. Disable to
|
return the callable instead.
|
|
.. versionchanged:: 8.0
|
Added the ``call`` parameter.
|
N)rt r Úcallable)r r9 r¹ Úvaluer: r: r; r» s
|
|
ú te.NoReturn)Úmessager0 c C s t || dS )zAborts the execution of the program with a specific error
|
message.
|
|
:param message: the error message to fail with.
|
Nr )r r¿ r: r: r; Úfail¦ s z Context.failc C s
|
t dS )zAborts the script.Nr r r: r: r; Úabort® s z Context.abortr )Úcoder0 c C s t |dS )z-Exits the application with a given exit code.Nr )r r r: r: r; Úexit² s z Context.exitc C s | j | ¡S )zaHelper method to get formatted usage string for the current
|
context and command.
|
)r4 Ú get_usager r: r: r; rÄ ¶ s zContext.get_usagec C s | j | ¡S )z^Helper method to get formatted help page for the current
|
context and command.
|
)r4 Úget_helpr r: r: r; rÅ ¼ s zContext.get_help)r4 r0 c C s t | ||j| dS )zvCreate a new context of the same type as this context, but
|
for a new command.
|
|
:meta private:
|
©rq rp )rD r9 )r r4 r: r: r; Ú_make_sub_context s zContext._make_sub_contextút.Callable[..., V])Ú_Context__callbackr Úkwargsr0 c O s d S rJ r: ©Ú_Context__selfrÉ r rÊ r: r: r; ÚinvokeÊ s zContext.invokec O s d S rJ r: rË r: r: r; rÍ Ó s )r, rÈ c O sÆ t |tr||}|jdkr"tdnt d|j¡}| |¡}|jD ],}|j|kr@|j r@|
|
|| |¡¡||j< q@|j |¡ n| }t | 4 |$ |||W 5 Q R £ W 5 Q R £ S Q R X W 5 Q R X dS )aÐ Invokes a command callback in exactly the way it expects. There
|
are two ways to invoke this method:
|
|
1. the first argument can be a callback and all other arguments and
|
keyword arguments are forwarded directly to the function.
|
2. the first argument is a click command object. In that case all
|
arguments are forwarded as well but proper click parameters
|
(options and click arguments) must be keyword arguments and Click
|
will fill in defaults.
|
|
Note that before Click 3.2 keyword arguments were not properly filled
|
in against the intention of this code and no context was created. For
|
more information about this change and why it was done in a bugfix
|
release see :ref:`upgrade-to-3.2`.
|
|
.. versionchanged:: 8.0
|
All ``kwargs`` are tracked in :attr:`params` so they will be
|
passed if :meth:`forward` is called at multiple levels.
|
Nz?The given command does not have a callback that can be invoked.rÈ )rB r, r¨ Ú TypeErrorr1 r2 rÇ r r9 Ú expose_valueÚtype_cast_valueÚ get_defaultÚupdaterR )rÌ rÉ r rÊ Z other_cmdr. rP r: r: r; rÍ Ü s&
|
|
ÿ
|
|
ÿ
|
)Ú _Context__cmdr rÊ r0 c O sF t |tstd| jD ]}||kr| j| ||< q| j|f||S )az Similar to :meth:`invoke` but fills in default keyword
|
arguments from the current context if the other command expects
|
it. This cannot invoke callbacks directly, only other commands.
|
|
.. versionchanged:: 8.0
|
All ``kwargs`` are tracked in :attr:`params` so they will be
|
passed if ``forward`` is called at multiple levels.
|
zCallback is not a command.)rB r, rÎ r rÍ )rÌ rÓ r rÊ rP r: r: r; Úforward s
|
|
zContext.forward)r9 Úsourcer0 c C s || j |< dS )zùSet the source of a parameter. This indicates the location
|
from which the value of the parameter was obtained.
|
|
:param name: The name of the parameter.
|
:param source: A member of :class:`~click.core.ParameterSource`.
|
N)r )r r9 rÕ r: r: r; Úset_parameter_source& s z Context.set_parameter_source)r9 r0 c C s | j |¡S )aX Get the source of a parameter. This indicates the location
|
from which the value of the parameter was obtained.
|
|
This can be useful for determining when a user specified a value
|
on the command line that is the same as the default value. It
|
will be :attr:`~click.core.ParameterSource.DEFAULT` only if the
|
value was actually taken from the default.
|
|
:param name: The name of the parameter.
|
:rtype: ParameterSource
|
|
.. versionchanged:: 8.0
|
Returns ``None`` if the parameter was not provided from any
|
source.
|
)r r )r r9 r: r: r; Úget_parameter_source/ s z Context.get_parameter_source)NNNNNNNFNNNNNNN)T)T).)T)r )5rE re rf rg r ro r1 ÚTypeÚ__annotations__ÚOptionalÚstrÚAnyÚMutableMappingÚintra ÚListÚCallabler ÚDictr r Ú BaseExceptionr r r ÚIteratorr Úpropertyr r¢ ÚContextManagerr* r¥ r© r r¬ r´ r¶ r· Úoverloadr» ÚUnionrÀ rÁ rà rÄ rÅ rÇ rÍ rÔ rd rÖ r× r: r: r: r; r+ sÌ
|
a ï
|
î -û % ( ÿ
|
þ ÿ þ ûû
|
û 6 þ c @ s e Zd ZU dZeZeje ed< dZ dZ
|
dZ d.ej e ej eje ejf ddddZeeje ejf d d
|
d Ze d d dZee d ddZee d ddZd/ej e eje ej e ejedddZeeje eje dddZeejd ddZee ejd d d d Zejd0ej ej e ej e ej e d ejd d!d"d#Z ejd1ej ej e ej e ej e e ejejd!d%d#Z d2ej ej e ej e ej e e e ejejd&d'd#Z d3eje ejf e ej e dd(d)d*Z ejejejd+d,d-Z dS )4Ú BaseCommanda¡ The base command implements the minimal API contract of commands.
|
Most code will never use this as it does not implement a lot of useful
|
functionality but it can act as the direct subclass of alternative
|
parsing methods that do not depend on the Click parser.
|
|
For instance, this can be used to bridge Click and other systems like
|
argparse or docopt.
|
|
Because base commands do not implement a lot of the API that other
|
parts of Click take for granted, they are not supported for all
|
operations. For instance, they cannot be used with the decorators
|
usually and they have no built-in callback system.
|
|
.. versionchanged:: 2.0
|
Added the `context_settings` parameter.
|
|
:param name: the name of the command to use unless a group overrides it.
|
:param context_settings: an optional dictionary with defaults that are
|
passed to the context object.
|
Ú context_classFTN)r9 Úcontext_settingsr0 c C s || _ |d kri }|| _d S rJ )r9 rê )r r9 rê r: r: r; r c s zBaseCommand.__init__©r. r0 c C s
|
d| j iS )ai Gather information that could be useful for a tool generating
|
user-facing documentation. This traverses the entire structure
|
below this command.
|
|
Use :meth:`click.Context.to_info_dict` to traverse the entire
|
CLI structure.
|
|
:param ctx: A :class:`Context` representing this command.
|
|
.. versionadded:: 8.0
|
r9 ©r9 ©r r. r: r: r; r t s zBaseCommand.to_info_dictr c C s d| j j d| j dS ©Nú<r« ú>©Ú __class__rE r9 r r: r: r; Ú__repr__ s zBaseCommand.__repr__c C s t dd S )Nz Base commands cannot get usage©ÚNotImplementedErrorrí r: r: r; rÄ
s zBaseCommand.get_usagec C s t dd S )Nz Base commands cannot get helprô rí r: r: r; rÅ s zBaseCommand.get_help)rq r rp Úextrar0 c K sd | j ¡ D ]\}}||kr
|
|||< q
|
| j| f||d|}|jdd | ||¡ W 5 Q R X |S )aÞ This function when given an info name and arguments will kick
|
off the parsing and create a new :class:`Context`. It does not
|
invoke the actual command callback though.
|
|
To quickly customize the context class used without overriding
|
this method, set the :attr:`context_class` attribute.
|
|
:param info_name: the info name for this invocation. Generally this
|
is the most descriptive name for the script or
|
command. For the toplevel script it's usually
|
the name of the script, for commands below it's
|
the name of the command.
|
:param args: the arguments to parse as list of strings.
|
:param parent: the parent context if available.
|
:param extra: extra keyword arguments forwarded to the context
|
constructor.
|
|
.. versionchanged:: 8.0
|
Added the :attr:`context_class` attribute.
|
rÆ F©r )rê Úitemsré r Ú
|
parse_args)r rq r rp rö r_ r½ r. r: r: r; Ú make_context s
|
ÿ ÿÿzBaseCommand.make_context©r. r r0 c C s t ddS )zÑGiven a context and a list of arguments this creates the parser
|
and parses the arguments, then modifies the context as necessary.
|
This is automatically invoked by :meth:`make_context`.
|
z1Base commands do not know how to parse arguments.Nrô )r r. r r: r: r; rù ² s zBaseCommand.parse_argsc C s t ddS )z{Given a context, this invokes the command. The default
|
implementation is raising a not implemented error.
|
z*Base commands are not invocable by defaultNrô rí r: r: r; rÍ ¹ s zBaseCommand.invoker' r- c sZ ddl m g }jdk rVjtjtrjjr| fddt|D ¡ q|S )a× Return a list of completions for the incomplete value. Looks
|
at the names of chained multi-commands.
|
|
Any command could be part of a chained multi-command, so sibling
|
commands are valid at any point during command completion. Other
|
command classes will return more completions.
|
|
:param ctx: Invocation context for this command.
|
:param incomplete: Value being completed. May be empty.
|
|
.. versionadded:: 8.0
|
r r& Nc 3 s, | ]$\}}|j kr || ¡ d V qdS ©©ÚhelpN)r Úget_short_help_str©Ú.0r9 r4 ©r' r. r: r; Ú <genexpr>Ô s
|
þz-BaseCommand.shell_complete.<locals>.<genexpr>) Úclick.shell_completionr' rp rB r4 r3 rA r® r< ©r r. r/ Úresultsr: r r; Úshell_complete¿ s
|
þ
|
zBaseCommand.shell_completer¸ r¾ )r Ú prog_nameÚ complete_varÚstandalone_moderö r0 c K s d S rJ r: ©r r r r r
|
rö r: r: r; ÚmainÜ s zBaseCommand.main.c K s d S rJ r: r r: r: r; r ç s )r r r r
|
Úwindows_expand_argsrö r0 c
|
|
K s |dkr.t jdd
}tjdkr6|r6t|}nt|}|dkrDt }| |||¡ z0zJ| j||f|0}| |¡}|s|W 5 Q R £ W W S |
|
¡ W 5 Q R X W nà t t fk
|
rÚ } zt t jd t | W 5 d} ~ X Y n¨ tk
|
r } z |sò | ¡ t
|
| j¡ W 5 d} ~ X Y nl tk
|
r } zL| jtjkrnt tjtt j¡t _t tjtt j¡t _t
|
d¡ n W 5 d} ~ X Y nX W n~ tk
|
rÊ } z&|r¬t
|
| j¡ n| j W Y ¢S W 5 d} ~ X Y n: tk
|
r |sâ t t dt jd t
|
d¡ Y nX dS )aÛ This is the way to invoke a script with all the bells and
|
whistles as a command line application. This will always terminate
|
the application after a call. If this is not wanted, ``SystemExit``
|
needs to be caught.
|
|
This method is also available by directly calling the instance of
|
a :class:`Command`.
|
|
:param args: the arguments that should be used for parsing. If not
|
provided, ``sys.argv[1:]`` is used.
|
:param prog_name: the program name that should be used. By default
|
the program name is constructed by taking the file
|
name from ``sys.argv[0]``.
|
:param complete_var: the environment variable that controls the
|
bash completion support. The default is
|
``"_<prog_name>_COMPLETE"`` with prog_name in
|
uppercase.
|
:param standalone_mode: the default behavior is to invoke the script
|
in standalone mode. Click will then
|
handle exceptions and convert them into
|
error messages and the function will never
|
return but shut down the interpreter. If
|
this is set to `False` they will be
|
propagated to the caller and the return
|
value of this function is the return value
|
of :meth:`invoke`.
|
:param windows_expand_args: Expand glob patterns, user dir, and
|
env vars in command line args on Windows.
|
:param extra: extra keyword arguments are forwarded to the context
|
constructor. See :class:`Context` for more information.
|
|
.. versionchanged:: 8.0.1
|
Added the ``windows_expand_args`` parameter to allow
|
disabling command line arg expansion on Windows.
|
|
.. versionchanged:: 8.0
|
When taking arguments from ``sys.argv`` on Windows, glob
|
patterns, user dir, and env vars are expanded.
|
|
.. versionchanged:: 3.0
|
Added the ``standalone_mode`` parameter.
|
Nr
|
Únt)ÚfilezAborted!) ÚsysÚargvÚosr9 r! rK r Ú_main_shell_completionrú rÍ rà ÚEOFErrorÚKeyboardInterruptr" Ústderrr r ÚshowZ exit_codeÚOSErrorÚerrnoÚEPIPEr1 r2 ÚTextIOr% Ústdoutr r )
|
r r r r r
|
r rö r. r rQ r: r: r; r ò sL 3
|
|
|
)Úctx_argsr r r0 c C sj |dkr,| dd¡ dd¡}d| d ¡ }tj |¡}|s@dS ddlm} || ||||}t |¡ dS )aø Check if the shell is asking for tab completion, process
|
that, then exit early. Called from :meth:`main` before the
|
program is invoked.
|
|
:param prog_name: Name of the executable in the shell.
|
:param complete_var: Name of the environment variable that holds
|
the completion instruction. Defaults to
|
``_{PROG_NAME}_COMPLETE``.
|
|
.. versionchanged:: 8.2.0
|
Dots (``.``) in ``prog_name`` are replaced with underscores (``_``).
|
Nr r Ú.Z _COMPLETEr
|
)r ) r r r Úenvironr Úshell_completionr r rà )r r r r Z complete_nameZ instructionr r r: r: r; r c s z"BaseCommand._main_shell_completion©r rÊ r0 c O s | j ||S )zAlias for :meth:`main`.)r ©r r rÊ r: r: r; Ú__call__ s zBaseCommand.__call__)N)N)NNNT)NNN.)NNNTT)N)!rE re rf rg r+ ré r1 rØ rÙ rx ry rz rÚ rÛ rÝ rÜ r rá r ró rÄ rÅ rß rú rù rÍ r ræ ÚSequencer ra r r# r: r: r: r; rè B s
|
ýü üú ' ûù
|
ûù úø u üû rè c sî e Zd ZdZd5eje ejejeejf ejej dejf ejej
|
d eje eje eje eje e e e e dd fd d
|
Z e ejeejf d fd d Ze ed ddZe ej
|
d d ddZe eddddZe ej
|
e d ddZe ej
|
e d ddZe ejd d ddZe ed d d Ze ed d d Zd6eed!d"d#Ze eddd$d%Z e eddd&d'Z e eddd(d)Z e eddd*d+Z e ej
|
e ej
|
e d,d-d.Z e ejd d/d0Z!e eej
|
d1 d2 fd3d4 Z" Z#S )7r, aî Commands are the basic building block of command line interfaces in
|
Click. A basic command handles command line parsing and might dispatch
|
more parsing to commands nested below it.
|
|
:param name: the name of the command to use unless a group overrides it.
|
:param context_settings: an optional dictionary with defaults that are
|
passed to the context object.
|
:param callback: the callback to invoke. This is optional.
|
:param params: the parameters to register with this command. This can
|
be either :class:`Option` or :class:`Argument` objects.
|
:param help: the help string to use for this command.
|
:param epilog: like the help string but it's printed at the end of the
|
help page after everything else.
|
:param short_help: the short help to use for this command. This is
|
shown on the command listing of the parent command.
|
:param add_help_option: by default each command registers a ``--help``
|
option. This can be disabled by this parameter.
|
:param no_args_is_help: this controls what happens if no arguments are
|
provided. This option is disabled by default.
|
If enabled this will add ``--help`` as argument
|
if no arguments are passed
|
:param hidden: hide this command from help outputs.
|
|
:param deprecated: issues a message indicating that
|
the command is deprecated.
|
|
.. versionchanged:: 8.1
|
``help``, ``epilog``, and ``short_help`` are stored unprocessed,
|
all formatting is done when outputting help text, not at init,
|
and is done even if not using the ``@command`` decorator.
|
|
.. versionchanged:: 8.0
|
Added a ``repr`` showing the command name.
|
|
.. versionchanged:: 7.1
|
Added the ``no_args_is_help`` parameter.
|
|
.. versionchanged:: 2.0
|
Added the ``context_settings`` parameter.
|
Nú [OPTIONS]TF.rO ) r9 rê r¨ r rþ ÚepilogÚ
|
short_helpÚoptions_metavarÚadd_help_optionÚno_args_is_helpr8 Ú
|
deprecatedr0 c sR t ||¡ || _|pg | _|| _|| _|| _|| _| | _|
|
| _ | | _
|
| | _ d S rJ ) Úsuperr r¨ r rþ r& r( r' r) r* r8 r+ ) r r9 rê r¨ r rþ r& r' r( r) r* r8 r+ ©rò r: r; r ² s
|
zCommand.__init__rë c s@ t |¡}|jdd | |¡D | j| j| j| j| jd |S )Nc S s g | ] }| ¡ qS r: )r )r rP r: r: r; Ú
|
<listcomp>Õ s z(Command.to_info_dict.<locals>.<listcomp>)r rþ r& r' r8 r+ ) r, r rÒ r rþ r& r' r8 r+ )r r. Ú info_dictr- r: r; r Ò s úzCommand.to_info_dictc C s" | ¡ }| ||¡ | ¡ d¡S )zmFormats the usage line into a string and returns it.
|
|
Calls :meth:`format_usage` internally.
|
Ú
|
)r¢ Ú format_usageÚgetvalueÚrstrip©r r. Ú formatterr: r: r; rÄ Þ s zCommand.get_usagec C s& | j }| |¡}|d k r"||f}|S rJ )r Úget_help_option)r r. r Ú help_optionr: r: r; r ç s
|
|
|
zCommand.get_params©r. r5 r0 c C s" | |¡}| |jd |¡¡ dS )zsWrites the usage line into the formatter.
|
|
This is a low-level method called by :meth:`get_usage`.
|
r« N)Úcollect_usage_piecesZ write_usager¬ r° )r r. r5 Úpiecesr: r: r; r1 ð s
|
zCommand.format_usagec C s6 | j r| j gng }| |¡D ]}| | |¡¡ q |S )zhReturns all the pieces that go into the usage line and returns
|
it as a list of strings.
|
)r( r r® r¯ )r r. r rP r: r: r; r9 ø s z Command.collect_usage_piecesc C s6 t |j}| jD ] }| |j¡ | |j¡ qt|S )z&Returns the names for the help option.)r
r{ r Údifference_updateÚoptsÚsecondary_optsrK )r r. Z all_namesrP r: r: r; Úget_help_option_names s
|
|
|
z Command.get_help_option_namesÚOptionc C sD | |¡}|r| jsdS tdtdddd}t|ddd|tdd S )
|
z Returns the help option object.NrO )r. rP r½ r0 c S s( |r$| j s$t| ¡ | jd | ¡ d S )N©r} )rw r" rÅ r} rà )r. rP r½ r: r: r; Ú show_help s
|
z*Command.get_help_option.<locals>.show_helpTFzShow this message and exit.)Úis_flagrZ rÏ r¨ rþ )r> r) r+ rÛ r? r )r r. Ú help_optionsrA r: r: r; r6 s
|
|
úzCommand.get_help_optionc C s( t |}| |¡D ]}| ||¡ q|S )z6Creates the underlying option parser for this command.)r r Ú add_to_parser)r r. ÚparserrP r: r: r; Ú make_parser s zCommand.make_parserc C s" | ¡ }| ||¡ | ¡ d¡S )zfFormats the help into a string and returns it.
|
|
Calls :meth:`format_help` internally.
|
r0 )r¢ Ú format_helpr2 r3 r4 r: r: r; rÅ ' s zCommand.get_helpé- )Úlimitr0 c C sJ | j rt | j ¡}n| jr(t| j|}nd}| jrBtdj|d}| ¡ S )z`Gets short help for the command or makes it by shortening the
|
long help string.
|
rª ú(Deprecated) {text}©Útext) r' ÚinspectÚcleandocrþ r# r+ r ÚformatÚstrip)r rI rL r: r: r; rÿ 0 s zCommand.get_short_help_strc C s4 | ||¡ | ||¡ | ||¡ | ||¡ dS )a0 Writes the help into the formatter if it exists.
|
|
This is a low-level method called by :meth:`get_help`.
|
|
This calls the following methods:
|
|
- :meth:`format_usage`
|
- :meth:`format_help_text`
|
- :meth:`format_options`
|
- :meth:`format_epilog`
|
N)r1 Úformat_help_textÚformat_optionsÚ format_epilogr4 r: r: r; rG @ s zCommand.format_helpc C sj | j dk r"t | j ¡ d¡d }nd}| jr<tdj|d}|rf| ¡ | ¡ | |¡ W 5 Q R X dS )z3Writes the help text to the formatter if it exists.Nú r rª rJ rK )
|
rþ rM rN Ú partitionr+ r rO Úwrite_paragraphÚ indentationÚ
|
write_text)r r. r5 rL r: r: r; rQ Q s
|
|
zCommand.format_help_textc C s\ g }| |¡D ] }| |¡}|dk r| |¡ q|rX| td¡ | |¡ W 5 Q R X dS )z8Writes all the options into the formatter if they exist.NÚOptions)r Úget_help_recordÚappendÚsectionr Úwrite_dl)r r. r5 r< rP r r: r: r; rR b s
|
zCommand.format_optionsc C s< | j r8t | j ¡}| ¡ | ¡ | |¡ W 5 Q R X dS )z2Writes the epilog into the formatter if it exists.N)r& rM rN rV rW rX )r r. r5 r& r: r: r; rS n s
|
|
zCommand.format_epilogrû c C sÀ |s*| j r*|js*t| ¡ |jd | ¡ | |¡}|j|d\}}}t|| |¡D ]}|
|
|||¡\}}qV|r¨|j s¨|js¨| t ddt|jd tt|¡d¡ ||_|j |j¡ |S )Nr@ )r z&Got unexpected extra argument ({args})z'Got unexpected extra arguments ({args})r« )r* rw r" rÅ r} rà rF rù rc r Úhandle_parse_resultrx rÀ r ÚlenrO r° ÚmaprÛ r r rÒ )r r. r rE r< Z param_orderrP r½ r: r: r; rù w s(
|
ýüÿzCommand.parse_argsc C sL | j r,tdj| jd}tt|dddd | jdk rH|j| jf|jS dS )zeGiven a context, this invokes the attached callback (if it exists)
|
in the right way.
|
z7DeprecationWarning: The command {name!r} is deprecated.rì Úred)ZfgT)ÚerrN) r+ r rO r9 r" r r¨ rÍ r )r r. r¿ r: r: r; rÍ s ÿþ
|
zCommand.invoker' r- c s ddl m g }r~d ¡ s~| |¡D ]Rttr*js*jsX| j ¡t
|
j krXq*| fddj jD ¡ q*| t |¡¡ |S )a Return a list of completions for the incomplete value. Looks
|
at the names of options and chained multi-commands.
|
|
:param ctx: Invocation context for this command.
|
:param incomplete: Value being completed. May be empty.
|
|
.. versionadded:: 8.0
|
r r& c 3 s& | ] }| ¡r |jd V qdS rü )r6 rþ )r r9 ©r' r/ rP r: r; r ¶ s
|
þz)Command.shell_complete.<locals>.<genexpr>)r r' Úisalnumr rB r? r8 Úmultipler× r9 rd rj r® r< r= r, r r r- rc r; r s( ÿþü
|
ÿû
|
þ
|
zCommand.shell_complete) NNNNNNr% TFFF)rH )$rE re rf rg r1 rÚ rÛ rÝ rÜ rà rß ra r r+ rá r rÄ r r r1 r9 r> r6 r rF rÅ rÞ rÿ rG rQ rR rS rù rÍ r Ú __classcell__r: r: r- r; r, sX , óò c
|
s e Zd ZdZdZdZd&eje e eje eje e ejej
|
dej f ej dd fdd Z e ejeej f d fd
|
d Ze eje d fd d Ze edd fdd Zd'e ej
|
egef dddZe eddddZe eje eje d fdd Ze ej d fdd Ze eje ejeje eje eje f ddd Ze eeje d d d Z e eje d d d!Z e eejd" d# fd$d% Z Z S )(r3 a¢ A multi command is the basic implementation of a command that
|
dispatches to subcommands. The most common version is the
|
:class:`Group`.
|
|
:param invoke_without_command: this controls how the multi command itself
|
is invoked. By default it's only invoked
|
if a subcommand is provided.
|
:param no_args_is_help: this controls what happens if no arguments are
|
provided. This option is enabled by default if
|
`invoke_without_command` is disabled or disabled
|
if it's enabled. If enabled this will add
|
``--help`` as argument if no arguments are
|
passed.
|
:param subcommand_metavar: the string that is used in the documentation
|
to indicate the subcommand place.
|
:param chain: if this is set to `True` chaining of multiple subcommands
|
is enabled. This restricts the form of commands in that
|
they cannot have optional arguments but it allows
|
multiple commands to be chained together.
|
:param result_callback: The result callback to attach to this multi
|
command. This can be set or changed later with the
|
:meth:`result_callback` decorator.
|
:param attrs: Other command arguments described in :class:`Command`.
|
TFN.)r9 Úinvoke_without_commandr* Úsubcommand_metavarrA Úresult_callbackÚattrsr0 c s t j|f| |d kr | }|| _|| _|d kr@|r<d}nd}|| _|| _|| _| jr|| jD ] }t|t r^|j
|
s^t dq^d S )Nz*COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...zCOMMAND [ARGS]...z<Multi commands in chain mode cannot have optional arguments.) r, r r* rg rh rA Ú_result_callbackr rB ÚArgumentÚrequiredrC ) r r9 rg r* rh rA ri rj rP r- r: r; r Ý s$
|
|
ÿzMultiCommand.__init__rë c
|
sz t |¡}i }| |¡D ]J}| ||¡}|d kr4q| |¡}|jdd | |¡||< W 5 Q R X q|j|| jd |S )NFr÷ )ÚcommandsrA )r, r r5 r7 rÇ r rÒ rA )r r. r/ rn r9 r4 Úsub_ctxr- r: r; r s
|
zMultiCommand.to_info_dictc s t |¡}| | j¡ |S rJ )r, r9 r[ rh ©r r. r r- r: r; r9 s z!MultiCommand.collect_usage_piecesr8 c s t ||¡ | ||¡ d S rJ )r, rR Úformat_commandsr4 r- r: r; rR s zMultiCommand.format_options)r r0 c s t t d fdd }|S )a¶ Adds a result callback to the command. By default if a
|
result callback is already registered this will chain them but
|
this can be disabled with the `replace` parameter. The result
|
callback is invoked with the return value of the subcommand
|
(or the list of return values from all subcommands if chaining
|
is enabled) as well as the parameters as they would be passed
|
to the main callback.
|
|
Example::
|
|
@click.group()
|
@click.option('-i', '--input', default=23)
|
def cli(input):
|
return 42
|
|
@cli.result_callback()
|
def process_result(result, input):
|
return result + input
|
|
:param replace: if set to `True` an already existing result
|
callback will be removed.
|
|
.. versionchanged:: 8.0
|
Renamed from ``resultcallback``.
|
|
.. versionadded:: 3.0
|
r¦ c sF j d ksr _ S fdd}tt t|¡ _ }|S )Nc s | f||} |f||S rJ r: )Z_MultiCommand__valuer rÊ Úinner©r§ Z old_callbackr: r; ÚfunctionB s zAMultiCommand.result_callback.<locals>.decorator.<locals>.function)rk r r1 r2 r( )r§ rt r ©r r rs r; Ú decorator; s z/MultiCommand.result_callback.<locals>.decorator)r( )r r rv r: ru r; ri s z MultiCommand.result_callbackc C sº g }| |¡D ]0}| ||¡}|dkr(q|jr0q| ||f¡ qt|r¶|jd tdd |D }g }|D ] \}}| |¡}| ||f¡ ql|r¶| t d¡ |
|
|¡ W 5 Q R X dS )zeExtra format methods for multi methods that adds all the commands
|
after the options.
|
Né c s s | ]}t |d V qdS )r N©r_ )r r? r: r: r; r \ s z/MultiCommand.format_commands.<locals>.<genexpr>ÚCommands) r5 r7 r8 r[ r_ r Úmaxrÿ r\ r r] ) r r. r5 rn Ú
|
subcommandr? rI Úrowsrþ r: r: r; rq K s"
|
z MultiCommand.format_commandsrû c st |s*| j r*|js*t| ¡ |jd | ¡ t ||¡}| jrL||_ g |_
|
n"|rn|d d
|dd
|_ |_
|
|j
|
S )Nr@ r
|
) r* rw r" rÅ r} rà r, rù rA r r )r r. r Úrestr- r: r; rù g s zMultiCommand.parse_argsc sÚ t jt jd fdd } jsjjr\ , t ¡}|jrDg n|W 5 Q R £ S Q R X td¡ j j }g _ g _js z
|
|¡\}}}|d k s®t | _ t ¡ |j || d}|* ||j |¡W 5 Q R £ W 5 Q R £ S Q R X W 5 Q R X ¾ |r dnd _ t ¡ g }|r
|
|¡\}}}|d k sZt |j || ddd }| |¡ |j g }|_ q4g }|D ](}| | |j |¡¡ W 5 Q R X q||W 5 Q R £ S Q R X d S )
|
N©r½ r0 c s" j d k r jj | f j} | S rJ )rk rÍ r ©r½ ©r. r r: r; Ú_process_resultw s
|
z,MultiCommand.invoke.<locals>._process_resultzMissing command.r² Ú*TF)rp rx ry )r1 rÜ r rg r, rÍ rA rÀ r r Úresolve_commandÚAssertionErrorr rú r4 r[ ) r r. r r r r> r? ro Zcontextsr- r r; rÍ v sP $ 8 û
|
zMultiCommand.invokec C s t |d }|}| ||¡}|d krD|jd k rD| |¡}| ||¡}|d kr|jst|d rl| ||j¡ | tdj |d¡ |r|nd ||dd
fS )Nr zNo such command {name!r}.rì r
|
)
|
r$ r7 r| rw r rù r rÀ r rO )r r. r r> Zoriginal_cmd_namer? r: r: r; r º s
|
z MultiCommand.resolve_command©r. r> r0 c C s t dS )z{Given a context and a command name, this returns a
|
:class:`Command` object if it exists or returns `None`.
|
Nrô ©r r. r> r: r: r; r7 Õ s zMultiCommand.get_commandc C s g S )zTReturns a list of subcommand names in the order they should
|
appear.
|
r: rí r: r: r; r5 Û s zMultiCommand.list_commandsr' r- c s< ddl m fddt||D }| t ||¡¡ |S )a0 Return a list of completions for the incomplete value. Looks
|
at the names of options, subcommands, and chained
|
multi-commands.
|
|
:param ctx: Invocation context for this command.
|
:param incomplete: Value being completed. May be empty.
|
|
.. versionadded:: 8.0
|
r r& c s g | ]\}} || ¡ d qS )rý )rÿ r r& r: r; r. í s ÿz/MultiCommand.shell_complete.<locals>.<listcomp>)r r' r< r® r, r r r- r& r; r á s
|
|
þzMultiCommand.shell_complete)NFNNFN)F) rE re rf rg rx ry r1 rÚ rÛ ra rà rÜ r r+ rá r rß r9 r rR r( ri rq rù rÍ r` r, r r7 r5 r rf r: r: r- r; r3 À sB ù÷& - "E þ c sü e Zd ZU dZdZejeje e d< dZ
|
ejej ejd eje f e d< d eje ejej eje ef eje f ejdd fdd Zd eeje ddd d
|
Zejejd ejf ed d dZejejejejejd ejf gef dddZejejej ejejd ejf gef ef dddZejejd ejf d d ddZejejejejejd ejf gd f dddZejejej ejejd ejf gd f d f dddZee eje dddZeeje dddZ ZS ) ÚGroupaM A group allows a command to have subcommands attached. This is
|
the most common way to implement nesting in Click.
|
|
:param name: The name of the group command.
|
:param commands: A dict mapping names to :class:`Command` objects.
|
Can also be a list of :class:`Command`, which will use
|
:attr:`Command.name` to create the dict.
|
:param attrs: Other command arguments described in
|
:class:`MultiCommand`, :class:`Command`, and
|
:class:`BaseCommand`.
|
|
.. versionchanged:: 8.0
|
The ``commands`` argument can be a list of command objects.
|
NÚ command_classÚ group_class)r9 rn rj r0 c sB t j|f| |d kr i }nt|tjr8dd |D }|| _d S )Nc S s i | ]}|j d k r|j |qS rJ rì ©r Úcr: r: r; Ú
|
<dictcomp>& s
|
z"Group.__init__.<locals>.<dictcomp>)r, r rB r r$ rn )r r9 rn rj r- r: r; r s zGroup.__init__)r? r9 r0 c C s8 |p|j }|dkrtdt| ||dd || j|< dS )zRegisters another :class:`Command` with this group. If the name
|
is not provided, the name of the command is used.
|
NzCommand has no name.T)r@ )r9 rÎ rG rn )r r? r9 r: r: r; Ú add_command+ s
|
|
zGroup.add_command.)Ú _Group__funcr0 c C s d S rJ r: ©r r r: r: r; r4 5 s z Group.commandr! c O s d S rJ r: r" r: r: r; r4 9 s c s ddl m d} rBt d rBt dkr0r8td \}d jr` d¡dkr`jd< tjdtj f t
|
d fd
|
d }|dk r||S |S ) a A shortcut decorator for declaring and attaching a command to
|
the group. This takes the same arguments as :func:`command` and
|
immediately registers the created command with this group by
|
calling :meth:`add_command`.
|
|
To customize the command class used, set the
|
:attr:`command_class` attribute.
|
|
.. versionchanged:: 8.1
|
This decorator can be applied without parentheses.
|
|
.. versionchanged:: 8.0
|
Added the :attr:`command_class` attribute.
|
r
|
)r4 Nr z7Use 'command(**kwargs)(callable)' to provide arguments.r: Úcls.r¦ c s | } |¡ |S rJ ©r ©r§ r? ©r r4 rÊ r r: r; rv ^ s
|
z Group.command.<locals>.decorator) Ú
|
decoratorsr4 r¼ r_ r r r r1 rà rÜ r, ©r r rÊ Úfuncrv r: r r; r4 ? s"
|
ÿÿþ
|
&c C s d S rJ r: r r: r: r; Úgrouph s z Group.groupc O s d S rJ r: r" r: r: r; r l s c s¶ ddl m d} rBt d rBt dkr0r8td \}d jdk r| d¡dkr|jtkrrtd< n
|
jd< tj dtj
|
f d d
|
fd d }|dk r²||S |S ) a A shortcut decorator for declaring and attaching a group to
|
the group. This takes the same arguments as :func:`group` and
|
immediately registers the created group with this group by
|
calling :meth:`add_command`.
|
|
To customize the group class used, set the :attr:`group_class`
|
attribute.
|
|
.. versionchanged:: 8.1
|
This decorator can be applied without parentheses.
|
|
.. versionchanged:: 8.0
|
Added the :attr:`group_class` attribute.
|
r
|
)r Nr z5Use 'group(**kwargs)(callable)' to provide arguments.r: r .r r¦ c s | } |¡ |S rJ r r ©r r rÊ r r: r; rv s
|
z Group.group.<locals>.decorator) r r r¼ r_ r r r rD r1 rà rÜ r r: r r; r r s&
|
ÿÿþ
|
|
&r
c C s | j |¡S rJ )rn r r r: r: r; r7 s zGroup.get_commandrë c C s
|
t | jS rJ )rb rn rí r: r: r; r5 ¡ s zGroup.list_commands)NN)N) rE re rf rg r r1 rÚ rØ r, rÙ r rç rD rÛ rÝ r$ rÜ r r ræ rà r4 r r+ r7 rß r5 rf r: r: r- r; r õ sL
|
( û ÿù
|
þ $þ ) þ $þ ,r c s e Zd ZdZdeje ejeje ej dd fdd Z
|
eddddZ e eeje d d
|
d Ze eje d d dZ ZS )ÚCommandCollectionak A command collection is a multi command that merges multiple multi
|
commands together into one. This is a straightforward implementation
|
that accepts a list of different multi commands as sources and
|
provides all the commands for each of them.
|
|
See :class:`MultiCommand` and :class:`Command` for the description of
|
``name`` and ``attrs``.
|
N)r9 Úsourcesrj r0 c s t j|f| |pg | _d S rJ )r, r r )r r9 r rj r- r: r; r ¯ s zCommandCollection.__init__)Ú multi_cmdr0 c C s | j |¡ dS )z1Adds a new multi command to the chain dispatcher.N)r r[ )r r r: r: r; Ú
|
add_source¹ s z CommandCollection.add_sourcer
c C s> | j D ]2}| ||¡}|d k r| jr0t| || | S qd S rJ )r r7 rA rG )r r. r> rÕ r r: r: r; r7 ½ s
|
|
z CommandCollection.get_commandrë c C s* t }| jD ]}| | |¡¡ q t|S rJ )r
r rÒ r5 rb )r r. r rÕ r: r: r; r5 É s
|
z CommandCollection.list_commands)NN)rE re rf rg r1 rÚ rÛ rß r3 rÜ r r r+ r, r7 r5 rf r: r: r- r; r ¥ s ýû
|
r r~ c C s t | trtt| S )ztCheck if the value is iterable but not a string. Raises a type
|
error, or return an iterator over the value.
|
)rB rÛ rÎ rM r r: r: r; Ú _check_iterÒ s
|
r c @ s* e Zd ZdZdZd<ejeje ejej e
|
j ej f e ejej ej ejg ej f f ejejed ej gej f eje e eje e e ejej eeje f ejejed egej ejd eje f f dd dd Zejeej f d
|
d d Zed
|
d dZeje e ejeje eje eje f dddZeed
|
ddZed
|
ddZejd=edejej dddZ ejd>ee ejej ej ejg ej f f dddZ d?ee ejej ej ejg ej f f dd dZ e edd d d Z eej eej f ejej e f d d!d"Z!eej ej d#d$d%Z"ej e d&d'd(Z#eej ej d#d)d*Z$eeje d+d,d-Z%eejej d+d.d/Z&eej eej f eje ejej eje f d0d1d2Z'eejejeef d+d3d4Z(eeje d+d5d6Z)eed+d7d8Z*eeejd d9d:d;Z+dS )@rO a A parameter to a command comes in two versions: they are either
|
:class:`Option`\s or :class:`Argument`\s. Other subclasses are currently
|
not supported by design as some of the internals for parsing are
|
intentionally not finalized.
|
|
Some settings are supported by both options and arguments.
|
|
:param param_decls: the parameter declarations for this option or
|
argument. This is a list of flags or argument
|
names.
|
:param type: the type that should be used. Either a :class:`ParamType`
|
or a Python type. The latter is converted into the former
|
automatically if supported.
|
:param required: controls if this is optional or not.
|
:param default: the default value if omitted. This can also be a callable,
|
in which case it's invoked when the default is needed
|
without any arguments.
|
:param callback: A function to further process or validate the value
|
after type conversion. It is called as ``f(ctx, param, value)``
|
and must return the value. It is called for all sources,
|
including prompts.
|
:param nargs: the number of arguments to match. If not ``1`` the return
|
value is a tuple instead of single value. The default for
|
nargs is ``1`` (except if the type is a tuple, then it's
|
the arity of the tuple). If ``nargs=-1``, all remaining
|
parameters are collected.
|
:param metavar: how the value is represented in the help page.
|
:param expose_value: if this is `True` then the value is passed onwards
|
to the command callback and stored on the context,
|
otherwise it's skipped.
|
:param is_eager: eager values are processed before non eager ones. This
|
should not be set for arguments or it will inverse the
|
order of processing.
|
:param envvar: a string or list of strings that are environment variables
|
that should be checked.
|
:param shell_complete: A function that returns custom shell
|
completions. Used instead of the param's type completion if
|
given. Takes ``ctx, param, incomplete`` and must return a list
|
of :class:`~click.shell_completion.CompletionItem` or a list of
|
strings.
|
|
.. versionchanged:: 8.0
|
``process_value`` validates required parameters and bounded
|
``nargs``, and invokes the parameter callback before returning
|
the value. This allows the callback to validate prompts.
|
``full_process_value`` is removed.
|
|
.. versionchanged:: 8.0
|
``autocompletion`` is renamed to ``shell_complete`` and has new
|
semantics described above. The old name is deprecated and will
|
be removed in 8.1, until then it will be wrapped to match the
|
new requirements.
|
|
.. versionchanged:: 8.0
|
For ``multiple=True, nargs>1``, the default must be a list of
|
tuples.
|
|
.. versionchanged:: 8.0
|
Setting a default is no longer required for ``nargs>1``, it will
|
default to ``None``. ``multiple=True`` or ``nargs=-1`` will
|
default to ``()``.
|
|
.. versionchanged:: 7.1
|
Empty environment variables are ignored rather than taking the
|
empty string value. This makes it possible for scripts to clear
|
variables if they can't unset them.
|
|
.. versionchanged:: 2.0
|
Changed signature for parameter callback to also be passed the
|
parameter. The old callback format will still work, but it will
|
raise a warning to give you a chance to migrate the code easier.
|
Z parameterNFTr' ) Ú param_declsrD rm Údefaultr¨ Únargsre ÚmetavarrÏ rZ Úenvvarr r0 c C s¬ | | | | |pd| ¡\| _| _| _t ||¡| _|d krT| jjrP| jj}nd}|| _ || _
|
|| _ || _ | | _ || _|
|
| _|| _| | _| | _| jjrÆ|| jjkrÆtd| jj d| jd| dt|sÒ|nd } | d k r¨|rztt| d } W n tk
|
r tdd Y nX |dkr¨| d k r¨z t| W n0 tk
|
rj |rXd}nd }t|d Y nX |dkr¨t| |kr¨|rd
|
nd }td | d | dd S )Nr: r
|
z'nargs' must be z (or None) for type z , but it was r z1'default' must be a list when 'multiple' is true.zK'default' must be a list of lists when 'multiple' is true and 'nargs' != 1.z+'default' must be a list when 'nargs' != 1.z item lengthÚlengthz
|
'default' z must match nargs=)Ú _parse_declsr9 r< r= r Ú convert_typerD Ú is_compositeÚarityrm r¨ r re rÏ r rZ r¡ r¢ Ú_custom_shell_completerX r¼ Únextr rÎ r_ )r r rD rm r r¨ r re r¡ rÏ rZ r¢ r Ú check_defaultr¿ Úsubjectr: r: r; r ( sf ÿ
|
ÿ
|
ÿþ ÿÿzParameter.__init__r c C s2 | j | j| j| j| j ¡ | j| j| j| j | j
|
d
|
S )zæGather information that could be useful for a tool generating
|
user-facing documentation.
|
|
Use :meth:`click.Context.to_info_dict` to traverse the entire
|
CLI structure.
|
|
.. versionadded:: 8.0
|
)
|
r9 Úparam_type_namer< r= rD rm r re r r¢ ) r9 r¬ r< r= rD r rm r re r r¢ r r: r: r; r s
|
özParameter.to_info_dictc C s d| j j d| j dS rî rñ r r: r: r; ró s zParameter.__repr__©ÚdeclsrÏ r0 c C s
|
t d S rJ rô )r r® rÏ r: r: r; r¤ s zParameter._parse_declsc C s | j S )zReturns the human readable name of this parameter. This is the
|
same as the name for options, but the metavar for arguments.
|
rì r r: r: r; Úhuman_readable_name s z Parameter.human_readable_namec C sF | j d k r| j S | j | ¡}|d kr0| jj ¡ }| jdkrB|d7 }|S )Nr
|
ú...)r¡ rD Ú get_metavarr9 r r )r r¡ r: r: r; Ú make_metavar¥ s
|
|
zParameter.make_metavarr¸ ©r. r¹ r0 c C s d S rJ r: ©r r. r¹ r: r: r; rÑ ³ s zParameter.get_default.c C s d S rJ r: r´ r: r: r; rÑ ¹ s c C s4 |j | jdd}|dkr | j}|r0t|r0| }|S )aµ Get the default for the parameter. Tries
|
:meth:`Context.lookup_default` first, then the local default.
|
|
:param ctx: Current context.
|
:param call: If the default is a callable, call it. Disable to
|
return the callable instead.
|
|
.. versionchanged:: 8.0.2
|
Type casting is no longer performed when getting a default.
|
|
.. versionchanged:: 8.0.1
|
Type casting can fail in resilient parsing mode. Invalid
|
defaults will not prevent showing help text.
|
|
.. versionchanged:: 8.0
|
Looks at ``ctx.default_map`` first.
|
|
.. versionchanged:: 8.0
|
Added the ``call`` parameter.
|
F©r¹ N)r» r9 r r¼ )r r. r¹ r½ r: r: r; rÑ ¿ s ©rE r. r0 c C s
|
t d S rJ rô ©r rE r. r: r: r; rD à s zParameter.add_to_parser©r. r< r0 c C sd | | j¡}tj}|d kr*| |¡}tj}|d krD| | j¡}tj}|d kr\| |¡}tj }||fS rJ )
|
r r9 rd rj Úvalue_from_envvarrk r» rm rÑ rl ©r r. r< r½ rÕ r: r: r; Ú consume_valueã s
|
|
zParameter.consume_value)r. r½ r0 c sÚ |dkr j sjdkr dS dS tjtjtj dfdd jdksRjjrntjtjdfdd nDjdkrtjtjd fd
|
d n tjtjd fd d j rÒtfd d |D S |S )zuConvert and validate a value against the option's
|
:attr:`type`, :attr:`multiple`, and :attr:`nargs`.
|
Néÿÿÿÿr: r~ c s8 z
|
t | W S tk
|
r2 ttd dd Y nX d S )NzValue must be an iterable.©r. rP )r rÎ r r r r r: r; Ú
|
check_iterþ s
|
ÿþz-Parameter.type_cast_value.<locals>.check_iterr
|
c s j | dS )N)rP r. ©rD r r r: r; Úconvert s z*Parameter.type_cast_value.<locals>.convertc s t fdd | D S )Nc 3 s | ]} | ¡V qd S rJ r¿ ©r Úxr r: r; r s ú=Parameter.type_cast_value.<locals>.convert.<locals>.<genexpr>)Útupler ©r¾ r. r r: r; rÀ s c s\ t | } t| jkrDttddt| jjt| ddt fdd| D S )Nz%Takes {nargs} values but 1 was given.z*Takes {nargs} values but {len} were given.)r r_ r½ c 3 s | ]} | ¡V qd S rJ r¿ rÁ r r: r; r # s rà )rÄ r_ r r r rO r rÅ r: r; rÀ s ý üù
|
c 3 s | ]} |V qd S rJ r: rÁ )rÀ r: r; r & s z,Parameter.type_cast_value.<locals>.<genexpr>)re r r1 rÜ rã rD r¦ rÄ ©r r. r½ r: )r¾ rÀ r. r r; rÐ ÷ s
|
zParameter.type_cast_valuer~ c C s, |d kr dS | j dks | jr(|dkr(dS dS )NTr
|
r: F)r re )r r½ r: r: r; Úvalue_is_missing* s
|
zParameter.value_is_missingc C sD | ||¡}| jr(| |¡r(t|| d| jd k r@| || |¡}|S )Nr½ )rÐ rm rÇ r r¨ rÆ r: r: r; Ú process_value3 s
|
zParameter.process_valuerë c C sZ | j d krd S t| j tr2tj | j ¡}|rV|S n$| j D ] }tj |¡}|r8| S q8d S rJ )r¢ rB rÛ r r r ©r r. r r¢ r: r: r; Úresolve_envvar_value> s
|
|
|
z Parameter.resolve_envvar_valuec C s, | |¡}|d k r(| jdkr(| j |¡}|S r )rÊ r rD Úsplit_envvar_valuerp r: r: r; r¹ P s
|
zParameter.value_from_envvar)r. r< r r0 c C s t || dV | ||¡\}}| | j|¡ z| ||¡}W n tk
|
r\ |jsT d }Y nX W 5 Q R X | jrz||j| j< ||fS )N)rP ) rR r» rÖ r9 rÈ Ú Exceptionrw rÏ r )r r. r< r r½ rÕ r: r: r; r^ X s z Parameter.handle_parse_resultc C s d S rJ r: rí r: r: r; rZ l s zParameter.get_help_recordc C s g S rJ r: rí r: r: r; r¯ o s zParameter.get_usage_piecesc C s" | j p | jg}d dd |D ¡S )z{Get a stringified version of the param for use in error messages to
|
indicate which param caused the error.
|
ú / c s s | ]}d | d V qdS )ú'Nr: rÁ r: r: r; r w s z+Parameter.get_error_hint.<locals>.<genexpr>)r< r¯ r° )r r. Z hint_listr: r: r; Úget_error_hintr s zParameter.get_error_hintr- c sj | j dk rZ| || |¡}|rHt|d trHddlm fdd|D }t tjd |¡S | j || |¡S )a Return a list of completions for the incomplete value. If a
|
``shell_complete`` function was given during init, it is used.
|
Otherwise, the :attr:`type`
|
:meth:`~click.types.ParamType.shell_complete` function is used.
|
|
:param ctx: Invocation context for this command.
|
:param incomplete: Value being completed. May be empty.
|
|
.. versionadded:: 8.0
|
Nr r& c s g | ] } |qS r: r: r r& r: r; r. s z,Parameter.shell_complete.<locals>.<listcomp>r' )
|
r¨ rB rÛ r r' r1 r2 rß rD r r r: r& r; r y s
|
zParameter.shell_complete) NNFNNNFNTFNN)T).)T),rE re rf rg r¬ r1 rÚ r$ rÛ rç r Ú ParamTyperÜ ra rà r+ rÞ rß r rá r ró r` r¤ rä r¯ r² ræ rÑ r rD ÚMappingrd r» rÐ rÇ rÈ rÊ r¹ r^ rZ r¯ rÏ r r: r: r: r; rO Ü s¦ I î ÿÿÿí X þ ÿ
|
þ ÿ þ ÿ þ ! þ 3 þ c s* e Zd ZdZdZd&ejeje ej e
|
edf ej e
|
ef ej e
|
ef e
|
e
|
eje
|
ejej e
|
e
|
e
|
ejej e j ej f eje e
|
e
|
e
|
ej dd fdd Zejeej f d fd
|
d Zeje e
|
ejeje eje eje f d d dZeeddddZeejejeef dddZejd'edejej dddZejd(ee
|
ejej ej ejg ej f f dddZd)ee
|
ejej ej ejg ej f f d fdd Zeej dd d Zeeje d fd d Z eejej dd d!Z eej ed"f ejej e f d# fd$d% Z Z!S )*r? aÖ Options are usually optional values on the command line and
|
have some extra features that arguments don't have.
|
|
All other parameters are passed onwards to the parameter constructor.
|
|
:param show_default: Show the default value for this option in its
|
help text. Values are not shown by default, unless
|
:attr:`Context.show_default` is ``True``. If this value is a
|
string, it shows that string in parentheses instead of the
|
actual value. This is particularly useful for dynamic options.
|
For single option boolean flags, the default remains hidden if
|
its value is ``False``.
|
:param show_envvar: Controls if an environment variable should be
|
shown on the help page. Normally, environment variables are not
|
shown.
|
:param prompt: If set to ``True`` or a non empty string then the
|
user will be prompted for input. If set to ``True`` the prompt
|
will be the option name capitalized.
|
:param confirmation_prompt: Prompt a second time to confirm the
|
value if it was prompted for. Can be set to a string instead of
|
``True`` to customize the message.
|
:param prompt_required: If set to ``False``, the user will be
|
prompted for input only when the option was specified as a flag
|
without a value.
|
:param hide_input: If this is ``True`` then the input on the prompt
|
will be hidden from the user. This is useful for password input.
|
:param is_flag: forces this option to act as a flag. The default is
|
auto detection.
|
:param flag_value: which value should be used for this flag if it's
|
enabled. This is set to a boolean automatically if
|
the option string contains a slash to mark two options.
|
:param multiple: if this is set to `True` then the argument is accepted
|
multiple times and recorded. This is similar to ``nargs``
|
in how it works but supports arbitrary number of
|
arguments.
|
:param count: this flag makes an option increment an integer.
|
:param allow_from_autoenv: if this is enabled then the value of this
|
parameter will be pulled from an environment
|
variable in case a prefix is defined on the
|
context.
|
:param help: the help string.
|
:param hidden: hide this option from help outputs.
|
:param attrs: Other command arguments described in :class:`Parameter`.
|
|
.. versionchanged:: 8.1.0
|
Help text indentation is cleaned here instead of only in the
|
``@option`` decorator.
|
|
.. versionchanged:: 8.1.0
|
The ``show_default`` parameter overrides
|
``Context.show_default``.
|
|
.. versionchanged:: 8.1.0
|
The default of a single option boolean flag is not shown if the
|
default value is ``False``.
|
|
.. versionchanged:: 8.0.1
|
``type`` is detected from ``flag_value`` if given.
|
ÚoptionNFT)r r~ r Úconfirmation_promptÚprompt_requiredÚ
|
hide_inputrB Ú
|
flag_valuere ÚcountÚallow_from_autoenvrD rþ r8 Ú show_choicesÚ show_envvarrj r0 c sT | rt | ¡} d|k}t j|f| | d| |dkr^| jd krJtd| j dd¡ ¡ }n|dkrld }n|}|| _|| _ || _
|
|| _ || _ | jd k o| j
|
| _ |d krÐ|d k r¸d}qè| j rÄd}qèt| j}n|dkrè| j sè|d k | _ | |r|r| js| rd| _nd| _|d kr&| j }| |rH| d krHt d |¡| _|| _|o`t| jtj| _|| _|
|
| _|
|
r| d krtjd d
|
| _|rd | _| | _ | | _ || _ || _ || _ | j!d krÌtd | jrì| jrì| jsìtd | js| jrtd| jr(| j r(| jd k r(td| jrP| j"r@td| jrPtdd S )Nr )rD re Tz&'name' is required with 'prompt=True'.r r« Fr: r )Úminr¼ z&nargs=-1 is not supported for options.z+'prompt' is not valid for non-boolean flag.z1Secondary flag is not valid for non-boolean flag.z9'prompt' with 'hide_input' is not valid for boolean flag.z%'count' is not valid with 'multiple'.z$'count' is not valid with 'is_flag'.)#rM rN r, r r9 rÎ r Ú
|
capitalizer rÓ rÔ rÕ r8 r ra r= rm r r r¥ rD rB rB Z BoolParamTypeÚ is_bool_flagrÖ r× ZIntRangerØ rþ r~ rÙ rÚ r re )r r r~ r rÓ rÔ rÕ rB rÖ re r× rØ rD rþ r8 rÙ rÚ rj Zdefault_is_missingZ prompt_textr- r: r; r Ð s
|
|
|
|
|
ÿzOption.__init__r c s0 t ¡ }|j| j| j| j| j| j| jd |S )N)rþ r rB rÖ r× r8 ) r, r rÒ rþ r rB rÖ r× r8 )r r/ r- r: r; r F
|
s
|
úzOption.to_info_dictr c C st g }g }d }g }|D ]Ê}| ¡ r>|d k r8td| d|}q|d d
dkrRdnd}||krÆ| |d¡\} }
|
| ¡ } | r| t| ¡ | | ¡ |
|
¡ }
|
|
|
r¬| |
|
¡ ¡ | |
|
krÞtd|dq| t|¡ | |¡ q|d kr&|r&|jdd d
|
|d d d d ¡
|
¡ }| ¡ s&d }|d krH|s@d ||fS td|sj|sjtd| d| d|||fS )NzName 'z' defined twicer
|
ú/ú;zBoolean option z) cannot use the same flag for true/false.c S s t | d S )Nr rx ©r r: r: r; Ú<lambda>t
|
ó z%Option._parse_decls.<locals>.<lambda>r^ r r r z#Could not determine name for optionz*No options defined but a name was passed (zH). Did you mean to declare an argument instead? Did you mean to pass '--z'?) Ú isidentifierrÎ Úsplitr3 r[ r r± rX Úsortr Úlower) r r® rÏ r< r= r9 Zpossible_namesÚdeclZ
|
split_charÚfirstÚsecondr: r: r; r¤ R
|
sN
|
|
ÿ
|
|
|
ÿzOption._parse_declsr¶ c C s¤ | j r d}n| jrd}nd}| jr| d}| jrj| jrj|j| | j| j|dd |j| | j| j|dd q |j| | j| j|| jd n|j| | j| j|| j d d S ) Nr[ r× ÚstoreZ_constT)rr r< ÚdestÚactionÚconstF)rr r< rë rì r )
|
re r× rB rÝ r= Ú
|
add_optionr< r9 rÖ r )r rE r. rì r: r: r; rD
|
sH
|
ÿûûûzOption.add_to_parserrë c sÔ j r
|
d S d tjt td fdd }|jg}jrL| |j¡ jpTd}g }jrÞj }|d krj
|
r|j d k rj d k r|j dj ¡ }|d k rÞt|tr´|nd dd |D ¡}| td
|
j|d ¡ |j}d |_zj|dd } W 5 ||_X d}
|
d} jd k r:tjtr2d } }
|
nj}
|
n|jd k rL|j}
|
| sb|
|
r&| d k r&| rxdj d} nt| ttfrd dd | D ¡} nlt | ¡r´td} nVjræjrætjrÔjnjd d } n$jrjs| sd} nt| } | r&| tdj| d¡ tj t j rtj rZj j dkrZj j!d kstj "¡ } | rt| | ¡ j#r| td¡ |r¼d |¡}|r°| d| dn
|
d| d} rÆdnd |¡|fS ) NF)r< r0 c s6 t | \}}|rd js2js2|d ¡ 7 }|S )NTr« )r rB r× r² )r< r Z any_slashes©Zany_prefix_is_slashr r: r; Ú _write_opts´
|
s z+Option.get_help_record.<locals>._write_optsrª r z, c s s | ]}t |V qd S rJ ©rÛ ©r Údr: r: r; r Ø
|
s z)Option.get_help_record.<locals>.<genexpr>zenv var: {var})ÚvarTrµ ú(ú)c s s | ]}t |V qd S rJ rñ rò r: r: r; r ö
|
s z (dynamic)r r
|
zdefault: {default})r rm z; z [ú]ú[rÍ )$r8 r1 r$ rÛ r< r= r[ rþ rÚ r¢ rØ rs r9 r rB r° r rO rw rÑ r~ rK rÄ rM Ú
|
isfunctionrÝ r r rD r Z_NumberRangeBaser× rÛ rz Z_describe_rangerm )r r. rð r rþ rö r¢ Zvar_strZ resilientÚ default_valuer~ Zshow_default_is_strZdefault_stringZ range_strZ extra_strr: rï r; rZ ®
|
s
|
ÿþýÿý
|
|
ÿþ ÿý
|
ý
|
ý
|
|
|
"zOption.get_help_recordr¸ r³ c C s d S rJ r: r´ r: r: r; rÑ s zOption.get_default.c C s d S rJ r: r´ r: r: r; rÑ s c sR | j rB| jsB|jjD ](}|j| jkr|jrt t|¡j S qd S t
|
j ||dS )Nrµ ) rB rÝ r4 r r9 r r1 r2 r? rÖ r, rÑ )r r. r¹ rP r- r: r; rÑ & s c
|
sT j dk st ¡}jr*tj |S t j |jjjj fdddS )zîThis is an alternative flow that can be activated in the full
|
value processing if a value does not exist. It will prompt the
|
user until a valid value exists and then returns the processed
|
value as result.
|
Nc s | ¡S rJ )rÈ rà r r: r; rá M râ z)Option.prompt_for_value.<locals>.<lambda>)r rD rÕ rÙ rÓ Z
|
value_proc) r r rÑ rÝ r rD rÕ rÙ rÓ )r r. r r: r r; Úprompt_for_value6 s
|
ùzOption.prompt_for_valuec s` t |¡}|d k r|S | jr\|jd k r\| jd k r\|j d| j ¡ }tj |¡}|r\|S d S )Nr ) r, rÊ rØ rs r9 r r r r rÉ r- r: r; rÊ P s ÿþý zOption.resolve_envvar_valuec C s^ | |¡}|d krd S | jdkt| j }|dkrZ| j |¡}| jrZ| jdkrZt|| j}|S r )rÊ r ra re rD rË rN )r r. r Z value_depthr: r: r; r¹ c s
|
zOption.value_from_envvarrO r¸ c sÆ t ||¡\}}|tkrJ jd k r<|js< |¡}tj}q¾ j}tj }nt j
|
r|d k rt dd |D r fdd|D }tj }n:|d tj hkr¾ jd k r¾ j s¨ jr¾|js¾ |¡}tj}||fS )Nc s s | ]}|t kV qd S rJ r ©r Úvr: r: r; r s z'Option.consume_value.<locals>.<genexpr>c s g | ]}|t kr jn|qS r: )r rÖ rü r r: r; r. s z(Option.consume_value.<locals>.<listcomp>)r, r» r r rw rû rd rn rÖ rj re Úanyrl rm rÔ rº r- r r; r» s s8
|
ÿþý ÿþýýü
|
zOption.consume_value)NNFFTFNNFFTNNFTF)T).)T)"rE re rf rg r¬ r1 rÚ r$ rÛ rç ra rÜ r rÐ r rá r r` rß r¤ r r+ rD rZ ræ rÑ rà rû rÊ r¹ rÑ rd r» rf r: r: r- r; r? s < ï
|
ív þ 5' l ÿ
|
þ ÿ þ ÿ þ þr? c sÎ e Zd ZdZdZdeje eje ej
|
dd fdd Z e eddd Z edd
|
d Zeje e ejeje eje eje f d d dZeeje dddZeedddZeeddddZ ZS )rl a Arguments are positional parameters to a command. They generally
|
provide fewer features than options but can have infinite ``nargs``
|
and are required by default.
|
|
All parameters are passed onwards to the constructor of :class:`Parameter`.
|
ZargumentN)r rm rj r0 c st |d kr,| d¡d k r d}n| dd¡dk}d|kr<tdt j|fd|i| | jd k rp| jd krptd
|
d S ) Nr Fr r
|
r re z9__init__() got an unexpected keyword argument 'multiple'.rm r¼ z('default' is not supported for nargs=-1.)r rÎ r, r r r )r r rm rj r- r: r; r £ s zArgument.__init__r c C s | j d k r| j S | j ¡ S rJ )r¡ r9 r r r: r: r; r¯ ¸ s
|
z Argument.human_readable_namec C sR | j d k r| j S | j | ¡}|s*| j ¡ }| js<d| d}| jdkrN|d7 }|S )Nrø r÷ r
|
r° )r¡ rD r± r9 r rm r )r rô r: r: r; r² ¾ s
|
|
|
zArgument.make_metavarr c C sd |s|sd g g fS t dt|dkrD|d }}| dd¡ ¡ }nt dt| d||gg fS )Nz%Could not determine name for argumentr
|
r r r z6Arguments take exactly one parameter declaration, got r )rÎ r_ r ræ )r r® rÏ r9 Úargr: r: r; r¤ Ê s
|
ÿzArgument._parse_declsrë c C s
|
| ¡ gS rJ ©r² rí r: r: r; r¯ Û s zArgument.get_usage_piecesc C s d| ¡ dS )NrÎ r rí r: r: r; rÏ Þ s zArgument.get_error_hintr¶ c C s |j | j| j| d d S )N)rë r rr )Ú add_argumentr9 r r· r: r: r; rD á s zArgument.add_to_parser)N)rE re rf rg r¬ r1 r$ rÛ rÚ ra rÜ r rä r¯ r² r` rß r¤ r+ r¯ rÏ r rD rf r: r: r- r; rl s& ýû þ rl )F)N)Vrh r rM r r Útypingr1 Ú collectionsr Ú
|
contextlibr r Ú functoolsr r r r Ú itertoolsr r r rª Ú
|
exceptionsr r r r r r Z
|
formattingr r Úglobalsr r rE r r r Ztermuir r r Úutilsr r! r" r# r$ r% Ú TYPE_CHECKINGZtyping_extensionsÚter r' ÚTypeVarrà rÜ r( r* rÛ rã r` r< ra rG ÚIterablerÞ rß rN rÚ rR r$ rc ÚEnumrd r+ rè r, r3 r r r rO r? rl r: r: r: r; Ú<module> s¾
|
þ ÿ þ ( ÿ þý ' H : 7 1-
|
8
|
