KidZddlmZmZddlZddlZddlZddlZddlZddl m Z ddl m Z ej j dkr dZeZdZd ZneZd Zd ZejeZd ZGd deZGddeZGddeZdZdZe jdZ Gdde Z!Gdde Z"Gdde"Z#Gdde"Z$Gdd e"Z%Gd!d"e"Z&Gd#d$e"Z'Gd%d&e"Z(Gd'd(e"Z)Gd)d*e Z*Gd+d,e Z+Gd-d.e Z,d=d0Z-d1Z.d2Z/d>d4Z0d?d5Z1 d@d6Z2d7Z3d8Z4dAd;Z5dBd<Z6dS)Ca 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)_utilc|SN)strings w/var/www/development/aibuddy-work/election-extract/venv/lib/python3.11/site-packages/pylatexenc/latexwalker/__init__.pyunicoder gsc|Sr r xs r ri!rc|Sr r rs r rrjrrcFt|dSNzutf-8)r encoders r rrns'!**"3"3G"<"<rc,|dSr)decoders r rros!((7"3"3rc t|Sr )tuple)argss r _maketuplerts ;;rceZdZdZdS)LatexWalkerErrorz8 Generic exception class raised by this module. N)__name__ __module__ __qualname____doc__r rr rrzs Drrc6eZdZdZdfd ZdZdZdZxZS)LatexWalkerParseErrora^ Represents an error while parsing LaTeX code. The following attributes are available if they were provided to the class constructor: .. py:attribute:: msg The error message .. py:attribute:: s The string that was currently being parsed .. py:attribute:: pos The index in the string where the error occurred, starting at zero. .. py:attribute:: lineno The line number where the error occurred, starting at 1. .. py:attribute:: colno The column number where the error occurred in the line `lineno`, starting at 1. Ncd|_||_||_||_||_||_g|_tt| | dSr ) input_sourcemsgsposlinenocolno open_contextssuperr%__init___dispstr)selfr(r)r*r+r, __class__s r r/zLatexWalkerParseError.__init__sc    #T**33DMMOODDDDDrc h|j}|jr|d|jz }|d||j|j|jzz}|jrS|dz }t|jD]9}|\}}}}|dd|||||z }:|S)Nz in {}z %sz Open LaTeX blocks: z{empty:8}{loc:>10} {what} )emptylocwhat) r(r'format_fmt_posr*r+r,r-reversed)r1r(dispcontextr7r*r+r,s r r0zLatexWalkerParseError._dispstrsh   7 9##D$566 6CUDMM$(DKLLMM   C , ,D#D$677 C C+2(c656==B<@MM#fUZ<[<[=A>CCC rc,||d||fzSd|zSd|zS)Nz@(%d,%d)z@%dz @ char %dr )r1r*r+r,s r r9zLatexWalkerParseError._fmt_poss2   !65/11&> !C  rc*|Sr )r0r1s r __str__zLatexWalkerParseError.__str__}}rNNNN) r r!r"r#r/r0r9r@ __classcell__r2s@r r%r%sz6 E E E E E E   !!!rr%c$eZdZdZdfd ZxZS)LatexWalkerEndOfStreamz: Reached end of input stream (e.g., end of file). r4cdtt|||_dSr )r.rFr/ final_space)r1rHr2s r r/zLatexWalkerEndOfStream.__init__s. $d++44666&rr4)r r!r"r#r/rCrDs@r rFrFsG''''''''''rrFctj}ddlm}|D]0\}}|||d|d|d1|S)a 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)rMrNrO)rLatexContextDb _defaultspecsrLadd_context_category)dbrLcatcatspecss r get_default_latex_context_dbrVsz,  ! # #B$$$$$$?? X '/'9-5n-E)1*)=  ? ? ? ? Irctjdtj|||}|j|_||_||_d|j_ |S)a .. 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)r[r\r]ms r MacrosDefras]( ! 4 GVW55A AIAHAI<@AM8 HrcptdtDS)Nc g|] }|j|f Sr )rZ).0r`s r z..s/###  a###r)dictrViter_macro_specsr rr rrs>T##-//@@BB###r)generate_dict_fncFeZdZdZd fd ZdZdZdZdZdZ d Z xZ S) LatexTokenaq 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.] r4c||_||_||_||_||_||_gd|_|jdvr|jdtt| dS)Ntokargr*len pre_space)macrocomment post_space) rmrnr*rorprs_fieldsappendr.rjr/)r1rmrnr*rorprsr2s r r/zLatexToken.__init__s"$@@@ 8+ + + L   - - - j$((*****rcDt|Sr _unicode_from_strr@r?s r __unicode__zLatexToken.__unicode__ 000rc\ddfdjDzdzS)Nz LatexToken(, c:g|]}|dt|S=getattrrdkr1s r rez'LatexToken.__repr__..s<000"#74???3000r))joinrtr?s`r __repr__zLatexToken.__repr__sS  II0000!%000 1 1 1   rc*|Sr rr?s r r@zLatexToken.__str__rArcHtfdjDS)Nc3\K|]&}t|t|kV'dSr rrdfotherr1s r z$LatexToken.__eq__..s<TTgdA&&'%*;*;;TTTTTTr)allrtr1rs``r __eq__zLatexToken.__eq__s,TTTTTdlTTTVVVrctSr NotImplementedrs r __ne__zLatexToken.__ne__N2rNrI) r r!r"r#r/ryrr@rr__hash__rCrDs@r rjrj:saaD + + + + + +111WWW322HHHHHrrjc\eZdZdZ d fd ZdZdZdZdZdZ dZ d Z d Z d Z xZS) LatexNodea[ 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 Jtt|jdi|||_||_||_t ddgt|z|_|8t t|jt|z|_ dS|j|_ dS)Nr*ror ) r.rr/ parsing_stater*rorlistrt_redundant_fields)r1rtrrr*rokwargsr2s r r/zLatexNode.__init__s (i'11&111*eU^d7mm;<<  (%*4 +=+=EV@W@W+W%X%XD " " "%)\D " " "rctS)a 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. )rr?s r nodeTypezLatexNode.nodeTypes rc"t||S)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)r1ts r isNodeTypezLatexNode.isNodeType s $"""rcz|jtd|jj|j|j|jzS)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]``. NzNCan't use latex_verbatim() on node because we don't have any parsing_state set)r TypeErrorr)r*ror?s r latex_verbatimzLatexNode.latex_verbatimsE   %9:: :!#DHtx/@$@AArcduoxkoNjjuo@jjko0jjko t fdjDS)Nc3\K|]&}t|t|kV'dSr rrs r rz#LatexNode.__eq__..%s<PPQ'$""geQ&7&77PPPPPPr)rrr*rorrtrs``r rzLatexNode.__eq__sD  MMOOu~~// /  4#5 5 I ! I !  PPPPP$,PPP    rctSr rrs r rzLatexNode.__ne__)rrcDt|Sr rwr?s r ryzLatexNode.__unicode__-rzrc*|Sr rr?s r r@zLatexNode.__str__/rArcjdzdtjzdfdjDzdzS)N(z"parsing_state=, r|c:g|]}|dt|Sr~rrs r rez&LatexNode.__repr__..5s,LLL74???3LLLrr)rr r8idrrrtr?s`r rzLatexNode.__repr__1ss MMOO $s * 0 7 74;M8N8N O O P IILLLLdlLLL M M N   rrB)r r!r"r#r/rrrrrrryr@rrCrDs@r rrs$$J3737222222&### B B B322H111rrc(eZdZdZfdZdZxZS)LatexCharsNodez 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 Ztt|jdddi|||_dS)Nrt)charsr )r.rr/r)r1rrr2s r r/zLatexCharsNode.__init__CsF,nd##,        rctSr )rr?s r rzLatexCharsNode.nodeTypeJrr r!r"r#r/rrCrDs@r rr:sQrrc(eZdZdZfdZdZxZS)LatexGroupNodea 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 |dd}tt|jdddi|||_||_dS)N delimiters{}rt)nodelistrr )popr.rr/rr)r1rrrr2s r r/zLatexGroupNode.__init__ds`ZZ j99 ,nd##,  .    ! $rctSr )rr?s r rzLatexGroupNode.nodeTypemrrrrDs@r rrMsQ,%%%%%rrc(eZdZdZfdZdZxZS)LatexCommentNodeag 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 |dd}tt|jdddi|||_||_dS)Ncomment_post_spacer4rt)rrrr )rr.rr/rrr)r1rrrrr2s r r/zLatexCommentNode.__init__~sf#ZZ(      /    &   rctSr )rr?s r rzLatexEnvironmentNode.nodeType%s##rrrDs@r rrsR44l&$$$$$$$rrc(eZdZdZfdZdZxZS)LatexSpecialsNodeaz 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 |dd}tt|jdddi|||_||_dS)Nrrt)specials_charsrr )rr.rr/rr)r1rrrr2s r r/zLatexSpecialsNode.__init__EsbJ--/&&/  3    -  rctSr )rr?s r rzLatexSpecialsNode.nodeTypeOs  rrrDs@r rr(sQ8!!!!!!!!!!!!rrc,eZdZdZgffd ZdZxZS) LatexMathNodea  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 |dd}tt|jdddi|||_||_||_dS)NrNNrt) displaytyperrr )rr.rr/rrr)r1rrrrr2s r r/zLatexMathNode.__init__qshZZ l;; +mT""+  =    '  $rctSr )rr?s r rzLatexMathNode.nodeType}srrrDs@r rrUs[6.0 % % % % % %rrc*eZdZfdZdZdZxZS)_PushPropOverridectt|||_||_||_dSr )r.rr/objpropname new_value)r1rrrr2s r r/z_PushPropOverride.__init__s9 &&//111  "rc|j?t|j|j|_t |j|j|j|Sr )rrrrinitvalsetattrr?s r __enter__z_PushPropOverride.__enter__s< > %"48T];;DL DHdmT^ < < < rcX|j"t|j|j|jdSdSr )rrrrr)r1typevalue tracebacks r __exit__z_PushPropOverride.__exit__s0 > % DHdmT\ : : : : : & %r)r r!r"r/rrrCrDs@r rrsV#####  ;;;;;;;rrc<eZdZdZfdZdZdZddZdZxZ S) ParsingStateaX 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 tt|d|_d|_d|_d|_d|_|dd}| ||dS)NF)r) latex_context in_math_modemath_mode_delimiter _do_sanitizeT) do_sanitize) r.rr/r)rrrrtr _set_fields)r1rrr2s r r/zParsingState.__init__sw lD!!**,,,!!#' V jj66  [99999rc r|jdddi|}|||S)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. rFr )r2 get_fieldsr)r1rps r sub_contextzParsingState.sub_contextsA DN C C C1B1B C C frcDtfdjDS)zl Returns the fields and values associated with this `ParsingState` as a dictionary. c4g|]}|t|fSr r)rdrr1s r rez+ParsingState.get_fields..s(AAAqaq))*AAAr)rfrtr?s`r rzParsingState.get_fieldss* AAAADLAAABBBrTc|D]B\}}||jvr#td||t |||C|r||dSdS)Nz'Invalid field for ParsingState: {}={!r}) given_fields)itemsrt ValueErrorr8r _sanitize)r1rrrvs r rzParsingState._set_fieldssLLNN  DAq $$ !J!Q!QRSUV!W!WXXX D!Q      0 NNN / / / / / 0 0rc|js4|jr/d|_d|vr&td|jdSdSdSdS)aC 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. NrzFParsingState: You set math_mode_delimiter=%r but in_math_mode is False)rrloggerwarning)r1rs r rzParsingState._sanitize sq  T%= '+D $$ 44,-1-E    44rT) r r!r"r#r/rrrrrCrDs@r rrs==| : : : : :(CCC 0 0 0 0rrceZdZdZdfd ZdZdZdZ ddZd Z d Z dd Z dd Z ddZ ddZddZdZ ddZxZS) LatexWalkeraR 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. Nc ||_d|_d|_|d|vrtjd|dd}t }|dg}|d| | n"t }nd|vrtdt|j||_ |d d |_|d d|_d |vrtjd |d =|r-t d|t't(|dS)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=...`.rN) keep_whichcustomz@Cannot specify both `latex_context=` and `macro_dict=` arguments)r)rtolerant_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_nodesrrXrrVfilter_contextrRvaluesiter_environment_specsrrdefault_parsing_staterrrr keysr.r r/)r1r)rrrdefault_latex_contextr2s r r/zLatexWalker.__init__us"   v%%-E $ZZ d;; (D(F(F% 5 D D ./!E!! 22%%'')@@BB!= > > v%%V&2f'& & & "!' +=t D D#ZZ??  ' '  )>    )*  \ NNKV[[]] [ [ [ k4  ))+++++rc &|jjdi|S)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 )rr)r1rs r make_parsing_statezLatexWalker.make_parsing_states 6t)5?????rc"|j|jddS)aW 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)rrr)rrr?s r parse_flagszLatexWalker.parse_flagss"!% 5!/ $    rc<td|dS)Nz0Ignoring parse error (tolerant parsing mode): %s)rinfo)r1excs r _report_ignore_parse_errorz&LatexWalker._report_ignore_parse_errors FLLLLLrTc 6 |}dg}|r||z }d|vr|ds|dgz }jdfd}tkrrqz dz drt d dd z d dd  Stkrqtkrt dkrQdztkrtdz} d} d } dzr{d} | ztkrc| zrF| | zz } | dz } | ztkr| zF| dvrt dd| z|  S| dvrt dd| z|  S|r| dvrtj d| zd} | -|d | | d| z\} }| r| |St | dkrdnd| d| | z Sd}| r| ztkr| zrk|| zz }| dz } |dr|dd }| d z} n3| ztkr| zkt d| | |Sdkrtjd}d}|| dd r1|z }|z }d}nY|z }| z }| }ntz }|}d}t d!dz|z||St%|\}}|vrt d"d S|vrt d#d Sd$r&|jr |jd%kst dd$d  Sd%rt dd%d S|j|&}|&t d'|t|j St d d S)(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[]r4ctd|dd}jr+|dt d||fS|dfS)Nr)r*r(Tas_dictcharrlr )r%pos_to_lineno_colnorr#rj)r(ro placeholderer*r)r1spaces r _token_parse_errorz1LatexWalker.get_token.._token_parse_error8s%**3*== A $ //222Z## d7NrrKz r-rrl)rH\FTmathmode_display)rrmathmode_inline)beginendz^\s*\{([\w* ._-]+)\}z+Bad \{} macro: expected {{environmentname}})r(ror/r7begin_environmentend_environmentrq)rmrnr*rorprs%z(\n|\r|\n\r)(?P\s*) extraspace)  z rr brace_open brace_close$$$rrO)rrr)roisspaceendswithrjrFisalpharematchr8groupr8compilesearch startswithstartziprrrtest_for_specialsr)r1r*include_brace_charsrNrrr brace_charsr2rq isalphamacroienvmatchr0rrsr`mlenarglenmspaceopenbracecharsclosebracecharssspecr)r1s`` @@r get_tokenzLatexWalker.get_tokensj   3355M!l  / . .K 6 ) )::233 , |+ F$        $CFFllqv~~//l QsVOE 1HC~~f%% 8!f&c!e,1#2#J8888 CFFllqv~~//l #a&&==(U;;; ; S6T>>1uA,...c!eHE LAQx!! # !eCFFllqQx'7'7'9'9lQs1uX%EFA!eCFFllqQx'7'7'9'9l  ""!&8d5j&)qECCCC ""!&7T%Z&)qECCCC )9 9 98$;Qs1uvvYGG#--JQQRWXX$(JDAq  H!050@0@,,FW q))(,,..(# J !eCFFllqQx'7'7'9'9l!CE(*JFA!**622&0_ Q!eCFFllqQx'7'7'9'9l'u#1(-*FFF F S6S== =>>EEaMMAD}77<((335JLL 'WWYYs]F7799S=DFFWWYYs]F55773;DWWYYFFQ)3q5V3C1D#SW(-&BBB B+.{*;' S6^ # #,AcFV[\\\ \ S6_ $ $-QsV!W\]]] ] <<c " " C". C=3TX[3[3[!&8d&)qECCCC <<S ! ! _"3#1X]^^^ ^+== s->    *%"%3u/C+D+DPUWWW W f!C&cqERRRRrc |d|d|d}}}|d|||d|}|jrtd||S)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*ror)r*rorz New node: %rr )rrrdebug)r1 node_classrr*rornodes r make_nodezLatexWalker.make_nodes|( JJu  vzz%00&**_2M2M SzRcs-RR6RR   / LL . . . rc ,|j|f|||d|||fS)N)rr*ro)r`)r1nclassrr*rors r _mknodeposlenzLatexWalker._mknodeposlens3 DN6 [CS [ [TZ [ [    rFc|jtj|j|_|j||S)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. Nr+)rrLineNumbersCalculatorr)r.)r1r*r,s r r.zLatexWalker.pos_to_lineno_colnos>   %!&!>59D.1g37 *DD%L ?L ?L ?L ?L ?L ?L ?L ?2w*$$))*;8E9<9O37.1g37 *DD5L ?L ?L ?L ?L ?L ?L ?L ?>w)##00P]0^^AL ?L ?L ?L ?L ?L ?L ?L ?Bw,&&2237-2XXEL ?L ?L ?L ?L ?L ?L ?L ?Fw-'' %d.C/ELLSWUU2232EE )).8E02.1g1*>>]L ?L ?L ?L ?L ?L ?L ?L ?dw&  )).8E03.1g.1g *77gL ?L ?L ?L ?L ?L ?L ?L ?pwAAA7%%d++;--nM".M"&M"3A=M"=8M"AM"'-M"!AM""M&)M&c||} ||dgd|}n#t$rYdSwxYw|jdkr#|jdkr||d|SdS)a Parses the latex content given to the constructor (and stored in `self.s`), starting at position `pos`, to attempt to parse an optional argument. 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. Attempts to parse an optional argument. If this is successful, we return a tuple `(node, pos, len)` if success where `node` is a :py:class:`LatexGroupNode`. Otherwise, this method returns None. .. versionadded:: 2.0 The `parsing_state` argument was introduced in version 2.0. Nr&F)rPrNrr?r' brace_typer)rr[rFrmrnrl)r1r*rrms r get_latex_maybe_optional_argz(LatexWalker.get_latex_maybe_optional_argis$   3355M ..:,UZ/<!>>CC%   44   7l " "sw#~~..ss=J/LL Lts3 AArc t||}d}|dkrd}nF|dkrd}n=|dkrd}n4|dkrd }n+t|d kr|\}}ntd |zd}|r |dkr||fg}|||| }|jd ks |j|kr8t d|j|d|j|zd||d| |j |jz||f|\}}} | t||||f|j || z|j z S)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. Nrrr'r(rr<>rz3Invalid brace type for get_latex_braced_group(): %srPrr?z8get_latex_braced_group: not an opening brace/bracket: %sr*Tr+)stop_upon_closing_bracer)rrrr*ror ) rrorr[rmrnr%r)r.get_latex_nodesr*rcr) r1r*ror closing_bracerPfirsttokrnposnlens r rlz"LatexWalker.get_latex_braced_groups8   3355M   MM 3  MM 3  MM 3  MM __ ! !(2 %J RU_`aa a"  @*++$. #>"? >>#;N0="?? << ' 'X\Z-G-G'&NQUQWX[Q\]**3*==  "&!5!5 L8< '%/$?'"6" " 4 !!.80=.8--H(0 (,t hl(B "DD Drc  ||}|}|||}|jdks |D|j|kr9t d|j|d||ndd|jd||d ||j}|j|jz}|j |}|tj d } | ||| }nR#ttf$r>}|||d |}||d|d if}Yd}~nd}~wwxYwt|dkr|\} } } } n|\} } } i} | | z}| d|} |jr|dd|zdz} |||| \}}}| "| jr| jd }| jd}ndg}}|t.|||| |g||||z|z  S)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. NrCr9z'get_latex_environment: expected \begin{zz}: r*Tr+r4wr*rz'arguments of environment "\begin{{{}}}"rinner_parsing_staterrrr)stop_upon_end_environmentrrK)rrrrrrr*ror )rr[rmrnr%r)r.r*rorget_environment_specrEnvironmentSpec parse_argsrF_exchandle_parse_subexpressionr8get is_math_moderrvlegacy_nodeoptarg_nodeargsrcr)r1r*rrstartposrxenv_spec argsresultr0argdaposalenadicparsing_state_innerrryrz legnodeoptarg legnodeargss r get_latex_environmentz!LatexWalker.get_latex_environments<   3355M>>#]>CC <. . .  'HLO,K,K'&C'6'BOOH\\\LL**3*==   #&lOlX\) .CCOTT   044H ,!,,tM,ZZJJ&(=> , , ,33<CCOTTA }AgQ+JJJJJJ , z??a  '1 $T4tt!+ T4DTk"hh'M9!, "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 )rrFr%r)r*r8r.rr+r,r-rurrr#)r1r0rmr7s r rz*LatexWalker._exchandle_parse_subexpression@s* a/ 0 0 %&G3::4@@**37D*AA A 1eT " " .183C $ 8 8 ? ? AHag  t{{4((#' ;0099 ; ; ;       + +A . . .4rrc  |}g}dd}rGdkrd}n3dkrd}n*dkrd}n!dkrd }ntd kr\}dkr|fg:|js3td |j|} Gd d } | ||} fd} | || } n#t $r}ssrr dzdz}nr dzdz}n rdzdz}tdj| j d|d tjd}j r |d} n||} Yd}~n:d}~wt$r*}j r |d} nYd}~nd}~wwxYw| rt| t rC| | j | j| xj t| jz c_ | jr]| \}}t&| j||t|}|||| | j | z fS)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(r'rrrsrrrzlCall to LatexWalker.get_latex_nodes(stop_upon_closing_mathmode={!r}) but parsing state has in_math_mode={!r}c"eZdZddZdZdZdS)/LatexWalker.get_latex_nodes..PosPointerr4Nc>||_||_||_||_dSr )r*r lastchars lastchars_pos)r1r*rrrs r r/z8LatexWalker.get_latex_nodes..PosPointer.__init__s&%2"!*%2"""rcF|xj|z c_|j ||_dSdSr )rr)r1r*rs r push_lastcharsz>LatexWalker.get_latex_nodes..PosPointer.push_lastcharss1%'%-),D&&&.-rc>|j|jf}d|_d|_|S)Nr4)rr)r1ress r flush_lastcharsz?LatexWalker.get_latex_nodes..PosPointer.flush_lastcharss%($.8!#%)" r)r4N)r r!r"r/rrr rr PosPointerrsF 3 3 3 3  - - -      rr)r*rc  $|j"|j}n8#t$r}$jr|cYd}~Sd}~wt $r}$jrJd}~wwxYw|j|jz|_|jdkr@||jt |j z |j |j zdSt |j r| \}}$ t|j||j z||j|z }||#r!t |#kr|j|_dSnt |j r$ t|j|j |jt |j z t |j }||#r!t |#kr|j|_dS|jdkrI|j %kr.do_reads  nnQU@S34?%DD)   (HHHHHH(    0111   Gcg%AE w&    cgCM0B0B&B(+ (?!BBBu1; "#"3"3"5"5%..78/4S]/B-537X;M)OO(((! c(mm~&E&EGAE4S]## $~~n<=O47M25'#cm:L:L2L25cm2D2D . F F  ---! c(mm~&E&EGAE4w-''7555/&GH#'R2237D2II  tw+++0/&GCJJ37SS2237D2II  W 999/&G228&B[2\2\  2237D2II twAAA-9w"<<<#tw.004"f # T [ [ #)C!! #66sw6MM 7&??????W.. 0&G@GGPP2237D2II "%0044SWcgFF/*-'\*A*Ahhy &'o&A&A!%(+'B''# 8<8L8L3Q&99M995($ -O**J7G7N7Nsw7W7WY\Y`-[8<8P8PQTQX8Y8Y-[-[-[]]]t !"#/ +0 #)GHT$Ysw%6 !/!!" c(mm~&E&E4w)##"nn-=;&?AO! c(mm~&E&E4tw*$$#') /**TquAO*\\CC.0EF///;;6==e>RSSA }Ag2.CCCCCC/?3xx1}}:=75%3605% "!EMAEEE~~&745O5:5I/7*-'*+%- &99 %%%&%//&+,?&@AO! c(mm~&E&E4t(&E)0055**15$*??  s"& A?A? A AA!Q R, AR''R, +W XAXX&+Z [=A[88[=*^,,`=A`` "d00f >ff T'z\end{z*Unexpected end of stream, was expecting {}r*r+Frrgr )rrorrr r8rFr%r)r*r.rr#rrrHrrr`rrru)r1r*rurrrrr)opening_brace_for_stop_upon_closing_braceorigposrrrr_endnowr0 expectingrrrrPs` ```` @r rvzLatexWalker.get_latex_nodesesh   3355M"481 " &#--@WX'# & 1-:T 1 NN;??7$$+3+?%AAAEES!5666EE;-&'&7&7&9&9OHe"nn^;B26HL&*R<R<R<R<R<R<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 rkr)r*rs r rkrk s+ q ( (K ( ( = =# = F FFrc Dt|fi||S)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 rprs r rprp s+ q ( (K ( ( E E# E N NNrrc Ft|fi|||S)a 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*ro)r rl)r)r*rors r rlrl s. q ( (K ( ( ? ?CT^ ? _ __rc Ft|fi|||S)aY 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*rrs r rr s9 q ( (K ( ( > >3O^ ? ` ``rc Ht|fi||||S)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. )rurr)r rv)r)r*rurrrs r rvrv s: q ( (K ( ( 8 8 7";#= 9  rcd}d}|D]}||tr ||jz }+|tr%|d|j|j||jz }j|tr||j||jz }|tr|d|j z|j zz }|tr5||j dt|jz|j dzz } |t rD|d|jd||jz }|t|jz }|d |jzz }~|t$r5||j dt|jz|j dzz }|d |jzz }|S) NcT||j|jdSd}t|j|jD]x\}}|dkr||t|gz }!|dkr||t|gz }=|dkr|t|gz }Wt d||S)Nr4*r'rzUnknown argument type: {!r})argspecargnlistrNnodelist_to_latexrr8)r argslatexargtargns r add_argsz#nodelist_to_latex..add_args s  x/78;L;T2 h.0ABB M MJD$s{{#!2D6!:!::I#!2D6!:!::I.v666  !>!E!Ed!K!KLLLrr4r4r;rrKz\begin{rz\end{%s}z<[UNKNOWN LATEX NODE: '%s']>)rrrrrZrrrrrrrrrrrrrrrrr )rrlatexns r rr s& E !J!J 9  << ' '  QW E  << ' '  E!++q/A/A88AJCWCWCWX XE  <<) * *  q//!*1E1E1EF FE  <<( ) )  S]1#77 7E  << ' '  Q\!_'8'D'DDq|TUV VE  <<, - -  Eqyyy((1:2F2F2FG GE &qz22 2E [19- -E  << & &  Q\!_'8'D'DDq|TUV VE  11::<<3HII Lrcj|dkrd|zS|dkrd|zS|dkrd|zS|dkrd|zS||z|zS) Nrz{%s}r'z[%s]rz(%s)rrz<%s>r ) brace_char thestrings r put_in_bracesrP sjc ""c ""c ""c ""  !J ..r* Fc d}d}g fd}d}ntrtj}nʼntrdjz}|nt rjdz}|netrdj z}n-tr@|rj D]}t|||dSd} d jd fnӉt r2d jz}| d jd fnt$rDjd jzd zjdz} d jd fn)t+djzt+d|z|z|zdz|z D]R\}}} t1|t2rt+d|dzz|z|z7|D]}t||dz|| SdS)Nr4c8jdSjj jjddSt jjjjD];\}}|dkrd}n|dkrd}n |dkrd}nd}||gd f zNr'z[.]: rz{.}: rz<*>: z : F)rrrrurN)rrr iterchildrenrs r rzdisp_node..add_argse s :  F Z  '1:+>+F    J K K K Faj0!*2EFF 4 4JD$s{{!   TFE 2 3 3 3 3 4 4rzr4z (specials)r;)indentr<zGroup: rFz \begin{%s}rz mathrKzUNKNOWN NODE TYPE: %s z r~)rr< skip_group)rrreprrrrZrrrrrstriprrn disp_noderurrrrrrprintrr r _basestring) rrr<rtitlerrrnnrskiprs ` @r rr_ s EGL444444$ y n % %?QW  n % %?Q[  ' ( (? =0 & ' '?aioo''' n % %?  e > >"VW===== FT1:u56666 * + +? 12 T1:u56666 m $ $? Q -g5al1oET1:u56666 %qzz||'<=>>> #f*w  & -g 5666#/MM4 h , ,  #vax.7*X5 6 6 6  M MB b7t L L L L L M MMrc@GfddtjS)Nc4eZdZdZfdZfdZxZS)0make_json_encoder..LatexNodesJSONEncoderzx A :py:class:`json.JSONEncoder` that can encode :py:class:`LatexNode` objects (and subclasses). c>t|j|i|dSr )r.r/)r1rrLatexNodesJSONEncoderr2s r r/z9make_json_encoder..LatexNodesJSONEncoder.__init__ s, 7E' . . 7 H H H H H Hrct|tr[|}d|jji}|jD]}|j|||<||jd|St|tj r| St| |S)NnodetypeTr+)rrr2r rt__dict__updater.r*rrto_json_objectr.default)r1rrdfldrr2 latexwalkers r rz8make_json_encoder..LatexNodesJSONEncoder.default s#y))  49--CZ_AcFF888MMNNN#y899 ,))+++.55==cBB Br)r r!r"r#r/rrC)r2rrs@r rr s|   I I I I I I C C C C C C C C C C Crr)json JSONEncoder)ruse_line_numbersrs` @r make_json_encoderr sSCCCCCCCC 0CCC< ! r)TT)rr )rNNN)rrFr )7r# __future__rrrGsysloggingr pylatexencr4rr version_infomajorr strr_str_from_unicoderx basestring getLoggerr rr Exceptionrr%rFrVraLazyDictdefault_macro_dictobjectrjrrrrrrrrrrr r[rkrprlrrvrrrrr rr rs4>>@87777777  A&&&K# # K<<33  8 $ $      y   =====,===D'''''-'''   P" " " J$U^ 0DDDDDDDD^nnnnnnnnbY&!!!!!Y!!!F     y   8KKKKKYKKK^K$K$K$K$K$9K$K$K$Z(!(!(!(!(! (!(!(!Z)))))I)))^;;;;;;;;&BBBBB6BBBVU<U<U<U<U<&U<U<U