_R/@sddlZddlZddlZddlZddlmZddlmZddlm Z ddl m Z ddl m Z ddl m Z dd l mZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddl"m#Z#ddl"m$Z$ddl"m%Z%ddl&m'Z'ddl&m(Z(ddl&m)Z)ddl*m+Z+ddl*m,Z,dd l*m-Z-dd!l*m.Z.dd"l*m/Z/e0Z1d#Z2d$Z3d%Z4d&Z5d'd(Z6d)d*Z7dd+d,Z8d-d.d/Z9d0d1Z:d2d3Z;edd4d5Z<d6d7Z=Gd8d9d9e0Z>Gd:d;d;e0Z?Gd<d=d=e?Z@Gd>d?d?e@ZAGd@dAdAeAZBGdBdCdCeAZCGdDdEdEe0ZDGdFdGdGeDZEGdHdIdIeDZFdS)JN)contextmanager)update_wrapper)repeat) isidentifier) iteritems)PY2) string_types)_check_for_unicode_literals)_verify_python3_env)Abort) BadParameter)ClickException)Exit)MissingParameter) UsageError) HelpFormatter) join_options) pop_context) push_context) OptionParser) split_opt)confirm)prompt)style)BOOL) convert_type)IntRange)echo) get_os_args)make_default_short_help)make_str)PacifyFlushWrapperzCOMMAND [ARGS]...z*COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...z (DEPRECATED)z7DeprecationWarning: The command %(name)s is deprecated.cCs6|jr2tttd|jidddddS)NnameZfgZrederrT) deprecatedrrDEPRECATED_INVOKE_NOTICEr#)cmdr(+/tmp/pip-build-5gj8f0j9/click/click/core.py_maybe_show_deprecated_notice0s r*cCs+tjjtjjtj|dS)zlExit without garbage collection, this speeds up exit by about 10ms for things like bash completion. N)sysstdoutflushstderros_exit)coder(r(r) fast_exit5s  r2cCs||dkr-dj|jddj}tjj|}|sIdSddlm}|||||rxtddS)z1Internal handler for the bash completion support.Nz _{}_COMPLETE-_r) bashcomplete) formatreplaceupperr/environget _bashcompleter5r2)r' prog_name complete_varZcomplete_instrr5r(r(r)r;>s !r;Fc Csp|j st|t rdS|r-d}nd}tdj||j|||jj|jj|jdS)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 '{}' is set to chain and '{}' was added as subcommand but it in itself is a multi command. ('{}' is a {} within a chained {} named '{}').)chain isinstance MultiCommand RuntimeErrorr6r# __class____name__)Z base_commandcmd_namer'registerZhintr(r(r)_check_multicommandLs   rFcCstttt||S)N)listzipriter)iterableZ batch_sizer(r(r)batchhsrKcCsyt|dd}t|dd}|dkriddlm}|dj|tdd|||S||||S)N__code__ co_argcountr)warnzoParameter callbacks take 3 args, (ctx, param, value). The 2-arg style is deprecated and will be removed in 8.0. stacklevel)getattrwarningsrOr6DeprecationWarning)callbackctxparamvaluer1argsrOr(r(r)invoke_param_callbackls  rYccsy dVWntk ro}zD|jdkr6||_|dk rZ|jdkrZ||_WYdd}~Xn@tk r}z |jdkr||_WYdd}~XnXdS)z>Context manager that attaches extra information to exceptions.N)r rUrVr)rUrVer(r(r)augment_usage_errors~s    r[cs"fdd}t|d|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. c sByj|}Wntk r3td}YnX|j |fS)Ninf)index ValueErrorfloatis_eager)itemidx)invocation_orderr(r)sort_keys  z,iter_params_for_processing..sort_keykey)sorted)rcZdeclaration_orderrdr()rcr)iter_params_for_processingsrgc@sKeZdZdZdddddddddddddddddZddZdd Zed d d Ze d dZ ddZ ddZ ddZ e ddZddZddZddZddZdd Zd!d"Zd#d$d%Zd&d'Zd(d)Zd*d+Zd,d-ZdS).ContextaThe context is a special internal object that holds state relevant for the script execution at every single level. It's normally invisible to commands unless they opt-in to getting access to it. The context is useful as it can pass internal objects around and can control special execution features such as reading data from environment variables. A context can be used as context manager in which case it will call :meth:`close` on teardown. .. versionadded:: 2.0 Added the `resilient_parsing`, `help_option_names`, `token_normalize_func` parameters. .. versionadded:: 3.0 Added the `allow_extra_args` and `allow_interspersed_args` parameters. .. versionadded:: 4.0 Added the `color`, `ignore_unknown_options`, and `max_content_width` parameters. .. versionadded:: 7.1 Added the `show_default` parameter. :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: if True, shows defaults for all options. Even if an option is later created with show_default=False, this command-level setting overrides it. NFcCs||_||_||_i|_g|_g|_|dkrW|dk rW|j}||_t|di|_|dkr|dk r|j dk r|j j |}||_ d|_ |dkr|dk r|j }||_ |dkr |dk r |j }||_ | dkr)|j} | |_| dkrG|j} | |_| dkre|j} | |_| dkr|dk r|j} n dg} | |_|dkr|dk r|j}||_| |_|dkr.|dk r:|jdk r:|jdk r:dj|j|jj}n |j}|dk rX|jdd}||_|dkr|dk r|j}||_||_g|_d|_dS)Nmetaz--helpz{}_{}r3r4r)parentcommand info_nameparamsrXprotected_argsobjrQ_meta default_mapr:invoked_subcommandterminal_widthmax_content_widthallow_extra_argsallow_interspersed_argsignore_unknown_optionshelp_option_namestoken_normalize_funcresilient_parsingauto_envvar_prefixr6r8r7color show_default_close_callbacks_depth)selfrkrjrlror{rqrsrtrzrurvrwrxryr|r}r(r(r)__init__sp                                        zContext.__init__cCs|jd7_t||S)Nr)rr)rr(r(r) __enter__s zContext.__enter__cCs3|jd8_|jdkr(|jtdS)Nrr)rcloser)rexc_type exc_valuetbr(r(r)__exit__s zContext.__exit__TccsK|s|jd7_z| }|VWdQRXWd|sF|jd8_XdS)aIThis 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)rcleanuprvr(r(r)scopes z Context.scopecCs|jS)aThis 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 )rp)rr(r(r)risz Context.metacCstd|jd|jS)z4Creates the formatter for the help and usage output.width max_width)rrsrt)rr(r(r)make_formatterszContext.make_formattercCs|jj||S)atThis decorator remembers a function as callback that should be executed when the context tears down. This is most useful to bind resource handling to the script execution. For instance, file objects opened by the :class:`File` type will register their close callbacks here. :param f: the function to execute on teardown. )r~append)rfr(r(r) call_on_closes zContext.call_on_closecCs(x|jD] }|q Wg|_dS)zInvokes all close callbacks.N)r~)rcbr(r(r)rs z Context.closecCsOd}|jdk r|j}|jdk rEdj|jj|}|jS)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. Nz{} {})rlrjr6 command_pathlstrip)rrr(r(r)rs  zContext.command_pathcCs)|}x|jdk r$|j}q W|S)zFinds the outermost context.N)rj)rnoder(r(r) find_roots zContext.find_rootcCs?|}x2|dk r:t|j|r.|jS|j}q WdS)z)Finds the closest object of a given type.N)r?rorj)r object_typerr(r(r) find_objects zContext.find_objectcCs/|j|}|dkr+||_}|S)zLike :meth:`find_object` but sets the innermost object to a new instance of `object_type` if it does not exist. N)rro)rrrr(r(r) ensure_object s zContext.ensure_objectcCs>|jdk r:|jj|}t|r6|}|SdS)z}Looks up the default for a parameter name. This by default looks into the :attr:`default_map` if available. N)rqr:callable)rr#rr(r(r)lookup_defaults   zContext.lookup_defaultcCst||dS)zAborts the execution of the program with a specific error message. :param message: the error message to fail with. N)r)rmessager(r(r)fail sz Context.failcCs tdS)zAborts the script.N)r )rr(r(r)abort(sz Context.abortrcCst|dS)z-Exits the application with a given exit code.N)r)rr1r(r(r)exit,sz Context.exitcCs|jj|S)zaHelper method to get formatted usage string for the current context and command. )rk get_usage)rr(r(r)r0szContext.get_usagecCs|jj|S)z^Helper method to get formatted help page for the current context and command. )rkget_help)rr(r(r)r6szContext.get_helpcOs|dd\}}|}t|tr|}|j}t|d|jd|}|dkrmtdx?|jD]4}|j|krw|jrw|j|||j)r6rBrCr#)rr(r(r)__repr__szBaseCommand.__repr__cCstddS)NzBase commands cannot get usage)NotImplementedError)rrUr(r(r)rszBaseCommand.get_usagecCstddS)NzBase commands cannot get help)r)rrUr(r(r)rszBaseCommand.get_helpc Ksx3t|jD]"\}}||kr|||_COMPLETE"`` with prog_name in uppercase. :param standalone_mode: the default behavior is to invoke the script in standalone mode. Click will then handle exceptions and convert them into error messages and the function will never return but shut down the interpreter. If this is set to `False` they will be propagated to the caller and the return value of this function is the return value of :meth:`invoke`. :param extra: extra keyword arguments are forwarded to the context constructor. See :class:`Context` for more information. NrfilerzAborted!)rr r rrGr!r/pathbasenamer+argv__file__r;rrrEOFErrorKeyboardInterruptrr.r rshowZ exit_codeIOErrorerrnoEPIPEr"r,r) rrXr<r=Zstandalone_moderrUrrZr(r(r)mainsP+     +  "  zBaseCommand.maincOs|j||S)zAlias for :meth:`main`.)r)rrXrr(r(r)__call__;szBaseCommand.__call__)rCrrrrurvrwrrrrrrrrrr(r(r(r)rws      jrc @seZdZdZddddddddddddd Zdd Zd d Zd d ZddZddZ ddZ ddZ ddZ dddZ ddZddZdd Zd!d"Zd#d$Zd%d&ZdS)'raCommands are the basic building block of command line interfaces in Click. A basic command handles command line parsing and might dispatch more parsing to commands nested below it. .. versionchanged:: 2.0 Added the `context_settings` parameter. .. versionchanged:: 7.1 Added the `no_args_is_help` parameter. :param name: the name of the command to use unless a group overrides it. :param context_settings: an optional dictionary with defaults that are passed to the context object. :param callback: the callback to invoke. This is optional. :param params: the parameters to register with this command. This can be either :class:`Option` or :class:`Argument` objects. :param help: the help string to use for this command. :param epilog: like the help string but it's printed at the end of the help page after everything else. :param short_help: the short help to use for this command. This is shown on the command listing of the parent command. :param add_help_option: by default each command registers a ``--help`` option. This can be disabled by this parameter. :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. Nz [OPTIONS]TFc Cstj|||||_|p%g|_|rSd|krS|jddd}||_||_||_||_| |_ | |_ | |_ | |_ dS)N rr) rrrTrmsplithelpepilogoptions_metavar short_helpadd_help_optionno_args_is_helphiddenr%) rr#rrTrmrrrrrrrr%r(r(r)ras        zCommand.__init__cCs/|j}|j|||jjdS)zmFormats the usage line into a string and returns it. Calls :meth:`format_usage` internally.  )r format_usagegetvaluerstrip)rrU formatterr(r(r)rs zCommand.get_usagecCs5|j}|j|}|dk r1||g}|S)N)rmget_help_option)rrUr help_optionr(r(r) get_paramss    zCommand.get_paramscCs/|j|}|j|jdj|dS)zsWrites the usage line into the formatter. This is a low-level method called by :meth:`get_usage`.  N)collect_usage_piecesZ write_usagerjoin)rrUrpiecesr(r(r)rszCommand.format_usagecCs@|jg}x-|j|D]}|j|j|qW|S)zhReturns all the pieces that go into the usage line and returns it as a list of strings. )rrextendget_usage_pieces)rrUrrVr(r(r)rs zCommand.collect_usage_piecescCsGt|j}x1|jD]&}|j|j|j|jqW|S)z&Returns the names for the help option.)setrxrmdifference_updateoptssecondary_opts)rrUZ all_namesrVr(r(r)get_help_option_namess zCommand.get_help_option_namesc CsX|j|}| s |j r$dSdd}t|ddddddd |d d S) zReturns the help option object.NcSs7|r3|j r3t|jd|j|jdS)Nr|)rzrrr|r)rUrVrWr(r(r) show_helpsz*Command.get_help_option..show_helpis_flagTr`rFrTrzShow this message and exit.)rrOption)rrU help_optionsrr(r(r)rs zCommand.get_help_optioncCs:t|}x'|j|D]}|j||qW|S)z6Creates the underlying option parser for this command.)rr add_to_parser)rrUparserrVr(r(r) make_parsers zCommand.make_parsercCs/|j}|j|||jjdS)zfFormats the help into a string and returns it. Calls :meth:`format_help` internally. r)r format_helprr)rrUrr(r(r)rs zCommand.get_help-cCs(|jp'|jr$t|j|p'dS)z`Gets short help for the command or makes it by shortening the long help string. r)rrr )rlimitr(r(r)get_short_help_strs  zCommand.get_short_help_strcCsD|j|||j|||j|||j||dS)a0Writes 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)rformat_help_textformat_options format_epilog)rrUrr(r(r)rs zCommand.format_helpc Cs|jrS|j|j.|j}|jr<|t7}|j|WdQRXn4|jr|j|j|jtWdQRXdS)z3Writes the help text to the formatter if it exists.N)rwrite_paragraph indentationr%DEPRECATED_HELP_NOTICE write_text)rrUr help_textr(r(r)rs         zCommand.format_help_textc Csvg}x?|j|D].}|j|}|dk r|j|qW|rr|jd|j|WdQRXdS)z8Writes all the options into the formatter if they exist.NOptions)rget_help_recordrsectionwrite_dl)rrUrrrVrr(r(r)rs zCommand.format_optionsc Cs;|jr7|j|j|j|jWdQRXdS)z2Writes the epilog into the formatter if it exists.N)rrrr)rrUrr(r(r)rs   zCommand.format_epilogcCs| r=|jr=|j r=t|jd|j|j|j|}|jd|\}}}x;t||j |D]!}|j |||\}}qW|r|j r|j r|j dj t|dkrdnddjtt|||_|S)Nr|rXz$Got unexpected extra argument{} ({})rsrr)rrzrrr|rrrrgrhandle_parse_resultrurr6lenrmapr!rX)rrUrXrrZ param_orderrVrWr(r(r)rs 7 zCommand.parse_argscCs3t||jdk r/|j|j|jSdS)zeGiven a context, this invokes the attached callback (if it exists) in the right way. N)r*rTrrm)rrUr(r(r)r$s zCommand.invoke)rCrrrrrrrrrrrrrrrrrrrr(r(r(r)r@s6           rc@seZdZdZdZdZddddddddZddZd d Zdd d Z d dZ ddZ ddZ ddZ ddZddZdS)r@aA multi command is the basic implementation of a command that dispatches to subcommands. The most common version is the :class:`Group`. :param invoke_without_command: this controls how the multi command itself is invoked. By default it's only invoked if a subcommand is provided. :param no_args_is_help: this controls what happens if no arguments are provided. This option is enabled by default if `invoke_without_command` is disabled or disabled if it's enabled. If enabled this will add ``--help`` as argument if no arguments are passed. :param subcommand_metavar: the string that is used in the documentation to indicate the subcommand place. :param chain: if this is set to `True` chaining of multiple subcommands is enabled. This restricts the form of commands in that they cannot have optional arguments but it allows multiple commands to be chained together. :param result_callback: the result callback to attach to this multi command. TFNc Kstj||||dkr&| }||_||_|dkrY|rSt}nt}||_||_||_|jrx6|j D]+}t |t r|j rt dqWdS)Nzresult_callbackrmr?ArgumentrequiredrA) rr#rrrr>rattrsrVr(r(r)rHs"          zMultiCommand.__init__cCs&tj||}|j|j|S)N)rrrr)rrUrr(r(r)rjsz!MultiCommand.collect_usage_piecescCs'tj||||j||dS)N)rrformat_commands)rrUrr(r(r)roszMultiCommand.format_optionscsfdd}|S)amAdds a result callback to the chain command. By default if a result callback is already registered this will chain them but this can be disabled with the `replace` parameter. The result callback is invoked with the return value of the subcommand (or the list of return values from all subcommands if chaining is enabled) as well as the parameters as they would be passed to the main callback. Example:: @click.group() @click.option('-i', '--input', default=23) def cli(input): return 42 @cli.resultcallback() def process_result(result, input): return result + input .. versionadded:: 3.0 :param replace: if set to `True` an already existing result callback will be removed. csWjdksr(_Sfdd}t|_}|S)Ncs|||||S)Nr()Z_MultiCommand__valuerXr)r old_callbackr(r)functionsz@MultiCommand.resultcallback..decorator..function)rr)rrr)r7r)rrr) decorators  z.MultiCommand.resultcallback..decoratorr()rr7rr()r7rr)resultcallbackss zMultiCommand.resultcallbackc Csg}xW|j|D]F}|j||}|dkr=q|jrIq|j||fqWt|r|jdtdd|D}g}x6|D].\}}|j|}|j||fqW|r|jd|j |WdQRXdS)zeExtra format methods for multi methods that adds all the commands after the options. Ncss|]}t|dVqdS)rN)r).0r'r(r(r) sz/MultiCommand.format_commands..Commands) list_commands get_commandrrrrmaxrrr) rrUrcommands subcommandr'rZrowsrr(r(r)rs"   $zMultiCommand.format_commandscCs| r=|jr=|j r=t|jd|j|jtj|||}|jrp||_ g|_ n-|r|dd|dd|_ |_ |j S)Nr|r) rrzrrr|rrrr>rnrX)rrUrXrestr(r(r)rs    'zMultiCommand.parse_argsc 'sfdd}jsujrhjs@tjStj|gSWdQRXjdjj}g_g_jsuj|\}}}|_tj|j ||d}|||j j|SWdQRXWdQRX|r1dnd_tjg}xi|rj|\}}}|j ||ddddd }|j ||jg}|_qSWg}x5|D]-}||j |j j|WdQRXqW||SWdQRXdS) Ncs.jdk r*jj|j}|S)N)rrrm)rW)rUrr(r)_process_resultsz,MultiCommand.invoke.._process_resultzMissing command.rj*ruTrvF) rnrr>rrrrXresolve_commandrrrrkr) rrUrrXrDr'Zsub_ctxZcontextsrr()rUrr)rsN        $    $zMultiCommand.invokecCst|d}|}|j||}|dkrd|jdk rd|j|}|j||}|dkr|j rt|dr|j||j|jdj||||ddfS)NrzNo such command '{}'.r) r!r ryrzrrrXrr6)rrUrXrDZoriginal_cmd_namer'r(r(r)r szMultiCommand.resolve_commandcCs tdS)z{Given a context and a command name, this returns a :class:`Command` object if it exists or returns `None`. N)r)rrUrDr(r(r)r &szMultiCommand.get_commandcCsgS)zTReturns a list of subcommand names in the order they should appear. r()rrUr(r(r)r ,szMultiCommand.list_commands)rCrrrrurvrrrrrrrrr r r(r(r(r)r@-s$   (   G  r@c@sgeZdZdZddddZdddZddZd d Zd d Zd dZ dS)GroupzA group allows a command to have subcommands attached. This is the most common way to implement nesting in Click. :param commands: a dictionary of commands. NcKs&tj||||pi|_dS)N)r@rr )rr#r rr(r(r)r:szGroup.__init__cCsN|p |j}|dkr'tdt|||dd||j|.decorator) decoratorsrk)rrXrrr()rXrkrrr)rkIsz Group.commandcs/ddlmfdd}|S)zA shortcut decorator for declaring and attaching a group to the group. This takes the same arguments as :func:`group` but immediately registers the created command with this instance by calling into :meth:`add_command`. r)groupcs&|}j||S)N)r)rr')rXrrrr(r)r`s zGroup.group..decorator)rr)rrXrrr()rXrrrr)rXsz Group.groupcCs|jj|S)N)r r:)rrUrDr(r(r)r gszGroup.get_commandcCs t|jS)N)rfr )rrUr(r(r)r jszGroup.list_commands) rCrrrrrrkrr r r(r(r(r)r3s    rc@sLeZdZdZddddZddZddZd d ZdS) CommandCollectionaA 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. NcKs&tj||||pg|_dS)N)r@rsources)rr#rrr(r(r)ruszCommandCollection.__init__cCs|jj|dS)z1Adds a new multi command to the chain dispatcher.N)rr)rZ multi_cmdr(r(r) add_sourcezszCommandCollection.add_sourcecCsSxL|jD]A}|j||}|dk r |jrGt||||Sq WdS)N)rr r>rF)rrUrDsourcerr(r(r)r ~s   zCommandCollection.get_commandcCs=t}x'|jD]}|j|j|qWt|S)N)rrupdater rf)rrUrrr(r(r)r s zCommandCollection.list_commands)rCrrrrrr r r(r(r(r)rns   rc @seZdZdZdZddddddddddddd Zdd Zed d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'ZdS)( Parametera A parameter to a command comes in two versions: they are either :class:`Option`\s or :class:`Argument`\s. Other subclasses are currently not supported by design as some of the internals for parsing are intentionally not finalized. Some settings are supported by both options and arguments. :param param_decls: the parameter declarations for this option or argument. This is a list of flags or argument names. :param type: the type that should be used. Either a :class:`ParamType` or a Python type. The later is converted into the former automatically if supported. :param required: controls if this is optional or not. :param default: the default value if omitted. This can also be a callable, in which case it's invoked when the default is needed without any arguments. :param callback: a callback that should be executed after the parameter was matched. This is called as ``fn(ctx, param, value)`` and needs to return the value. :param nargs: the number of arguments to match. If not ``1`` the return value is a tuple instead of single value. The default for nargs is ``1`` (except if the type is a tuple, then it's the arity of the tuple). :param metavar: how the value is represented in the help page. :param expose_value: if this is `True` then the value is passed onwards to the command callback and stored on the context, otherwise it's skipped. :param is_eager: eager values are processed before non eager ones. This should not be set for arguments or it will inverse the order of processing. :param envvar: a string or list of strings that are environment variables that should be checked. .. versionchanged:: 7.1 Empty environment variables are ignored rather than taking the empty string value. This makes it possible for scripts to clear variables if they can't unset them. .. versionchanged:: 2.0 Changed signature for parameter callback to also be passed the parameter. The old callback format will still work, but it will raise a warning to give you a chance to migrate the code easier. Z parameterNFTc Cs|j|pf|\|_|_|_t|||_|dkri|jjrc|jj}nd}||_||_ ||_ d|_ ||_ ||_ | |_||_| |_| |_dS)NrF) _parse_declsr#rrrtype is_compositearityrrTnargsmultiplerdefaultr`metavarenvvarautocompletion) r param_declsrrr#rTr!r$rr`r%r&r(r(r)rs"$           zParameter.__init__cCsdj|jj|jS)Nz<{} {}>)r6rBrCr#)rr(r(r)rszParameter.__repr__cCs|jS)zReturns the human readable name of this parameter. This is the same as the name for options, but the metavar for arguments. )r#)rr(r(r)human_readable_nameszParameter.human_readable_namecCsc|jdk r|jS|jj|}|dkrF|jjj}|jdkr_|d7}|S)Nrz...)r$r get_metavarr#r8r!)rr$r(r(r) make_metavars  zParameter.make_metavarcCs7t|jr|j}n |j}|j||S)z;Given a context variable this calculates the default value.)rr#type_cast_value)rrUrr(r(r)rs zParameter.get_defaultcCsdS)Nr()rrrUr(r(r)rszParameter.add_to_parsercCsO|j|j}|dkr-|j|}|dkrK|j|j}|S)N)r:r#value_from_envvarr)rrUrrWr(r(r) consume_values   zParameter.consume_valuecsjjr{jdkr3tdjjjrbtfdd|pZfDSj|pqfSfdd|jdktjS)zGiven a value this runs it properly through the type system. This automatically handles things like `nargs` and `multiple` as well as composite types. rzAttempted to invoke composite type but nargs has been set to {}. This is not supported; nargs needs to be set to a fixed value > 1.c3s*|] }j|pfVqdS)N)r)rx)rUrr(r)rsz,Parameter.type_cast_value..csEdkrj|Stfdd|p=fDS)Nrc3s"|]}|dVqdS)rNr()rr.)_convertlevelr(r)rsz>Parameter.type_cast_value.._convert..)rtuple)rWr0)r/rUr)r0r)r/s z+Parameter.type_cast_value.._convert)rrr!rr6r"r1bool)rrUrWr()r/rUrr)r+ s  &zParameter.type_cast_valuecCs |dk r|j||SdS)zaGiven a value and context this runs the logic to convert the value as necessary. N)r+)rrUrWr(r(r) process_value"s zParameter.process_valuecCs<|dkrdS|jdks(|jr8|fkr8dSdS)NTrF)r!r")rrWr(r(r)value_is_missing-s  $zParameter.value_is_missingcCsh|j||}|dkr7|j r7|j|}|jrd|j|rdtd|d||S)NrUrV)r3rzrrr4r)rrUrWr(r(r)full_process_value4s zParameter.full_process_valuecCs|jdkrdSt|jttfrdx[|jD](}tjj|}|dk r5|Sq5Wn%tjj|j}|dkr|SdS)Nr)r%r?r1rGr/r9r:)rrUr%rr(r(r)resolve_envvar_value?s   zParameter.resolve_envvar_valuecCs@|j|}|dk r<|jdkr<|jj|}|S)Nr)r6r!rsplit_envvar_value)rrUrr(r(r)r,MszParameter.value_from_envvarcCst|d||j||}y|j||}Wn$tk ra|jsWd}YnX|jdk ryt|j|||}Wntk r|jsYnXWdQRX|jr||j|j <||fS)NrV) r[r-r5 ExceptionrzrTrYrrmr#)rrUrrXrWr(r(r)rSs"      zParameter.handle_parse_resultcCsdS)Nr()rrUr(r(r)rgszParameter.get_help_recordcCsgS)Nr()rrUr(r(r)rjszParameter.get_usage_piecescCs/|jp|jg}djdd|DS)z{Get a stringified version of the param for use in error messages to indicate which param caused the error. z / css|]}t|VqdS)N)repr)rr.r(r(r)rrsz+Parameter.get_error_hint..)rr(r)rrUZ hint_listr(r(r)get_error_hintmszParameter.get_error_hint)rCrrrparam_type_namerrrr(r*rrr-r+r3r4r5r6r,rrrr:r(r(r(r)rs: ,          rc@seZdZdZdZdddddddddddddddddZdd Zd d Zd d ZddZ ddZ ddZ ddZ ddZ dS)raOptions are usually optional values on the command line and have some extra features that arguments don't have. All other parameters are passed onwards to the parameter constructor. :param show_default: controls if the default value should be shown on the help page. Normally, defaults are not shown. If this value is a string, it shows the string instead of the value. This is particularly useful for dynamic options. :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: if set then the value will need to be confirmed if it was prompted for. :param hide_input: if this is `True` then the input on the prompt will be hidden from the user. This is useful for password input. :param is_flag: forces this option to act as a flag. The default is auto detection. :param flag_value: which value should be used for this flag if it's enabled. This is set to a boolean automatically if the option string contains a slash to mark two options. :param multiple: if this is set to `True` then the argument is accepted multiple times and recorded. This is similar to ``nargs`` in how it works but supports arbitrary number of arguments. :param count: this flag makes an option increment an integer. :param allow_from_autoenv: if this is enabled then the value of this parameter will be pulled from an environment variable in case a prefix is defined on the context. :param help: the help string. :param hidden: hide this option from help outputs. optionNFTcKs|jdttk}tj||d| ||dkr[|jjddj}n|dkrpd}n|}||_||_||_ | |_ |dkr|dk rd}nt |j }|r|rd|_ |dkr|j }||_||_|jrIt|jt rI| dt gkrIt|_d|_n d|_| |_| r| dkrtdd|_|rd|_ ||_| |_| |_||_||_||_|jdkrtd |jr|jr|j rtd |j r&|j r&td |jrS|j rS|jdk rStd |jr|jrttd n|jrtddS)Nr#rTr4rFminrzOptions cannot have nargs < 0z+Cannot prompt for flags that are not bools.z*Got secondary option for non boolean flag.z5Hidden input does not work with boolean flag prompts.z6Options cannot be multiple and count at the same time.z3Options cannot be count and flags at the same time.)r:_missingrrr#r7 capitalizerconfirmation_prompt hide_inputrr2rr#r flag_valuer?rr is_bool_flagcountrr"allow_from_autoenvrr} show_choices show_envvarr!r)rr'r}rr@rArrBr"rDrErrrrFrGrZdefault_is_missingZ prompt_textr(r(r)rsh                -               !     zOption.__init__c Csg}g}d}g}x|D]}t|rR|dk rItd|}q|dddkrndnd}||kr|j|d\} } | j} | r|jt| |j| | j} | r|j| jq|jt||j|qW|dkrp|rp|jddd|ddjd d j }t|spd}|dkr|sd||fStd | r| rtd j ||||fS) NzName defined twicer/;recSst|d S)Nr)r)r.r(r(r)sz%Option._parse_decls..rr3r4z#Could not determine name for optionzhNo options defined but a name was passed ({}). Did you mean to declare an argument instead of an option?) rrrrrrrsortr7lowerr6) rdeclsrrrr#Zpossible_namesdeclZ split_charfirstsecondr(r(r)rsF     "          zOption._parse_declscCs d|jd|jd|i}|jr0d}n|jrBd}nd}|jr|jdddj|}|jr|jr|j |j d|d d ||j |jd|d d |q|j |j d|d |j |n||d<|j |j |dS) Ndestr!rorrDstorez{}_constactionconstTF) r#r!r"rDrpopr6rCr add_optionrrB)rrrUrrSZ action_constr(r(r)r!s&         zOption.add_to_parsercs<jr dSgfdd}|jg}jrY|j|jjped}g}jrj}|dkrjr|jdk rdj |jj j }|dk r|jdj t |t tfr djdd|Dn|jdk rjs6|jrt jtr]d j j}n^t jt tfrdjd djD}n$tjjrd }n j}|jd j |jr|jd |rdj |rdj |nddj|}r)dndj||fS)Ncs\t|\}}|r+dgdd<j rXj rX|djj7}|S)NTz {})rrrDr6r*)rrZ any_slashes)any_prefix_is_slashrr(r) _write_optsDs z+Option.get_help_record.._write_optsrz{}_{}z env var: {}z, css|]}t|VqdS)N)str)rdr(r(r)rZsz)Option.get_help_record..z({})css|]}t|VqdS)N)rY)rrZr(r(r)rcsz (dynamic)z default: {}rz{}[{}]z{} z; z / )rrrrrrGr%rEr{r6r#r8r?rGr1rr#r}r inspectZ isfunctionr)rrUrXrrrr%Zdefault_stringr()rWrr)r?sD      1 !"    *zOption.get_help_recordcCs`|jrP|j rPx6|jjD](}|j|jkr |jr |jSq WdStj||S)N) rrCrkrmr#r#rBrr)rrUrVr(r(r)rss  zOption.get_defaultcstj}jr(tj|Stjd|djdjdjdjdfddS) 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. r#rrArFr@Z value_proccsj|S)N)r3)r.)rUrr(r)rJsz)Option.prompt_for_value..)rrCrrrrArFr@)rrUr#r()rUrr)prompt_for_values      zOption.prompt_for_valuecCsltj||}|dk r"|S|jrh|jdk rhdj|j|jj}tjj |SdS)Nz{}_{}) rr6rEr{r6r#r8r/r9r:)rrUrr%r(r(r)r6s  zOption.resolve_envvar_valuecCs|j|}|dkrdS|jdkt|j}|dkr|dk r|jj|}|jr|jdkrt||j}|S)Nrr)r6r!r2r"rr7rK)rrUrZ value_depthr(r(r)r,s zOption.value_from_envvarcCsE|dkr2|jdk r2|j r2|j|Stj|||S)N)rrzr\rr5)rrUrWr(r(r)r5s% zOption.full_process_value)rCrrrr;rrrrrr\r6r,r5r(r(r(r)rus2 %F -  4   rc@syeZdZdZdZdddZeddZdd Zd d Z d d Z ddZ ddZ dS)rzArguments are positional parameters to a command. They generally provide fewer features than options but can have infinite ``nargs`` and are required by default. All parameters are passed onwards to the parameter constructor. argumentNcKs|dkrB|jddk r*d}n|jdddk}tj||d|||jdk r|jdkrtddS)Nr#Fr!rrrz>nargs=-1 in combination with a default value is not supported.)r:rrr#r!r)rr'rrr(r(r)rs  zArgument.__init__cCs#|jdk r|jS|jjS)N)r$r#r8)rr(r(r)r(szArgument.human_readable_namecCsr|jdk r|jS|jj|}|s=|jj}|jsUdj|}|jdkrn|d7}|S)Nz[{}]rz...)r$rr)r#r8rr6r!)rvarr(r(r)r*s  zArgument.make_metavarcCs|s%|sdggfStdt|dkr`|d}}|jddj}ntdjt|||ggfS)Nz%Could not determine name for argumentrrr3r4z8Arguments take exactly one parameter declaration, got {})rrr7rLr6)rrMrr#argr(r(r)rs  zArgument._parse_declscCs |jgS)N)r*)rrUr(r(r)rszArgument.get_usage_piecescCst|jS)N)r9r*)rrUr(r(r)r:szArgument.get_error_hintcCs&|jd|jd|jd|dS)NrQr!ro) add_argumentr#r!)rrrUr(r(r)rszArgument.add_to_parser) rCrrrr;rrr(r*rrr:rr(r(r(r)rs     r)Grr[r/r+ contextlibr functoolsr itertoolsr_compatrrrr Z _unicodefunr r exceptionsr r rrrrZ formattingrrglobalsrrrrrZtermuirrrtypesrrrutilsrrr r!r"objectr>rrrr&r*r2r;rFrKrYr[rgrhrrr@rrrrrr(r(r(r)sz          ;<