��W� � @ s� d d l Z d d l Z d d l m Z d d l m Z d d l m Z d d l m Z m
Z
m Z d d l m
Z
m Z m Z m Z d d l m Z m Z m Z m Z m Z d d l m Z m Z d d
l m Z m Z d d l m Z m Z d d l m! Z! m" Z" d d
l# m$ Z$ m% Z% m& Z& d d l' m( Z( m) Z) e* � Z+ d Z, d Z- d d d � Z. d d d � Z/ d d � Z0 d d � Z1 e d d d � � Z2 d d � Z3 Gd d � d e* � Z4 Gd d! � d! e* � Z5 Gd" d# � d# e5 � Z6 Gd$ d% � d% e6 � Z7 Gd& d' � d' e7 � Z8 Gd( d) � d) e7 � Z9 Gd* d+ � d+ e* � Z: Gd, d- � d- e: � Z; Gd. d/ � d/ e: � Z< d d0 l= m> Z> m? Z? d S)1� N)�contextmanager)�repeat)�update_wrapper� )� convert_type�IntRange�BOOL)�make_str�make_default_short_help�echo� get_os_args)�ClickException�
UsageError� BadParameter�Abort�MissingParameter)�prompt�confirm)�
HelpFormatter� join_options)� OptionParser� split_opt)� push_context� pop_context)�PY2� isidentifier� iteritems)�_check_for_unicode_literals�_verify_python3_envzCOMMAND [ARGS]...z*COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...c C sz | d k r( d | j d d � j � } t j j | � } | sD d Sd d l m } | | | | | � rv t j d � d S)z1Internal handler for the bash completion support.Nz _%s_COMPLETE�-�_r )� bashcomplete) �replace�upper�os�environ�get�
_bashcompleter! �sys�exit)�cmd� prog_name� complete_varZcomplete_instrr! � r- �/core.pyr' s r' Fc C sn | j s t | t � r d S| r- d } n d } t d | | j | | | j j | j j | j f � � d S)NzcIt is not possible to add multi commands as children to another multi command that is in chain modezdFound a multi command as subcommand to a multi command that is in chain mode. This is not supporteda %s. Command "%s" is set to chain and "%s" was added as subcommand but it in itself is a multi command. ("%s" is a %s within a chained %s named "%s"). This restriction was supposed to be lifted in 6.0 but the fix was flawed. This will be fixed in Click 7.0)�chain�
isinstance� MultiCommand� RuntimeError�name� __class__�__name__)Z base_command�cmd_namer* �registerZhintr- r- r. �_check_multicommand( s r8 c C s t t t t | � | � � � S)N)�list�zipr �iter)�iterableZ
batch_sizer- r- r. �batch= s r= c C sw t | d d � } t | d d � } | d k rg d d l m } | t d | � d d �| | | � S| | | | � S)N�__code__� co_argcount� r )�warnz}Invoked legacy parameter callback "%s". The new signature for such callbacks starting with click 2.0 is (ctx, param, value).�
stacklevel)�getattr�warningsrA �Warning)�callback�ctx�param�value�code�argsrA r- r- r. �invoke_param_callbackA s
rL c c s� y d VWn� t k
ro } zD | j d k r6 | | _ | d k rZ | j d k rZ | | _ � WYd d } ~ Xn@ t k
r� } z | j d k r� | | _ � WYd d } ~ Xn Xd S)zPContext manager that attaches extra information to exceptions that
fly.
N)r rG rH r )rG rH �er- r- r. �augment_usage_errorsP s rN c s" � f d d � } t | d | �S)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.
c sB y � j | � } Wn t k
r3 t d � } Yn X| j | f S)N�inf)�index�
ValueError�float�is_eager)�item�idx)�invocation_orderr- r. �sort_keyh s
z,iter_params_for_processing.<locals>.sort_key�key)�sorted)rV Zdeclaration_orderrW r- )rV r. �iter_params_for_processingc s rZ c @ sH e Z d Z d Z d d d d d d d d d d d d d d d d � Z d d � Z d d � Z e d
d d � � Z e d
d � � Z
d d � Z d d � Z d d � Z
e d d � � Z d d � Z d d � Z d d � Z d d � Z d d � Z d! d" � Z d# d$ d% � Z d& d' � Z d( d) � Z d* d+ � Z d, d- � Z d S).�ContextaC 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.
.. versionadded:: 2.0
Added the `resilient_parsing`, `help_option_names`,
`token_normalize_func` parameters.
.. versionadded:: 3.0
Added the `allow_extra_args` and `allow_interspersed_args`
parameters.
.. versionadded:: 4.0
Added the `color`, `ignore_unknown_options`, and
`max_content_width` parameters.
: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. 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.
NFc C s� | | _ | | _ | | _ i | _ g | _ g | _ | d k rW | d k rW | j } | | _ t | d i � | _ | d k r� | d k r� | j d k r� | j j
| � } | | _ d | _ | d k r� | d k r� | j } | | _ | d k r | d k r | j
} | | _
|
d k r)| j }
|
| _ | d k rG| j } | | _ | d k re| j } | | _ |
d k r�| d k r�| j }
n d g }
|
| _ | d k r�| d k r�| j } | | _ | | _ | d k r,| d k r;| j d k r;| j d k r;d | j | j j � f } n | j � | _ | | _ | d k re| d k re| j } | | _ g | _ d | _ d S)N�metaz--helpz%s_%sr )�parent�command� info_name�paramsrK �protected_args�objrC �_meta� default_mapr& �invoked_subcommand�terminal_width�max_content_width�allow_extra_args�allow_interspersed_args�ignore_unknown_options�help_option_names�token_normalize_func�resilient_parsing�auto_envvar_prefixr# �color�_close_callbacks�_depth)�selfr^ r] r_ rb rn rd rf rg rm rh ri rj rk rl ro r- r- r. �__init__� sj zContext.__init__c C s | j d 7_ t | � | S)Nr )rq r )rr r- r- r. � __enter__B s
zContext.__enter__c C s3 | j d 8_ | j d k r( | j � t � d S)Nr r )rq �closer )rr �exc_type� exc_value�tbr- r- r. �__exit__G s
zContext.__exit__Tc c sK | s | j d 7_ z | � } | VWd QRXWd | sF | j d 8_ Xd S)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)rq )rr �cleanup�rvr- r- r. �scopeM 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 utiltiies 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 = __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
)rc )rr r- r- r. r\ s s z Context.metac C s t d | j d | j � S)z4Creates the formatter for the help and usage output.�widthZ max_width)r rf rg )rr r- r- r. �make_formatter� s zContext.make_formatterc C s | j j | � | S)at This decorator remembers a function as callback that should be
executed when the context tears down. This is most useful to bind
resource handling to the script execution. For instance, file objects
opened by the :class:`File` type will register their close callbacks
here.
:param f: the function to execute on teardown.
)rp �append)rr �fr- r- r. �
call_on_close� s zContext.call_on_closec C s( x | j D]
} | � q
Wg | _ d S)z Invokes all close callbacks.N)rp )rr �cbr- r- r. ru � s z
Context.closec C sK d } | j d k r | j } | j d k rA | j j d | } | j � 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� )r_ r] � command_path�lstrip)rr r{ r- r- r. r� � s zContext.command_pathc C s) | } x | j d k r$ | j } q W| S)z Finds the outermost context.N)r] )rr �noder- r- r. � find_root� s
zContext.find_rootc C s? | } x2 | d k r: t | j | � r. | j S| j } q Wd S)z)Finds the closest object of a given type.N)r0 rb r] )rr � object_typer� r- r- r. � find_object� s
zContext.find_objectc C s/ | j | � } | d k r+ | � | _ } | S)z�Like :meth:`find_object` but sets the innermost object to a
new instance of `object_type` if it does not exist.
N)r� rb )rr r� r{ r- r- r. �
ensure_object� s zContext.ensure_objectc C s> | j d k r: | j j | � } t | � r6 | � } | Sd S)z}Looks up the default for a parameter name. This by default
looks into the :attr:`default_map` if available.
N)rd r& �callable)rr r3 r{ r- r- r. �lookup_default� s
zContext.lookup_defaultc C s t | | � � d S)z�Aborts the execution of the program with a specific error
message.
:param message: the error message to fail with.
N)r )rr �messager- r- r. �fail� s z Context.failc C s
t � � d S)zAborts the script.N)r )rr r- r- r. �abort� s z
Context.abortr c C s t j | � d S)z-Exits the application with a given exit code.N)r( r) )rr rJ r- r- r. r) � s z Context.exitc C s | j j | � S)zaHelper method to get formatted usage string for the current
context and command.
)r^ � get_usage)rr r- r- r. r� � s zContext.get_usagec C s | j j | � S)z^Helper method to get formatted help page for the current
context and command.
)r^ �get_help)rr r- r- r. r� � s zContext.get_helpc O s� | d d � \ } } | } t | t � r� | } | j } t | d | j d | �} | d k rm t d � � x? | j D]4 } | j | k rw | j rw | j | � | | j <qw W| d d � } t | � � | � | | | � SWd QRXWd QRXd S)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`.
N� r_ r] z?The given command does not have a callback that can be invoked.)
r0 �CommandrF r[ r3 � TypeErrorr` � expose_value� get_defaultrN )rK �kwargsrr rF rG Z other_cmdrH r- r- r. �invoke� s
zContext.invokec O sr | d d � \ } } t | t � s1 t d � � x. | j D]# } | | k r; | j | | | <q; W| j | | � S)z�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.
Nr� zCallback is not a command.)r0 r� r� r` r� )rK r� rr r* rH r- r- r. �forward s zContext.forward)r5 �
__module__� __qualname__�__doc__rs rt ry r r| �propertyr\ r~ r� ru r� r� r� r� r� r� r� r) r� r� r� r� r- r- r- r. r[ r s8 M { %
'r[ c @ s� e Z d Z d Z d Z d Z d Z d d d � Z d d � Z d d
� Z d d d � Z
d
d � Z d d � Z d d d d d d � Z
d d � Z d S)� 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.
FTNc C s( | | _ | d k r i } | | _ d S)N)r3 �context_settings)rr r3 r� r- r- r. rs G s zBaseCommand.__init__c C s t d � � d S)Nz Base commands cannot get usage)�NotImplementedError)rr rG r- r- r. r� R s zBaseCommand.get_usagec C s t d � � d S)Nz Base commands cannot get help)r� )rr rG r- r- r. r� U s zBaseCommand.get_helpc
K s x3 t | j � D]" \ } } | | k r | | | <q Wt | d | d | | �} | j d d � � | j | | � Wd QRX| 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.
:param info_name: the info name for this invokation. 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 it's
the name of the script.
: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.
r_ r] rz FN)r r� r[ r| �
parse_args)rr r_ rK r] �extrarX rI rG r- r- r. � make_contextX s zBaseCommand.make_contextc C s t d � � d S)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.N)r� )rr rG rK r- r- r. r� o s zBaseCommand.parse_argsc C s t d � � d S)z{Given a context, this invokes the command. The default
implementation is raising a not implemented error.
z*Base commands are not invokable by defaultN)r� )rr rG r- r- r. r� w s zBaseCommand.invokec K s� t s t � n t � | d k r/ t � } n t | � } | d k ru t t j j t j
ri t j
d pl t � � } t | | | � y� yF | j
| | | � �* } | j | � } | s� | S| j � Wd QRXWnx t t f k
rt d t j � t � � YnH t k
rH} z( | s � | j � t j | j � WYd d } ~ Xn XWn; t k
r�| sc� t d d t j �t j d � Yn Xd S)a1 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`.
.. versionadded:: 3.0
Added the `standalone_mode` flag to control the standalone mode.
: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 extra: extra keyword arguments are forwarded to the context
constructor. See :class:`Context` for more information.
Nr �filezAborted!r )r r r r r9 r r$ �path�basenamer( �argv�__file__r' r� r� r) �EOFError�KeyboardInterruptr �stderrr r
ZshowZ exit_code) rr rK r+ r, Zstandalone_moder� rG r{ rM r- r- r. �main} s< %
"
'
zBaseCommand.mainc O s | j | | � S)zAlias for :meth:`main`.)r� )rr rK r� r- r- r. �__call__� s zBaseCommand.__call__)r5 r� r� r� rh ri rj rs r� r� r� r� r� r� r� r- r- r- r. r� + s Lr� c
@ s� e Z d Z d Z d d d d d d d d d d � Z d d � Z d d
� Z d d � Z d
d � Z d d � Z d d � Z
d d � Z d d � Z d d � Z
d d � Z d d � Z d d � Z d d � Z d! d" � Z d S)#r� 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.
.. 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.
: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.
Nz [OPTIONS]Tc
C sz t j | | | � | | _ | p% g | _ | | _ | | _ | | _ | d k rd | rd t | � } | | _ | | _ d S)N)
r� rs rF r` �help�epilog�options_metavarr
�
short_help�add_help_option)
rr r3 r� rF r` r� r� r� r� r� r- r- r. rs � s zCommand.__init__c C s/ | j � } | j | | � | j � j d � S)N�
)r~ � format_usage�getvalue�rstrip)rr rG � formatterr- r- r. r� � s zCommand.get_usagec C s5 | j } | j | � } | d k r1 | | g } | S)N)r` �get_help_option)rr rG r{ Z help_optionr- r- r. �
get_params� s
zCommand.get_paramsc C s/ | j | � } | j | j d j | � � d S)z)Writes the usage line into the formatter.r� N)�collect_usage_piecesZ write_usager� �join)rr rG r� �piecesr- r- r. r� s zCommand.format_usagec C s@ | j g } x- | j | � D] } | j | j | � � q W| S)zhReturns all the pieces that go into the usage line and returns
it as a list of strings.
)r� r� �extend�get_usage_pieces)rr rG r{ rH r- r- r. r�
s z Command.collect_usage_piecesc C sG t | j � } x1 | j D]& } | j | j � | j | j � q W| S)z&Returns the names for the help option.)�setrk r` �difference_update�opts�secondary_opts)rr rG Z all_namesrH r- r- r. �get_help_option_names s
z Command.get_help_option_namesc C sX | j | � } | s | j r$ d Sd d � } t | d d d d d d d | d
d �S) z Returns the help option object.Nc S s7 | r3 | j r3 t | j � d | j �| j � d S)Nro )rm r r� ro r) )rG rH rI r- r- r. � show_help! s z*Command.get_help_option.<locals>.show_help�is_flagTrS r� FrF r� zShow this message and exit.)r� r� �Option)rr rG Z help_optionsr� r- r- r. r� s zCommand.get_help_optionc C sR t | � } | j | _ | j | _ x' | j | � D] } | j | | � q4 W| S)z6Creates the underlying option parser for this command.)r ri rj r� �
add_to_parser)rr rG �parserrH r- r- r. � make_parser* s zCommand.make_parserc C s/ | j � } | j | | � | j � j d � S)z�Formats the help into a string and returns it. This creates a
formatter and will call into the following formatting methods:
r� )r~ � format_helpr� r� )rr rG r� r- r- r. r� 3 s zCommand.get_helpc C sD | j | | � | j | | � | j | | � | j | | � d S)z�Writes the help into the formatter if it exists.
This calls into the following methods:
- :meth:`format_usage`
- :meth:`format_help_text`
- :meth:`format_options`
- :meth:`format_epilog`
N)r� �format_help_text�format_options�
format_epilog)rr rG r� r- r- r. r� ; s
zCommand.format_helpc C s; | j r7 | j � | j � � | j | j � Wd QRXd S)z3Writes the help text to the formatter if it exists.N)r� �write_paragraph� indentation�
write_text)rr rG r� r- r- r. r� J s
zCommand.format_help_textc C sv g } x? | j | � D]. } | j | � } | d k r | j | � q W| rr | j d � � | j | � Wd QRXd S)z8Writes all the options into the formatter if they exist.NZOptions)r� �get_help_recordr �section�write_dl)rr rG r� r� rH r{ r- r- r. r� Q s zCommand.format_optionsc C s; | j r7 | j � | j � � | j | j � Wd QRXd S)z2Writes the epilog into the formatter if it exists.N)r� r� r� r� )rr rG r� r- r- r. r� ] s
zCommand.format_epilogc C s� | j | � } | j d | � \ } } } x; t | | j | � � D]! } | j | | | � \ } } qC W| r� | j r� | j r� | j d t | � d k r� d p� d d j t
t | � � f � | | _ | S)NrK z$Got unexpected extra argument%s (%s)r �sr� r� )
r� r� rZ r� �handle_parse_resultrh rm r� �lenr� �mapr rK )rr rG rK r� r� Z param_orderrH rI r- r- r. r� d s zCommand.parse_argsc C s) | j d k r% | j | j | j � Sd S)zeGiven a context, this invokes the attached callback (if it exists)
in the right way.
N)rF r� r` )rr rG r- r- r. r� t s zCommand.invoke)r5 r� r� r� rs r� r� r� r� r� r� r� r� r� r� r� r� r� r� r- r- r- r. r� � s$ r� c @ s� e Z d Z d Z d Z d Z d d d d d d d d � Z d d � Z d d
� Z d d d � Z d
d � Z
d d � Z d d � Z d d � Z
d d � Z d d � Z d S)r1 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.
TFNc K s� t j | | | � | d k r& | } | | _ | | _ | d k rY | rS t } n t } | | _ | | _ | | _ | j r� x6 | j D]+ } t
| t � r� | j r� t
d � � q� Wd S)Nz<Multi commands in chain mode cannot have optional arguments.)r� rs �no_args_is_help�invoke_without_command�SUBCOMMANDS_METAVAR�SUBCOMMAND_METAVAR�subcommand_metavarr/ �result_callbackr` r0 �Argument�requiredr2 ) rr r3 r� r� r� r/ r� �attrsrH r- r- r. rs � s zMultiCommand.__init__c C s& t j | | � } | j | j � | S)N)r� r� r r� )rr rG r{ r- r- r. r� � s z!MultiCommand.collect_usage_piecesc C s' t j | | | � | j | | � d S)N)r� r� �format_commands)rr rG r� r- r- r. r� � s zMultiCommand.format_optionsc s � � f d d � } | S)am Adds a result callback to the chain 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.resultcallback()
def process_result(result, input):
return result + input
.. versionadded:: 3.0
:param replace: if set to `True` an already existing result
callback will be removed.
c sW � j � � d k s � r( � � _ � S� � f d d � } t | � � � _ } | S)Nc s � � | | | � | | � S)Nr- )Z_MultiCommand__valuerK r� )r� � old_callbackr- r. �function� s z@MultiCommand.resultcallback.<locals>.decorator.<locals>.function)r� r )r� r� r{ )r" rr )r� r� r. � decorator� s z.MultiCommand.resultcallback.<locals>.decoratorr- )rr r" r� r- )r" rr r. �resultcallback� s
zMultiCommand.resultcallbackc C s� g } xZ | j | � D]I } | j | | � } | d k r= q | j pI d } | j | | f � q W| r� | j d � � | j | � Wd QRXd S)zeExtra format methods for multi methods that adds all the commands
after the options.
Nr� ZCommands)�
list_commands� get_commandr� r r� r� )rr rG r� ZrowsZ
subcommandr* r� r- r- r. r� � s z MultiCommand.format_commandsc C s� | r= | j r= | j r= t | j � d | j �| j � t j | | | � } | j rp | | _ g | _
n- | r� | d d � | d d � | _ | _
| j
S)Nro r ) r� rm r r� ro r) r� r� r/ ra rK )rr rG rK �restr- r- r. r� � s
'zMultiCommand.parse_argsc ' s � � f d d � } � j su � j rh � j s@ t j � � � S� � t j � � � | g � SWd QRX� j d � � j � j } g � _ g � _ � j s � �u � j � | � \ } } } | � _ t j � � � | j | | d � �} | � | | j
j | � � SWd QRXWd QRX� �� | r1d p4d � _ t j � � � g } xi | r�� j � | � \ } } } | j | | d � d d d d �} | j | � | j g } | _ qSWg } x5 | D]- } | � | j | j
j | � � Wd QRXq�W| | � SWd QRXd S)
Nc s. � j d k r* � j � j | � j � } | S)N)r� r� r` )rI )rG rr r- r. �_process_result� s z,MultiCommand.invoke.<locals>._process_resultzMissing command.r] �*rh Tri F) ra r� r/ r� r� r� rK �resolve_commandre r� r^ r ) rr rG r� rK r6 r* Zsub_ctxZcontextsr{ r- )rG rr r. r� � sH
$
$zMultiCommand.invokec C s� t | d � } | } | j | | � } | d k rd | j d k rd | j | � } | j | | � } | d k r� t | � d r� | j | | j � | j d | � | | | d d � f S)Nr zNo such command "%s".r )r r� rl r r� rK r� )rr rG rK r6 Zoriginal_cmd_namer* r- r- r. r� A s z MultiCommand.resolve_commandc C s
t � � d S)z{Given a context and a command name, this returns a
:class:`Command` object if it exists or returns `None`.
N)r� )rr rG r6 r- r- r. r� [ s zMultiCommand.get_commandc C s g S)zTReturns a list of subcommand names in the order they should
appear.
r- )rr rG r- r- r. r� a s zMultiCommand.list_commands)r5 r� r� r� rh ri rs r� r� r� r� r� r� r� r� r� r- r- r- r. r1 | s % D r1 c @ sg e Z d Z d Z d d d d � Z d d d � Z d d � Z d d
� Z d d � Z d
d � Z d S)�Groupz�A group allows a command to have subcommands attached. This is the
most common way to implement nesting in Click.
:param commands: a dictionary of commands.
Nc K s& t j | | | � | p i | _ d S)N)r1 rs �commands)rr r3 r� r� r- r- r. rs o s zGroup.__init__c C sN | p | j } | d k r' t d � � t | | | d d �| | j | <d S)z�Registers another :class:`Command` with this group. If the name
is not provided, the name of the command is used.
NzCommand has no name.r7 T)r3 r� r8 r� )rr r* r3 r- r- r. � add_commandt s
zGroup.add_commandc s � � � f d d � } | S)a A shortcut decorator for declaring and attaching a command to
the group. This takes the same arguments as :func:`command` but
immediately registers the created command with this instance by
calling into :meth:`add_command`.
c s& t � � � | � } � j | � | S)N)r^ r� )r� r* )rK r� rr r- r. r� � s
z Group.command.<locals>.decoratorr- )rr rK r� r� r- )rK r� rr r. r^ ~ s z
Group.commandc s � � � f d d � } | S)z�A shortcut decorator for declaring and attaching a group to
the group. This takes the same arguments as :func:`group` but
immediately registers the created command with this instance by
calling into :meth:`add_command`.
c s& t � � � | � } � j | � | S)N)�groupr� )r� r* )rK r� rr r- r. r� � s
z Group.group.<locals>.decoratorr- )rr rK r� r� r- )rK r� rr r. r� � s z Group.groupc C s | j j | � S)N)r� r& )rr rG r6 r- r- r. r� � s zGroup.get_commandc C s
t | j � S)N)rY r� )rr rG r- r- r. r� � s zGroup.list_commands)
r5 r� r� r� rs r� r^ r� r� r� r- r- r- r. r� h s
r� c @ sL e Z d Z d Z d d d d � Z d d � Z d d � Z d d
� Z d S) �CommandCollectiona 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.
Nc K s& t j | | | � | p g | _ d S)N)r1 rs �sources)rr r3 r� r� r- r- r. rs � s zCommandCollection.__init__c C s | j j | � d S)z1Adds a new multi command to the chain dispatcher.N)r� r )rr Z multi_cmdr- r- r. �
add_source� s z CommandCollection.add_sourcec C sS xL | j D]A } | j | | � } | d k r
| j rG t | | | � | Sq
Wd S)N)r� r� r/ r8 )rr rG r6 �sourcer{ r- r- r. r� � s z CommandCollection.get_commandc C s= t � } x' | j D] } | j | j | � � q Wt | � S)N)r� r� �updater� rY )rr rG r{ r� r- r- r. r� � s z CommandCollection.list_commands)r5 r� r� r� rs r� r� r� r- r- r- r. r� � s
r� c @ s� e Z d Z d Z d Z d d d d d d d d d d d d �
Z e d d � � Z d
d � Z d d
� Z d d � Z
d d � Z d d � Z d d � Z
d d � Z d d � Z d d � Z d d � Z d d � Z d d! � Z d" d# � Z d S)$� Parametera! 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.
.. versionchanged:: 2.0
Changed signature for parameter callback to also be passed the
parameter. In Click 2.0, the old callback format will still work,
but it will raise a warning to give you change to migrate the
code easier.
: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 later 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 callback that should be executed after the parameter
was matched. This is called as ``fn(ctx, param,
value)`` and needs to return the value. Before Click
2.0, the signature was ``(ctx, value)``.
: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).
: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.
Z parameterNFTc C s� | j | p f | � \ | _ | _ | _ t | | � | _ | d k ri | j j rc | j j } n d } | | _ | | _ | | _
d | _ | | _ | | _
| | _ | | _ |
| _ d S)Nr F)� _parse_declsr3 r� r� r �type� is_compositeZarityr� rF �nargs�multipler� �defaultrS �metavar�envvar) rr � param_declsr� r� r� rF r� r� r� rS r� r- r- r. rs � s * zParameter.__init__c C s | j S)z�Returns the human readable name of this parameter. This is the
same as the name for options, but the metavar for arguments.
)r3 )rr r- r- r. �human_readable_name s z Parameter.human_readable_namec C sc | j d k r | j S| j j | � } | d k rF | j j j � } | j d k r_ | d 7} | S)Nr z...)r� r� Z get_metavarr3 r# r� )rr r� r- r- r. � make_metavar s
zParameter.make_metavarc C s7 t | j � r | j � } n | j } | j | | � S)z;Given a context variable this calculates the default value.)r� r� �type_cast_value)rr rG r{ r- r- r. r� s zParameter.get_defaultc C s d S)Nr- )rr r� rG r- r- r. r� s zParameter.add_to_parserc C sO | j | j � } | d k r0 | j | j � } | d k rK | j | � } | S)N)r& r3 r� �value_from_envvar)rr rG r� rI r- r- r. �
consume_value s zParameter.consume_valuec s� � j j rv � j d k r. t d � j � � � j r] t � � f d d � | pU f D� � S� j | pl f � � � S� � � f d d � � � | � j d k t � j � � S)z�Given a value this runs it properly through the type system.
This automatically handles things like `nargs` and `multiple` as
well as composite types.
r z�Attempted to invoke composite type but nargs has been set to %s. This is not supported; nargs needs to be set to a fixed value > 1.c 3 s* | ] } � j | p f � � � Vq d S)N)r� )�.0�x)rG rr r- r. � <genexpr>3 s z,Parameter.type_cast_value.<locals>.<genexpr>c sE � d k r � j | � � � St � � f d d � | p= f D� � S)Nr c 3 s" | ] } � | � d � Vq d S)r Nr- )r r )�_convert�levelr- r. r 9 s z>Parameter.type_cast_value.<locals>._convert.<locals>.<genexpr>)r� �tuple)rI r )r rG rr )r r. r 6 s z+Parameter.type_cast_value.<locals>._convert)r� r� r� r� r� r
�bool)rr rG rI r- )r rG rr r. r ' s
&zParameter.type_cast_valuec C s | d k r | j | | � Sd S)zaGiven a value and context this runs the logic to convert the
value as necessary.
N)r )rr rG rI r- r- r. �
process_value< s zParameter.process_valuec C s< | d k r d S| j d k s( | j r8 | f k r8 d Sd S)NTr F)r� r� )rr rI r- r- r. �value_is_missingG s
$zParameter.value_is_missingc C s^ | j | | � } | d k r- | j | � } | j rZ | j | � rZ t d | d | � � | S)NrG rH )r r� r� r
r )rr rG rI r- r- r. �full_process_valueN s z Parameter.full_process_valuec C s{ | j d k r d St | j t t f � rd xI | j D]( } t j j | � } | d k r5 | Sq5 Wn t j j | j � Sd S)N)r� r0 r
r9 r$ r% r& )rr rG r� r{ r- r- r. �resolve_envvar_valueY s z Parameter.resolve_envvar_valuec C s@ | j | � } | d k r< | j d k r< | j j | � } | S)Nr )r r� r� �split_envvar_value)rr rG r{ r- r- r. r d s zParameter.value_from_envvarc C s� t | d | ��� | j | | � } y | j | | � } Wn$ t k
ra | j sW � d } Yn X| j d k r� y t | j | | | � } Wn t k
r� | j s� � Yn XWd QRX| j r� | | j | j <| | f S)NrH )
rN r r � Exceptionrm rF rL r� r` r3 )rr rG r� rK rI r- r- r. r� j s$
z Parameter.handle_parse_resultc C s d S)Nr- )rr rG r- r- r. r� s zParameter.get_help_recordc C s g S)Nr- )rr rG r- r- r. r� � s zParameter.get_usage_pieces)r5 r� r� r� �param_type_namers r� r r r� r� r r r r
r r r r� r� r� r- r- r- r. r� � s& )
r� c @ s� e Z d Z d Z d Z d d d d d d d d d d d d d d � Z d d � Z d
d � Z d d
� Z d d � Z d d � Z
d d � Z d d � Z d d � Z
d 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: controls if the default value should be shown on the
help page. Normally, defaults are not shown.
:param prompt: if set to `True` or a non empty string then the user will
be prompted for input if not set. If set to `True` the
prompt will be the option name capitalized.
:param confirmation_prompt: if set then the value will need to be confirmed
if it was prompted for.
: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.
ZoptionNFTc
K sl |
j d t � t k } t j | | d | |
�| d k r[ | j j d d � j � } n | d k rp d } n | } | | _ | | _ | | _ | d k r� | d k r� d } n t
| j � } | r� | r� d | _ | d k r� | j } | | _
| | _ | j
r:t | j t
� r:| d k r:t | _ d | _ n d | _ | | _ | r| d k rpt d d � | _ | rd | _ | | _ |
| _ | | _ | | _ | j d k r�t d � � | j r�| j
r�| j r�t d
� � | j r| j rt d � � | j r2| j r2| j d k r2t d � � | j rh| j rSt d
� � n | j
rht d � � d S)Nr� r� Tr r� F�minr z Options cannot have nargs < 0z+Cannot prompt for flags that are not bools.z*Got secondary option for non boolean flag.z5Hidden input does not work with boolean flag prompts.z6Options cannot be multiple and count at the same time.z3Options cannot be count and flags at the same time.)r& �_missingr� rs r3 r" �
capitalizer �confirmation_prompt�
hide_inputr r� r� r� �
flag_valuer0 r r� � is_bool_flag�countr r� �allow_from_autoenvr� � show_defaultr� r� )rr r� r r r r r� r r� r r r� r� r� Zdefault_is_missingZ prompt_textr- r- r. rs � sb
zOption.__init__c C s� g } g } d } g } x� | D]� } t | � rR | d k rI t d � � | } q | d d � d k rn d pq d } | | k r� | j | d � \ } }
| j � } | r� | j t | � � | j | � |
j � }
|
r| j |
j � � q | j t | � � | j | � q W| d k rp| rp| j d d d � � | d d j d d � j � } t | � spd } | d k r�| s�d | | f St d
� � | r�| r�t d | � � | | | f S)
NzName defined twicer �/�;rX c S s t | d � S)Nr )r� )r r- r- r. �<lambda> s z%Option._parse_decls.<locals>.<lambda>r r z#Could not determine name for optionzhNo options defined but a name was passed (%s). Did you mean to declare an argument instead of an option?���)
r r� �splitr� r r r� �sortr" �lower) rr �declsr� r� r� r3 Zpossible_namesZdeclZ
split_char�first�secondr- r- r. r� � sD
"
zOption._parse_declsc C s d | j d | j d | i } | j r0 d } n | j rB d } n d } | j r� | j d d � | j r� | j r� | j | j d | d d d
| �| j | j d | d d d | �q| j | j d | d d | j
| �n | | d <| j | j | � d S) N�destr� rb r r Zstore�actionZ_const�constTF) r3 r� r� r r� �popr r� Z
add_optionr� r )rr r� rG r� r( r- r- r. r� s(
zOption.add_to_parserc s+ g � � � f d d � } | � j � g } � j rL | j | � j � � � j pX d } g } � j d k r� � j r� | j d t � j t t f � r� d j d d � � j D� � n � j f � � j
r� | j d � | r d | r� | d
p� d d j | � f } � rd pd j | � | f S)
Nc sW t | � \ } } | r+ d g � d d � <� j rS � j rS | d � j � 7} | S)NTr� )r r� r r )r� r{ Z any_slashes)�any_prefix_is_slashrr r- r. � _write_opts: s z+Option.get_help_record.<locals>._write_optsr� z default: %sz, c s s | ] } d | Vq d S)z%sNr- )r �dr- r- r. r J s z)Option.get_help_record.<locals>.<genexpr>r� z%s[%s]z z; z / ) r� r� r r� r� r r0 r9 r
r� r� )rr rG r, r{ r� r� r- )r+ rr r. r� 7 s 7
)zOption.get_help_recordc C s` | j rP | j rP x6 | j j D]( } | j | j k r | j r | j Sq Wd St j | | � S)N) r� r r^ r` r3 r� r r� r� )rr rG rH r- r- r. r� T s zOption.get_defaultc sb � j � � } � j r( t � j | � St � j d | d � j d � j d � � f d d � �S)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.
r� r r Z
value_procc s � j � | � S)N)r )r )rG rr r- r. r q s z)Option.prompt_for_value.<locals>.<lambda>)r� r r r r r )rr rG r� r- )rG rr r. �prompt_for_value` s zOption.prompt_for_valuec C sj t j | | � } | d k r" | S| j rf | j d k rf d | j | j j � f } t j j | � Sd S)Nz%s_%s) r� r r rn r3 r# r$ r% r& )rr rG r{ r� r- r- r. r s s zOption.resolve_envvar_valuec C s� | j | � } | d k r d S| j d k t | j � } | d k r� | d k r� | j j | � } | j r� | j d k r� t | | j � } | S)Nr r )r r� r r� r� r r= )rr rG r{ Z value_depthr- r- r. r | s zOption.value_from_envvarc C sE | d k r2 | j d k r2 | j r2 | j | � St j | | | � S)N)r rm r. r� r )rr rG rI r- r- r. r � s
zOption.full_process_value)r5 r� r� r� r rs r� r� r� r� r. r r r r- r- r- r. r� � s B , r� c @ sm e Z d Z d Z d Z d d d � Z e d d � � Z d d � Z d
d � Z d d
� Z
d d � Z d S)r� z�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 parameter constructor.
ZargumentNc K s� | d k rB | j d � d k r* d } n | j d d � d k } t j | | d | | �| j d k r� | j d k r� t d � � d S)Nr� Fr� r r r� z>nargs=-1 in combination with a default value is not supported.)r& r� rs r� r� r� )rr r� r� r� r- r- r. rs � s zArgument.__init__c C s# | j d k r | j S| j j � S)N)r� r3 r# )rr r- r- r. r � s z Argument.human_readable_namec C sU | j d k r | j S| j j � } | j s8 d | } | j d k rQ | d 7} | S)Nz[%s]r z...)r� r3 r# r� r� )rr �varr- r- r. r � s
zArgument.make_metavarc C s� | s% | s d g g f St d � � t | � d k r` | d } } | j d d � j � } n7 t | � d k r� | \ } } n t d t | � � � | | g g f S)Nz%Could not determine name for argumentr r r r r� z@Arguments take exactly one or two parameter declarations, got %d)r� r� r" r# )rr r$ r� r3 �argr- r- r. r� � s
zArgument._parse_declsc C s
| j � g S)N)r )rr rG r- r- r. r� � s zArgument.get_usage_piecesc C s& | j d | j d | j d | � d S)Nr' r� rb )� add_argumentr3 r� )rr r� rG r- r- r. r� � s zArgument.add_to_parser) r5 r� r� r� r rs r� r r r� r� r� r- r- r- r. r� � s
r� )r^ r� )@r$ r( �
contextlibr � itertoolsr � functoolsr �typesr r r Zutilsr r
r r �
exceptionsr
r r r r Ztermuir r Z
formattingr r r� r r �globalsr r Z_compatr r r Z _unicodefunr r �objectr r� r� r' r8 r= rL rN rZ r[ r� r� r1 r� r� r� r� r� Z
decoratorsr^ r� r- r- r- r. �<module> sF "(
� ����5 �� <