⚝
One Hat Cyber Team
⚝
Your IP:
216.73.216.144
Server IP:
157.245.143.252
Server:
Linux www 6.11.0-9-generic #9-Ubuntu SMP PREEMPT_DYNAMIC Mon Oct 14 13:19:59 UTC 2024 x86_64
Server Software:
nginx/1.26.0
PHP Version:
8.3.11
Buat File
|
Buat Folder
Eksekusi
Dir :
~
/
lib
/
python3
/
dist-packages
/
click
/
__pycache__
/
View File Name :
core.cpython-312.pyc
Wd 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 ejd r d dl3Z4d d"l5m6Z6 ejn d#ejp d$ejr f % Z: ejn d& Z;d'd(d)e<d*ejz ej| e<d+f fd,Z? dNd-d.d/e<d0d+d1e@d*df d2ZAd3ej e; d4eCd*ej ej| e;d$f fd5ZEe dOd'd(d6ej d7 d*ejz d fd8 ZGd9ej d7 d:ej d7 d*ej d7 fd;ZI G d< d=e j ZK G d> d( ZL G d? d@ ZM G dA d+eM ZN G dB d.eN ZO G dC dDeO ZP G dE dFeO ZQdGejr d*ejz ejr fdHZR G dI d7 ZS G dJ dKeS ZT G dL dMeS ZUy)P N)abc)contextmanager) ExitStack)update_wrapper)gettext)ngettext)repeat) TracebackType )typesAbort) BadParameter)ClickExceptionExit)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)PacifyFlushWrapperCompletionItemF.)boundVctxContext incompletereturnCommandc # K t j t | j }|j | D ]< }|j | s|j | | }|*|j r7||f > yw)zList 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)tcast MultiCommandcommand list_commands startswith get_commandhidden)r, r. multinamer5 s ,/usr/lib/python3/dist-packages/click/core.py_complete_visible_commandsr= 0 se FF< -E##C( ??: &''T2G"7>>Gm# )s A A8 A8" A8/ A8 base_commandr4 cmd_namecmdregisterc | j rt |t sy |rd}nd}t | d| j d|d|dt | j dt | j d| j d ) 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 isinstancer4 RuntimeErrorr; type__name__)r> r? r@ rA hints r< _check_multicommandrI C s Z\%B < = & <,,/ 0 < $<vd3i.@.@-A T, / 8 8 9 : $ iterable batch_sizec J t t t t | | S N)listzipr iter)rK rL s r< batchrR [ s VDNJ78 99rJ param Parameterc # K d y# t $ r.}|j | |_ ||j ||_ d}~wt $ r}|j | |_ d}~ww xY ww)z>Context manager that attaches extra information to exceptions.N)r r, rS r )r, rS es r< augment_usage_errorsrW _ sa 55=AE AG 55=AE s. A# A# A ); A AA A#invocation_orderdeclaration_orderc h dddt j t t f f fd }t || S )zGiven 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. itemrT r/ c z j | }| j |fS # t $ r t d }Y %w xY w)Ninf)index ValueErrorfloatis_eager)r[ idxrX s r< sort_keyz,iter_params_for_processing.<locals>.sort_key{ sF )//5C == #%% ,C s # ::key)r2 Tupleboolr` sorted)rX rY rc s ` r< iter_params_for_processingri r s3 &{ &qwwtU{'; & # 22rJ c e Zd ZdZ ej Z ej Z ej Z ej Z ej Z y)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) rG __module__ __qualname____doc__enumauto COMMANDLINE ENVIRONMENTDEFAULT DEFAULT_MAPPROMPT rJ r< rk rk sY $))+K:$))+K>diikG6$))+KA TYY[F@rJ rk c # e Zd ZU dZeZej d ed< dJdddej d dej e d ej ej d ej e d ej ej e ej f d ej e d ej e dedej e dej e dej e dej ej e dej ej e ge f dej e dej e ddf"dZdej$ e ej f fdZdKdZdej ej e dej e d ej e ddfd ZedLd edej2 d fd Zedej$ e ej f fd Z defd!Z d"ej< e de fd#Z d$ej d%ej f dej d%ej f fd&Z!dMd'Z"ede fd( Z#dKd)Z$d*ej e dej e fd+Z%d*ej e de fd,Z&ejN dLd-e d.d/dej ej fd0 Z(ejN dNd-e d.d1dej ejR ej ej g ej f f fd2 Z(dLd-e d.edej ej fd3Z(d4e dd5fd6Z*dOd7Z+dPd8e dd5fd9Z,de fd:Z-de fd;Z.dQd<Z/ejN d=d>d?ej d@ej de fdA Z0ejN d=dd?ej d@ej dej fdB Z0d=ejR dC d?ej d@ej dejR ej e f fdDZ0dEdd?ej d@ej dej fdFZ1d-e dGe2ddfdHZ3d-e dej e2 fdIZ4y)Rr- 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_classNr5 r0 parent info_nameobjauto_envvar_prefix default_mapterminal_widthmax_content_widthresilient_parsingallow_extra_argsallow_interspersed_argsignore_unknown_optionshelp_option_namestoken_normalize_funccolor show_defaultr/ c > || _ || _ || _ i | _ g | _ g | _ |rt |j n t | _ || |j }|| _ t |di | _ |+|)|'|j |j j | }|| _ d | _ || |j }|| _ || |j }|| _ | |j } | | _ | |j" } | | _ | |j$ } | | _ | | |j& } ndg} | | _ || |j( }|| _ | | _ |D|R|j, F| j :|j, d| j j/ }n|j/ }||j1 dd }|| _ || |j2 }|| _ || |j4 }|| _ g | _ d| _ i | _ t= | _ y )Nmetaz--help_-r ) ry r5 rz paramsargsprotected_argsset _opt_prefixesr{ getattr_metar} getinvoked_subcommandr~ r r r r r r r r| upperreplacer r _close_callbacks_depth_parameter_sourcer _exit_stack)selfr5 ry rz r{ r| r} r~ r r r r r r r r r s r< __init__zContext.__init__ s ( " +- !# ,.FLV-A-A)BRURW ;6-**C )0)D %""". ,,00;KEP 48 !f&8 # 2 2N 0> $); & 8 8 3D # & 7 7 !1 " *&-&E&E # .E$ ! )%,%C%C " -C# $!$*$<$<!%-J! /@ 'F,>#)#>#> ! ! (9 %"--9NN. 0014>>3G3G3I2JK # "4!9!9!; )!3!;!;C!E 3E =V /LLE (- F$6!..L /;?A ?A $;rJ c | j j | | j | j | j | j | j dS )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 )r5 rz r r r r| )r5 to_info_dictrz r r r r| r s r< r zContext.to_info_dict sK ||006 $ 5 5'+'C'C&*&A&A"&"9"9 rJ c F | xj dz c_ t | | S Nr )r r r s r< __enter__zContext.__enter__ s q T rJ exc_type exc_valuetbc | xj dz c_ | j dk( r| j t y Nr r )r closer )r r r r s r< __exit__zContext.__exit__ s, q ;;! JJL rJ cleanupc # K |s| xj dz c_ | 5 }| ddd |s| xj dz c_ yy# 1 sw Y "xY w# |s| xj dz c_ w w xY ww)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 rvs r< scopez Context.scope se : KK1 K ! q q s1 A,A AA A,A A A))A,c | 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 s r< r z Context.meta s 4 zzrJ c P | j | j | j S )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)rx r~ r r s r< make_formatterzContext.make_formatter s- ##%%1G1G $ rJ context_managerc 8 | j 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 s r< with_resourcezContext.with_resource% s 6 --o>>rJ f.c 8 | j 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 s r< call_on_closezContext.call_on_closeB s ((++rJ c V | j j t | _ y)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 s r< r z Context.closeN s $;rJ c d}| j | j }| j | j j g}t | j j t rJ| j j j | D ]" }|j |j | $ dj | d| }|j S )zThe 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. ) rz ry command_pathrD r5 r0 get_paramsextendget_usage_piecesjoinlstrip)r r parent_command_pathrS s r< r zContext.command_pathW s >> % B ;; "#';;#;#;"< $++--w7 ![[ 0 0 ; ;D AE'..u/E/Ed/KL B HH 012!B48Byy{rJ c T | }|j |j }|j |S )z Finds the outermost context.ry )r nodes r< find_rootzContext.find_rootj s+ kk%;;D kk% rJ object_typec n | }|1t |j | r |j S |j }|1y)z)Finds the closest object of a given type.N)rD r{ ry )r r r s r< find_objectzContext.find_objectq s: &* $((K0xx;;D rJ c H | j | }| | x| _ }|S )zLike :meth:`find_object` but sets the innermost object to a new instance of `object_type` if it does not exist. )r r{ )r r r s r< ensure_objectzContext.ensure_object} s, k * : 'M )DHr rJ r; callte.Literal[True]c y rN rv r r; r s r< lookup_defaultzContext.lookup_default rJ zte.Literal[False]c y rN rv r s r< r zContext.lookup_default r rJ c ~ | j 1| j j | }|rt | r | S |S y)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)r} r callable)r r; r values r< r zContext.lookup_default s> '$$((.E wLrJ message te.NoReturnc t || )zAborts the execution of the program with a specific error message. :param message: the error message to fail with. r )r r s r< failz Context.fail s $''rJ c t )zAborts the script.r r s r< abortz Context.abort s g rJ codec t | )z-Exits the application with a given exit code.r )r r s r< exitz Context.exit s 4jrJ c 8 | j j | S )zaHelper method to get formatted usage string for the current context and command. )r5 get_usager s r< r zContext.get_usage s ||%%d++rJ c 8 | j j | S )z^Helper method to get formatted help page for the current context and command. )r5 get_helpr s r< r zContext.get_help s ||$$T**rJ c > t | ||j | S )zvCreate a new context of the same type as this context, but for a new command. :meta private: rz ry )rF r; )r r5 s r< _make_sub_contextzContext._make_sub_context s tDz'W\\$GGrJ _Context__callbackt.Callable[..., V]r kwargsc y rN rv _Context__selfr r r s r< invokezContext.invoke rJ c y rN rv r s r< r zContext.invoke r rJ )r0 r c > t |t r|}|j t d t j d|j }| j | }|j D ]L }|j |vs|j s |j ||j | ||j < N |j j | n| }t | 5 |5 ||i |cddd cddd S # 1 sw Y nxY w ddd y# 1 sw Y yxY w)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 )rD r0 r TypeErrorr2 r3 r r r; expose_valuetype_cast_value get_defaultupdaterW )r r r r other_cmdr, rS s r< r zContext.invoke s 2 j' *"I!!) U VV$8):L:L M **95C"))::V+0B0B).)>)>U . .s 3*F5::& * JJ f %C !& )!4262 * ) * ) )s$ D"C=* D=D DD _Context__cmdc t |t s t d | j D ] }||vs| j | ||< | j |g|i |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.)rD r0 r r r )r r r r rS s r< forwardzContext.forward s_ %) 89 9]]EF" & e 4u # v}}U4T4V44rJ sourcec " || j |< y)zSet 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 r; r s r< set_parameter_sourcez Context.set_parameter_source& s (. t$rJ c 8 | j 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 r; s r< get_parameter_sourcez Context.get_parameter_source/ s %%))$//rJ )NNNNNNNFNNNNNNN)r/ r- T)r/ N.)r/ r )r )r5 r0 r/ r- )5rG rl rm rn r rx r2 Type__annotations__OptionalstrAnyMutableMappingintrg ListCallabler 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 rk r r rv rJ r< r- r- s \B 0=OQVVO,< )-%)!%.2@D*.-1"'-1483759CG"&)-#j'j' 9%j' ::c? j' ZZ j' JJsO j' ZZ 0 0aee <=j' 3j' ::c?j' j' **T*j' "#D!1j' !" 4 0j' ::affSk2 j' jjSE3J)? @ j' zz$ !j'" jj&#j'$ %j'X affS!%%Z 0 * **QVVM 23 ::m, JJ} % #!T #!QZZ -B #! #!J affS!%%Z( 6 ?Q-=-=a-@ ?Q ?: ,qzz#quu* 5 ,!**S!%%Z:P ,' c $ qvvay QZZ] q ZZ48 1 AEE ZZ58 2 AGGAEE1::b!%%i#8 89 : 3 d ajj>O ((C (M ( ] ,3 , +# + H ZZ ( uu %% ZZ uu %% 33GG ;<33 uu33 %% 33 33j5 5)*5:;%%5 5*. .o .$ .0 0O1L 0rJ c b e Zd ZU dZeZej e ed< dZ dZ dZ d&dej e dej ej e ej f ddfd Zd edej" e ej f fd Zde fd Zd ede fd Zd ede fdZ d&dej e dej, e dej e dej def dZd edej, e dej, e fdZd edej fdZd ede dej, d fdZej6 d'dej ej8 e dej e dej e dd dej dd f d Z ej6 d(dej ej8 e dej e dej e de dej dej f d Z d)dej ej8 e dej e dej e de d e dej dej fd!Z d&d"ej e ej f de dej e ddfd#Z dej d$ej dej fd%Z y)* 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_classFTNr; context_settingsr/ c ( || _ |i }|| _ y rN )r; r )r r; r s r< r zBaseCommand.__init__c s" # ! ?O rJ r, c 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 r; r; r r, s r< r zBaseCommand.to_info_dictt s ""rJ c P d| j j d| j dS N<r > __class__rG r; r s r< __repr__zBaseCommand.__repr__ & 4>>**+1TYYKq99rJ c t d )Nz Base commands cannot get usageNotImplementedErrorr s r< r zBaseCommand.get_usage s !"BCCrJ c t d )Nz Base commands cannot get helpr$ r s r< r zBaseCommand.get_help s !"ABBrJ rz r ry extrac | j j D ] \ }}||vs |||< | j | f||d|}|j d 5 | j || ddd |S # 1 sw Y |S xY w)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 Fr N)r itemsr r parse_args)r rz r ry r' re r r, s r< make_contextzBaseCommand.make_context s 6 //557JC% "c 8 !d %f 8= YYuY % OOC & & & s A22A<c t d )zGiven 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.r$ )r r, r s r< r+ zBaseCommand.parse_args s ""UVVrJ c t d )z{Given a context, this invokes the command. The default implementation is raising a not implemented error. z*Base commands are not invocable by defaultr$ r s r< r zBaseCommand.invoke s ""NOOrJ r. r( c ddl m g }j nj t j t r;j j r%|j fdt | D j n|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' c 3 p K | ]- \ }}|j vr ||j / ywhelpN)r get_short_help_str).0r; r5 r( r, s r< <genexpr>z-BaseCommand.shell_complete.<locals>.<genexpr> s> )T g3#5#55 #4g.H.H.JKK)Ts 36) click.shell_completionr( ry rD r5 r4 rC r r= )r r, r. resultsr( s ` @r< shell_completezBaseCommand.shell_complete sm :,.jj$**C#++|49J9J )CC)T jj$ rJ prog_name complete_varstandalone_moder r c y rN rv r r r: r; r< r' s r< mainzBaseCommand.main rJ c y rN rv r> s r< r? zBaseCommand.main r@ rJ windows_expand_argsc . |4t j dd }t j dk( r|rt | }n t | }| t }| j ||| | j ||fi |5 }| j | }|s |cddd S |j ddd yy# 1 sw Y xY w# t t f$ r*} t t j t | d} ~ wt $ r<} |s | j# t j | j$ Y d} ~ yd} ~ wt& $ r} | j( t( j* k( rt- j. t, j0 t3 t j4 t _ t- j. t, j0 t3 t j t _ t j d n Y d} ~ yd} ~ ww xY w# t6 $ r=} |r t j | j$ n| j$ cY d} ~ S Y d} ~ yd} ~ wt $ r? |s t t9 d t j t j d Y yw xY w)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!) sysargvosr; r" rO r! _main_shell_completionr, r r EOFErrorKeyboardInterruptr# stderrr r show exit_codeOSErrorerrnoEPIPEr2 r3 TextIOr& stdoutr r ) r r r: r; r< rB r' r, r rV s r< r? zBaseCommand.main s f <88AB<Dww$#6#D):D ,.I ##E9lC. &T&&y$@%@C S)B* ! A@ HHJ A@@ /0 %#**%g1$! &&%% 77ekk)!"2DSZZ2P!QCJ!"2DSZZ2P!QCJHHQK # % {{" & " : SZZ 0 HHQK s #B< 7B0 B< B0&B< 0B95B< <H %C00 H<2D3.H 3 H?B<H ;H HH J-I >J AJJctx_argsc |6|j dd j dd }d| dj }t j j | }|syddlm} || |||| }t j | y)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 . _COMPLETEr )r9 ) r r rH environr shell_completionr9 rF r )r rT r: r; complete_name instructionr9 r s r< rI z"BaseCommand._main_shell_completionc sx $ % - -c3 7 ? ?S IM }oY7==?Ljjnn\2 4 D(I|[ Q rJ r c & | j |i |S )zAlias for :meth:`main`.)r? r r r s r< __call__zBaseCommand.__call__ s tyy$)&))rJ rN )NNNT)NNN.)NNNTT)!rG rl rm rn r- r r2 r r r r r r r r r r r r r! r r r r, r+ r r9 r Sequencer? rg rI r^ rv rJ r< r r B s 0 &-M166'?, " " FJOjjoO **Q%5%5c155j%ABO O" # #AFF3:,> # :# :DW D DCG C C '+ %::c?% ffSk% 7# % % %NWg WQVVC[ WQVVC[ WP' Paee P ' s qvvFV?W : ZZ -1%)(,.2 jjC ) ::c? jjo , ZZ -1%)(, # jjC ) ::c? jjo -1%)(, $$( ojjC )o ::c?o jjo o o " o o oj )- ""3:. jjo @*aee *quu * *rJ r c e Zd ZdZ d+dej e dej ej eej f dej ej dej f dej ej d d ej e d ej e d ej e d ej e d e de de de ddf fd Z de dej eej f f fd Zde defdZde dej d fdZde deddfdZde dej e fdZde dej e fdZde dej d fd Zde defd Zde defd Zd,d edefd Zde deddfd!Z de deddfd"Z de deddfd#Z de deddfd$Z de d%ej e dej e fd&Z de dej fd'Z!de d(edej d) f fd* Z" xZ#S )-r0 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. Nr; r r .r rT r3 epilog short_helpoptions_metavaradd_help_optionno_args_is_helpr9 deprecatedr/ c t | || || _ |xs g | _ || _ || _ || _ || _ | | _ | | _ | | _ | | _ y rN ) superr r r r3 ra rc rb rd re r9 rf )r r; r r r r3 ra rb rc rd re r9 rf r s r< r zCommand.__init__ sf /0 ! ,2<R . $ . . $rJ r, c t | | }|j | j | D cg c] }|j c}| j | j | j | j | j |S c c}w )N)r r3 ra rb r9 rf ) rh r r r r3 ra rb r9 rf )r r, info_dictrS r s r< r zCommand.to_info_dict s| G(- 6:ooc6JK6JUE&&(6JK;;;; Ls Bc |j }| j || |j j d S )zmFormats the usage line into a string and returns it. Calls :meth:`format_usage` internally. )r format_usagegetvaluerstripr r, formatters r< r zCommand.get_usage s< &&( #y)!!#**400rJ c P | j }| j | }|g ||}|S rN )r get_help_option)r r, r help_options r< r zCommand.get_params s5 [[**3/ "#2#{#B rJ rq c | | j | }|j |j dj | y)zsWrites the usage line into the formatter. This is a low-level method called by :meth:`get_usage`. r N)collect_usage_pieces write_usager r )r r, rq piecess r< rm zCommand.format_usage s3 **3/ c . .0@ArJ c | j r | j gng }| j | D ]" }|j |j | $ |S )zhReturns all the pieces that go into the usage line and returns it as a list of strings. )rc r r r )r r, r rS s r< rv z Command.collect_usage_pieces sM (,';';d"" #__S)E IIe,,S1 2 * rJ c t |j }| j D ]8 }|j |j |j |j : t | S )z&Returns the names for the help option.)r r r difference_updateoptssecondary_optsrO )r r, all_namesrS s r< get_help_option_namesz Command.get_help_option_names sR --. [[E ' ' 3 ' '(<(< = ! I rJ Optionc | j | }|r | j sydt dddt ddfd}t |ddd |t d S ) z Returns the help option object.Nr, rS rT r r/ c |rC| j s6t | j | j | j y y y )Nr )r r# r r r )r, rS r s r< show_helpz*Command.get_help_option.<locals>.show_help s1 S 2 2S\\^3995 3urJ TFzShow this message and exit.)is_flagra r r r3 )r rd r- r r r )r r, help_optionsr s r< rs zCommand.get_help_option sh 11#6 4#7#7 7 ; s t 01 rJ c l t | }| j | D ] }|j || |S )z6Creates the underlying option parser for this command.)r r add_to_parser)r r, parserrS s r< make_parserzCommand.make_parser s4 c"__S)E , * rJ c |j }| j || |j j d S )zfFormats the help into a string and returns it. Calls :meth:`format_help` internally. rl )r format_helprn ro rp s r< r zCommand.get_help' s< &&( i(!!#**400rJ limitc | j r t j | j }n%| j rt | j | }nd}| j rt d j | }|j S )z`Gets short help for the command or makes it by shortening the long help string. r (Deprecated) {text}text) rb inspectcleandocr3 r$ rf r formatstrip)r r r s r< r4 zCommand.get_short_help_str0 sg ??##DOO4D YY*499e<DD ??*+222=Dzz|rJ c | j || | j || | j || | j || y)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)rm format_help_textformat_options format_epilogrp s r< r zCommand.format_help@ sD #y) c9- C+ 3 *rJ c d | j 2t j | j j d d }nd}| j rt d j | }|r;|j |j 5 |j | ddd yy# 1 sw Y yxY w)z3Writes the help text to the formatter if it exists.N r r r r ) r3 r r partitionrf r r write_paragraph indentation write_text)r r, rq r s r< r zCommand.format_help_textQ s 99 ##DII.88>qADD ??*+222=D % % '&&($$T* )( )(s B&&B/c g }| j | D ]' }|j | }||j | ) |r5|j t d 5 |j | ddd yy# 1 sw Y yxY w)z8Writes all the options into the formatter if they exist.NOptions)r get_help_recordappendsectionr write_dl)r r, rq r| rS r s r< r zCommand.format_optionsb ss __S)E&&s+B~ B * ""1Y<0""4( 10 00s A66A?c | j rZt j | j }|j |j 5 |j | ddd yy# 1 sw Y yxY w)z2Writes the epilog into the formatter if it exists.N)ra r r r r r )r r, rq ra s r< r zCommand.format_epilogn sY ;; %%dkk2F % % '&&($$V, )( )(s A((A1r c |sM| j rA|j s5t |j |j |j | j | }|j | \ }}}t || j | D ] }|j ||| \ }} |rj|j s^|j sR|j t ddt | j dj! t# t$ | ||_ |j( j+ |j( |S )Nr )r z&Got unexpected extra argument ({args})z'Got unexpected extra arguments ({args})r )re r r# r r r r r+ ri r handle_parse_resultr r r lenr r mapr r r r )r r, r r r| param_orderrS r s r< r+ zCommand.parse_argsw s ,,S5J5J syy 1 HHJ!!#&"("3"3"3"> dK/ T__S=QRE 33CtDKE4 S ,,S5J5J HH<=I &chhs3~ 6&7 !5!56 rJ c | j r=t d j | j }t t |d d | j ' |j | j fi |j S y)zeGiven a context, this invokes the attached callback (if it exists) in the right way. z7DeprecationWarning: The command {name!r} is deprecated.r red)fgT)errN) rf r r r; r# r r r r )r r, r s r< r zCommand.invoke sk ??If$))f$ w5)t 4 == $ 3::dmm:szz: : %rJ r. r( c ddl m g }rd j s| j | D ] t t rCj s7j s,|j j t j u rW|j fdg j j D |j t | A | |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 h K | ]) }|j r |j + ywr1 )r7 r3 )r5 r; r( r. rS s r< r6 z)Command.shell_complete.<locals>.<genexpr> s3 Dz2 #4ejj99 Ds /2)r7 r( isalnumr rD r r9 multipler r; rk rq r r| r} rh r9 )r r, r. r8 r( rS r s ` @@r< r9 zCommand.shell_complete s :,. jm 3 3 5 -"5&1 || !NN 4 4UZZ @*66 7 D%** Du/C/C D .$ uw-c:>?rJ ) NNNNNNz [OPTIONS]TFFF)- )$rG rl rm rn r2 r r r r r r rg r r- r r r r r rm rv r rs r r r r r4 r r r r r+ r r9 __classcell__r s @r< r0 r0 s 'X FJ7;26 $"&&*+6 $ % %jjo % **Q%5%5c155j%AB % **QZZQUU 34 % 166+./ % jjo % 3 % JJsO % C % % % % % %@ AFF3:,> 1W 1 1g !&&*= B BM Bd B AFF3K QVVC[ 7 qzz(/C *w < 1G 1 1 S +w += +T +"+G + +$ +" )' )m ) )- -] -t -g QVVC[ QVVC[ 0 ;' ;aee ;!' !s !qvvFV?W ! !rJ c t e Zd ZdZdZdZ d!dej e de dej e dej e d e d ej ej d ej f d ej d df fd Z de d ej eej f f fd Zde d ej e f fd Zde ded df fd Zd"de d ej egef fdZde ded dfdZde dej e d ej e f fd Zde d ej f fd Zde dej e d ej2 ej e ej e ej e f fdZde ded ej e fd Z de d ej e fd Z de d ed ej d f fd Z xZ S )#r4 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`. TFNr; invoke_without_commandre subcommand_metavarrC result_callback.attrsr/ c t | |fi | || }|| _ || _ ||rd}nd}|| _ || _ || _ | j r:| j D ]* }t |t s|j r!t d y y )Nz*COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...zCOMMAND [ARGS]...z<Multi commands in chain mode cannot have optional arguments.) rh r re r r rC _result_callbackr rD ArgumentrequiredrE ) r r; r re r rC r r rS r s r< r zMultiCommand.__init__ s '' ""8 8O . &<# %%Q"%8""4 !0 :: eX.u~~&/ % rJ r, c R t | | }i }| j | D ]W }| j || }||j | }|j d 5 |j | ||< d d d Y |j || j |S # 1 sw Y xY w)NFr) )commandsrC )rh r r6 r8 r r r rC )r r, rj r r; r5 sub_ctxr s r< r zMultiCommand.to_info_dict s G(- &&s+D&&sD1G++G4G u -!(!5!5g!> .- , ($**= .-s B B& c \ t | | }|j | j |S rN )rh rv r r )r r, r r s r< rv z!MultiCommand.collect_usage_pieces s) W )# . $))* rJ rq c J t | || | j || y rN )rh r format_commands)r r, rq r s r< r zMultiCommand.format_options s" sI. S),rJ r c 0 dt dt f fd }|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 r/ c j r _ S fd}t t j t | x_ }|S )Nc 4 | g|i |} |g|i |S rN rv )_MultiCommand__valuer r innerr old_callbacks r< functionzAMultiCommand.result_callback.<locals>.decorator.<locals>.functionB s, $W>t>v>0000rJ )r r r2 r3 r) )r r r r r r s ` @r< decoratorz/MultiCommand.result_callback.<locals>.decorator; sN 00L#w()% 1 *8q(8KQ)O OD !BIrJ )r) )r r r s `` r< r z MultiCommand.result_callback s : q rJ c g }| j | D ]7 }| j || }||j r%|j ||f 9 t | r|j dz t d |D z }g }|D ]) \ }}|j | }|j ||f + |r5|j t d 5 |j | ddd yyy# 1 sw Y yxY w)zeExtra format methods for multi methods that adds all the commands after the options. N c 3 8 K | ] }t |d yw)r Nr )r5 r@ s r< r6 z/MultiCommand.format_commands.<locals>.<genexpr>\ s -NXcc#a&kXs Commands) r6 r8 r9 r r r maxr4 r r r ) r r, rq r subcommandr@ r rowsr3 s r< r z MultiCommand.format_commandsK s ,,S1J""3 3C{zz OOZ - . 2 x= OOa'#-NX-N*NNED#+ C--e4 Z ./ $, &&q}5 &&t, 65 65s C$$C-r c T |sM| j rA|j s5t |j |j |j t | || }| j r||_ g |_ |j S |r|d d |dd c|_ |_ |j S )Nr r ) re r r# r r r rh r+ rC r r )r r, r restr s r< r+ zMultiCommand.parse_argsg s ,,S5J5J syy 1 HHJw!#t, ::!%C CH xx +/8T!"X (C xxrJ c dt j dt j f fd }j sW j r15 t } | j rg n| cd d d S j t d g j j }g _ g _ j s}5 j | \ }}}|J |_ t |j || }|5 ||j j | cd d d cd d d S 5 |rdnd _ t g }|rX j | \ }}}|J |j ||dd }|j | |j g c}|_ |rXg }|D ]7 }|5 |j |j j | d d d 9 || cd d d S # 1 sw Y xY w# 1 sw Y nxY w d d d # 1 sw Y xY w# 1 sw Y xY w# 1 sw Y y xY w) Nr r/ c p j ( j j | fi j } | S rN )r r r r r, r s r< _process_resultz,MultiCommand.invoke.<locals>._process_resultw s5 $$0" 4#8#8%N3::NLrJ zMissing command.r *TF)ry r r )r2 r r r rh r rC r r r resolve_commandr r, r5 r ) r r, r r r r? r@ r contextsr s `` r< r zMultiCommand.invokev s% 155 QUU !!** ,B*2D S HHQ)* + 0##/chh/ zz &*&:&:3&E##t&)1&s# **8T#*F *7??+A+A'+JK W ,0SdC " GN3 H&*&:&:3&E##t& ** %),1 + (%,\\2"gl B# IIgoo 4 4W => W $ #2&3 S= S, WW J W/ Ss\ %HAH* !H, H*A6I8 I+H6,IHH H**H36H? ;II c t |d }|}| j || }|/|j #|j | }| j || }|`|j sTt | d r | j ||j |j t d j | |r|nd ||dd fS )Nr zNo such command {name!r}.r r ) r% r8 r r r r+ r r r r )r r, r r? original_cmd_namer@ s r< r z MultiCommand.resolve_command s DG$ $ sH- ;333?//9H""31C ;s 4 4"1%SXX. HHQ23::@Q:R S xD#tABx77rJ r? c t )z{Given a context and a command name, this returns a :class:`Command` object if it exists or returns `None`. r$ r r, r? s r< r8 zMultiCommand.get_command s "!rJ c g S )zTReturns a list of subcommand names in the order they should appear. rv r s r< r6 zMultiCommand.list_commands s rJ r. r( c ddl m} t || D cg c] \ }} |||j }}}|j t | || |S c c}}w )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' r2 )r7 r( r= r4 r rh r9 )r r, r. r( r; r5 r8 r s r< r9 zMultiCommand.shell_complete si : "<C!L !L g 4g&@&@&B C!L uw-c:>? s "A )NFNNFNF) rG rl rm rn r r r2 r r rg r r r r- r r r rv r r r) r r r+ r rf r0 r r8 r6 r9 r r s @r< r4 r4 sE 2 # !%',,0.2>B$jjo$ !%$ D) $ JJsO $ $ AJJsAEEz$:;$ $ $L AFF3:,> $ AFF3K -' -m - -+t + A368J +Z-7 -} - -8 g QVVC[ QVVC[ B'' B'aee B'H88"#&&+8 C !**W"5qvvc{B C86"w "# "!**W:M " QVVC[ ' s qvvFV?W rJ c e Zd ZU dZdZej ej e e d< dZ ej ej ej d ej e f e d< ddej e dej ej ej e ef ej e f dej ddf fd Zdd edej e ddfd Zej& d ej( d ej f defd Zej& dej dej dej( ej( d ej f gef fd Zdej dej dej ej( ej( d ej f gef ef fdZej& d ej( d ej f dd fd Zej& dej dej dej( ej( d ej f gd f fd Zdej dej dej ej( ej( d ej f gd f d f fdZdede dej e fdZdedej2 e fdZ xZS ) 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_classr; r r r/ c t | |fi | | i }|| _ y t |t j r'|D ci c] }|j |j | }}|| _ y c c}w rN )rh r rD r r_ r; r )r r; r r cr s r< r zGroup.__init__ sq '' H 9A #,, /+3J8aqvv7I 8HJ 9A Ks A'A'r@ c z |xs |j }| t d t | ||d || j |< y)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)rA )r; r rI r )r r@ r; s r< add_commandzGroup.add_command+ s? sxx < 23 3D$d; ! drJ _Group__func.c y rN rv r r s r< r5 z Group.command5 rJ r r c y rN rv r] s r< r5 z Group.command9 r rJ c H ddl m d}r+t d r t dk( rrJ d \ }d j r j d j d< dt j d t j f d t f fd }| || 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 )r5 Nr z7Use 'command(**kwargs)(callable)' to provide arguments.rv clsr .r/ c F i | }j | |S rN r )r r@ r r5 r r s r< r z Group.command.<locals>.decorator^ s, 37D3F3A6C S !JrJ ) decoratorsr5 r r r r r2 r r r0 )r r r funcr r5 s ``` @r< r5 z Group.command? s " (37 HT!W%D Qv IH I-GTD &**U"3"; . .F5M CJ/ G T? "rJ c y rN rv r s r< groupz Group.grouph r rJ c y rN rv r] s r< r z Group.groupl r rJ c ddl m d}r+t d r t dk( rrJ d \ }d j Aj d 0 j t u rt d< n j d< dt j d t j f d d f fd }| || 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.rv r r .r/ r c F i | }j | |S rN r )r r@ r r r r s r< r z Group.group.<locals>.decorator s, ///2C S !JrJ ) r r r r r r rF r2 r r )r r r r r r s ``` @r< r z Group.groupr s " &37 HT!W%D Qv GF G-GTD 'FJJu,=,E 4' $T u $ 0 0u CJ/ G T? "rJ r, r? c 8 | j j | S rN )r r r s r< r8 zGroup.get_command s }} **rJ c , t | j S rN )rh r r s r< r6 zGroup.list_commands s dmm$$rJ NNrN ) rG rl rm rn r r2 r r r0 r r r rF r r r_ r r r r r r5 r r- r8 r r6 r r s @r< r r s ( 26M1::affWo.5 GKKAGGAFF7OQVVD\$A BCJ !% AjjoA ** GGA$$S'\2AJJw4GG H A A A$"w "ajjo " " ZZ ajjaee 4 ZZ UU &'ee QZZQUU +,g5 6 'UU'&'ee' QZZQUU 3 4g =>G H'R ZZ AJJsAEEz 2 w ZZ UU &'ee QZZQUU +,g5 6 *UU*&'ee* QZZQUU 3 4g =>G H*X+w +# +!**W:M +% %QVVC[ %rJ r c e Zd ZdZ ddej e dej ej e dej ddf fd Z deddfd Z d e d edej e fd Zd e dej e fd Z xZS )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``. Nr; sourcesr r/ c < t | |fi | |xs g | _ y rN )rh r r )r r; r r r s r< r zCommandCollection.__init__ s" ''-4] rJ multi_cmdc : | j j | y)z1Adds a new multi command to the chain dispatcher.N)r r )r r s r< add_sourcez CommandCollection.add_source s I&rJ r, r? c | j D ]3 }|j || }|| j r t | || |c S y rN )r r8 rC rI )r r, r? r r s r< r8 z CommandCollection.get_command sD llF##C2B~::'h; # rJ c t }| j D ]" }|j |j | $ t | S rN )r r r r6 rh )r r, r r s r< r6 z CommandCollection.list_commands s: llF IIf**3/ 0 # bzrJ r )rG rl rm rn r2 r r r r4 r r r r- r0 r8 r6 r r s @r< r r s !%48;jjo; AFF< 01; ; ;'L 'T ' w # !**W:M QVVC[ rJ r r c D t | t rt t | S )ztCheck if the value is iterable but not a string. Raises a type error, or return an iterator over the value. )rD r r rQ )r s r< _check_iterr s % ;rJ c e Zd ZdZdZ d0dej ej e dej ej e j ej f de dej ej ej ej g ej f f dej ej ed ej gej f d ej e d e d ej e d e d e dej ej eej e f dej ej ed egej ej" d ej" e f f ddfdZdej& eej f fdZdefdZdej e d e dej, ej e ej" e ej" e f fdZedefd ZdefdZej6 d1dedddej ej fd Z ej6 d2dede dej ej ej ej g ej f f fd Z d1dede dej ej ej ej g ej f f fd Z d e deddfd Z ded!ej> eej f dej, ej e f fd"Z!ded#ej dej fd$Z"d#ej de fd%Z#ded#ej dej fd&Z$dedej e fd'Z%dedej ej fd(Z&ded!ej> eej f d)ej" e dej, ej ej" e f fd*Z'dedej ej, eef fd+Z(dedej" e fd,Z)dedefd-Z*ded.edej" d fd/Z+y)3rT 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. parameterN param_declsrF r defaultr nargsr metavarr ra envvarr9 r( r/ c | | | | j |xs d| \ | _ | _ | _ t j || | _ |/| j j r| j j }nd}|| _ || _ || _ || _ | | _ || _ | | _ || _ | | _ | | _ | j j rL|| j j k7 r3t' d| j j d| j d| d t) | s|nd } | Z|r t+ t- | d } |dk7 r<| 9 t- | |dkD r't1 | |k7 r|rd nd }t' d | d | d y y y y y # t. $ r t' d d w xY w# t. $ r |rd}nd }t' | d w xY w)Nrv r z'nargs' must be z (or None) for type z , but it was rV 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 lengthlengthz 'default' z must match nargs=) _parse_declsr; r| r} r convert_typerF is_compositearityr r r r r r ra r r _custom_shell_completer_ r nextr r r )r r rF r r r r r r r ra r r9 check_defaultr subjects r< r zParameter.__init__( s ( 484E4E 2|5 1 49d 1 &+%7%7g%F =yy%% ( &4# yy%%%499??*B &tyy&7 8 !YYM ugQ@ ,4G+<G$M ($(,[ -G(N A:-"; <#M2 qyS %75%@3;- ( ( 1CE7! L &Ay #<: ) % $ ( O #$$ % <#!: $ 'TG ( 1t; <s 9F F* F'* Gc | j | j | j | j | j j | j | j | j | j | j d S )zGather 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 ) r; param_type_namer| r} rF r r r r r ) r; r r| r} rF r r r r r r r s r< r zParameter.to_info_dict sa II # 3 3II " 1 1II**, ZZ ||kk rJ c P d| j j d| j dS r r r s r< r! zParameter.__repr__ r" rJ declsc t rN r$ )r r r s r< r zParameter._parse_decls s "##rJ c | 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 s r< human_readable_namez Parameter.human_readable_name s yyrJ c | j | j S | j j | }|$| j j j }| j dk7 r|dz }|S )Nr ...)r rF get_metavarr; r r )r r s r< make_metavarzParameter.make_metavar s_ << #<< ))''- ?iinn**,G ::? u GrJ r, r r c y rN rv r r, r s r< r zParameter.get_default r rJ c y rN rv r) s r< r zParameter.get_default r rJ c |j | j d }| | j }|rt | r | }|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. Fr )r r; r r )r r, r r s r< r zParameter.get_default s@ . ""4995"9 =LLE HUOGE rJ r c t rN r$ r r r, s r< r zParameter.add_to_parser s !##rJ r| c F |j | j }t j }|!| j | }t j }|+|j | j }t j }|!| j | }t j }||fS rN ) r r; rk rq value_from_envvarrr r rt r rs )r r, r| r r s r< consume_valuezParameter.consume_value s # ,, =**3/E$00F =&&tyy1E$00F =$$S)E$,,Ff} rJ r c r | j s j dk( rdS dS dt j dt j t j f fd j dk( s j j r(dt j dt j f fd n` j dk( r)dt j dt j f fd n(dt j dt j f fd j rt fd | D S | S ) zuConvert and validate a value against the option's :attr:`type`, :attr:`multiple`, and :attr:`nargs`. Nrv r r/ c f t | S # t $ r t t d d w xY w)NzValue must be an iterable.r, rS )r r r r r s r< check_iterz-Parameter.type_cast_value.<locals>.check_iter sA "5)) #23D s "0r c , j | S )N)rS r, rF r s r< convertz*Parameter.type_cast_value.<locals>.convert s yydy<<rJ c : t fd | D S )Nc 3 D K | ] }j | y wrN r8 r5 xr, r s r< r6 z=Parameter.type_cast_value.<locals>.convert.<locals>.<genexpr> s! P>OTYYq$ 4>O )tupler r6 r, r s r< r9 z*Parameter.type_cast_value.<locals>.convert s Pj>O PPPrJ c t | } t | j k7 rFt t ddt | j j t | t fd| D S )Nz%Takes {nargs} values but 1 was given.z*Takes {nargs} values but {len} were given.)r r r5 c 3 D K | ] }j | y wrN r8 r< s r< r6 z=Parameter.type_cast_value.<locals>.convert.<locals>.<genexpr># s DeTYYq$ 4er> )r? r r r r r r@ s r< r9 z*Parameter.type_cast_value.<locals>.convert su j /0u:+& C H J !&tzzs5z&B " De DDDrJ c 3 . K | ] } | y wrN rv )r5 r= r9 s r< r6 z,Parameter.type_cast_value.<locals>.<genexpr>& s ?->->s )r r r2 r r rF r r? )r r, r r6 r9 s `` @@r< r zParameter.type_cast_value s = $***:2 D D aee 155(9 ::?dii 4 4 =quu = = ZZ2 Qquu Q Q Q Equu E E ==?Z->?? ?u~ rJ c L |y| j dk7 s | j r|dk( ryy)NTr rv F)r r )r r s r< value_is_missingzParameter.value_is_missing* s' = JJ!Ot}}%2+rJ c | j || }| j r | j | r t || | j | j || | }|S )Nr5 )r r rE r r )r r, r s r< process_valuezParameter.process_value3 sV $$S%0 ==T 2 25 9"s$7 7 == $MM#tU3E rJ c | j y t | j t r.t j j | j }|r|S y | j D ]' }t j j | }|s%|c S y rN )r rD r rH rX r )r r, r r s r< resolve_envvar_valuez Parameter.resolve_envvar_value> so ;; dkk3 ' ,B ++ZZ^^F+ I & rJ c | j | }|*| j dk7 r| j j | }|S r )rI r rF split_envvar_value)r r, r s r< r0 zParameter.value_from_envvarP s: $ 9 9# > >djjAo--b1B rJ r c \ t || 5 | j || \ }}|j | j | | j || }d d d | j r|j | j < |fS # t $ r |j s d }Y Kw xY w# 1 sw Y PxY w)N)rS ) rW r1 r r; rG Exceptionr r r )r r, r| r r r s r< r z Parameter.handle_parse_resultX s "#T 2 . .sD 9ME6 $ $TYY 7 **36 3 $)CJJtyy !d{ ,, 3 2s) 2B"BB B" B B""B+c y rN rv r s r< r zParameter.get_help_recordl s rJ c g S rN rv r s r< r zParameter.get_usage_pieceso s rJ c h | j xs | j g}dj d |D S )z{Get a stringified version of the param for use in error messages to indicate which param caused the error. / c 3 ( K | ] }d | d yw)'Nrv )r5 r= s r< r6 z+Parameter.get_error_hint.<locals>.<genexpr>w s 6IqAaS(Is )r| r# r )r r, hint_lists r< get_error_hintzParameter.get_error_hintr s0 II;$":":!; zz6I666rJ r. c 2 | j j| j || | }|r.t |d t rddlm} |D cg c] } || }}t j t j d | S | j j || | S c c}w )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 r r' r( ) r rD r r7 r( r2 r3 r rF r9 )r r, r. r8 r( r s r< r9 zParameter.shell_completey s & & 211#tZHG:gaj#6A6=>g>!,g>66!&&!12G< <yy''T:>> ?s B) NNFNNNFNTFNNr r ),rG rl rm rn r r2 r r_ r r r ParamTyper rg r r- r r r r r r! rf r r r# r' r r r r Mappingrk r1 r rE rG rI r0 r r r rU r9 rv rJ r< rT rT s GR "O 48<@ EIQU!% #' ! <@ %VZZ 30V jj !%%!789V V AGGAEE1::b!%%i+@$@ AB V **QZZ+quu(Equu(L MN V zz#V V C V V V 1773 3#789V JJ+s+ /0!&&+=>@ V& 'Vp affS!%%Z 0 ,:# :$ZZ_$48$ C !&&+qvvc{: ;$ S c ZZ7; "4 AEE ZZ), "& AGGAEE1::b!%%i#8 89 : *. "& AGGAEE1::b!%%i#8 89 : B$L $w $4 $ "#))CJ"7 ' ( (1 7 1 155 1 QUU 1 faee 155 AJJsO $W AEE1B "#))CJ"7?@vvc{ s # $( 7 qzz!''#s(:K/L G s 7' 7c 7?' ?s ?qvvFV?W ?rJ c % e Zd ZdZdZ d*dej ej e dej e edf dej e ef dej e ef de d e d ej e d ej ej d e d e de dej ej e j ej f dej e de de de dej ddf$ fd Zdej eej f f fd Zdej e de dej" ej e ej$ e ej$ e f fdZded eddfd Zd edej ej" eef fd Zej0 d+d ed d dej ej fd! Zej0 d,d ed e dej ej ej ej4 g ej f f fd" Z d+d ed e dej ej ej ej4 g ej f f f fd# Zd edej fd$Zd edej e f fd% Z d edej ej fd&Z d ed'ej< ed(f dej" ej e f f fd) Z xZ!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. optionNr r r confirmation_promptprompt_required hide_inputr flag_valuer countallow_from_autoenvrF r3 r9 show_choices show_envvarr r/ c | rt j | } d|v}t | |f| | d| |du rB| j t d | j j dd j }n |du rd }n|}|| _ || _ || _ || _ || _ | j d uxr | j | _ |*|d}n>| j rd}n/t | j }n|du r| j s |d u| _ | |r |r | j s| rd| _ nd| _ | | j" }| |r | t% j& d | | _ || _ |xr$ t- | j( t$ j. | _ || _ | | _ | r&| t% j6 d | _ |rd | _ | | _ | | _ || _ || _ || _ | jB d k( r t d | j r#| j* r| j0 s t d | j0 s| j r t d | j0 r#| j r| j t d | j4 r/| jD r t d | j* r t d y y )Nr )rF r Tz&'name' is required with 'prompt=True'.r r Frv r )minr3 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'.)#r r rh r r; r r capitalizer r[ r\ r] r9 r rg r} r r r r rF r rD BoolParamType is_bool_flagr^ r_ IntRanger` r3 r ra rb r r )r r r r r[ r\ r] r r^ r r_ r` rF r3 r9 ra rb r default_is_missing prompt_textr s r< r zOption.__init__ s ( ##D)D &e 3 L4(LeL T>yy HII+/99+<+<S#+F+Q+Q+SK u_ K K! #6 . $ "&D!8!UAUAU=U ?% '' t 2 23 d&<&< &0t%;D " )$-- ! $ !\\)J t| **4<DI $ ")"XjEDWDW.X!+ | !NNq 1 ! "4 ( (& zzR HII{{t||D4E4E MNN$$)<)< STT T__9P O zz==#$KLL<<#$JKK rJ c t | }|j | j | j | j | j | j | j |S )N)r3 r r r^ r_ r9 ) rh r r r3 r r r^ r_ r9 )r rj r s r< r zOption.to_info_dictF sU G(* ;;LL**;; rJ r r c g }g }d }g }|D ] }|j r|t d| d |}'|d d dk( rdnd}||v r|j |d \ } } | j } | r+|j t | |j | | j } | r |j | j | | k( st d|d |j t | |j | |M|rK|j d |d d j d d j }|j sd }||sd ||fS t d |s|st d| d| d |||fS )NzName 'z' defined twicer /;zBoolean option z) cannot use the same flag for true/false.c t | d S )Nr r )r= s r< <lambda>z%Option._parse_decls.<locals>.<lambda>t s s1Q4yjrJ rd 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 splitro r r r r_ sortr lower) r r r r| r} r; possible_namesdecl split_charfirstseconds r< r zOption._parse_declsR s D "##fTF/$BCC$(!HOS %$(JJz1$=ME6 !LLNE &--i.>? E* #]]_F &--fmmo> ( -dX 69 9 #)))D/:KK%/ 2 <N $8 9!!$Q'//S9??AD$$& < T>11 AB BN<TF C((,vR1 T>))rJ r r, c | j rd}n| j rd}nd}| j r| d}| j ra| j rU|j | | j | j |d |j | | j | j |d y |j | | j | j || j y |j | | j | j || j y ) Nr r_ store_constT)r{ r| destactionconstF)r{ r| r} r~ r ) r r_ r rg r} add_optionr| r; r^ r )r r r, r~ s r< r zOption.add_to_parser s == F ZZ F F << xv&F T%8%8!! 499499VSW " !! ,, ! " !! ! // " YYYY jj rJ c j ry ddt j t dt f fd } | j g} j r!|j | j j xs d}g } j r j }|M j rA|j 5 j )|j d j j }|Tt |t r|ndj d |D }|j t! d j# | |j$ }d |_ j' |d } ||_ d} d} j( ,t j( t rd x} } n% j( } n|j( |j( } | s| r| | rd j( d} nt | t* t, f rdj d | D } nt/ j0 | r t! d } nt j2 r@ j r4t5 j6 r j n j d d } n( j2 r j s| sd} n t | } | r*|j t! d j# | t j8 t: j< rh j> r/ j8 j@ dk( r j8 jB - j8 jE } | r|j | jF r|j t! d |r!dj | }|r| d| dnd| d}rdndj | |fS # ||_ w xY w)NFr| r/ c t | \ }}|rdj s"j s|dj z }|S )NTr )r r r_ r' )r| r any_slashesany_prefix_is_slashr s r< _write_optsz+Option.get_help_record.<locals>._write_opts sI +4 0OB &*#<< $++-.//IrJ r r z, c 3 2 K | ] }t | y wrN r r5 ds r< r6 z)Option.get_help_record.<locals>.<genexpr> s ":6a3q66 zenv var: {var})varTr, ()c 3 2 K | ] }t | y wrN r r s r< r6 z)Option.get_help_record.<locals>.<genexpr> s *I=a3q6=r z (dynamic)r r zdefault: {default})r r z; z [][rQ )$r9 r2 r_ r r| r} r r3 rb r r` r| r; r rD r r r r r r rO r? r isfunctionrg r r rF r _NumberRangeBaser_ rd r _describe_ranger )r r, r r r3 r' r var_str resilient default_valuer show_default_is_strdefault_string range_str extra_strr s ` @r< r zOption.get_help_record sP ;; # ajjo # $))$ % IIk$"5"56 7yyB [[F~++..: - # 6 6 7q 9J8K LF! "&#. ":6":: Q / 0 7 7G 7 DE )) $ . , ,Su , =M$-C ! # ($++S1599#l # 0 0 ) ++L <]5N"#$T%6%6$7q!9MD%=9!%*I=*I!I##M2!"; ""t':': "+"&,,TYYD4G4GK"" ""4+>+>}!#!$]!3 Q 3 4 ; ;N ; ST tyy%"8"8 9ZZDIIMMQ$6499==;P 113I Y' == LL: ' %(I/3dV3yk+1YKq9ID+<<R@$FFg %.C !s N> > Or r c y rN rv r) s r< r zOption.get_default r rJ c y rN rv r) s r< r zOption.get_default r rJ c & | j rt| j sh|j j D ]N }|j | j k( s |j s*t j t | j c S y t | - || S )Nr, ) r rg r5 r r; r r2 r3 r r^ rh r )r r, r rS r s r< r zOption.get_default& so << 1 1 ++::*u}} 66&%0;;; , w"3T"22rJ c j J j } j rt j | S t j | j j j j fd S )zThis 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. c ( j | S rN )rG )r= r, r s r< rp z)Option.prompt_for_value.<locals>.<lambda>M s !3!3C!;rJ )r rF r] ra r[ value_proc)r r rg r rF r] ra r[ )r r, r s `` r< prompt_for_valuezOption.prompt_for_value6 s} {{&&& ""3' 4;;0 0 KK ** $ 8 8; rJ c t | | }||S | j rd|j X| j L|j d| j j }t j j | }|r|S y )Nr ) rh rI r` r| r; r rH rX r )r r, r r r s r< rI zOption.resolve_envvar_valueP s} W )# . >I # #&&2 %../q 1B0CDF 'B rJ c | j | }|y | j dk7 t | j z }|dkD rL| j j | }| j r%| j dk7 rt || j }|S r )rI r rg r rF rK rR )r r, r value_depths r< r0 zOption.value_from_envvarc sv $ 9 9# > :zzQ$t}}*== ?--b1B}}q 2tzz* rJ r| rT c ~ t | || \ }}|t u r]| j 1|j s%| j | }t j }||fS | j }t j }||fS | j rK|It d |D r7|D cg c] }|t u r | j n| }}t j }||fS |d t j hv rQ| j E| j s | j r-|j s!| j | }t j }||fS c c}w )Nc 3 , K | ] }|t u y wrN r )r5 vs r< r6 z'Option.consume_value.<locals>.<genexpr> s :EqA**Es )rh r1 r r r r rk ru r^ rq r anyrs r r\ )r r, r| r r r r s r< r1 zOption.consume_values s; -c48 v % %{{&s/D/D --c2(//0 f} - (44* f} % MM!:E::OTUu!->(>T__AEuEU$00F f} t_ 4 45 5 ' $"6"6))))#.E$++Ff} Vs D:)NNFFTFNNFFTNNFTFr r )"rG rl rm rn r r2 r r_ r r rg r r rW r r r rf r r r r- r r r r r r rI r0 rX rk r1 r r s @r< r r s :x O 4815%*27 $ $((, #'<@ $ ! !#tLZZ 30tL ggdCo.tL c " tL WWT3Y / tL tL tL D!tL JJquu%tL tL tL !tL jj !%%!789tL jjo tL tL !tL" #tL$ %tL& 'tLl affS!%%Z 0 3*ZZ_3*483* C !&&+qvvc{: ;3*j%L %w %4 %NjG7 jGqzz!''#s(:K/L jGX ZZ7; "4 AEE ZZ), "& AGGAEE1::b!%%i#8 89 : *.33"&3 AGGAEE1::b!%%i#8 89 :3 G 4 AJJsO &W AEE1B # # "#))C,<"=# ' (# # rJ r c e Zd ZdZdZ ddej e dej e dej ddf fd Z e defd Z defd Zd ej e d e dej ej e ej e ej e f fd Zdedej e fdZdedefdZdededdfdZ xZS )r 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`. argumentNr r r r/ c |)|j d d}n|j dd dkD }d|v r t d t | |fd|i| | j | j d k( r t d y y ) Nr Fr r r r z9__init__() got an unexpected keyword argument 'multiple'.r r3 z('default' is not supported for nargs=-1.)r r rh r r r )r r r r r s r< r zArgument.__init__ s yy#/ 99Wa014 WX X AxA5A ||'DJJ",< JKK -='rJ c f | j | j S | j j S rN )r r; r r s r< r# z Argument.human_readable_name s' << #<< yy rJ c | j | j S | j j | }|s| j j }| j sd| d}| j dk7 r|dz }|S )Nr r r r% )r rF r& r; r r r )r r s r< r' zArgument.make_metavar sj << #<< ii##D)))//#C}}cU!*C ::? 5LC rJ r r c |s|sd g g fS t d t | dk( r(|d x}}|j dd j }nt dt | d ||gg fS )Nz%Could not determine name for argumentr r r r z6Arguments take exactly one parameter declaration, got rV )r r r rt )r r r r; args r< r zArgument._parse_decls s R|# CD D u:? q !D3<<S)//1DJ<q" cUB rJ r, c $ | j gS rN r' r s r< r zArgument.get_usage_pieces s !!#$$rJ c * d| j dS )NrS r r s r< rU zArgument.get_error_hint s 4$$&'q))rJ r c T |j | j | j | y )N)r} r r{ ) add_argumentr; r r. s r< r zArgument.add_to_parser s $**$GrJ rN )rG rl rm rn r r2 r_ r r rg r r r r# r' rf r r r- r rU r r r r s @r< r r s !O &*LZZ_L **T"L L L* !S ! ! c ZZ_ 48 C !&&+qvvc{: ; "%G %s %*' *c *HL Hw H4 HrJ r r rN )Vro rP r rH rF typingr2 collectionsr contextlibr r functoolsr r r r itertoolsr r r r exceptionsr r r r r r formattingr r globalsr r r r r r termuir r r utilsr! r" r# r$ r% r& TYPE_CHECKINGtyping_extensionsterY r( TypeVarr r r) r+ r r rf r= rg rI Iterabler r rR r rW r_ ri Enumrk r- r r0 r4 r r r rT r r rv rJ r< <module>r s % $ $ & ( " % $ ! % ' * %??"0 AIIcCJ/0 AIIcN$ $ #$ZZY'($( SX ,/6?KO 0:AJJqM :s :qvvaggafo7N : 59 ::k2ZZ $3jj-3zz+.3 VVK3(Adii A4_ 0 _ 0DC* C*L uk up r7 rj m%L m%`* *Zquu AEE!2 r? r?j E Y E PIHy IHrJ