*hSrSSKJrJr SSKrSSKrSSKrSSKrSSKrSSK J r SSK J r \RRS:a Sr\rSrS rO\rS rS r\R("\5rS r"S S\5r"SS\5r"SS\5rSrSr\ R<"SS9r"SS\ 5r!"SS\ 5r""SS\"5r#"SS\"5r$"SS \"5r%"S!S"\"5r&"S#S$\"5r'"S%S&\"5r("S'S(\"5r)"S)S*\ 5r*"S+S,\ 5r+"S-S.\ 5r,S9S/jr-S0r.S1r/S:S2jr0S;S3jr1SS8jr6g)?a The ``latexwalker`` module provides a simple API for parsing LaTeX snippets, and representing the contents using a data structure based on node classes. LatexWalker will understand the syntax of most common macros. However, ``latexwalker`` is NOT a replacement for a full LaTeX engine. (Originally, ``latexwalker`` was designed to extract useful text for indexing for text database searches of LaTeX content.) Simple example usage:: >>> from pylatexenc.latexwalker import LatexWalker, LatexEnvironmentNode >>> w = LatexWalker(r""" ... \textbf{Hi there!} Here is \emph{a list}: ... \begin{enumerate}[label=(i)] ... \item One ... \item Two ... \end{enumerate} ... and $x$ is a variable. ... """) >>> (nodelist, pos, len_) = w.get_latex_nodes(pos=0) >>> nodelist[0] LatexCharsNode(pos=0, len=1, chars='\n') >>> nodelist[1] LatexMacroNode(pos=1, len=18, macroname='textbf', nodeargd=ParsedMacroArgs(argnlist=[LatexGroupNode(pos=8, len=11, nodelist=[LatexCharsNode(pos=9, len=9, chars='Hi there!')], delimiters=('{', '}'))], argspec='{'), macro_post_space='') >>> nodelist[5].isNodeType(LatexEnvironmentNode) True >>> nodelist[5].environmentname 'enumerate' >>> nodelist[5].nodeargd.argspec '[' >>> nodelist[5].nodeargd.argnlist [LatexGroupNode(pos=60, len=11, nodelist=[LatexCharsNode(pos=61, len=9, chars='label=(i)')], delimiters=('[', ']'))] >>> nodelist[7].latex_verbatim() '$x$' You can also use `latexwalker` directly in command-line, producing JSON or a human-readable node tree:: $ echo '\textit{italic} text' | latexwalker --output-format=json { "nodelist": [ { "nodetype": "LatexMacroNode", "pos": 0, "len": 15, "macroname": "textit", [...] $ latexwalker --help [...] The parser can be influenced by specifying a collection of known macros and environments (the "latex context") that are specified using :py:class:`pylatexenc.macrospec.MacroSpec` and :py:class:`pylatexenc.macrospec.EnvironmentSpec` objects in a :py:class:`pylatexenc.macrospec.LatexContextDb` object. See the doc of the module :py:mod:`pylatexenc.macrospec` for more information. )print_functionunicode_literalsN) macrospec)_utilcU$N)strings \/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pylatexenc/latexwalker/__init__.pyunicoder gscU$r r xs r ri!rcU$r r rs r rrjrrc6[U5RS5$Nzutf-8)r encoders r rrns'!*"3"3G"SUlXlX lX0lX@lXPl/Ul[[U]'UR55 gr ) input_sourcemsgsposlinenocolno open_contextssuperr(__init___dispstr)selfr,r-r.r/r0 __class__s r r3LatexWalkerParseError.__init__sB    #T3DMMODrc URnUR(aUSRUR5- nUSURURUR UR 5--nUR(aJUS- n[UR5H,nUupEpgUSRSURXVU5US9- nM. U$)Nz in {}z %sz Open LaTeX blocks: z{empty:8}{loc:>10} {what} )emptylocwhat) r,r+format_fmt_posr.r/r0r1reversed)r5r,dispcontextr<r.r/r0s r r4LatexWalkerParseError._dispstrshh    9##D$5$56 6CUDMM$((DKKLMM    , ,D#D$6$67+2(66==B<@MM#UZ<[=A>CC8  rc.UbUbSX#4-$SU-$SU-$)Nz@(%d,%d)z@%dz @ char %dr )r5r.r/r0s r r>LatexWalkerParseError._fmt_poss0   !6/11&> !C  rc"UR5$r )r4r5s r __str__LatexWalkerParseError.__str__}}r)r0r+r/r,r1r.r-NNNN) r!r"r#r$r%r3r4r>rGr& __classcell__r6s@r r(r(s"6 E !rr(c0^\rSrSrSrSU4SjjrSrU=r$)LatexWalkerEndOfStreamz2 Reached end of input stream (e.g., end of file). c6>[[U] 5 Xlgr )r2rNr3 final_space)r5rQr6s r r3LatexWalkerEndOfStream.__init__s $d46&rrQr9)r!r"r#r$r%r3r&rKrLs@r rNrNs''rrNc[R"5nSSKJn UH up#UR UUSUSUSS9 M" U$)aJ Return a :py:class:`pylatexenc.macrospec.LatexContextDb` instance initialized with a collection of known macros and environments. TODO: document categories. If you want to add your own definitions, you should use the :py:meth:`pylatexenc.macrospec.LatexContextDb.add_context_category()` method. If you would like to override some definitions, use that method with the argument `prepend=True`. See docs for :py:meth:`pylatexenc.macrospec.LatexContextDb.add_context_category()`. If there are too many macro/environment definitions, or if there are some irrelevant ones, you can always filter the returned database using :py:meth:`pylatexenc.macrospec.LatexContextDb.filter_context()`. .. versionadded:: 2.0 The :py:class:`pylatexenc.macrospec.LatexContextDb` class as well as this method, were all introduced in `pylatexenc 2.0`. )specsmacros environmentsspecials)rXrYrZ)rLatexContextDb _defaultspecsrWadd_context_category)dbrWcatcatspecss r get_default_latex_context_dbrasU,  ! ! #B$  '/'9-5n-E)1*)=  ? Irc[R"S5 [R"XU5nURUlXlX#lSURl U$)aV .. deprecated:: 2.0 Use :py:func:`pylatexenc.macrospec.std_macro` instead which does the same thing, or invoke the :py:class:`~pylatexenc.macrospec.MacroSpec` class directly (or a subclass). In `pylatexenc 1.x`, `MacrosDef` was a class. Since `pylatexenc 2.0`, `MacrosDef` is a function which returns a :py:class:`~pylatexenc.macrospec.MacroSpec` instance. In this way the earlier idiom ``MacrosDef(...)`` still works in `pylatexenc 2`. The field names of the constructed object might have changed since `pylatexenc 1.x`, so you might have to adapt existing code if you were accessing individual fields of `MacrosDef` objects. In the object returned by `MacrosDef()`, we provide the legacy attributes `macname`, `optarg`, and `numargs`, so that existing code accessing those properties can continue to work. z`pylatexenc.latexwalker.MacrosDef` is now obsolete. It should still work in most use cases, but new code should use `pylatexenc.macrospec.MacroSpec` instead.T) rpylatexenc_deprecated_2r std_macro macronamemacnameoptargnumargs args_parser&_like_pylatexenc1x_ignore_leading_star)rfrgrhms r MacrosDefrlsT( !! 4 GW5A AIHI<@AMM8 Hrc[[5R5Vs/sHnURU4PM sn5$s snfr )dictraiter_macro_specsre)rks r rrs>T-/@@B#BA aB##s?)generate_dict_fncR^\rSrSrSrS U4SjjrSrSrSrSr Sr S r S r U=r $) LatexTokeni:a= Represents a token read from the LaTeX input. This is used internally by :py:class:`LatexWalker`'s methods. You probably don't need to worry about individual tokens. Rather, you should use the high-level functions provided by :py:class:`LatexWalker` (e.g., :py:meth:`~LatexWalker.get_latex_nodes()`). So most likely, you can ignore this class entirely. Instances of this class are what the method :py:meth:`LatexWalker.get_token()` returns. See the doc of that function for more information on how tokens are parsed. This is not the same thing as a LaTeX token, it's just a part of the input which we treat in the same way (e.g. a bunch of content characters, a comment, a macro, etc.) Information about the object is stored into the fields `tok` and `arg`. The `tok` field is a string which identifies the type of the token. The `arg` depends on what `tok` is, and describes the actual input. Additionally, this class stores information about the position of the token in the input stream in the field `pos`. This `pos` is an integer which corresponds to the index in the input string. The field `len` stores the length of the token in the input string. This means that this token spans in the input string from `pos` to `pos+len`. Leading whitespace before the token is not returned as a separate 'char'-type token, but it is given in the `pre_space` field of the token which follows. Pre-space may contain a newline, but not two consecutive newlines. The `post_space` is only used for 'macro' and 'comment' tokens, and it stores any spaces encountered after a macro, or the newline with any following spaces that terminates a LaTeX comment. When we encounter two consecutive newlines these are not included in `post_space`. The `tok` field may be one of: - 'char': raw character(s) which have no special LaTeX meaning and which are part of the text content. The `arg` field contains the characters themselves. - 'macro': a macro invocation, but not ``\begin`` or ``\end`` The `arg` field contains the name of the macro, without the leading backslash. - 'begin_environment': an invocation of ``\begin{environment}``. The `arg` field contains the name of the environment inside the braces. - 'end_environment': an invocation of ``\end{environment}``. The `arg` field contains the name of the environment inside the braces. - 'comment': a LaTeX comment delimited by a percent sign up to the end of the line. The `arg` field contains the text in the comment line, not including the percent sign nor the newline. - 'brace_open': an opening brace. This is usually a curly brace, and sometimes also a square bracket. What is parsed as a brace depends on the arguments to :py:meth:`~LatexWalker.get_token()`. The `arg` is a string which contains the relevant brace character. - 'brace_close': a closing brace. This is usually a curly brace, and sometimes also a square bracket. What is parsed as a brace depends on the arguments to :py:meth:`~LatexWalker.get_token()`. The `arg` is a string which contains the relevant brace character. - 'mathmode_inline': a delimiter which starts/ends inline math. This is (e.g.) a single '$' character which is not part of a double '$$' display environment delimiter. The `arg` is the string value of the delimiter in question ('$') - 'mathmode_display': a delimiter which starts/ends display math, e.g., ``\[``. The `arg` is the string value of the delimiter in question (e.g., ``\[`` or ``$$``) - 'specials': a character or character sequence that has a special meaning in LaTeX. E.g., '~', '&', etc. The `arg` field is then the corresponding :py:class:`~pylatexenc.macrospec.SpecialsSpec` instance. [The rationale for setting `arg` to a `SpecialsSpec` instance, in contrast to the behavior for macros and envrionments, is that macros and environments are delimited directly by LaTeX syntax and are determined unambiguously without any lookup in the latex context database. This is not the case for specials.] c>XlX lX0lX@lXPlX`l/SQUlURS;aUR RS5 [[U]+5 g)Ntokargr.len pre_space)macrocomment post_space) rurvr.rwrxr{_fieldsappendr2rrr3)r5rurvr.rwrxr{r6s r r3LatexToken.__init__sT"$@ 88+ + LL   - j$(*rc4[UR55$r _unicode_from_strrGrFs r __unicode__LatexToken.__unicode__ 00rc SSRURVs/sHnU<S[X5<3PM sn5-S-$s snf)Nz LatexToken(, =))joinr|getattrr5ks r __repr__LatexToken.__repr__sR  II!%0!-A"#74?3!-0 1 1   0sA c"UR5$r rrFs r rGLatexToken.__str__rIrcF^^[UU4SjTR55$)Nc3V># UHn[TU5[TU5:Hv M g7fr r.0fotherr5s r $LatexToken.__eq__..s$TlgdA&'%*;;l&))allr|r5rs``r __eq__LatexToken.__eq__sTdllTVVrc[$r NotImplementedrs r __ne__LatexToken.__ne__N2rN)r|rvrwr.r{rxrurT)r!r"r#r$r%r3rrrGrr__hash__r&rKrLs@r rrrr:s.aD +1W3Hrrrch^\rSrSrSrSU4SjjrSrSrSrSr S r Sr S r S r S rS rU=r$) LatexNodeia Represents an abstract 'node' of the latex document. Use :py:meth:`nodeType()` to figure out what type of node this is, and :py:meth:`isNodeType()` to test whether it is of a given type. You should use :py:meth:`LatexWalker.make_node()` to create nodes, so that the latex walker has the opportunity to do some additional setting up. All nodes have the following attributes: .. py:attribute:: parsing_state The parsing state at the time this node was created. This object stores additional context information for this node, such as whether or not this node was parsed in a math mode block of LaTeX code. See also the :py:meth:`LatexWalker.make_parsing_state()` and the `parsing_state` argument of :py:meth:`LatexWalker.get_latex_nodes()`. .. py:attribute:: pos The position in the parsed string that this node represents. The parsed string can be recovered as `parsing_state.s`, see :py:attr:`ParsingState.s`. .. py:attribute:: len How many characters in the parsed string this node represents, starting at position `pos`. The parsed string can be recovered as `parsing_state.s`, see :py:attr:`ParsingState.s`. .. versionadded:: 2.0 The attributes `parsing_state`, `pos` and `len` were added in `pylatexenc 2.0`. Nc >[[U] "S0UD6 X0lX@lXPl[ SS/[U5-5UlUb0[ [UR5[U5-5Ul gURUl g)Nr.rwr ) r2rr3 parsing_stater.rwrlistr|_redundant_fields)r5r|rrr.rwkwargsr6s r r3LatexNode.__init__ss i'1&1*eU^d7m;<  (%*4 +=EV@W+W%XD "%)\\D "rc[$)z Returns the class which corresponds to the type of this node. This is a Python class object, that is one of :py:class:`~pylatexenc.latexwalker.LatexCharsNode`, :py:class:`~pylatexenc.latexwalker.LatexGroupNode`, etc. )rrFs r nodeTypeLatexNode.nodeTypes rc[X5$)z Returns `True` if the current node is of the given type. The argument `t` must be a Python class such as, e.g. :py:class:`~pylatexenc.latexwalker.LatexGroupNode`. ) isinstance)r5ts r isNodeTypeLatexNode.isNodeType s $""rcURc [S5eURRURURUR-$)z Return the chunk of LaTeX code that this node represents. This is a shorthand for ``node.parsing_state.s[node.pos:node.pos+node.len]``. zNCan't use latex_verbatim() on node because we don't have any parsing_state set)r TypeErrorr-r.rwrFs r latex_verbatimLatexNode.latex_verbatimsL    %9: :!!##DHHtxx/@AArcj^^TSL=(a TR5TR5:H=(a TRTRL=(a` TRTR:H=(a@ TRTR:H=(a [ UU4SjTR 55$)Nc3V># UHn[TU5[TU5:Hv M g7fr rrs r r#LatexNode.__eq__..%s$P,Q'$"geQ&77,r)rrr.rwrr|rs``r rLatexNode.__eq__sD  MMOu~~/ /   4#5#5 5 II ! II !  P$,,P   rc[$r rrs r rLatexNode.__ne__)rrc4[UR55$r rrFs r rLatexNode.__unicode__-rrc"UR5$r rrFs r rGLatexNode.__str__/rIrc UR5RS-SR[UR55-SR UR Vs/sHo<S[X5<3PM sn5-S-$s snf)N(z"parsing_state=, rrr)rr!r=idrrr|rrs r rLatexNode.__repr__1sx MMO $ $s * 0 7 74;M;M8N O P IIdllLl74?3lL M N   MsB )r|rrwrr.rJ)r!r"r#r$r%r3rrrrrrrrGrr&rKrLs@r rrsI$J37372&# B3H1rrc2^\rSrSrSrU4SjrSrSrU=r$)LatexCharsNodei:z A string of characters in the LaTeX document, without any special LaTeX code. .. py:attribute:: chars The string of characters represented by this node. c >>[[U] "SSS0UD6 Xlg)Nr|charsr )r2rr3r)r5rrr6s r r3LatexCharsNode.__init__Cs) nd,     rc[$r )rrFs r rLatexCharsNode.nodeTypeJrr r!r"r#r$r%r3rr&rKrLs@r rr:srrc2^\rSrSrSrU4SjrSrSrU=r$)LatexGroupNodeiMa A LaTeX group delimited by braces, ``{like this}``. Note: in the case of an optional macro or environment argument, this node is also used to represents a group delimited by square braces instead of curly braces. .. py:attribute:: nodelist A list of nodes describing the contents of the LaTeX braced group. Each item of the list is a :py:class:`LatexNode`. .. py:attribute:: delimiters A 2-item tuple that stores the delimiters for this group node. Usually this is `('{', '}')`, except for optional macro arguments where this might be for instance `('[', ']')`. .. versionadded:: 2.0 The `delimiters` field was added in `pylatexenc 2.0`. c n>URSS5n[[U]"SSS0UD6 XlX0lg)N delimiters{}r|)nodelistrr )popr2rr3rr)r5rrrr6s r r3LatexGroupNode.__init__ds>ZZ j9  nd, .  ! $rc[$r )rrFs r rLatexGroupNode.nodeTypemrr)rrrrLs@r rrMs,%rrc2^\rSrSrSrU4SjrSrSrU=r$)LatexCommentNodeipaK A LaTeX comment, delimited by a percent sign until the end of line. .. py:attribute:: comment The comment string, not including the '%' sign nor the following newline .. py:attribute:: comment_post_space The newline that terminated the comment possibly followed by spaces (e.g., indentation spaces of the next line) c n>URSS5n[[U]"SSS0UD6 XlX0lg)Ncomment_post_spacer9r|rzrr )rr2rr3rzr)r5rzrrr6s r r3LatexCommentNode.__init__~sB#ZZ(URS[R"55nURSS5nURSS5nURS/5n[[U]"S SSS.UD6 XlX0lX@lXPl X`l g) Nnodeargdmacro_post_spacer9 nodeoptargnodeargs)rerr)rrr|rr ) rrParsedMacroArgsr2rr3rerrrr)r5rerrrrrr6s r r3LatexMacroNode.__init__sJ (A(A(CD$6;::lD1 J+ nd, A 9   # 0$ rc[$r )rrFs r rLatexMacroNode.nodeTyperr)rrerrrrrLs@r rrs5l!&rrc2^\rSrSrSrU4SjrSrSrU=r$)LatexEnvironmentNodeia A LaTeX Environment Node, i.e. ``\begin{something} ... \end{something}``. .. py:attribute:: environmentname The name of the environment ('itemize', 'equation', ...) .. py:attribute:: nodelist A list of :py:class:`LatexNode`'s that represent all the contents between the ``\begin{...}`` instruction and the ``\end{...}`` instruction. .. py:attribute:: nodeargd The :py:class:`pylatexenc.macrospec.ParsedMacroArgs` object that represents the arguments passed to the environment. These are arguments that are present after the ``\begin{xxxxxx}`` command, as in ``\begin{tabular}{ccc}`` or ``\begin{figure}[H]``. Arguments must be declared in the latex context passed to the :py:class:`LatexWalker` constructor, using a suitable :py:class:`pylatexenc.macrospec.EnvironmentSpec` object. Some known environments are already declared in the default latex context. .. versionadded:: 2.0 The `nodeargd` attribute was introduced in `pylatexenc 2`. The following attributes are available, but they are obsolete since `pylatexenc 2.0`. .. py:attribute:: envname .. deprecated:: 2.0 This attribute was renamed `environmentname` for consistency with the rest of the package. .. py:attribute:: optargs .. deprecated:: 2.0 Macro arguments are stored in `nodeargd` in `pylatexenc 2`. Accessing the argument `optargs` will still give a list of initial optional arguments for standard latex macros, for backwards compatibility. .. py:attribute:: args .. deprecated:: 2.0 Macro arguments are stored in `nodeargd` in `pylatexenc 2`. Accessing the argument `args` will still give a list of curly-brace-delimited arguments for standard latex macros, for backwards compatibility. c >URS[R"55nURS/5nURS/5n[[U]"SSSS.UD6 XlX lX@lXl XPl X`l g)Nroptargsr)environmentnamerr)envnamerrrr ) rrrr2rr3rrrrrr)r5rrrrrrr6s r r3LatexEnvironmentNode.__init__s::j)*C*C*EF**Y+zz&"% "D2 @ >   /  &   rc[$r )rrFs r rLatexEnvironmentNode.nodeType%s##r)rrrrrrrrLs@r rrs4l&$$rrc2^\rSrSrSrU4SjrSrSrU=r$)LatexSpecialsNodei(a. Represents a specials type node, e.g. ``&`` or ``~`` .. py:attribute:: specials_chars The name of the specials (string), *without* the leading backslash. .. py:attribute:: nodeargd If the specials spec (cf. :py:class:`~pylatexenc.macrospec.SpecialsSpec`) has `args_parser=None` then the attribute `nodeargd` is set to `None`. If `args_parser` is specified in the spec, then the attribute `nodeargd` is a :py:class:`pylatexenc.macrospec.ParsedMacroArgs` instance that represents the arguments to the specials. The `nodeargd` attribute can also be `None` even if the specials expects arguments, in the special situation where :py:meth:`LatexWalker.get_latex_expression()` encounters this specials. Arguments must be declared in the latex context passed to the :py:class:`LatexWalker` constructor, using a suitable :py:class:`pylatexenc.macrospec.SpecialsSpec` object. Some known latex specials are already declared in the default latex context. .. versionadded:: 2.0 Latex specials were introduced in `pylatexenc 2.0`. c n>URSS5n[[U]"SSS0UD6 XlX0lg)Nrr|)specials_charsrr )rr2rr3rr)r5rrrr6s r r3LatexSpecialsNode.__init__Es@J- / 3  - rc[$r )rrFs r rLatexSpecialsNode.nodeTypeOs  r)rrrrLs@r rr(s8!!!rrc8^\rSrSrSr/4U4SjjrSrSrU=r$) LatexMathNodeiUa A Math node type. Note that currently only 'inline' math environments are detected. .. py:attribute:: displaytype Either 'inline' or 'display', to indicate an inline math block or a display math block. (Note that math environments such as ``\begin{equation}...\end{equation}``, are reported as :py:class:`LatexEnvironmentNode`'s, and not as :py:class:`LatexMathNode`'s.) .. py:attribute:: delimiters A 2-item tuple containing the begin and end delimiters used to delimit this math mode section. .. versionadded:: 2.0 The `delimiters` attribute was introduced in `pylatexenc 2`. .. py:attribute:: nodelist The contents of the environment, given as a list of :py:class:`LatexNode`'s. c z>URSS5n[[U]"SSS0UD6 XlX lX@lg)NrNNr|) displaytyperrr )rr2rr3rrr)r5rrrrr6s r r3LatexMathNode.__init__qsDZZ l;  mT+ =  ' $rc[$r )rrFs r rLatexMathNode.nodeType}sr)rrrrrLs@r rrUs6.0 %rrc4^\rSrSrU4SjrSrSrSrU=r$)_PushPropOverrideicN>[[U] 5 XlX lX0lgr )r2r r3objpropname new_value)r5rrrr6s r r3_PushPropOverride.__init__s  /1 "rcURbP[URUR5Ul[ URURUR5 U$r )rrrrinitvalsetattrrFs r __enter___PushPropOverride.__enter__s? >> %"488T]];DL DHHdmmT^^ < rcvURb,[URURUR5 ggr )rrrrr)r5typevalue tracebacks r __exit___PushPropOverride.__exit__s) >> % DHHdmmT\\ : &r)rrrr) r!r"r#r$r3rrr&rKrLs@r r r s#  ;;rr cH^\rSrSrSrU4SjrSrSrS SjrSr Sr U=r $) ParsingStateia Stores some information about the current parsing state, such as whether we are currently in a math mode block. One of the ideas of `pylatexenc` is to make the parsing of LaTeX code mostly state-independent mark-up parsing (in contrast to a full TeX engine, whose state constantly changes and whose parsing behavior is altered dynamically while parsing). However a minimal state of the context might come in handy sometimes. Perhaps some macros or specials should behave differently in math mode than in text mode. This class also stores some essential information that is associated with :py:class:`LatexNode`\ 's and which provides a context to better understand the node structure. For instance, we store the original parsed string, and each node refers to which part of the string they represent. .. py:attribute:: s The string that is parsed by the :py:class:`LatexWalker` .. py:attribute:: latex_context The latex context (with macros/environments specifications) that was used when parsing the string `s`. This is a :py:class:`pylatexenc.macrospec.LatexContextDb` object. .. py:attribute:: in_math_mode Whether or not we are in a math mode chunk of LaTeX (True or False). This can be inline or display, and can be caused by an equation environment. .. py:attribute:: math_mode_delimiter Information about the kind of math mode we are currently in, if `in_math_mode` is `True`. This is a string which can be set to aid the parser. The parser sets this field to the math mode delimiter that initiated the math mode (one of ``'$'``, ``'$$'``, ``r'\('``, ``r'\)'``). For user-initiated math modes (e.g. by a custom environment definition), you can set this string to any custom value EXCEPT any of the core math mode delimiters listed above. .. note:: The tokenizer/parser relies on the value of the `math_mode_delimiter` attribute to disambiguate two consecutive dollar signs ``...$$...`` into either a display math mode delimiter or two inline math mode delimiters (as in ``$a$$b$``). You should only set `math_mode_delimiter='$'` if you know what you're doing. .. versionadded:: 2.0 This class was introduced in version 2.0. .. versionadded:: 2.7 The attribute `math_mode_delimiter` was introduced in version 2.7. .. versionchanged:: 2.7 All arguments must now be specified as keyword arguments as of version 2.7. c >[[U] 5 SUlSUlSUlSUlSUlURSS5nURXS9 g)NF)r- latex_context in_math_modemath_mode_delimiter _do_sanitizeT) do_sanitize) r2rr3r-r r!r"r|r _set_fields)r5rr$r6s r r3ParsingState.__init__sW lD*,!!#' V jj6  9rc lUR"SSS0UR5D6nURU5 U$)a Return a new :py:class:`ParsingState` instance that is a copy of the current parsing state, but where the given properties keys have been set to the corresponding values (given as keyword arguments). This makes it easy to create a sub-context in a given parser. For instance, if we enter math mode, we might write:: parsing_state_inner = parsing_state.sub_context(in_math_mode=True) If no arguments are provided, this returns a copy of the present parsing context object. r#Fr )r6 get_fieldsr%)r5rps r sub_contextParsingState.sub_contexts2 NN C C1B C frc l[URVs/sHo[X54PM sn5$s snf)zT Returns the fields and values associated with this `ParsingState` as a dictionary. )rnr|r)r5rs r r(ParsingState.get_fieldss- DLLALq)*LABBAs1cUR5H:up4X0R;a[SRX455e[ XU5 M< U(aUR US9 gg)Nz'Invalid field for ParsingState: {}={!r}) given_fields)itemsr| ValueErrorr=r _sanitize)r5rr$rvs r r%ParsingState._set_fieldssZLLNDA $ !J!Q!QRS!WXX DQ #  NNN / rcUR(dAUR(a/SUlSU;a![RSUR5 gggg)a Sanitize the parsing state. E.g., clear any `math_mode_delimiter` if `in_math_mode` is `False`. The argument `given_fields` is what fields the user required to set; this is used to generate warnings if incompatible field configurations were explicitly required to be set. Nr"zFParsingState: You set math_mode_delimiter=%r but in_math_mode is False)r!r"loggerwarning)r5r/s r r2ParsingState._sanitize sL  T%=%='+D $$ 4,-1-E-E5&> r)r|r!r r"r-T) r!r"r#r$r%r3r*r(r%r2r&rKrLs@r rrs(=| :(C 0rrc^\rSrSrSrSU4SjjrSrSrSrSSjr Sr S r SS jr SS jr SS jrSS jrSSjrSrSSjrSrU=r$) LatexWalkeri"aZ A parser which walks through an input stream, parsing it as LaTeX markup. Arguments: - `s`: the string to parse as LaTeX code - `latex_context`: a :py:class:`pylatexenc.macrospec.LatexContextDb` object that provides macro and environment specifications with instructions on how to parse arguments, etc. If you don't specify this argument, or if you specify `None`, then the default database is used. The default database is obtained with :py:func:`get_default_latex_context_db()`. .. versionadded:: 2.0 This `latex_context` argument was introduced in version 2.0. Additional keyword arguments are flags which influence the parsing. Accepted flags are: - `tolerant_parsing=True|False` If set to `True`, then the parser generally ignores syntax errors rather than raising an exception. - `strict_braces=True|False` This option refers specifically to reading a encountering a closing brace when an expression is needed. You generally won't need to specify this flag, use `tolerant_parsing` instead. The methods provided in this class perform various parsing of the given string `s`. These methods typically accept a `pos` parameter, which must be an integer, which defines the position in the string `s` to start parsing. These methods, unless otherwise documented, return a tuple `(node, pos, len)`, where node is a :py:class:`LatexNode` describing the parsed content, `pos` is the position at which the LaTeX element of iterest was encountered, and `len` is the length of the string that is considered to be part of the `node`. That is, the position in the string that is immediately after the node is `pos+len`. The following obsolete flag is accepted by the constructor for backwards compatibility with `pylatexenc 1.x`: - `macro_dict`: This argument is kept for compatibility with `pylatexenc 1.x`. This is a dictionary of known LaTeX macro specifications. If specified, this should be a dictionary where the keys are macro names and values are :py:class:`pylatexenc.macrospec.MacroSpec` instances, as returned for instance by the `pylatexenc 1.x`-emulating function :py:func:`MacrosDef`. If you specify this argument, you cannot provide a custom `latex_context`. This argument is superseded by the `latex_context` argument. Furthermore, if you specify this argument, no specials are parsed so that the behavior closer to `pylatexenc 1.x`. .. deprecated:: 2.0 The `macro_dict` argument has been replaced by the much more powerful `latex_context` argument which allows you to further provide environment specifications, etc. - `keep_inline_math=True|False`: Obsolete option. In `pylatexenc 1.x`, this option triggered a weird behavior especially since there is a similarly named option in :py:class:`pylatexenc.latex2text.LatexNodes2Text` with a different meaning. [See `Issue #14 `_.] You should now only use the option `math_mode=` in :py:class:`pylatexenc.latex2text.LatexNodes2Text`. .. deprecated:: 2.0 This option is ignored starting from `pylatexenc 2`. Instead, you should set the option `math_mode=` accordingly in :py:class:`pylatexenc.latex2text.LatexNodes2Text`. .. py:attribute:: s The string that is being parsed. Do NOT modify this attribute. c >XlSUlSUlUcSU;ar[R"S5 UR SS5n[ 5nURS/S9nURSUR5UR55 O[ 5nOSU;a [S5e[URUS9Ul UR S S 5UlUR S S5UlS U;a[R"S 5 US U(a$[ R#SUR%55 [&[(U]W5 g)NF macro_dictzThe `macro_dict=...` option in LatexWalker() is obsolete since pylatexenc 2. It'll still work, but please consider using instead the more versatile option `latex_context=...`.rY) keep_whichcustomz@Cannot specify both `latex_context=` and `macro_dict=` arguments)r-r tolerant_parsingT strict_braceskeep_inline_mathzThe keep_inline_math=... option in LatexWalker() has no effect in pylatexenc 2. Please consider using the more versatile option math_mode=... in LatexNodes2Text() instead.z.LatexWalker(): Unknown flag(s) encountered: %r)r- _line_no_calc debug_nodesrrcrrafilter_contextr]valuesiter_environment_specsrrdefault_parsing_stater@rAr6r7keysr2r;r3)r5r-r rr=default_latex_contextr6s r r3LatexWalker.__init__usO"   v%--E $ZZ d; (D(F% 5 D D ./!E! 22%%')@@B!= > v%V&2ff'& "!' +=t D#ZZ?  '  ) )>  )*  NNKV[[] [ k4)+rc :URR"S0UD6$)a Return a new parsing state object that corresponds to the current string that we are parsing (`s` provided to the constructor) and the current latex context (`latex_context` provided to the constructor). If no arguments are provided, this returns the default parsing state. If keyword arguments are provided, then they can override fields from the default parsing state. For instance, if we enter math mode, you might use:: parsing_state_mathmode = \ my_latex_walker.make_parsing_state(in_math_mode=True) r )rHr*)r5rs r make_parsing_stateLatexWalker.make_parsing_states))55???rc6URURSS.$)a' The parse flags currently set on this object. Returns a dictionary with keys 'keep_inline_math', 'tolerant_parsing' and 'strict_braces'. .. deprecated:: 2.0 The 'keep_inline_math' key is always set to `None` starting in `pylatexenc 2` and might be removed entirely in future versions. N)r@rArB)r@rArFs r parse_flagsLatexWalker.parse_flagss#!% 5 5!// $   rc0[RSU5 g)Nz0Ignoring parse error (tolerant parsing mode): %s)r6info)r5excs r _report_ignore_parse_error&LatexWalker._report_ignore_parse_errors FLrc ^^^^UcTR5nS/nU(aXr- nSU;aURS5(dUS/- nTRmSmUUUU4SjnT[T5:awTTR 5(a_TTT- mTS- mTR S5(a[ S STS - S TSS S 9$T[T5:aTTR 5(aM_T[T5:a [TS 9eTTS:XGa TS-[T5:a [5eTTS-n Sn S n TTS-R5(anSn TU -[T5:aZTTU -R5(a?U TTU -- n U S- n TU -[T5:aTTU -R5(aM?U S;a[ SSU -TU TS 9$U S;a[ SSU -TU TS 9$U(aU S;a{[R"STTU -S5n U c'U"SRU 5U SU -S9upU (aU eU$[ U S:XaSOSU RS5TXR5-TS 9$SnU (aTU -[T5:a{TTU -R 5(a`UTTU -- nU S- n UR S5(a USS nU S -n O/TU -[T5:aTTU -R 5(aM`[ SU TU TUS9$TTS:Xa[R"S5RTT5nSnUbURS5R!S 5(a)UR#5T- nUR#5T- nSnOIUR#5T- nUR5T- nUR5nO[T5T- nUnSn[ S!TTS-TU-TUTUS9$[%U6unnTTU;a[ S"TTTSTS 9$TTU;a[ S#TTTSTS 9$TR!S$T5(a.UR&(aUR(S%:Xd [ SS$TS TS 9$TR!S%T5(a [ SS%TSTS 9$UR*R-TTUS&9nUb [ S'UT[UR.5TS 9$[ S TTTSTS 9$)(a Parses the latex content given to the constructor (and stored in `self.s`), starting at position `pos`, to parse a single "token", as defined by :py:class:`LatexToken`. Parse the token in the stream pointed to at position `pos`. For tokens of type 'char', usually a single character is returned. The only exception is at paragraph boundaries, where a single 'char'-type token has argument '\\n\\n'. Returns a :py:class:`LatexToken`. Raises :py:exc:`LatexWalkerEndOfStream` if end of stream reached. The argument `include_brace_chars=` allows to specify additional pairs of single characters which should be considered as braces (i.e., of 'brace_open' and 'brace_close' token types). It should be a list of 2-item tuples, for instance ``[('[', ']'), ('<', '>')]``. The pair `('{', '}')` is always considered as braces. The delimiters may not have more than one character each. If `environments=False`, then ``\begin`` and ``\end`` tokens count as regular 'macro' tokens (see :py:class:`LatexToken`); otherwise (the default) they are considered as the token types 'begin_environment' and 'end_environment'. The parsing of the tokens might be influcenced by the `parsing_state` (a :py:class:`ParsingState` instance). Currently, the only influence this has is that some latex specials are parsed differently if in math mode. See doc for :py:class:`ParsingState`. If `parsing_state` is `None`, the default parsing state returned by :py:meth:`make_parsing_state()` is used. .. deprecated:: 2.0 The flag `keep_inline_math` is only accepted for compatibiltiy with earlier versions of `pylatexenc`, but it has no effect starting in `pylatexenc 2`. See the :py:class:`LatexWalker` class doc. .. deprecated:: 2.0 If `brackets_are_chars=False`, then square bracket characters count as 'brace_open' and 'brace_close' token types (see :py:class:`LatexToken`); otherwise (the default) they are considered just like other normal characters. .. versionadded:: 2.0 The `parsing_state` argument was introduced in version 2.0. Nrbrackets_are_chars[]r9c >[STTUS.TRTSS9D6nTR(a TRU5 S[ SUTUTS94$US4$)Nr-r.r,Tas_dictcharrtr )r(pos_to_lineno_colnor@rUrr)r,rw placeholderer.r-r5spaces r _token_parse_error1LatexWalker.get_token.._token_parse_error8s|%**3*= A $$//2Z## d7NrrVz r`rrtrS\FTmathmode_display)rrmathmode_inline)beginendz^\s*\{([\w* ._-]+)\}z+Bad \{} macro: expected {{environmentname}})r,rwrbrkbegin_environmentend_environmentry)rurvr.rwrxr{%z(\n|\r|\n\r)(?P\s*) extraspace)  z rz brace_open brace_close$$$rrZ)rMrr-rwisspaceendswithrrrNisalpharematchr=grouprlcompilesearch startswithstartzipr!r"r test_for_specialsr)r5r.include_brace_charsrYrBrr brace_charsrery isalphamacroienvmatchrcrr{rkmlenarglenmspaceopenbracecharsclosebracecharssspecr-rds`` @@r get_tokenLatexWalker.get_tokenspj   335M!l   .K 6 )::233 |+ FF$  $CFlqv~~// QsVOE 1HC~~f%%!f&c!e,1#2J88 CFlqv~~// #a&=(U; ; S6T>1uA,..c!eHE LAQx!!# !eCFlqQx'7'7'9'9Qs1uX%EFA!eCFlqQx'7'7'9'9  "!&8d5j&)qECC "!&7T%Z&)qECC)9 988$;Qs1uvYG#-JQQRWX$(JDA H!050@,FW q),,.(# J!eCFlqQx'7'7'9'9!CE(*JFA!**622&0_ Q!eCFlqQx'7'7'9'9'u#1(-*F F S6S= =>EEaMAD}77<(335JLLWWYs]F779S=DFWWYs]F5573;DWWYFQ)3q5V1D#SW(-&B B+.{*;' S6^ #,AcFV[\ \ S6_ $-QsV!W\] ] <<c " ""..=3T3TX[3[!&8d&)qECC <<S ! !"3#1X]^ ^++== s->   *%"%3u/C/C+DPUW W f!C&cqERRrc URS5URS5URS5pTnU"SX4US.UD6nUR(a[RSU5 U$)a! Create and return a node of type `node_class` which holds a representation of the latex code at position `pos` and of length `len` in the parsed string. The node class should be a :py:class:`LatexNode` subclass. Keyword arguments are supplied directly to the constructor of the node class. Mandatory keyword-only arguments are 'pos', 'len', and 'parsing_state'. All nodes produced by :py:meth:`get_latex_nodes()` and friends use this method to create node classes. .. versionadded:: 2.0 This method was introduced in `pylatexenc 2.0`. r.rwr)r.rwrz New node: %rr )rrDr6debug)r5 node_classrr.rwrnodes r make_nodeLatexWalker.make_nodes_( JJu vzz%0&**_2M Rc-R6R    LL . rc 4UR"U4X#US.UD6UU4$)N)rr.rw)r)r5nclassrr.rwrs r _mknodeposlenLatexWalker._mknodeposlens+ NN6 [S [TZ [    rcURc%[R"UR5UlURR XS9$)a% Return the line and column number corresponding to the given `pos` in our string `self.s`. The first time this function is called, line numbers are calculated for the entire string. These are cached for future calls which are then fast. Return a tuple `(lineno, colno)` giving line number and column number. Line numbers start at 1 and column numbers start at zero, i.e., the beginning of the document (`pos=0`) has line and column number `(1,0)`. If `as_dict=True`, then a dictionary with keys 'lineno', 'colno' is returned instead of a tuple. r^)rCrLineNumbersCalculatorr-ra)r5r.r_s r raLatexWalker.pos_to_lineno_colnosA    %!&!UR[UURURURS 9sSSS5 $URS;aURR+S5(aKUR[UURSSURURURS9sSSS5 $UR[UURURURS 9sSSS5 $[ SR)UR5URU40URUSS 9D6e!,(df  g=f)a Parses the latex content given to the constructor (and stored in `self.s`), starting at position `pos`, to parse a single LaTeX expression. Reads a latex expression, e.g. macro argument. This may be a single char, an escape sequence, or a expression placed in braces. This is what TeX calls a "token" (and not what we call a token... anyway). Parsing might be influenced by the `parsing_state`. See doc for :py:class:`ParsingState`. If `parsing_state` is `None`, then the default parsing state is used. Returns a tuple `(node, pos, len)`, where `pos` is the position of the first char of the expression and `len` the length of the expression. .. versionadded:: 2.0 The `parsing_state` argument was introduced in version 2.0. NrAF)rYrryrlzExpected expression, got \endTr^r9rrrr.rwrrerrrrr.rwrZrrrr.rwrzrwrsrtz+Expected expression, got closing brace '{}'r`rjrirh)rrerrrr.rwzUnknown token type: {})rMr rrurvr@r(r-rarrr.rr{rwrrget_latex_expressionget_latex_braced_grouprAr=r)r5r.rArrus r r LatexWalker.get_latex_expressions*   335M t_m D..5 .VCww'!77e#003< FFCK#66sD6IKK $11.@M8:69gg67 2 9E D$)).8E47GG37;>>>59D.1gg377 *D%E D2ww*$))*;8E9<9O9O37.1gg377 *D5E D>ww)#00P]0^AE DBww,&22377-2XEE DFww-' %%d.C.C/ELLSWWU2232E )).8E02.1gg1*>]E Ddww& )).8E03.1gg.1gg *7gE DpwwAA77%%d++--nC 77l "sww#~..ss=J/L L&   sA A'&A'c hUcUR5nSnUS:XaSnO=US:XaSnO4US:XaSnO+US:XaS nO"[U5S :XaUup$O[S U-5eSnU(a US:waX$4/nURXUS 9nURS :wdUR U:wa7[ SURUSURU-S.URUSS9D6eURURUR-X$4US9upxn UR[UUX$4URX-UR- S9$)a Parses the latex content given to the constructor (and stored in `self.s`), starting at position `pos`, to read a latex group delimited by braces. Reads a latex expression enclosed in braces ``{ ... }``. The first token of `s[pos:]` must be an opening brace. Parsing might be influenced by the `parsing_state`. See doc for :py:class:`ParsingState`. If `parsing_state` is `None`, the default parsing state is used. Returns a tuple `(node, pos, len)`, where `node` is a :py:class:`LatexGroupNode` instance, `pos` is the position of the first char of the expression (which has to be an opening brace), and `len` is the length of the group, including the closing brace (relative to the starting position). The group must be delimited by the given `brace_type`. `brace_type` may be one of ``{``, ``[``, ``(`` or ``<``, or a 2-item tuple of two distinct single characters providing the opening and closing brace chars (e.g., ``("<", ">")``). .. versionadded:: 2.0 The `parsing_state` argument was introduced in version 2.0. NrrrZr[rr<>rz3Invalid brace type for get_latex_braced_group(): %srrrsz8get_latex_braced_group: not an opening brace/bracket: %sr]Tr^)stop_upon_closing_bracer)rrrr.rwr ) rMrwr1rrurvr(r-raget_latex_nodesr.rr) r5r.rr closing_bracerfirsttokrnposnlens r r"LatexWalker.get_latex_braced_groups8   335M  M 3 M 3 M 3 M _ !(2 %J RU_`a a" *+$.#>"? >>#0="? <<< 'X\\Z-G'&&NQUQWQWX[Q\]**3*=  "&!5!5 LL8<< '%/$?'"6"  !!.80=.8-H(0 (, hll(B "D Drc UcUR5nUnURXS9nURS:wdUbNURU:wa>[ SUR USUbUOS<SUR<3S.UR USS 9D6eUc URnURUR-nURRU5nUc[R"S 5nURXUS 9n[U5S:XaUuppOUupn 0n X-nU R#SU5n UR$(aUR'SSU-S-S9n UR)UUU S9upnU b0U R*(aU R*S nU R*SnOS/nnUR-[.UUUU U/UUUU-U- S9 $![[4a8nURUUS R!U55nUbUeSUS 04nSnAGN SnAff=f)a Parses the latex content given to the constructor (and stored in `self.s`), starting at position `pos`, to read a latex environment. Reads a latex expression enclosed in a ``\begin{environment}...\end{environment}``. The first token in the stream must be the ``\begin{environment}``. If `environmentname` is given and nonempty, then additionally a :py:exc:`LatexWalkerParseError` is raised if the environment in the input stream does not match the provided environment name. Arguments to the begin environment command are parsed according to the corresponding specification in the given latex context `latex_context` provided to the constructor. The environment name is looked up as a "macro name" in the macro spec. Parsing might be influenced by the `parsing_state`. See doc for :py:class:`ParsingState`. If `parsing_state` is `None`, the default parsing state is used. Returns a tuple (node, pos, len) where node is a :py:class:`LatexEnvironmentNode`. .. versionadded:: 2.0 The `parsing_state` argument was introduced in version 2.0. Nrwrmz'get_latex_environment: expected \begin{zz}: r]Tr^r9wr.rz'arguments of environment "\begin{{{}}}"rinner_parsing_staterrr!r")stop_upon_end_environmentrrV)rrrrrrr.rwr )rMrrurvr(r-rar.rwr get_environment_specrEnvironmentSpec parse_argsrN_exchandle_parse_subexpressionr=get is_math_moder*rlegacy_nodeoptarg_nodeargsrr)r5r.rrstartposrenv_spec argsresultrcargdaposalenadicparsing_state_innerrrr legnodeoptarg legnodeargss r get_latex_environment!LatexWalker.get_latex_environmentsg<   335M>>#>C <<. .  'HLLO,K'&&'6'BOH\\LL**3*=   #&llOllX\\) ..CCOT   004H ,!,,tM,ZJ z?a '1 $Tt!+ TDk"hh'M99! ,33<CCOTA }AgQ+J ,s#F99H -G<<Hc Z[U[5(aJ[SURURSR U5S.UR URSS9D6n[USS5bBURc5URc(UR UR5uUlUl URR[SR U5UR/UR UR5Q765 UR(aURU5 gU$) aI (INTERNAL.) Handle an exception raised by a method that you called to parse a macro arguments or another "sub-expression". Use as:: except (LatexWalkerEndOfStream, LatexWalkerParseError) as e: e = self._exchandle_parse_subexpression(e, , "what this is about") if e is not None: raise e ... # do sth to recover from parse error in tolerant mode Use in an exception handler that captures both `LatexWalkerEndOfStream` and `LatexWalkerParseError`. Returns what exception you should raise if you got one of these while parsing, e.g., macro arguments. zEnd of input while parsing {}r]Tr^r.Nz{}r )rrNr(r-r.r=rarr/r0r1r}rr@rU)r5rcrur<s r r*LatexWalker._exchandle_parse_subexpression@s a/ 0 0%&&GG3::4@**377D*A A 1eT " .1883C $ 8 8 ? AHag  t{{4(#'' ;009 ;   + +A .rc ^^^^^^UcTR5n/nSmSnT(aCTS:XaSnO/TS:XaSnO&TS:XaSnOTS:XaS nO[T5S :XaTunmTS:waUT4/mTb@UR(d/[R S R TUR55 Un "S S 5n U "XS9n UUUUUU4Sjn U "X{5n U (a[U [ 5(aLU RU RU RS9 U =R[U R5- sl U R (aNU R#5unnTR%[&U R(UU[U5S9nUR+U5 XyU RU - 4$M![ anT(dT(dT(aT(a ST-S-nOT(a ST-S-nOT(aST-S-n[STRU RSR W5S.TR[TR5SS9D6nTR(aTRU5 Sn SnAGNUeUn SnAGNSnAf[a0nTR(aTRU5 Sn SnAGNeSnAff=f)a' Parses the latex content given to the constructor (and stored in `self.s`) into a list of nodes. Returns a tuple `(nodelist, pos, len)` where: - `nodelist` is a list of :py:class:`LatexNode`\ 's representing the parsed LaTeX code. - `pos` is the same as the `pos` given as argument; if there is leading whitespace it is reported in `nodelist` using a :py:class:`LatexCharsNode`. - `len` is the length of the parsed expression. If one of the `stop_upon_...=` arguments are provided (cf below), then the `len` includes the length of the token/expression that stopped the parsing. If `stop_upon_closing_brace` is given and set to a character, then parsing stops once the given closing brace is encountered (but not inside a subgroup). The brace is given as a character, ']', '}', ')', or '>'. Alternatively you may specify a 2-item tuple of two single distinct characters representing the opening and closing brace chars. The returned `len` includes the closing brace, but the closing brace is not included in any of the nodes in the `nodelist`. If `stop_upon_end_environment` is provided, then parsing stops once the given environment was closed. If there is an environment mismatch, then a `LatexWalkerParseError` is raised except in tolerant parsing mode (see :py:meth:`parse_flags()`). Again, the closing environment is included in the length count but not the nodes. If `stop_upon_closing_mathmode` is specified, then the parsing stops once the corresponding math mode (assumed already open) is closed. This argument may take the values `None` (no particular request to stop at any math mode token), or one of ``$``, ``$$``, ``\)`` or ``\]`` indicating a closing math mode delimiter that we are expecting and at which point parsing should stop. If the token '$' (respectively '$$') is encountered, it is interpreted as the *beginning* of a new math mode chunk *unless* the argument `stop_upon_closing_mathmode=...` has been set to '$' (respectively '$$'). If `read_max_nodes` is non-`None`, then it should be set to an integer specifying the maximum number of top-level nodes to read before returning. (Top-level nodes means that macro arguments, environment or group contents, etc., do not count towards `read_max_nodes`.) If `None`, the entire input string will be parsed. .. note:: There are a few important differences between ``get_latex_nodes(read_max_nodes=1)`` and ``get_latex_expression()``: The former reads a logical node of the LaTeX document, which can be a sequence of characters, a macro invocation with arguments, or an entire environment, but the latter reads a single LaTeX "token" in a similar way to how LaTeX parses macro arguments. For instance, if a macro is encountered, then ``get_latex_nodes(read_max_nodes=1)`` will read and parse its arguments, and include it in the corresponding :py:class:`LatexMacroNode`, whereas ``get_latex_expression()`` will return a minimal :py:class:`LatexMacroNode` with no arguments regardless of the macro's argument specification. The same holds for latex specials. For environments, ``get_latex_nodes(read_max_nodes=1)`` will return the entire parsed environment into a :py:class:`LatexEnvironmentNode`, whereas ``get_latex_expression()`` will return a :py:class:`LatexMacroNode` named 'begin' with no arguments. Parsing might be influenced by the `parsing_state`. See doc for :py:class:`ParsingState`. If `parsing_state` is `None`, the default parsing state is used. .. versionadded:: 2.0 The `parsing_state` argument was introduced in version 2.0. Nrrr[rZrrrrrzlCall to LatexWalker.get_latex_nodes(stop_upon_closing_mathmode={!r}) but parsing state has in_math_mode={!r}c*\rSrSrSSjrSrSrSrg)/LatexWalker.get_latex_nodes..PosPointeriNc4XlX lX0lX@lgr )r.r lastchars lastchars_pos)r5r.rrrs r r38LatexWalker.get_latex_nodes..PosPointer.__init__s%2"!*%2"rcVU=RU- slURcXlggr )rr)r5r.rs r push_lastchars>LatexWalker.get_latex_nodes..PosPointer.push_lastcharss'%'%%-),&.rcRURUR4nSUlSUlU$)Nr9)rr)r5ress r flush_lastchars?LatexWalker.get_latex_nodes..PosPointer.flush_lastcharss*(($..8!#%)" r)rrrr.)r9N)r!r"r#r$r3rrr&r rr PosPointerrs 3  -  rr)r.rc >T$RURT"URS9nURUR -UlURS:XaHURUR[ UR5- URUR-S9 g[ UR5(aUR5upET$R[URXRR-XBRU- S9nURU5 T#(a![ U5T#:aURUlgO[ UR5(aT$R[URURUR[ UR5- [ UR5S9nURU5 T#(a![ U5T#:aURUlgURS:XaYURT%:waH[ S3T$R URS UR-S .T$R#URSS 9D6egURS :XaT'(dT[ S3T$R URS R%UR5S .T$R#URSS 9D6eURT':waU[ S3T$R URSR%URT'5S .T$R#URSS 9D6egURS;GaT&bURT&:XagURS;aU[ S3T$R URSR%URT&5S .T$R#URSS 9D6eURS;deOdURS;aT[ S3T$R URSR%UR5S .T$R#URSS 9D6eSSS.R'URUR5nURS;aSOSn URR)SURS9n T$R+URUU S9upn X-UlURT$RRU U URU4URX-UR- S95 T#(a[ U5T#:aggURS:XasT$RRURUR4URUR S9nURU5 T#(a[ U5T#:aggURS :XagT$R7URURURS!9unnnUU-UlURU5 T#(a[ U5T#:aggURS#:XagT$R9URURURS$9unnnUU-UlURU5 T#(a[ U5T#:aggURS&:XGapURnURR:R=U5nUc[>R@"S'5nURCT$URUR -URS(9n[ U5S+:XaUunnnnOUunnn0nUU-UlUb0URF(aURFS*nURFS,nOS/nnT$RURURUUR4UUURURUR- S-9 nURU5 S.U;a US.UlT#(a[ U5T#:aggURS/:XGaURnURUR -UlSnURCT$URURS(9n U b*[ U 5S+:XaU unnnn!OU unnn0n!UU-UlO0n!T$RURURJUURURUR- S19nURU5 S.U!;a U!S.UlT#(a[ U5T#:agg[ S3T$R URS2R%U5S .T$R#URSS 9D6e![anT$R(aUsSnA$eSnAf[ anT$R(aeeSnAff=f![ ahnUR,R[/SR%UR5UR/T$R#UR5Q765 eSnAff=f![ aOnUR,R[/S"UR/T$R#UR5Q765 eSnAff=f![ ahnUR,R[/S%R%UR5UR/T$R#UR5Q765 eSnAff=f![[ 4aOnT$REUUS)R%U55nUbUeSURUR -S*04nSnAGNASnAff=f![[ 4aLnT$REUUS0R%URJ55nUbUeSURS*04n SnAGNJSnAff=f)4aM Read a single token and process it, recursing into brace blocks and environments etc if needed, and appending stuff to nodelist. Return True whenever we should stop trying to read more. (e.g. upon reaching the a matched stop_upon_end_environment etc.) Can return an exception instance to give more information than simply `True`. rNr`r.rFrTrtz*Unexpected mismatching closing brace: '%s'r]r^rnz$Unexpected closing environment: '{}'zDUnexpected mismatching closing environment: '{}', was expecting '{}'r)\)\]z2Mismatching closing math mode: '{}', expected '{}')rvru\(\[z"Unexpected closing math mode: '{}'rr)rr)rrvinlinedisplayr)stop_upon_closing_mathmoderzmath mode "{}")rrrrr.rwrz)rrzrr.rwrsrz open bracerm)rrzbegin environment "{}"ryr9rzarguments of macro "{}"rrrVrnew_parsing_staterZzarguments of specials "{}"rzUnknown token: {!r}r )'rr.rrNr@r(rwrurrxrvrrrrr}r-rar=rr*rr1rrrr{rrr get_macro_specr MacroSpecrrrrrr)(rr)rurccharsposrstrnode spacestrnodecorresponding_closing_mathmoderrmathinline_nodelistmposr commentnode groupnodebposblenenvnodeeposelenremspec margsresultrmaposmalenmdicrrrrrspdicrread_max_nodesr5rrrs( r do_read,LatexWalker.get_latex_nodes..do_reads  nnQUU@S34??%DGGcgg%AE ww&   cggCMM0B&B(+ (?!B1;;"#"3"3"5..78/4]]/B-577X;M)O(!c(m~&EGGAES]]## $~~n<=OO47MM25''#cmm:L2L25cmm2D . F  -!c(m~&EGGAEww-'7755/&&GGH#''R22377D2I  ww++0/&&GGCJJ377S22377D2I  WW 99/&&GG228&B[2\  22377D2I wwAA-9ww"<<#ww.04"ff # T [ [ #)C! #66sww6M 77&????WW. 0&&GG@GGP22377D2I "%044SWWcggF/*-''\*Ahy &'oo&A&A!%(+'B'# 8<8L8L3Q&99M95( !"#// +0 #)GHTYsww%6 !/!"c(m~&Eww)#"nn-=;&?AO!c(m~&Eww*$#'') /**TquuAOO*\C?3x1}:=75%3605% "!EMAEE~~&745OO5:5I5I/7*-''*+%%- &9 %&%/&+,?&@AO!c(m~&E(&&EE)005**155$*?  q * ((H(  0010  P-OO**J7G7N7Nsww7WY\Y`Y`-[8<8P8PQTQXQX8Y-[]N-OO**J|SWW-[8<8P8PQTQXQX8Y-[]&-OO**"#;#B#B377#KSWWG$($<$R>RSA }Ag2.C/s%e5 g53h6,3j.2l%m)5 f>?ff>f f>%f99f> h3 A#h..h36 jA j  j lA#k??lm&Am!!m&)o9AooT'z\end{z*Unexpected end of stream, was expecting {}r]r^Frrr )rMrwr!r6r7r=rNr(r-r.rar@rUrrrQrrrrrr})r5r.rrrrrr)opening_brace_for_stop_upon_closing_braceorigposrr)rr_endnowrc expectingrrrrs` ```` @r rLatexWalker.get_latex_nodesesh   335M"481 "&#-@WX'# & 1-:T:T NN;??$$+3+?+?%AEES!5!566E;;&'&7&7&9OHe"nn^;B26HL&*R<R, pos, len)`. `pos` is the first char of the expression, and `len` is its length. .. deprecated:: 1.0 Please use :py:meth:`LatexWalker.get_latex_expression()` instead. r.)r;rr-r.rPs r rr s" q (K ( = =# = FFrc 4[U40UD6RUS9$)z Attempts to parse an optional argument. Returns a tuple `(groupnode, pos, len)` if success, otherwise returns None. .. deprecated:: 1.0 Please use :py:meth:`LatexWalker.get_latex_maybe_optional_arg()` instead. r )r;rr s r rr s" q (K ( E E# E NNrc 4[U40UD6RXS9$)ap Reads a latex expression enclosed in braces {...}. The first token of `s[pos:]` must be an opening brace. Returns a tuple `(node, pos, len)`. `pos` is the first char of the expression (which has to be an opening brace), and `len` is its length, including the closing brace. .. deprecated:: 1.0 Please use :py:meth:`LatexWalker.get_latex_braced_group()` instead. )r.r)r;r)r-r.rrPs r rr s" q (K ( ? ?C ? __rc 6[U40UD6RUUS9$)aA Reads a latex expression enclosed in a \begin{environment}...\end{environment}. The first token in the stream must be the \begin{environment}. Returns a tuple (node, pos, len) with node being a :py:class:`LatexEnvironmentNode`. .. deprecated:: 1.0 Please use :py:meth:`LatexWalker.get_latex_environment()` instead. )r.r)r;r)r-r.rrPs r rr s- q (K ( > >3O^ ? ``rc 8[U40UD6RUUUS9$)a` Parses latex content `s`. Returns a tuple `(nodelist, pos, len)` where nodelist is a list of `LatexNode` 's. If `stop_upon_closing_brace` is given, then `len` includes the closing brace, but the closing brace is not included in any of the nodes in the `nodelist`. .. deprecated:: 1.0 Please use :py:meth:`LatexWalker.get_latex_nodes()` instead. )rrr)r;r)r-r.rrrrPs r rr s/ q (K ( 8 8 7";#= 9 rcSnSnUGH3nUcM UR[5(aX#R- nM3UR[5(a5USUR<UR <U"UR 5<3- nMUR[5(a&X#R<U"UR 5<3- nMUR[5(a!USUR-UR-- nMUR[5(a:X#RS[UR5-URS-- nGMQUR[ 5(aTUSUR"<SU"UR 5<3- nU[UR5- nUS UR"-- nGMUR[$5(a:X#RS[UR5-URS-- nGMUS UR'5R(-- nGM6 U$) NcfUbURb URcgSn[URUR5Hlup#US:XaUbU[U/5- nMM!US:XaUbU[U/5- nM;M=US:XaU[U/5- nMT[ SR U55e U$)Nr9*rZrzUnknown argument type: {!r})argspecargnlistrnodelist_to_latexr1r=)r argslatexargtargns r add_args#nodelist_to_latex..add_args s  x//78;L;L;T h..0A0ABJDs{#!2D6!::I$#!2D6!::I$.v66  !>!E!Ed!KLLCrr9rhrorrVz\begin{rz\end{%s}z<[UNKNOWN LATEX NODE: '%s']>)rrrrrerrrrrrzrrrrrrrrrr!)rrlatexns r rr s& E  9  << ' ' WW E  << ' ' !++q/A/A8AJJCWX XE  <<) * * //!**1EF FE  <<( ) ) S]1#7#77 7E  << ' ' \\!_'8'DDq||TUV VE  <<, - - qyy(1::2FG GE &qzz2 2E [199- -E  << & & \\!_'8'DDq||TUV VE  11::<3H3HIICF LrchUS:XaSU-$US:XaSU-$US:XaSU-$US:XaSU-$X-U-$) Nrz{%s}rZz[%s]rz(%s)rz<%s>r ) brace_char thestrings r put_in_bracesr!P s\c ""c ""c ""c ""  !J ..rc ^^ SnSn/m U U4SjnTcSnGO TR[5(a[TR5nGOTR[5(aSTR -nU"5 GOTR[ 5(aTRS-nU"5 GOvTR[5(aSTRR5-nGO=TR[5(aFU(aTRH n[XqUS9 M gSnT RS TRS 45 OTR[ 5(a5S TR"-nU"5 T RS TRS 45 OTR[$5(aNTR&S TR(-S -TR&S-nT RS TRS 45 O&[+STR-5R.-5 [+SU-U-U-S-U-5 T HJup(n [1U[25(a[+SUS--U-U-5 M4UHn[XqS-X)S9 M ML g)Nr9c~>TRcgTRRbTRRcTRS5 g[ TRRTRR5H6upUS:XaSnOUS:XaSnO US:XaSnOSnTRX!/S 45 M8 g) N)z zNrZz[.]: rz{.}: rz<*>: z : F)rrrr}r)rrr iterchildrenrs r rdisp_node..add_argse s ::   ZZ   '1::+>+>+F    J K ajj00!**2E2EFJDs{!   FE 2 3Grzrhz (specials)ro)indentrAzGroup: * Fz \begin{%s}rz mathrVzUNKNOWN NODE TYPE: %s z r)r&rA skip_group)rrreprrrrerrrrzstriprrv disp_noder}rrrrrrprintrr!r _basestring) rr&rAr)titlerzrnnrskipr$s ` @r r,r,_ s EGL4$ y n % %QWW  n % %Q[[  ' ( (  =0 & ' 'aiioo'' n % % ee"W= T1::u56 * + + 1 12 T1::u56 m $ $ Q -g5all1oET1::u56 %qzz|'<'<=> #f*w  & -g 56#/4 h , , #vax.7*X5 6 B b7 L $0rcD^^"UU4SjS[R5mT$)Nc@>^\rSrSrSrUU4SjrUUU4SjrSrU=r$)0make_json_encoder..LatexNodesJSONEncoderi z` A :py:class:`json.JSONEncoder` that can encode :py:class:`LatexNode` objects (and subclasses). c&>[TU]"U0UD6 gr )r2r3)r5rrLatexNodesJSONEncoderr6s r r39make_json_encoder..LatexNodesJSONEncoder.__init__ s ' 7 H Hrc|>[U[5(aiUnSURR0nURHnUR UX4'M UR TRURSS95 U$[U[R5(aUR5$[TU]7U5$)NnodetypeTr^)rrr6r!r|__dict__updaterar.rrto_json_objectr2default)r5rrdfldr6r6 latexwalkers r r=8make_json_encoder..LatexNodesJSONEncoder.default s#y)) 4 499CZZ_AF%888MN#y8899))++.=cB Brr ) r!r"r#r$r%r3r=r&rK)r6r6r@s@r r6r4 s  I C Crr6)json JSONEncoder)r@use_line_numbersr6s` @r make_json_encoderrE s%CC 0 0C< ! r)TT)rr )rNNN)rr'Fr9)7r% __future__rrr{sysloggingrB pylatexencr9rr version_infomajorr strr._str_from_unicoder basestring getLoggerr!r6r Exceptionrr(rNrarlLazyDictdefault_macro_dictobjectrrrrrrrrrrr rr;rrrrrrrr!r,rEr rr rTs4>@8  A&K##K<3   8 $  y =,=D'-' P" J^^ 0DD^nnbY&!Y!F y 8KYK^K$9K$Z(! (!Z)I)^;;&B6BVU<&U