]h_SSKJr SSKJr SSKrSSKrSSKrSSKrSSK r SSK r SSK Jr SSK J r SSKJr SSKJr SSKJr SSKJr SS KJr SS KJr SS KJr SS KJr S SKJr S SKJr S SKJr S SKJr S SKJ r S SKJ!r! S SKJ"r" S SKJ#r# S SK$J%r% S SK$J&r& S SK'J(r( S SK'J)r) S SK*J+r+ S SK*J,r, S SK*J-r- S SK.J/r/ S SK.J0r0 S SK.J1r1 S S K2J3r3 S S!K2J4r4 S S"K2J5r5 S S#K2J6r6 S S$K2J7r7 S S%K2J8r8 \ Rr(aS S&K:J;r; \ Rx"S'S(S)9r=\ Rx"S*5r>SIS,jr?SJSKS/jjr@SLS0jrA\SMSNS1jj5rBSOS2jrC"S3S4\R5rE"S5S+5rF"S6S.5rG"S7S8\H5rI"S9S:\G\IS;9rJ"S<S-\G5rK"S=S>\K\IS;9rL"S?S@\K5rMSPSAjrN"SBSC5rO"SDSE\O5rP"SFSG\O5rQSQSHjrRg)R) annotationsN)abc)Counter)AbstractContextManager)contextmanager) ExitStack)update_wrapper)gettext)ngettext)repeat) TracebackType)typesAbort) BadParameter)ClickException)Exit)MissingParameter)NoArgsIsHelpError 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)PacifyFlushWrapperCompletionItemFt.Callable[..., t.Any])boundVContextc## [R"[UR5nUR U5HInUR U5(dMUR X5nUcM1UR(aMDX44v MK g7f)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)tcastGroupcommand list_commands startswith get_commandhidden)ctx incompletemultinamer5s >>m# )sABB*B= Br4CommandcUR(a[U[5(dgU(aSU<SUR<S3nOSU<SUR<S3n[ U5e)Nz$It is not possible to add the group z to another group z that is in chain mode.zFound the group z! as subcommand to another group z. that is in chain mode. This is not supported.)chain isinstancer4r= RuntimeError) base_commandcmd_namecmdregistermessages r>_check_nested_chainrJHsz   ZU%;%;28,?"''**A C  xl+!!$$R T  w c P[[[[U5U5SS065$)NstrictF)listzipr iter)iterable batch_sizes r>batchrS\s" VDNJ7FF GGrKc## Sv g![a/nURcXlUbURcXleSnAf[anURcXleSnAff=f7f)z>Context manager that attaches extra information to exceptions.N)rr:paramr)r:rUes r>augment_usage_errorsrW`sZ   55=E  G  55=E s.A& A& A#*= A# AA##A&c&^SU4Sjjn[XS9$)aReturns all declared parameters in the order they should be processed. The declared parameters are re-shuffled depending on the order in which they were invoked, as well as the eagerness of each parameters. The invocation order takes precedence over the declaration order. I.e. the order in which the user provided them to the CLI is respected. This behavior and its effect on callback evaluation is detailed at: https://click.palletsprojects.com/en/stable/advanced/#callback-evaluation-order c>TRU5nUR(+U4$![a [S5nN*f=f)Ninf)index ValueErrorfloatis_eager)itemidxinvocation_orders r>sort_key,iter_params_for_processing..sort_keysF )//5C== #%% ,C s '??key)r_ Parameterreturnztuple[bool, float])sorted)radeclaration_orderrbs` r>iter_params_for_processingrjss & # 22rKc\rSrSrSr\R "5r\R "5r\R "5r \R "5r \R "5r Sr g)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) __name__ __module__ __qualname____firstlineno____doc__enumauto COMMANDLINE ENVIRONMENTDEFAULT DEFAULT_MAPPROMPT__static_attributes__rnrKr>rlrlsO ))+K:))+K>iikG6))+KA YY[F@rKrlc\rSrSr%Sr\rS\S'S%S&Sjjr\ S'Sj5r S(Sjr S)S jr S*S jr \S+S,S jj5r\ S(S j5rS-S jrS.SjrS/SjrS0Sjr\ S1Sj5rS)SjrS2SjrS3Sjr\R4S+S4Sjj5r\R4S5S6Sjj5rS+S7SjjrS8SjrS9SjrS:S;SjjrS1SjrS1Sjr SSj5r"S?S jr"S@S!jr#SAS"jr$SBS#jr%S$r&g)Cr0aGThe 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.2 The ``protected_args`` attribute is deprecated and will be removed in Click 9.0. ``args`` will contain remaining unparsed tokens. .. 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. ztype[HelpFormatter]formatter_classNc^X lXlX0l0Ul/Ul/UlU(a[ UR5O [ 5UlUcUb URnX@l[US05Ul Uc.Ub+Ub(URbURRU5nX`l SUl UcUb URnXplUcUb URnXlU c UR n XlU c UR"n XlU c UR$n XlU cUb UR&n OS/n XlUcUb UR(nXlXlUcGUbCUR,b6URb)UR,SURR/53nOUR/5nUbUR1SS5nXPlUcUb UR2nXlUcUb UR4nUUl/UlSUl0Ul[=5Ulg)Nmetaz--help_-r) parentr5 info_nameparamsargs_protected_argsset _opt_prefixesobjgetattr_meta default_mapgetinvoked_subcommandterminal_widthmax_content_widthallow_extra_argsallow_interspersed_argsignore_unknown_optionshelp_option_namestoken_normalize_funcresilient_parsingauto_envvar_prefixupperreplacecolor show_default_close_callbacks_depth_parameter_sourcer _exit_stack)selfr5rrrrrrrrrrrrrrrs r>__init__Context.__init__sp(  ")+ ! +-DJs6+?+?'@PSPU ;6-**C'.vvr'B   %""". ,,00;KCN/3  !f&8#22N+9  $); & 8 8 .?  #&77  !1 " *&-&E&E # .E$ ! )%,%C%C "-C#  $!$*$<$<!%-J!->  'F,>#)#>#> DX! (9  %"--9NN.0014>>3G3G3I2JK#"4!9!9!;   )!3!;!;C!E .@ =V/LLE#(  F$6!..L*6=? =?$;rKcLSSKnURS[SS9 UR$)Nrzo'protected_args' is deprecated and will be removed in Click 9.0. 'args' will contain remaining unparsed tokens. stacklevel)warningswarnDeprecationWarningr)rrs r>protected_argsContext.protected_argss/  >   ###rKcURRU5URURURUR UR S.$)zGather 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 )r5rrrrr)r5 to_info_dictrrrrrrs r>rContext.to_info_dictsK||006 $ 5 5'+'C'C&*&A&A"&"9"9   rKcFU=RS- sl[U5 U$Nr)rrrs r> __enter__Context.__enter__s q T rKcU=RS-slURS:XaUR5 [5 gNrr)rcloser)rexc_type exc_valuetbs r>__exit__Context.__exit__s, q ;;!  JJL rKc## U(dU=RS- slUnUv SSS5 U(dU=RS-slgg!,(df  N,=f!U(dU=RS-slff=f7f)aThis 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. rN)r)rcleanuprvs r>scope Context.scopesd: KK1 K ! q  q s1BAA AB AAA==BcUR$)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 )rrs r>r Context.metas4zzrKcJURURURS9$)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)r~rrrs r>make_formatterContext.make_formatter-s-##%%1G1G$  rKc8URRU5$)aARegister 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)rcontext_managers r> with_resourceContext.with_resource;s6--o>>rKc8URRU5$)aURegister 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. )rcallback)rfs r> call_on_closeContext.call_on_closeXs((++rKcVURR5 [5Ulg)zInvoke all close callbacks registered with :meth:`call_on_close`, and exit all context managers entered with :meth:`with_resource`. N)rrrrs r>r Context.closeds  $;rKcSnURb URnURbURR/n[URR[ 5(aLURRR U5H#nURURU55 M% SRU5SU3nUR5$)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.  ) rr command_pathrCr5r@ get_paramsextendget_usage_piecesjoinlstrip)rrparent_command_pathrUs r>rContext.command_pathms  >> %B ;; "#';;#;#;"< $++--w77![[00;;DAE'..u/E/Ed/KLBHH012!B48Byy{rKcZUnURbURnURbMU$)zFinds the outermost context.r)rnodes r> find_rootContext.find_roots+kk%;;Dkk% rKc~UnUb8[URU5(a UR$URnUbM8g)z)Finds the closest object of a given type.N)rCrr)r object_typers r> find_objectContext.find_objects=#$((K00xx;;D  rKcJURU5nUcU"5=UlnU$)zpLike :meth:`find_object` but sets the innermost object to a new instance of `object_type` if it does not exist. )rr)rrrs r> ensure_objectContext.ensure_objects,  k * :'M )DHr rKcgNrnrr=calls r>lookup_defaultContext.lookup_defaultrKcgrrnrs r>rr03rKcURb;URRU5nU(a[U5(aU"5$U$g)zGet 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)rrcallable)rr=rvalues r>rrs@    '$$((.EwLrKc[X5e)ztAborts the execution of the program with a specific error message. :param message: the error message to fail with. r)rrIs r>fail Context.fails ''rKc[5e)zAborts the script.rrs r>abort Context.aborts g rKc8UR5 [U5e)zExits the application with a given exit code. .. versionchanged:: 8.2 Callbacks and context managers registered with :meth:`call_on_close` and :meth:`with_resource` are closed before exiting. )rr)rcodes r>exit Context.exits 4jrKc8URRU5$)zQHelper method to get formatted usage string for the current context and command. )r5 get_usagers r>rContext.get_usages||%%d++rKc8URRU5$)zNHelper method to get formatted help page for the current context and command. )r5get_helprs r>rContext.get_helps||$$T**rKc6[U5"XRUS9$)z^Create a new context of the same type as this context, but for a new command. :meta private: rr)typer=)rr5s r>_make_sub_contextContext._make_sub_contexts Dz'\\$GGrKcgrrnrrrkwargss r>invokeContext.invokes rKcgrrnrs r>rrsTWrKcr[U[5(aUnURc [S5e[R "SUR5nUR U5nURHTnURU;dMUR(dM(URXVRU55X6R'MV URRU5 OUn[U5 U U"U0UD6sSSS5 sSSS5 $!,(df  O=fSSS5 g!,(df  g=f)aInvokes 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. .. versionchanged:: 8.0 All ``kwargs`` are tracked in :attr:`params` so they will be passed if :meth:`forward` is called at multiple levels. .. versionchanged:: 3.2 A new context is created, and missing arguments use default values. Nz?The given command does not have a callback that can be invoked.t.Callable[..., V])rCr@r TypeErrorr2r3r rr= expose_valuetype_cast_value get_defaultupdaterW)rrrr other_cmdr:rUs r>rrs( h ( ( I!!)U66"6 8J8JK((3C"))::V+0B0B0B).)>)>..s3*F::&* JJ  f %C !$ '00( '( ' 's$/D(2D : D( D D(( D6c[U[5(d [S5eURHnXC;dM URUX4'M UR"U/UQ70UD6$)aJSimilar 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.)rCr@rrr)rrGrrrUs r>forwardContext.forwards\#w''89 9[[E" $ E 2 !{{30000rKc X RU'g)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)rr=sources r>set_parameter_sourceContext.set_parameter_source/s(.t$rKc8URRU5$)aGet 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. )rr)rr=s r>get_parameter_sourceContext.get_parameter_source8s %%))$//rK)rrrrrrrrrrrrr5rrrrrrrrrrrrr)NNNNNNNFNNNNNNN)"r5r@rContext | Noner str | Noner t.Any | Nonerr&r&cabc.MutableMapping[str, t.Any] | Noner int | Nonerr)rboolr bool | Nonerr+rr+rzlist[str] | Nonerzt.Callable[[str], str] | Nonerr+rr+rgNone)rg list[str]rgdict[str, t.Any])rgr0)rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Nonergr,T)rr*rgzcabc.Iterator[Context])rgr)rzAbstractContextManager[V]rgr/)rr-rgr-)rgr,rgstr)rtype[V]rgzV | None)rr3rgr/)r=r2rt.Literal[True]rgr'.)r=r2rzt.Literal[False]rg$t.Any | t.Callable[[], t.Any] | None)r=r2rr*rgr')rIr2rg t.NoReturn)rgr7)r)rintrgr7)r5r@rgr0)rrrt.Anyrr9rgr/)rr@rr9rr9rgr9)rzCommand | t.Callable[..., V]rr9rr9rgz t.Any | V)rGr@rr9rr9rgr9)r=r2rrlrgr,)r=r2rgzParameterSource | None)'rorprqrrrsrr~__annotations__rpropertyrrrrrrrrrrrrrrrr2overloadrrrrrrr rrr r#r{rnrKr>r0r0s`J,9O(8 "& $ )->B%)(,"'(,/3.2.2>B!$(#h'h'h' h'  h' ' h'<h'#h'&h' h'&h'"-h'!,h',h'<h' !h'""#h'$ %h'T $ $ * , (  !   #!#!J6  ?: ,'$ ZZ15. ZZ2533/3 -33((, + HZZ*6;GL ZZWW.14.1@E.1QV.1 .1`1&.0rKcR\rSrSr%Sr\rS\S'SrSr Sr S"S#Sjjr S$S jr S%S jr S&S jrS'S jrS(S jrS)SjrS)SjrS*SjrS+SjrS&SjrS,S-SjjrS(SjrS(SjrS(SjrS(SjrS.S/SjjrS0SjrS1SjrS2Sjr\R@S3S4Sjj5r!\R@S5S6Sjj5r!S7S8Sjjr!S.S9Sjjr"S:S jr#S!r$g);r@iKaCommands 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: If ``True`` or non-empty string, issues a message indicating that the command is deprecated and highlights its deprecation in --help. The message can be customized by using a string as the value. .. versionchanged:: 8.2 This is the base class for all commands, not ``BaseCommand``. ``deprecated`` can be set to a string as well to customize the deprecation message. .. 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. z type[Context] context_classFTNc XlUc0nX lX0lU=(d /UlXPlX`lXlXplXlSUl Xl Xl Xl gr) r=context_settingsrrhelpepilogoptions_metavar short_helpadd_help_option _help_optionno_args_is_helpr9 deprecated) rr=r@rrrArBrDrCrErGr9rHs r>rCommand.__init__sf&  #! BR! (.|   .$. . $rKcURURU5Vs/sHo"R5PM snURURUR UR URS.$s snf)N)r=rrArBrDr9rH)r=rrrArBrDr9rH)rr:rUs r>rCommand.to_info_dicts]II9=9MN9M))+9MNIIkk//kk//  NsA4cPSURRSURS3$N __class__ror=rs r>__repr__Command.__repr__&4>>**+1TYYKq99rKcUR5nURX5 UR5RS5$)z]Formats the usage line into a string and returns it. Calls :meth:`format_usage` internally.  )r format_usagegetvaluerstriprr: formatters r>rCommand.get_usages: &&(  #)!!#**400rKc2URnURU5nUb/UQUPnSSKnUVVs/sHoURHofPM M nnn[ U5nSUR 55n U Hn UR SU S3SS9 M U$s snnf)Nrc3:# UHupUS:dM Uv M g7f)rNrn).0optcounts r> %Command.get_params..sV4HjcETUIcc4Hs  zThe parameter zM is used more than once. Remove its duplicate as parameters should be unique.r)rget_help_optionroptsritemsr) rr:r help_optionrrUr`rf opts_counterduplicate_opts duplicate_opts r>rCommand.get_paramss**3/  "+v+{+F  %+BVEzzCzCVDB"4=LVL4F4F4HVN!/  (8OO ! "0 CsBc|URU5nURURSRU55 g)zcWrites the usage line into the formatter. This is a low-level method called by :meth:`get_usage`. rN)collect_usage_pieces write_usagerr)rr:r[piecess r>rWCommand.format_usages3 **3/c..0@ArKcUR(a UR/O/nURU5H#nURURU55 M% U$)zXReturns all the pieces that go into the usage line and returns it as a list of strings. )rCrrr)rr:rrUs r>rnCommand.collect_usage_piecessM(,';';d"" #__S)E IIe,,S1 2* rKc[UR5nURH9nURUR5 URUR 5 M; [ U5$)z&Returns the names for the help option.)rrrdifference_updaterfsecondary_optsrN)rr: all_namesrUs r>get_help_option_namesCommand.get_help_option_namessR--. [[E  ' ' 3  ' '(<(< =!IrKcURU5nU(aUR(dgURc0SSKJn U"U6"U5 UR R 5UlUR$)zReturns the help option object. Skipped if :attr:`add_help_option` is ``False``. .. versionchanged:: 8.1.8 The help option is now cached to avoid creating it multiple times. Nr)rh)rxrErF decoratorsrhrpop)rr:rrhs r>reCommand.get_help_optionsc!66s; (<(<    $ / * +D 1 $  1D    rKcn[U5nURU5HnURX!5 M U$)z6Creates the underlying option parser for this command.)rr add_to_parser)rr:parserrUs r> make_parserCommand.make_parsers2s#__S)E    ,* rKcUR5nURX5 UR5RS5$)zVFormats the help into a string and returns it. Calls :meth:`format_help` internally. rV)r format_helprXrYrZs r>rCommand.get_help"s: &&(  (!!#**400rKcUR(a![R"UR5nO*UR(a[ URU5nOSnUR (aI[ UR [5(aSUR S3OSn[S5RX#S9nUR5$)zPGets short help for the command or makes it by shortening the long help string. r (DEPRECATED: ) (DEPRECATED){text} {deprecated_message}textdeprecated_message) rDinspectcleandocrAr'rHrCr2rformatstrip)rlimitrrs r>get_short_help_strCommand.get_short_help_str+s ??##DOO4D YY*499erCommand.format_helpBs< #) c- C+ 3*rKcURb3[R"UR5RS5SnOSnUR(aI[ UR[ 5(aSURS3OSn[S5RX4S 9nU(a;UR5 UR5 URU5 SSS5 gg!,(df  g=f) z3Writes the help text to the formatter if it exists.N rrrrrrr) rArr partitionrHrCr2rrwrite_paragraph indentation write_text)rr:r[rrs r>rCommand.format_help_textSs 99 ##DII.88>qADD ??doos33 02#  23::;D   % % '&&($$T*)( )(s C  C.c /nURU5H*nURU5nUcMURU5 M, U(a5UR[ S55 UR U5 SSS5 gg!,(df  g=f)z8Writes all the options into the formatter if they exist.NOptions)rget_help_recordappendsectionrwrite_dl)rr:r[rfrUrs r>rCommand.format_optionskss__S)E&&s+B~ B* ""1Y<0""4(10 00s #A?? B cUR(a[[R"UR5nUR5 UR 5 UR U5 SSS5 gg!,(df  g=f)z2Writes the epilog into the formatter if it exists.N)rBrrrrr)rr:r[rBs r>rCommand.format_epilogwsY ;;%%dkk2F  % % '&&($$V,)( )(s A.. A<c URR5HupVXT;dM XdU'M UR"U4XS.UD6nURSS9 UR Xr5 SSS5 U$!,(df  U$=f)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 FrN)r@rgr>r parse_args)rrrrextrarerr:s r> make_contextCommand.make_contextsz6//557JC"c 8  SSUS YYuY % OOC && & % s A// A>c dU(d-UR(aUR(d [U5eURU5nUR US9upBn[ XPR U55HnURXU5uprM U(aqUR(d`UR(dOUR[SS[U55RSR[[U55S95 X!lUR"R%UR"5 U$)N)rz&Got unexpected extra argument ({args})z'Got unexpected extra arguments ({args})r)rGrrrrrjrhandle_parse_resultrrr lenrrmapr2rrr)rr:rrrf param_orderrUrs r>rCommand.parse_argss,,S5J5J#C( (!!#&"("3"3"3">K/ __S=QRE33CtDKE4S ,,S5J5J HH<=I&chhs3~6&7     !5!56 rKcXUR(ae[UR[5(aSUR3OSn[S5R UR US9n[ [USS9SS9 URb'UR"UR40URD6$g ) zUGiven a context, this invokes the attached callback (if it exists) in the right way. rrzFDeprecationWarning: The command {name!r} is deprecated.{extra_message})r= extra_messageredfgTerrN) rHrCr2rrr=r&r#rrr)rr:rrIs r>rCommand.invokes ??)3DOOS)I)I!DOO$%r Xf$))=fA  w5)t 4 == $::dmm:szz: : %rKc^^^^SSKJm /nT(aTSR5(dURT5Hm[ T[ 5(aNTR (d=TR(d.TRTR5[RLaMhURUUU4Sj/TRQTRQ55 M TRb{TRm[ TR ["5(aATR R$(a&URUU4Sj['TT555 TRbM{U$)aoReturn a list of completions for the incomplete value. Looks at the names of options and chained multi-commands. Any command could be part of a chained multi-command, so sibling commands are valid at any point during command completion. :param ctx: Invocation context for this command. :param incomplete: Value being completed. May be empty. .. versionadded:: 8.0 rr*c3v># UH.nURT5(dMT"UTRS9v M0 g7frAN)r7rA)r_r=r+r;rUs r>rb)Command.shell_complete..s1 Dz2:N4ejj9 Ds99c3t># UH-upUTR;dMT"XR5S9v M/ g7fr)rr)r_r=r5r+r:s r>rbrs9)T 3#6#66LN4.H.H.JK)Ts88)click.shell_completionr+isalnumrrCOptionr9multipler#r=rlrvrrfrvrr5r4rBr?)rr:r;resultsr+rUs `` @@r>shell_completeCommand.shell_completes :(* jm3355-"5&11||!NN44UZZ@*667 D%** Du/C/C D.$jj$**C#++u--#++2C2C)CC)T jj$rKc grrnrr prog_name complete_varstandalone_moders r>main Command.mainsrKc grrnrs r>rrsrKc rUc:[RSSn[RS:XaU(a [ U5nO [ U5nUc [ 5nURXbU5 UR"X!40UD6nURU5nU(d UsSSS5 $UR5 SSS5 g!,(df  g=f![[4a'n [S9 [5U eSn A f[ aBn U(deU R#5 [R"U R$5 Sn A gSn A f[&an U R([(R*:Xa[,R."[,R0[3[R455[l[,R."[,R0[3[R55[l[R"S5 Sn A geSn A ff=f![6aBn U(a%[R"U R$5 Sn A gU R$sSn A $Sn A f[aB U(de[5[RS9 [R"S5 gf=f)aThis 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 ``"__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. Nrnt)filezAborted!)sysargvosr=r%rNr$_main_shell_completionrrrEOFErrorKeyboardInterruptr&stderrrrshow exit_codeOSErrorerrnoEPIPEr2r3TextIOr)stdoutrr) rrrrrwindows_expand_argsrr:rrVs r>rrsf <88ABHH HHH J6*'I' I'!J6'A J65J6cUc6URSS5RSS5nSUS3R5n[RR U5nU(dgSSKJn U"XX#U5n[R"U5 g)aCheck 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 (``_``). Nrr. _COMPLETEr)r) rrrenvironrshell_completionrrr)rctx_argsrr complete_name instructionrrs r>rCommand._main_shell_completionst$  %--c37??SIM}oY7==?Ljjnn\2  4 DI[ Q  rKc&UR"U0UD6$)zAlias for :meth:`main`.)rrrrs r>__call__Command.__call__syy$)&))rK) rFrErr@rHrBrAr9r=rGrCrrD) NNNNNNz [OPTIONS]TFFF)r=r&r@r(rt.Callable[..., t.Any] | Nonerzlist[Parameter] | NonerAr&rBr&rDr&rCr&rEr*rGr*r9r*rH bool | strrgr,r:r0rgr/r1r:r0rgr2)r:r0rglist[Parameter]r:r0r[rrgr,r:r0rgr-)r:r0rgz Option | None)r:r0rgr)-)rr8rgr2r) rr&rr-rr%rr9rgr0r:r0rr-rgr-r:r0rgr9r:r0r;r2rglist[CompletionItem])NNNT) rcabc.Sequence[str] | Nonerr&rr&rr4rr9rgr7)NNN.) rrrr&rr&rr*rr9rgr9)NNNTT)rrrr&rr&rr*rr*rr9rgr9)rzcabc.MutableMapping[str, t.Any]rr2rr&rgr,)rr9rr9rgr9)%rorprqrrrsr0r>r:rrrrrrRrrrWrnrxrerrrrrrrrrrrr2r<rrrr{rnrKr>r@r@Ks-d$+M=*## DH26)-!!%&1 $ %!&*%*%A*%0 *% ' *%  *%*%*%$*%*%*%*%*% *%X  :12B !61.+"+0 )-"& ### #  #  #J.; -^ZZ+/ $#'+/ '!  )    ZZ+/ $#' # '!      +/ $#' $$( o'oo! o  o " oo oj$( 1!   @*rKc(\rSrSrSSjrSSjrSrg)_FakeSubclassCheckic2[XRS5$Nr) issubclass __bases__)clssubclasss r>__subclasscheck__$_FakeSubclassCheck.__subclasscheck__(MM!$455rKc2[XRS5$r)rCr)rinstances r>__instancecheck__$_FakeSubclassCheck.__instancecheck__r rKrnN)rr rgr*)r r9rgr*)rorprqrrrr r{rnrKr>rrs 66rKrc\rSrSrSrSrg) _BaseCommandizP .. deprecated:: 8.2 Will be removed in Click 9.0. Use ``Command`` instead. rnNrorprqrrrsr{rnrKr>rrrKr) metaclassc^\rSrSr%SrSrSrSrS\S'Sr S\S 'SSU4S jjjr S U4S jjr S!S"S jjr \ RS#S j5r\ RS$Sj5rS%Sjr\ RS&Sj5r\ RS'Sj5rS(SjrS)S*SjjrS+SjrS,SjrS,U4SjjrS-U4SjjrS-SjrS.U4SjjrS/U4SjjrS0SjrS1U4SjjrSrU=r$)2r4iaA group is a command that nests other commands (or more groups). :param name: The name of the group command. :param commands: Map names to :class:`Command` objects. Can be a list, which will use :attr:`Command.name` as the keys. :param invoke_without_command: Invoke the group's callback even if a subcommand is not given. :param no_args_is_help: If no arguments are given, show the group's help and exit. Defaults to the opposite of ``invoke_without_command``. :param subcommand_metavar: How to represent the subcommand argument in help. The default will represent whether ``chain`` is set or not. :param chain: Allow passing more than one subcommand argument. After parsing a command's arguments, if any arguments remain another command will be matched, and so on. :param result_callback: A function to call after the group's and subcommand's callbacks. The value returned by the subcommand is passed. If ``chain`` is enabled, the value will be a list of values returned by all the commands. If ``invoke_without_command`` is enabled, the value will be the value returned by the group's callback, or an empty list if ``chain`` is enabled. :param kwargs: Other arguments passed to :class:`Command`. .. versionchanged:: 8.0 The ``commands`` argument can be a list of command objects. .. versionchanged:: 8.2 Merged with and replaces the ``MultiCommand`` base class. TFNztype[Command] | None command_classztype[Group] | type[type] | None group_classc >[T U]"U40UD6 Uc0nOJ[U[R5(a+UV s0sHoR cMU R U _M nn X lUcU(+nX@lX0lUc U(aSnOSnXPl X`l Xpl UR(aGURH6n [U [5(dMU R(aM-[S5e ggs sn f)Nz*COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...zCOMMAND [ARGS]...z5A group in chain mode cannot have optional arguments.)superrrCrSequencer=commandsrGinvoke_without_commandsubcommand_metavarrB_result_callbackrArgumentrequiredrD) rr=rrrGrrBresult_callbackrcrUrQs r>rGroup.__init__s ((  H #,, / /+3J8avv  8HJ[TU]U5n0nURU5HUnURX5nUcMUR U5nUR SS9 URU5X4'SSS5 MW UR X0RS9 U$!,(df  M=f)NFr)rrB)rrr6r8r rrrB)rr: info_dictrr=r5sub_ctxrQs r>rGroup.to_info_dictsG(- &&s+D&&s1G++G4Gu-!(!5!5g!>.-, (**= .-s B B' c|U=(d URnUc [S5e[XUSS9 XRU'g)zsRegisters another :class:`Command` with this group. If the name is not provided, the name of the command is used. NzCommand has no name.T)rH)r=rrJr)rrGr=s r> add_commandGroup.add_command+s;sxx <23 3Dd;! drKcgrrnr _Group__funcs r>r5 Group.command5sBErKcgrrnrs r>r5r,8s9T"T0TD6"U5nTRU5 U$rr')rrGrr5rrs r> decorator Group.command..decorator\s*"D3F3A6C   S !JrK)rr-rgr@)r{r5rrrr)rrrfuncr1r5s``` @r>r5r,=s" (.2 HT!W%%t9>& I 0GTD   &**U"3"; ..F5M    T? "rKcgrrnr*s r>group Group.groupfs>ArKcgrrnrs r>r5r6is7:rKcd^^^^SSKJm SnT(a6[TS5(a#[T5S:XaT(aS5eTunSmTRbCTR S5c1TR[ La[ T5TS'OTRTS'S UUUU4SjjnUbU"U5$U$) aA 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)r5Nrz5Use 'group(**kwargs)(callable)' to provide arguments.rnrcF>T"T0TD6"U5nTRU5 U$rr0)rrGrr5rrs r>r1Group.group..decorators*//2C   S !JrK)rr-rgr4)r{r5rrrrr )rrrr3r1r5s``` @r>r5r6ns" &.2 HT!W%%t9>& G 0GTD    'FJJu,=,E4' $T u $ 0 0u     T? "rKc^^SUU4SjjnU$)aAdds 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 c>^^TRmTbT(a TTlT$SUU4Sjjn[[R"[U5T5=TlnU$)Nc4>T"U/UQ70UD6nT"U/UQ70UD6$rrn)rrrinnerr old_callbacks r>function:Group.result_callback..decorator..functions,$Ur1(Group.result_callback..decoratorsS00L#w()% 1 1*8q(8KQ)O OD !BIrK)rr,rgr,rn)rrr1s`` r>rGroup.result_callbacks:  rKc8URRU5$)zmGiven a context and a command name, this returns a :class:`Command` object if it exists or returns ``None``. )rr)rr:rFs r>r8Group.get_commands}}  **rKc,[UR5$)zCReturns a list of subcommand names in the order they should appear.)rhrrr:s r>r6Group.list_commandssdmm$$rKc\>[TU]U5nURUR5 U$r)rrnrr)rr:rrQs r>rnGroup.collect_usage_piecess) W )# . $))* rKcF>[TU]X5 URX5 gr)rrformat_commands)rr:r[rQs r>rGroup.format_optionss s. S,rKc/nURU5H>nURX5nUcMUR(aM,URXE45 M@ [ U5(aUR S- [ SU55- n/nUH(upEURU5nURXH45 M* U(a5UR[S55 URU5 SSS5 ggg!,(df  g=f)zUExtra format methods for multi methods that adds all the commands after the options. Nc3># UHn[US5v M g7f)rNr)r_rGs r>rb(Group.format_commands..s-NXcc#a&kkXsCommands) r6r8r9rrrmaxrrrr) rr:r[r subcommandrGrrowsrAs r>rLGroup.format_commandss,,S1J""33C{zz OOZ- .2 x==OOa'#-NX-N*NNED#+ --e4 Z./$,&&q}5&&t,65 65s C66 Dc.>U(d-UR(aUR(d [U5e[TU]X5nUR (aX1l/UlUR$U(aUSSUSSsUlUlUR$r)rGrrrrrBrr)rr:rrestrQs r>rGroup.parse_argssz,,S5J5J#C( (w!#, ::"& CHxx,0!Hd12h )C xxrKc >^^SUU4SjjnTR(daTR(a6T [T T] T5nU"TR(a/OU5sSSS5 $TR [ S55 /TRQTRQn/Tl/TlTR(dyT TRTU5upVnUceUTl [T T] T5 URXTTS9nU U"URRU55sSSS5 sSSS5 $T U(aSOSTl [T T] T5 /nU(aZTRTU5upVnUceURUUTSSS9nURU5 UR/soGlU(aMZ/nUH8nU URURRU55 SSS5 M: U"U5sSSS5 $!,(df  GN=f!,(df  O=fSSS5 GM!,(df  GN=f!,(df  M=f!,(df  g=f) Ncr>TRb(TR"TRU40TRD6nU$r)rrrrr:rs r>_process_result%Group.invoke.._process_results3$$0 4#8#8%N3::NLrKzMissing command.r*TF)rrrrr9rgr9) rrrrrBrrrresolve_commandrrr5r) rr:r^rrrFrGr$contextsrQs `` r>r Group.invokes   ""**,B*2DS HHQ)* +1$$0sxx0  zz&*&:&:3&E#t&)1&s#**8#*F*7??+A+A'+JKW ,0SdC " GN3  H&*&:&:3&E#t&**%),1 +(%,\\2"l$B#IIgoo44W=>W$#2&3S=S,WW JW/Ss[*H:AH6=!H H63BI6 I?+I*I H H' #H66 I I I I(c[US5nUnURX5nUc/URb"URU5nURX5nUc\UR(dK[ U5S(aUR X5 UR [S5RUS95 U(aUOSXRSS4$)NrzNo such command {name!r}.r=r) r(r8rrr rrrr)rr:rrForiginal_cmd_namerGs r>rbGroup.resolve_commandHsDG$$s- ;333?//9H""31C ;s44(#A&* HHQ23::@Q:R SxD#ABx77rKc >SSKJn [X5VVs/sHupEU"XER5S9PM nnnUR [ TU]X55 U$s snnf)aReturn 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 rr*r)rr+r?rrrr)rr:r;r+r=r5rrQs r>rGroup.shell_completecsa :"?  s A)rrBrrrGr)NNFNNFN)r=r&rzAcabc.MutableMapping[str, Command] | cabc.Sequence[Command] | Nonerr*rGr+rr&rBr*rrrr9rgr,rr)rGr@r=r&rgr,)r+r-rgr@)rr9rr9rgz-t.Callable[[t.Callable[..., t.Any]], Command])rr9rr9rgz7t.Callable[[t.Callable[..., t.Any]], Command] | Command)r+r-rgr4)rr9rr9rgz+t.Callable[[t.Callable[..., t.Any]], Group])rr9rr9rgz3t.Callable[[t.Callable[..., t.Any]], Group] | GroupF)rr*rgzt.Callable[[F], F]r:r0rFr2rgzCommand | Nonerrrr)r:r0rr-rgz,tuple[str | None, Command | None, list[str]]r)rorprqrrrsrrrr:rrrr'r2r<r5r5rr8r6rnrrLrrrbrr{ __classcell__rQs@r>r4r4s:#+/M'.48K07  ','+)-9=... !% .%.'..7.. ..`$"ZZEEZZ<<&+< 6<<''&+' @'RZZAAZZ::&+: 4::**&+* <*X+Z+ % --8 B'H88"+8 586rKc\rSrSrSrSrg) _MultiCommandiwzN .. deprecated:: 8.2 Will be removed in Click 9.0. Use ``Group`` instead. rnNrrnrKr>rprpwrrKrpcp^\rSrSrSrSS U4SjjjrS SjrS U4SjjrS U4SjjrSr U=r $) CommandCollectioni~aA :class:`Group` that looks up subcommands on other groups. If a command is not found on this group, each registered source is checked in order. Parameters on a source are not added to this group, and a source's callback is not invoked when invoking its commands. In other words, this "flattens" commands in many groups into this one group. :param name: The name of the group command. :param sources: A list of :class:`Group` objects to look up commands from. :param kwargs: Other arguments passed to :class:`Group`. .. versionchanged:: 8.2 This is a subclass of ``Group``. Commands are looked up first on this group, then each of its sources. c H>[TU]"U40UD6 U=(d /Ulgr)rrsources)rr=rtrrQs r>rCommandCollection.__init__s" (($+Mr rKc:URRU5 g)z$Add a group as a source of commands.N)rtr)rr5s r> add_sourceCommandCollection.add_sources E"rKc>[TU]X5nUbU$URH8nURX5nUcMUR(a [ XU5 Us $ gr)rr8rtrBrJ)rr:rFrrrQs r>r8CommandCollection.get_commandsZ W  / >IllF##C2B~::'; #rKc>[[TU] U55nURH#nUR URU55 M% [ U5$r)rrr6rtrrh)rr:rrrQs r>r6CommandCollection.list_commandssH57056llF IIf**3/ 0#bzrK)rt)NN)r=r&rtzlist[Group] | Nonerr9rgr,)r5r4rgr,rlr) rorprqrrrsrrwr8r6r{rmrns@r>rrrr~sT " &*22$2 2  22#"rKrrcN[U[5(a[e[U5$)zlCheck if the value is iterable but not a string. Raises a type error, or return an iterator over the value. )rCr2rrP)rs r> _check_iterr~s % ;rKc\rSrSrSrSrSSSjjrSSjrSSjrSSjr \ SS j5r S S jr \ RS!S"S jj5r\ RS#S$S jj5rS!S$S jjrS%SjrS&SjrS'SjrS(SjrS'SjrS)SjrS*SjrS+SjrS,SjrS-SjrS SjrS.SjrSrg)/rfiacA 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. :param deprecated: If ``True`` or non-empty string, issues a message indicating that the argument is deprecated and highlights its deprecation in --help. The message can be customized by using a string as the value. A deprecated parameter cannot be required, a ValueError will be raised otherwise. .. versionchanged:: 8.2.0 Introduction of ``deprecated``. .. versionchanged:: 8.2 Adding duplicate parameter names to a :class:`~click.core.Command` will result in a ``UserWarning`` being shown. .. versionchanged:: 8.2 Adding duplicate parameter names to a :class:`~click.core.Command` will result in a ``UserWarning`` being shown. .. 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. parameterNc `U U U URU=(d SU 5uUlUlUl[R "X$5UlUc4UR R(aUR RnOSnX0l XPl X`l Xpl Xl X@lXlXlXlXlXlUR R(aMX`R R:wa4[)SUR RSUR <SUS35e[+U5(dUOSnUbdU(a[-[/U5S5nUS:waAUb>[/U5 US:a,[3U5U:waU(aS OS n[)S US US35eU(a;U (a3[)SUR4SUR6SUR4S35egg![0a [)S5Sef=f![0a U(aSnOS n[)U5Sef=f)Nrnrz'nargs' must be z (or None) for type z , but it was rz1'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=zThe z 'z1' is deprecated and still required. A deprecated z cannot be required.) _parse_declsr=rfrvr convert_typer  is_compositearityrrnargsrrdefaultr^metavarenvvar_custom_shell_completerHr\rnextr~rrparam_type_namehuman_readable_name)r param_declsr rrrrrrrr^rrrH check_defaultrIsubjects r>rParameter.__init__s1&   484E4E  2|5 1 49d1&+%7%7%F  =yy%%     (    &4#$ yy%%%99??*B &tyy&78!YYMugQ@ ,4G+<+rParameter.to_info_dict{saII#33II"11II**, ZZ ||kk  rKcPSURRSURS3$rMrPrs r>rRParameter.__repr__rTrKc[5erNotImplementedError)rdeclsrs r>rParameter._parse_declss "##rKcUR$)z}Returns the human readable name of this parameter. This is the same as the name for options, but the metavar for arguments. rfrs r>rParameter.human_readable_names yyrKcURb UR$URRXS9nUc$URRR 5nUR S:waUS- nU$)NrUr:r...)rr  get_metavarr=rr)rr:rs r> make_metavarParameter.make_metavarsb << #<< ))''d'< ?iinn**,G ::? u GrKcgrrnrr:rs r>rParameter.get_defaultrrKcgrrnrs r>rrrrKcURURSS9nUc URnU(a[U5(aU"5nU$)aEGet 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)rr=rr)rr:rrs r>rrsB.""4995"9 =LLE HUOOGE rKc[5errrrr:s r>rParameter.add_to_parsers !##rKcJURUR5n[RnUc!UR U5n[R nUc+UR UR5n[RnUc!URU5n[RnX44$r) rr=rlrvvalue_from_envvarrwrryrrx)rr:rfrrs r> consume_valueParameter.consume_values# ,, =**3/E$00F =&&tyy1E$00F =$$S)E$,,F}rKc^^^^Uc%TR(dTRS:XaS$S$S UU4SjjmTRS:XdTRR(a S UU4SjjmO%TRS:Xa S UUU4SjjmO S UUU4SjjmTR(a[ U4S jT"U555$T"U5$) zeConvert and validate a value against the option's :attr:`type`, :attr:`multiple`, and :attr:`nargs`. Nrncb>[U5$![a [[S5TTS9Sef=f)NzValue must be an iterable.r:rU)r~rrrr]s r> check_iter-Parameter.type_cast_value..check_itersA "5)) #23D  s  .rc&>TRUTTS9$)Nrr r]s r>convert*Parameter.type_cast_value..convert syydy<[UU4SjT"U555$)Nc3J># UHnTRUTT5v M g7frrr_xr:rs r>rb=Parameter.type_cast_value..convert.. s#P>OTYYq$44>O #)tuplerrr:rs r>rr sPj>OPPPrKc >[T"U55n[U5TR:wa@[[ SS[U55R TR[U5S9TTS9e[UU4SjU55$)Nz%Takes {nargs} values but 1 was given.z*Takes {nargs} values but {len} were given.)rrrc3J># UHnTRUTT5v M g7frrrs r>rbr s!DeTYYq$44er)rrrrr rrs r>rr suj/0u:+& CHJ!&tzzs5z&B"DeDDDrKc34># UH nT"U5v M g7frrn)r_rrs r>rb,Parameter.type_cast_value.. s?->->srr9rgzcabc.Iterator[t.Any]ra)rrr rr)rr:rrrs`` @@r>rParameter.type_cast_values =$***:2 D D   ::?dii44 = =ZZ2  Q Q  E E ==?Z->?? ?u~rKc\UcgURS:wdUR(aUS:Xagg)NTrrnF)rr)rrs r>value_is_missingParameter.value_is_missing# s' = JJ!Ot}}%2+rKcURX5nUR(aURU5(a [XS9eURbUR XU5nU$)Nr)rrrrr)rr:rs r> process_valueParameter.process_value, sS$$S0 ==T22599"s7 7 == $MM#U3E rKc@URcg[UR[5(a4[RR UR5nU(aU$gURH-n[RR U5nU(dM+Us $ gr)rrCr2rrr)rr:rrs r>resolve_envvar_valueParameter.resolve_envvar_value7 sy ;;  dkk3 ' ' ,B  ++ZZ^^F+2I & rKcURU5nUb+URS:waURRU5nU$r)rrr split_envvar_value)rr:rs r>rParameter.value_from_envvarI s:44S9 >djjAo--b1B rKc[XS9 URX5upEUR(aUbU[R[R 4;ap[ UR[5(aSUR3OSn[S5RURURUS9n[[USS9SS 9 URURU5 UR!X5nSSS5 UR&(aWUR(UR'WU4$!["a UR$(deSnNVf=f!,(df  N`=f) N)rUrrzKDeprecationWarning: The {param_type} {name!r} is deprecated.{extra_message}) param_typer=rrrTr)rWrrHrlrxryrCr2rrrrr&r#r r=r Exceptionrrr)rr:rfrrrrrIs r>rParameter.handle_parse_resultQ sC"# 2 ..s9ME%#++#//.8-M-Ma()SU&&#3311"/U7u-48  $ $TYY 7 **3693F   $)CJJtyy !d{ ,,  ;3 2s*CE#D**E E E  E EcgrrnrGs r>rParameter.get_help_record| s rKc/$rrnrGs r>rParameter.get_usage_pieces s rKcrUR=(d UR/nSRSU55$)zkGet a stringified version of the param for use in error messages to indicate which param caused the error.  / c3.# UH nSUS3v M g7f)'Nrn)r_rs r>rb+Parameter.get_error_hint.. s6IqAaS(Is)rfrr)rr: hint_lists r>get_error_hintParameter.get_error_hint s0II;$":":!; zz6I666rKc(URbeURXU5nU(a5[US[5(aSSKJn UVs/sH oT"U5PM nn[ R "SU5$URRXU5$s snf)aXReturn 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 rr*r) rrCr2rr+r2r3r r)rr:r;rr+r s r>rParameter.shell_complete s  & & 211#ZHG:gaj#66A6=>g>!,g>660': :yy'':>> ?s B)rrrrHrrr^rrr=rrfrrvr ) NNFNNNFNTFNNF)rrr types.ParamType | t.Any | Nonerr*rr6rz5t.Callable[[Context, Parameter, t.Any], t.Any] | Nonerr)rr*rr&rr*r^r*rzstr | cabc.Sequence[str] | NonerzNt.Callable[[Context, Parameter, str], list[CompletionItem] | list[str]] | NonerHrrgr,r.r1rcabc.Sequence[str]rr*rgz'tuple[str | None, list[str], list[str]]rr0r:r0rr4rgr'r5r:r0rr*rgr6rrr:r0rgr,)r:r0rfcabc.Mapping[str, t.Any]rgtuple[t.Any, ParameterSource])r:r0rr9rgr9)rr9rgr*r:r0rgr&r:r0rgr')r:r0rfrrr-rgztuple[t.Any, list[str]]r:r0rgztuple[str, str] | Nonerr)rorprqrrrsrrrrRrr;rrr2r<rrrrrrrrrrrrrr{rnrKr>rfrfsWr"O26/38