Ki KddlZejjdkr dZeZdZdZneZdZdZGdd e Z Gd d e Z Gd d e Z Gdde Z dS)Nc|SN)ss x/var/www/development/aibuddy-work/election-extract/venv/lib/python3.11/site-packages/pylatexenc/macrospec/_argparsers.pyunicoder %s1Hc|Srrxs rr'!r c|Srrr s rrr(rr cFt|dSNzutf-8)r encoder s rrr,s'!**"3"3G"<"<r c,|dSr)decoder s rrr-s!((7"3"3r c:eZdZdZgdffd ZdZdZdZxZS)ParsedMacroArgsa Parsed representation of macro arguments. The base class provides a simple way of storing the arguments as a list of parsed nodes. This base class can be subclassed to store additional information and provide more advanced APIs to access macro arguments for certain categories of macros. Arguments: - `argnlist` is a list of latexwalker nodes that represent macro arguments. If the macro arguments are too complicated to store in a list, leave this as `None`. (But then code that uses the latexwalker must be aware of your own API to access the macro arguments.) The difference between `argnlist` and the legacy `nodeargs` is that all options, regardless of optional or mandatory, are stored in the list `argnlist` with possible `None`\ 's at places where optional arguments were not provided. Previously, whether a first optional argument was included in `nodeoptarg` or `nodeargs` depended on how the macro specification was given. - `argspec` is a string or a list that describes how each corresponding argument in `argnlist` represents. If the macro arguments are too complicated to store in a list, leave this as `None`. For standard macros and parsed arguments this is a string with characters '*', '[', '{' describing an optional star argument, an optional square-bracket-delimited argument, and a mandatory argument. Attributes: .. py:attribute:: argnlist The list of latexwalker nodes that was provided to the constructor .. py:attribute:: argspec Argument type specification provided to the constructor .. py:attribute:: legacy_nodeoptarg_nodeargs A tuple `(nodeoptarg, nodeargs)` that should be exposed as properties in :py:class:`~pylatexenc.latexwalker.LatexMacroNode` to provide (as best as possible) compatibility with pylatexenc < 2. This is either `(<1st optional arg node>, )` if the first argument is optional and all remaining args are mandatory; or it is `(None, )` for any other argument structure. c tt|jdi|||_||_||j|j|_dS)Nr)superr__init__argnlistargspec_get_legacy_attribslegacy_nodeoptarg_nodeargs)selfrrkwargs __class__s rrzParsedMacroArgs.__init__fs[-ot$$-77777     $ $T\4= A A '''r cd}|dr$|dd}|dz }|d$|dddkr6td|ddDr||||dzdfSd|fS)Nr*[c3"K|] }|dkV dS){Nr.0r s r z6ParsedMacroArgs._get_legacy_attribs..us&&E&EAqCx&E&E&E&E&E&Er ) startswithall)r rrnskips rrz#ParsedMacroArgs._get_legacy_attribsps  %% abbkG QJE  %%  1Q3<3  3&E&E&E&E&E#E#E e_huQwxx&8: :(# #r c8t|j|jS)a Called when we export the node structure to JSON when running latexwalker in command-line. Return a representation of the current parsed arguments in an object, typically a dictionary, that can easily be exported to JSON. The object may contain latex nodes and other parsed-argument objects, as we use a custom JSON encoder that understands these types. Subclasses may rr)dictrrr s rto_json_objectzParsedMacroArgs.to_json_object{s%L]    r cXd|jj|j|jS)Nz{}(argspec={!r}, argnlist={!r}))formatr"__name__rrr2s r__repr__zParsedMacroArgs.__repr__s*077 N #T\4=   r ) r6 __module__ __qualname____doc__rrr3r7 __classcell__r"s@rrr2s22f!#BBBBBBB$$$   $       r rc6eZdZdZ dfd ZddZdZxZS) MacroStandardArgsParseraX Parses the arguments to a LaTeX macro. This class parses a simple macro argument specification with a specified arrangement of optional and mandatory arguments. This class also serves as base class for more advanced argument parsers (e.g. for a ``\verb+...+`` macro argument parser). In such cases, subclasses should attempt to provide the most suitable `argspec` (and `argnlist` for the corresponding :py:class:`ParsedMacroArgs`) for their use, if appropriate, or set them to `None`. Arguments: - `argspec`: must be a string in which each character corresponds to an argument. The character '{' represents a mandatory argument (single token or LaTeX group) and the character '[' denotes an optional argument delimited by braces. The character '\*' denotes a possible star char at that position in the argument list, a corresponding ``latexwalker.LatexCharsNode('*')`` (or `None` if no star) will be inserted in the argument node list. For instance, the string '\*{[[{' would be suitable to specify the signature of the '\\newcommand' macro. Currently, the argspec string may only contain the characters '\*', '{' and '['. The `argspec` may also be `None`, which is the same as specifying an empty string. - `optional_arg_no_space`: If set to `True`, then an optional argument cannot have any whitespace between the preceeding tokens and the '[' character. Set this to `True` in cases such as for ``\\`` in AMS-math environments, where AMS apparently introduced a patch to prevent a bracket on a new line after ``\\`` from being interpreted as the optional argument to ``\\``. - `args_math_mode`: Either `None`, or a list of the same length as `argspec`. If a list is given, then each item must be `True`, `False`, or `None`. The corresponding argument (cf. `argspec`) is then respectively parsed in math mode (`True`), in text mode (`False`), or with the mode unchanged (`None`). If `args_math_mode` is `None`, then all arguments are parsed in the same mode as the current mode. - additional unrecognized keyword arguments are passed on to superclasses in case of multiple inheritance Attributes: .. py:attribute:: argspec Argument type specification provided to the constructor. .. py:attribute:: optional_arg_no_space See the corresponding constructor argument. .. py:attribute:: args_math_mode See the corresponding constructor argument. NFc Ftt|jdi||r|nd|_||_||_t |jtrtd|jDs'td |jd|_ dS)Nrc3K|]}|dvV dS)z*[{Nrr)s rr+z3MacroStandardArgsParser.__init__..s&44!1:444444r zCargspec must be a string containing chars '*', '[', '{{' only: {!r}Fr) rr>rroptional_arg_no_spaceargs_math_mode isinstance _basestringr- TypeErrorr5&_like_pylatexenc1x_ignore_leading_star)r rrArBr!r"s rrz MacroStandardArgsParser.__init__s5%t,,5?????")1wwr %:",$, 44 44t|44444 U %% 7<333r c |ddlm}|g}jWt jt jkr-t djjfd}|}jr:| |}|j dkr|j dkr|j |jz}tjD]\} } | dkr@||d ||  \} } } | | z}|| L| d krjrM|t |jkr5|j|r|d||||  }||d|\} } } | | z}|| | dkr| |}|j dkrf|j drL|||j|| d|j d |j d z}|dt/d| t1j|}||||z fS)aP Parse the arguments encountered at position `pos` in the :py:class:`~pylatexenc.latexwalker.LatexWalker` instance `w`. You may override this function to provide custom parsing of complicated macro arguments (say, ``\verb+...+``). The method will be called by keyword arguments, so the argument names should not be altered. The argument `w` is the :py:class:`pylatexenc.latexwalker.LatexWalker` object that is currently parsing LaTeX code. You can call methods like `w.get_goken()`, `w.get_latex_expression()` etc., to parse and read arguments. The argument `parsing_state` is the current parsing state in the :py:class:`~pylatexenc.latexwalker.LatexWalker` (e.g., are we currently in math mode?). See doc for :py:class:`~pylatexenc.latexwalker.ParsingState`. This function should return a tuple `(argd, pos, len)` where: - `argd` is a :py:class:`ParsedMacroArgs` instance, or an instance of a subclass of :py:class:`ParsedMacroArgs`. The base `parse_args()` provided here returns a :py:class:`ParsedMacroArgs` instance. - `pos` is the position of the first parsed content. It should be the same as the `pos` argument, except if there is whitespace at that position in which case the returned `pos` would have to be the position where the argument contents start. - `len` is the length of the parsed expression. You will probably want to continue parsing stuff at the index `pos+len` in the string. r latexwalkerNz-Invalid args_math_mode={!r} for argspec={!r}!cjSj|}| |jkrS|dkrdSdS)NT) in_math_modeF)rBrK sub_context)jamm parsing_stater s rget_inner_parsing_statezCMacroStandardArgsParser.parse_args..get_inner_parsing_statesn"*$$%a(C{c]%???$$d{{$00d0CCC ,,%,@@ @r charr$r(F) strict_bracesrOr&)rOr%rOcharsposlenz+Unknown macro argument kind for macro: {!r}r0)rrImake_parsing_staterBrVr ValueErrorr5rF get_tokentokargrU enumerateget_latex_expressionappendrArisspaceget_latex_maybe_optional_argr, make_nodeLatexCharsNodeLatexWalkerErrorr)r wrUrOrIrrPprZrMargtnodenpnloptarginfotupleparseds` ` r parse_argsz"MacroStandardArgsParser.parse_argss+D #"""""  0022M   * t" # #s4<'8'8 8 8L$fT%8$,GGII I A A A A A A   6 &++a..Cw&  SW^^Gcg% ..- - GAts{{!"!7!7"'"9"9!"<"<"8""r2 G%%%%-!c!#hh,,13q6>>CSCS,OOD)))"#"@"@"9"9!"<"<#A###*OOD)))!0r2G%%%%kk!nn7f$$););C)@)@$OO K$>2I2I!2L2L*-37$CC ! AAOOD))))'AHHNN!L    QsU##r cdd|jj|j|j|jS)NzA{}(argspec={!r}, optional_arg_no_space={!r}, args_math_mode={!r}))r5r"r6rrArBr2s rr7z MacroStandardArgsParser.__repr__Zs1RYY N #T\43M     r )NFNrr6r8r9r:rrlr7r;r<s@rr>r>sy;;xc*eZdZdZdfd ZdZxZS)ParsedVerbatimArgsa Parsed representation of arguments to LaTeX verbatim constructs, such as ``\begin{verbatim}...\end{verbatim}`` or ``\verb|...|``. Instances of `ParsedVerbatimArgs` are returned by the args parser :py:class:`VerbatimArgsParser`. Arguments: - `verbatim_chars_node` --- a properly initialized :py:class:`pylatexenc.latexwalker.LatexCharsNode` that stores the verbatim text provided. It is used to initialize the base class :py:class:`ParsedMacroArgs` to expose a single mandatory argument with the given verbatim text. The `verbatim_text` attribute is initialized from this node, too. - `verbatim_delimiters` --- a 2-item tuple of characters used to delimit the verbatim arguemnt (in case of a ``\verb+...+`` macro) or `None`. Attributes: .. py:attribute:: verbatim_text The verbatim text that was provided .. py:attribute:: verbatim_delimiters If the verbatim text was specified as an argument to ``\verb$...$``, then this is set to a 2-item tuple that specifies the begin and end delimiters. Otherwise, the attribute is `None`. Nc vtt|jdd|gd||j|_||_dS)Nr(r0r)rrprrT verbatim_textverbatim_delimiters)r verbatim_chars_nodersr!r"s rrzParsedVerbatimArgs.__init__s_ 1 $''0 )*     16#6   r cXd|jj|j|jS)Nz0{}(verbatim_text={!r}, verbatim_delimiters={!r}))r5r"r6rrrsr2s rr7zParsedVerbatimArgs.__repr__s,AHH N #T%79Q   r r)r6r8r9r:rr7r;r<s@rrprpcsV> 7 7 7 7 7 7       r rpc0eZdZdZfdZddZdZxZS)VerbatimArgsParsera Parses the arguments to various LaTeX "verbatim" constructs such as ``\begin{verbatim}...\end{verbatim}`` environment or ``\verb+...+``. This class also serves to illustrate how to write custom parsers for complicated macro arguments. See also :py:class:`MacroStandardArgsParser`. Arguments: .. py:attribute:: verbatim_arg_type One of 'verbatim-environment' or 'verb-macro'. c Ztt|jdddi|||_dS)Nrr(r)rrwrverbatim_arg_type)r ryr!r"s rrzVerbatimArgsParser.__init__s:0 $''0GGGGGG!2r Nc tddlm}|jdkr|jd|}|dkr||j|d||z }t ||j||j|||z|| }|||fS|jd kr|j| rY|d z }|t|jkr||j|d |j| Y|j|}|d z} |j|| } | dkr||j|d |j| | } t ||j|| | | | z ||f}||| d z|z fSdS)NrrHzverbatim-environmentz\end{verbatim}z#Cannot find matching \end{verbatim})rrUmsgrS)rtz verb-macror%z!Missing argument to \verb commandz=End of stream reached while reading argument to \verb command)rtrs) rrIryrfindLatexWalkerParseErrorrprarbr_rV) r rdrUrOrI endverbposlen_argd verbdelimcharbeginposendposverbargs rrlzVerbatimArgsParser.parse_argss3""""""  !%; ; ;"3S99JR!77c>8c>D%$%KK 0J>K67c#c$h,6G4748 %0%:%:D#t$ $  !\ 1 1#c(""$$ q#ac((??%;;#@<#c(""$$ CHM1uHSXXmX66F||!77cX8 c(6/*G%$%KK 0J>K6=4<4:8O %0%E%E &3M$B D#vax|, ,A 2 1r cLd|jj|jS)Nz{}(verbatim_arg_type={!r}))r5r"r6ryr2s rr7zVerbatimArgsParser.__repr__s'+22 N #T%;   r rrnr<s@rrwrwsf  33333;-;-;-;-|       r rw)sys version_infomajorr strrD_str_from_unicode_unicode_from_str basestringobjectrr>rprwrr rrs.@ AK# # K<<33 ^ ^ ^ ^ ^ f^ ^ ^ DJ J J J J fJ J J ^2 2 2 2 2 2 2 2 lS S S S S 0S S S S S r