*h KSSKr\RRS:a Sr\rSrSrO\rSrSr"SS \ 5r "S S \ 5r "S S \ 5r "SS\ 5r g)NcU$N)ss ]/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pylatexenc/macrospec/_argparsers.pyunicoder %s1HcU$rrxs rr'!r cU$rrr s rrr(rr c6[U5RS5$Nzutf-8)r encoder s rrr,s'!*"3"3G", )` if the first argument is optional and all remaining args are mandatory; or it is `(None, )` for any other argument structure. c >[[U] "S0UD6 XlX lUR URUR5Ulg)Nr)superr__init__argnlistargspec_get_legacy_attribslegacy_nodeoptarg_nodeargs)selfrrkwargs __class__s rrParsedMacroArgs.__init__fsA ot-77    $ $T\\4== A 'r cSnURS5(a"USSnUS- nURS5(aM"USSS:Xa%[SUSS55(a X#X#S-S4$SU4$)Nr*[c3*# UH oS:Hv M g7f){Nr.0r s r 6ParsedMacroArgs._get_legacy_attribs..us&EACx) startswithall)r!rrnskips rr#ParsedMacroArgs._get_legacy_attribsps  %%abkG QJE  %% 1Q<3 3&E&E#E#E_hQwx&8: :(# #r c>[URURS9$)au 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_objectParsedMacroArgs.to_json_object{sLL]]  r cxSRURRURUR5$)Nz{}(argspec={!r}, argnlist={!r}))formatr#__name__rrr7s r__repr__ParsedMacroArgs.__repr__s.077 NN # #T\\4==  r )rrr ) r< __module__ __qualname____firstlineno____doc__rrr8r=__static_attributes__ __classcell__r#s@rrr2s*2f!#BB$ $  r rcD^\rSrSrSrSU4SjjrSSjrSrSrU=r $) MacroStandardArgsParsera 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. c <>[[U] "S0UD6 U(aUOSUlX lX0l[ UR[5(a![SUR55(d$[SRUR55eSUl g)Nrc3*# UH oS;v M g7f)z*[{Nrr+s rr-3MacroStandardArgsParser.__init__..s4|!:|r/zCargspec must be a string containing chars '*', '[', '{{' only: {!r}Fr) rrGrroptional_arg_no_spaceargs_math_mode isinstance _basestringr1 TypeErrorr;&_like_pylatexenc1x_ignore_leading_star)r!rrLrMr"r#s rr MacroStandardArgsParser.__init__s{ %t5??")wr %:",$,, 444t||444U % 7<3r c ^^SSKJn TcUR5m/nTRb[[ TR5[ TR 5:wa/[ SRTRTR 55eUU4SjnUnTR(aJURU5nURS:Xa)URS:XaURUR-n[TR 5GHupU S:Xa1URUS U"U 5S 9upn X-nURU 5 M=U S :XaTR (aNU[ UR"5:a5UR"UR%5(aURS5 MUR'UU"U 5S 9nUcURS5 MUupn X-nURU 5 MU S:XaURU5nURS:XanURR)S5(aNURUR+UR,U"U 5SURS S95 URS -nGMURS5 GM[/SRU 55e [1TR US9nXXr- 4$)a 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}!c>TRcT$TRUnUbUTR:XaT$US:XaTRSS9$TRSS9$)NT) in_math_modeF)rMrW sub_context)jamm parsing_stater!s rget_inner_parsing_stateCMacroStandardArgsParser.parse_args..get_inner_parsing_statesl""*$$%%a(C{c]%?%??$$d{$00d0CC ,,%,@ @r charr&r*F) strict_bracesr[r()r[r'r[charsposlenz+Unknown macro argument kind for macro: {!r}r5)rrUmake_parsing_staterMrcr ValueErrorr;rQ get_tokentokargrb enumerateget_latex_expressionappendrLrisspaceget_latex_maybe_optional_argr0 make_nodeLatexCharsNodeLatexWalkerErrorr)r!wrbr[rUrr\prgrYargtnodenpnloptarginfotupleparseds` ` r parse_args"MacroStandardArgsParser.parse_argssvD #  002M    * t"" #s4<<'8 8L$fT%8%8$,,GI I A   6 6++a.Cww& SWW^GGcgg% .GAs{!"!7!7"'"9!"<"8"2 G%--!c!##h,133q6>>CSCSOOD)"#"@"@"9!"<#A##*OOD)!02G%kk!n77f$););C)@)@OO K$>$>2I!2L*-377$C ! AOOD)'AHHNW/^!LL  QU##r cSRURRURURUR 5$)NzA{}(argspec={!r}, optional_arg_no_space={!r}, args_math_mode={!r}))r;r#r<rrLrMr7s rr= MacroStandardArgsParser.__repr__Zs9RYY NN # #T\\43M3M     r )rQrMrrL)NFNr r<r?r@rArBrryr=rCrDrEs@rrGrGs(;x[[U] "SSU/S.UD6 URUlX lg)Nr*r5r)rrrra verbatim_textverbatim_delimiters)r!verbatim_chars_noderr"r#s rrParsedVerbatimArgs.__init__sC  $0 )*  166#6 r cxSRURRURUR5$)Nz0{}(verbatim_text={!r}, verbatim_delimiters={!r}))r;r#r<rrr7s rr=ParsedVerbatimArgs.__repr__s2AHH NN # #T%7%79Q9Q  r )rrr) r<r?r@rArBrr=rCrDrEs@rrrcs> 7  r rc<^\rSrSrSrU4SjrSSjrSrSrU=r $)VerbatimArgsParseria 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 >>[[U] "SSS0UD6 Xlg)Nrr*r)rrrverbatim_arg_type)r!rr"r#s rrVerbatimArgsParser.__init__s!  $0GGG!2r c `SSKJn URS:XaxURR SU5nUS:XaUR URUSS9eXR- n[ URURUURX"U-UUS9S 9nXrU4$URS :XGaURUR5(a]US - nU[UR5:aUR URUS S9eURUR5(aM]URUnUS -n URR X5n U S:XaUR URUS S9eURXn [ URURUU U X- S9X4S9nXrU S -U- 4$g)NrrTzverbatim-environmentz\end{verbatim}z#Cannot find matching \end{verbatim})rrbmsgr`)rz verb-macror'z!Missing argument to \verb commandz=End of stream reached while reading argument to \verb command)rr) rrUrrfindLatexWalkerParseErrorrrnrorlrc) r!rqrbr[rU endverbposlen_argd verbdelimcharbeginposendposverbargs rryVerbatimArgsParser.parse_argss"  ! !%; ;"3S9JR!77cc>8>D%$%KK 0J0J>K67cc#$h6G4748 %0%:Dt$ $  ! !\ 1##c(""$$q#acc(?%;;##@<##c(""$$CCHM1uHSSXXm6F|!77ccX8 cc(*G%$%KK 0J0J>K6=4<4:O %0%E &3$B Dvax|, ,A 2r cbSRURRUR5$)Nz{}(verbatim_arg_type={!r}))r;r#r<rr7s rr=VerbatimArgsParser.__repr__s*+22 NN # #T%;%;  r )rrr}rEs@rrrs 3;-|  r r)sys version_infomajorr strrO_str_from_unicode_unicode_from_str basestringobjectrrGrrrr rrs@ AK##K<3 ^ f^ DJ fJ ^2 2 lS 0S r