U 6e: @sdZddlZddlZddlZddlZddlmZddlmZm Z m Z m Z m Z m Z mZmZddlmZmZddlmZddlmZmZmZmZmZddlmZmZdd lmZd d d d ddddgZ Gdd d ej!Z"dddej#ej$dddfej%ee e&e'e'eee'eej!e'ee&d dd Z(d)ej%ee e&e'eej!e'eee ej!fdddZ)ej#ej$dfe ej!eee'ee&dddZ*e e&eee'ee&dddZ+ej!ee ddd Z,e ej!ee e&d!d"d#Z-e dd$d%d Z.e e dd&d'd Z/Gd(ddZ0dS)*z Dispatching ~~~~~~~~~~~ N) GeneratorType)IOAnyCallableDictIteratorListOptionalTuple) add_commandsset_default_command) autocomplete)ATTR_EXPECTS_NAMESPACE_OBJECTATTR_WRAPPED_EXCEPTIONS!ATTR_WRAPPED_EXCEPTIONS_PROCESSOR DEST_FUNCTIONPARSER_FORMATTER) CommandErrorDispatchingError) get_arg_spec ArghNamespacedispatchdispatch_commanddispatch_commandsparse_and_resolverun_endpoint_functionr EntryPointcsJeZdZdZddfdd Zeeddfdd Zedd d Z Z S) rzC A namespace object which collects the stack of functions. Nreturncstj||g|_dSN)super__init___functions_stack)selfargskwargs __class__/lib/python3.8/site-packages/argh/dispatching.pyr!2szArghNamespace.__init__)keyvaluercs(|tkr|j|nt||dSr)rr"appendr __setattr__)r#r*r+r&r(r)r-6s zArghNamespace.__setattr__cCs |jdS)N)r")r#r(r(r) get_functionDszArghNamespace.get_function) __name__ __module__ __qualname____doc__r!strrr-rr/ __classcell__r(r(r&r)r-sFT) parserargvadd_help_command completion output_file errors_file raw_output namespaceskip_unknown_argsrc Csp|r6ttd|r6|ddkr6|d|dt|||||d\} } | s^||dSt| | |||dS)a Parses given list of arguments using given parser, calls the relevant function and prints the result. Internally calls :func:`~argh.dispatching.parse_and_resolve` and then :func:`~argh.dispatching.run_endpoint_function`. :param parser: the ArgumentParser instance. :param argv: a list of strings representing the arguments. If `None`, ``sys.argv`` is used instead. Default is `None`. :param add_help_command: if `True`, converts first positional argument "help" to a keyword argument so that ``help foo`` becomes ``foo --help`` and displays usage information for "foo". Default is `False`. .. versionchanged:: 0.30 The default value is now ``False`` instead of ``True``. .. deprecated:: 0.30 This argument will be removed in v.0.31. The user is expected to use ``--help`` instead of ``help``. :param output_file: A file-like object for output. If `None`, the resulting lines are collected and returned as a string. Default is ``sys.stdout``. :param errors_file: Same as `output_file` but for ``sys.stderr``, and `None` is not accepted. :param raw_output: If `True`, results are written to the output file raw, without adding whitespaces or newlines between yielded strings. Default is `False`. :param completion: If `True`, shell tab completion is enabled. Default is `True`. (You will also need to install it.) See :mod:`argh.completion`. :param skip_unknown_args: If `True`, unknown arguments do not cause an error (`ArgumentParser.parse_known_args` is used). :param namespace: An `argparse.Namespace`-like object. By default an :class:`argh.dispatching.ArghNamespace` object is used. Please note that support for combined default and nested functions may be broken if a different type of object is forced. By default the exceptions are not wrapped and will propagate. The only exception that is always wrapped is :class:`~argh.exceptions.CommandError` which is interpreted as an expected event so the traceback is hidden. You can also mark arbitrary exceptions as "wrappable" by using the :func:`~argh.decorators.wrap_errors` decorator. Wrapped exceptions, or other "expected errors" like parse failures, will cause a SystemExit to be raised. zwThe argument `add_help_command` in `dispatch()` is deprecated. The user is expected to type `--help` instead of `help`.rhelpz--help)r6r9r7r=r>N)function namespace_objr:r;r<)warningswarnDeprecationWarningpopr,r print_usager) r6r7r8r9r:r;r<r=r>Zendpoint_functionrAr(r(r)rHs4T    )r6r7r9r=r>rcCsh|r t||dkr"tjdd}|s,t}|rJ|j||d\}}||_n|j||d}t|}||fS)z^ .. versionadded:: 0.30 Parses CLI arguments and resolves the endpoint function. N)r=)r sysr7rparse_known_argsZ _unknown_args parse_args _get_function_from_namespace_obj)r6r7r9r=r>rAZ unknown_argsr@r(r(r)rs )r@rAr:r;r<rcCst|||}t|||S)z .. versionadded:: 0.30 Extracts arguments from the namespace object, calls the endpoint function and processes its output. )_execute_command_process_command_output)r@rAr:r;r<linesr(r(r)rs )rNr:r<rcCsZ|dkrt}n|}|D] }|t||s|dq|dkrV|d|SdS)N r)ioStringIOwriter4seekread)rNr:r<Zout_ioliner(r(r)rMs   rM)rArc Cs^t|tr4z |}WqLttfk r0YdSXnt|tsBdSt|t}t|dsZdS|S)N__call__) isinstancerr/AttributeError IndexErrorhasattrrgetattr)rAr@r(r(r)rKs      rK)r@rAr;rc #sfdd}tg}|ttg7}ttddd}z|}|D] }|Vq@Wnvt|k r}zTtt|} |t| ||dt|tr|j dk r|j nd} t | W5d}~XYnXdS) a Assumes that `function` is a callable. Tries different approaches to call it (with `namespace_obj` or with ordinary signature). Yields the results line by line. If :class:`~argh.exceptions.CommandError` is raised, its message is written to the error file, and a SystemExit is raised. All other exceptions propagate unless marked as wrappable by :func:`wrap_errors`. c 3s:ttdr}nddtfddtDt}fdd|jD}t|dg}tfd d|D}|jr||j7}t|d t|d g}|rtg|j|jg|}tD].}|}| d s||krqt|||<qƈ||}t |t t t fr&|D] } | Vqn|dk r6|VdS) NFcSs |ddS)N-_)replace)r*r(r(r) _flat_key:sz2_execute_command.._call.._flat_keyc3s|]\}}||fVqdSrr().0kv)r_r(r) =sz2_execute_command.._call..csg|] }|qSr(r(r`ra all_inputr(r) Dsz3_execute_command.._call..Z kwonlyargsc3s|]}||fVqdSrr(rdrer(r)rcFsvarkwkeywordsr])r[rdictvarsitemsrr$Zvarargsr startswithrWrlisttuple) resultspecZ positionalZkwonlyrirhZ not_kwargsraZ normalized_krUr@rA)r_rfr)_call4s0       z_execute_command.._call)excrcSs|jjd|S)Nz: )r'r0)rtr(r(r)default_exception_processoresz5_execute_command..default_exception_processorrONrG) rr[r Exceptionr4rorrRrWcoderHexit) r@rAr;rsZwrappable_exceptionsrurprUrtZ processorrwr(rrr)rL%s$.  rLr@rcOs*tjtd}t||t|f||dS)a A wrapper for :func:`dispatch` that creates a one-command parser. Uses :attr:`argh.constants.PARSER_FORMATTER`. This:: dispatch_command(foo) ...is a shortcut for:: parser = ArgumentParser() set_default_command(parser, foo) dispatch(parser) This function can be also used as a decorator:: @dispatch_command def main(foo: int = 123) -> int: return foo + 1 formatter_classN)argparseArgumentParserrr r)r@r$r%r6r(r(r)rzs  ) functionsrcOs*tjtd}t||t|f||dS)aL A wrapper for :func:`dispatch` that creates a parser, adds commands to the parser and dispatches them. Uses :attr:`PARSER_FORMATTER`. This:: dispatch_commands([foo, bar]) ...is a shortcut for:: parser = ArgumentParser() add_commands(parser, [foo, bar]) dispatch(parser) rzN)r|r}rr r)r~r$r%r6r(r(r)rs  c@sfeZdZdZdeeeeeefddddZdee dddZ e dd d d Z dd d dZ dS)ra An object to which functions can be attached and then dispatched. When called with an argument, the argument (a function) is registered at this entry point as a command. When called without an argument, dispatching is triggered with all previously registered commands. Usage:: from argh import EntryPoint app = EntryPoint("main", {"description": "This is a cool app"}) @app def ls() -> None: for i in range(10): print i @app def greet() -> None: print "hello" if __name__ == "__main__": app() N)name parser_kwargsrcCs|pd|_g|_|pi|_dS)NZunnamed)rcommandsr)r#rrr(r(r)r!s zEntryPoint.__init__)r@cCs|r|||S|Sr)_register_command _dispatchr#r@r(r(r)rVs zEntryPoint.__call__rycCs|j|dSr)rr,rr(r(r)rszEntryPoint._register_commandrcCs>|jstd|jdtjf|j}t||jt|dS)Nzno commands for entry point "")rrrr|r}rr r)r#r6r(r(r)rs  zEntryPoint._dispatch)NN)N) r0r1r2r3r r4rrr!rrVrrr(r(r(r)rs )NTNF)1r3r|rPrHrBtypesrtypingrrrrrrr r Zargh.assemblingr r Zargh.completionr Zargh.constantsrrrrrZargh.exceptionsrrZ argh.utilsr__all__ Namespacerstdoutstderrr}r4boolrrrrMrKrLrrrr(r(r(r) s (     v  %    U