o NEgm@sdZddlZddlZddlmZmZmZmZmZm Z ddl Z ddl m Z m Z ddlmZdedeefd d Ze jd d Gd ddZe jd d GdddZe jd d GdddeZGdddZdS)z"Statement parsing classes for cmd2N)DictIterableListOptionalTupleUnion) constantsutils)Cmd2ShlexError str_to_splitreturncCstj|dddS)z A wrapper around shlex.split() that uses cmd2's preferred arguments. This allows other classes to easily call split() the same way StatementParser does. :param str_to_split: the string being split :return: A list of tokens F)commentsposix)shlexsplit)r rf/var/www/eduai.edurigo.com/doc_train/edurigo_ai/Puru/venv/lib/python3.10/site-packages/cmd2/parsing.py shlex_splitsrT)frozenc@sjeZdZdZejejedZ ejeje dZ ejeje dZ edZedZedZdS)MacroArgz Information used to replace or unescape arguments in a macro value when the macro is resolved Normal argument syntax: {5} Escaped argument syntax: {{5}}  validatorz(?`_ is your friend for anything complex. ``cmd2`` has the decorator (:func:`~cmd2.decorators.with_argparser`) which you can use to make your command method receive a namespace of parsed arguments, whether positional or denoted with switches. 2. For commands with simple positional arguments, use :attr:`~cmd2.Statement.args` or :attr:`~cmd2.Statement.arg_list` 3. If you don't want to have to worry about quoted arguments, see :attr:`argv` for a trick which strips quotes off for you. r-r0cst||}|S)a'Create a new instance of Statement. We must override __new__ because we are subclassing `str` which is immutable and takes a different number of arguments as Statement. NOTE: attrs takes care of initializing other members in the __init__ it generates. )super__new__)clsr0pos_argskw_argsstmt __class__rrr8s zStatement.__new__r cCs8|jr|jrd|j|j}|S|jr|j}|Sd}|S)zCombine command and args with a space separating them. Quoted arguments remain quoted. Output redirection and piping are excluded, as are any command terminators. z{} {}r6)commandargsformatselfrtnrrrcommand_and_argss zStatement.command_and_argscCshd}|jr ||j7}|jr|d|j7}|jr|d|j7}|jr2|d|j7}|jr2|d|j7}|S)zHA string containing any ending terminator, suffix, and redirection charsr6 z | ) terminatorsuffixpipe_tooutput output_torBrrr post_commands zStatement.post_commandcCs |j|jS)zeConcatenate :meth:`~cmd2.Statement.command_and_args` and :meth:`~cmd2.Statement.post_command`)rErL)rCrrrexpanded_command_lines zStatement.expanded_command_linecCs<|jrt|jg}|jD] }|t|q |Sg}|S)aa list of arguments a-la ``sys.argv``. The first element of the list is the command after shortcut and macro expansion. Subsequent elements of the list contain any additional arguments, with quotes removed, just like bash would. This is very useful if you are going to use ``argparse.parse_args()``. If you want to strip quotes from the input, you can use ``argv[1:]``. )r?r strip_quotesr4append)rCrD cur_tokenrrrargvs  zStatement.argv)rrrrrrrr r#r@rawr?r2r3r4multiline_commandrGrHrIrJrKobjectr8propertyrErLrMrrQ __classcell__rrr=rr5Ws* r5c @s:eZdZdZ    d$deeedeeedeeeefdeeeefddf dd Zd d d ed e de e effddZ dede efddZ dedefddZdedefddZdedeeefde de ee effddZdedefddZede ede eeffd d!Zde ede efd"d#ZdS)%StatementParserz>Parse user input as a string into discrete command components.N terminatorsmultiline_commandsaliases shortcutsr c Cs|dur tjf|_nt||_|durt|_nt||_|dur&t|_n||_|dur0tj}tt| dddd|_ g}| tj | tj | |jdd|D}| dd gd |}d |}t||_dS) aInitialize an instance of StatementParser. The following will get converted to an immutable tuple before storing internally: terminators, multiline commands, and shortcuts. :param terminators: iterable containing strings which should terminate commands :param multiline_commands: iterable containing the names of commands that accept multiline input :param aliases: dictionary containing aliases :param shortcuts: dictionary containing shortcuts NcSs t|dS)Nr)len)xrrrs z*StatementParser.__init__..T)keyreversecSg|]}t|qSr)r'escape.0r]rrr z,StatementParser.__init__..z\sz\Z|z\A\s*(\S*?)({}))r MULTILINE_TERMINATORrXtuplerYdictrZDEFAULT_SHORTCUTSsorteditemsr[extendQUOTESREDIRECTION_CHARSjoinrAr'r(_command_pattern) rCrXrYrZr[invalid_command_charssecond_group_items second_groupexprrrr__init__s*          zStatementParser.__init__F) is_subcommandwordrxc Csd}t|tsddtt|fS|sdS|tjrdS|sB|jD]\}}||rAd}|ddd|jD7}d|fSq#d }g}| tj | |j |dd d |D7}|j |}|rq||d krqd }d}||fS)aDetermine whether a word is a valid name for a command. Commands can not include redirection characters, whitespace, or termination characters. They also cannot start with a shortcut. :param word: the word to check as a command :param is_subcommand: Flag whether this command name is a subcommand name :return: a tuple of a boolean and an error string If word is not a valid command, return ``False`` and an error string suitable for inclusion in an error message of your choice:: checkit = '>' valid, errmsg = statement_parser.is_valid_command(checkit) if not valid: errmsg = "alias: {}".format(errmsg) Fz%must be a string. Received {} instead)Fzcannot be an empty string)Fz'cannot start with the comment characterzcannot start with a shortcut: z, css|]\}}|VqdS)Nr)rdshortcut_rrr Fsz3StatementParser.is_valid_command..z$cannot contain: whitespace, quotes, cSrar)rquotercrrrreMrfz4StatementParser.is_valid_command..rTr6) isinstancer#rAtype startswithr COMMENT_CHARr[rqrnrprXrrsearchgroup) rCryrxvalidrzr{errmsgerrcharsmatchrrris_valid_command#s2       z StatementParser.is_valid_commandlinec CsZ||}|tjrgSzt|}Wnty%}zt|d}~ww||}|S)a# Lex a string into a list of tokens. Shortcuts and aliases are expanded and comments are removed. :param line: the command line being lexed :return: A list of tokens :raises: Cmd2ShlexError if a shlex error occurs (e.g. No closing quotation) N) _expandlstriprr rr ValueErrorr split_on_punctuation)rCrtokensexrrrtokenizeVs   zStatementParser.tokenizec Csd}|ddtjkrtj}d}d}g}||}t|d}t|D]\}} |jD] } | | r7|}| }nq*q#|ra|tjkrGt|d}||d|\}}|d|}||dd}n||\} } | |jvry| }| }|dd}g}d} d}d}z| tj }Wn t yt|}Ynwz| tj }Wn t yt|}Ynwz| tj }Wn t yt|}Ynw||kr||kr||dd}t|d|} |d|}n8||kr||krtj }|}ntj }|}t||dkrt||d}|rt||d}|d|}|r#d|}nd}|s5||\}}|dd}||jvr>|}nd}t|||||||| ||d }|S)a Tokenize the input and parse it into a :class:`~cmd2.Statement` object, stripping comments, expanding aliases and shortcuts, and extracting output redirection directives. :param line: the command line being parsed :return: a new :class:`~cmd2.Statement` object :raises: Cmd2ShlexError if a shlex error occurs (e.g. No closing quotation) r6NrrF) rRr?r4rSrGrHrIrJrK)r LINE_FEEDrr\ enumeraterXr_command_and_argsrYindexREDIRECTION_PIPErREDIRECTION_OUTPUTREDIRECTION_APPENDr expand_user_in_tokensrqrN expand_userr5)rCrrGr?r@r4rterminator_posposrPtest_terminator testcommandtestargsrIrJrK pipe_index redir_index append_indexpipe_to_tokens output_index unquoted_pathrHrS statementrrrparseqs                        zStatementParser.parserawinputcCsv||}d}d}|j|}|r'|d}||dd}|r%|s'd}||jvr/|}nd}t||||d}|S)ahPartially parse input into a :class:`~cmd2.Statement` object. The command is identified, and shortcuts and aliases are expanded. Multiline commands are identified, but terminators and output redirection are not parsed. This method is used by tab completion code and therefore must not generate an exception if there are unclosed quotes. The :class:`~cmd2.Statement` object returned by this method can at most contain values in the following attributes: :attr:`~cmd2.Statement.args`, :attr:`~cmd2.Statement.raw`, :attr:`~cmd2.Statement.command`, :attr:`~cmd2.Statement.multiline_command` :attr:`~cmd2.Statement.args` will include all output redirection clauses and command terminators. Different from :meth:`~cmd2.parsing.StatementParser.parse` this method does not remove redundant whitespace within args. However, it does ensure args has no leading or trailing whitespace. :param rawinput: the command line as entered by the user :return: a new :class:`~cmd2.Statement` object r6rN)rRr?rS)rrrrrendstriprYr5)rCrrr?r@rrSrrrrparse_command_onlys$    z"StatementParser.parse_command_only command_nameto_parsepreserve_quotescCs<t|ts||d|}|r||jfS||jddfS)af Convenience method used by the argument parsing decorators. Retrieves just the arguments being passed to their ``do_*`` methods as a list. :param command_name: name of the command being run :param to_parse: what is being passed to the ``do_*`` method. It can be one of two types: 1. An already parsed :class:`~cmd2.Statement` 2. An argument string in cases where a ``do_*`` method is explicitly called. Calling ``do_help('alias create')`` would cause ``to_parse`` to be 'alias create'. In this case, the string will be converted to a :class:`~cmd2.Statement` and returned along with the argument list. :param preserve_quotes: if ``True``, then quotes will not be stripped from the arguments :return: A tuple containing the :class:`~cmd2.Statement` and a list of strings representing the arguments rFrN)r~r5rr4rQ)rCrrrrrrget_command_arg_list=s  z$StatementParser.get_command_arg_listc Cst|j}t|}|r>d}|j|}|r<|d}||vr<|j||d||dd}||t|}|s |j D]'\}}| |rht |}t ||ksZ||dkr^|d7}| ||d}|SqA|S)zExpand aliases and shortcutsFrNrF) r3rZkeysr%rrrrrremover[rr\replace) rCrremaining_aliaseskeep_expandingrr?rz expansion shortcut_lenrrrr^s,  &   zStatementParser._expandrcCs:d}d}|r |d}t|dkrd|dd}||fS)z`Given a list of tokens, return a tuple of the command and the args as a string. r6rrrFN)r\rq)rr?r@rrrrs z!StatementParser._command_and_argsc Csg}||j|tjg}|D]l}t|dks!|dtjvr'||qd}||}d} ||vrQ||vrP||7}|d7}|t|krK||}nn||vs8n|}||kro||7}|d7}|t|krj||}nn||ksW||d}|t|kr}nq0q|S)a|Further splits tokens from a command line using punctuation characters. Punctuation characters are treated as word breaks when they are in unquoted strings. Each run of punctuation characters is treated as a single token. :param tokens: the tokens as parsed by shlex :return: a new list of tokens, further split using punctuation rrr6)rnrXr rpr\rorO) rCr punctuationpunctuated_tokenscur_initial_token cur_indexcur_char new_tokencur_puncrrrrsH          z$StatementParser.split_on_punctuation)NNNN)rrrrrrr#rrwr%rrrrr5rrrrr staticmethodrrrrrrrWs>   $C3; !$ rW)rr'rtypingrrrrrrrr6r r exceptionsr r#rsrr,r5rWrrrrs