Ki*dZddlmZmZddlZddlZddlZddlZddlZddl Z ej j dkr dZ e ZejZn ejZeZddlZddlmZddlmZdd lmZejeZGd d eZGd d eZGddeZdhdZdidZ dZ!dZ"djdZ#djdZ$dZ%dZ&ddddddd d!d"d#d$d%d&d' Z'e(d(ed)ie(d*ed+e(d,ed-e(d.ed/e(d0ed1e(d2ed3e(d4ed5e(d6ed7e(d8ed9e(d:ed;e(d<ed=e(d>ed?i e(d@edAe(d0edBe(d2edCe(d8edDe(dEedFie(d@edGe(d0edHe(dIedJe(dKedLe(dMedNe(d8edOe(dEedPidQZ)e(dRe(dEe(dSe(dTf\Z*Z+Z,Z-dUZ.ej/dVkrdWZ.dXZ0dYZ1ej2dZ[Z3 ej2d\[Z4 d]Z5 ddddd^dddd_d^dddd_d^d`Z6daZ7GdbdceZ8Gdddeej9Z: dkdfZ;dldgZ)s' (where `` is an integer) to refer to the n-th argument (starting at '%(1)s'). You cannot mix the two %-formatting styles. - If `simplify_repl` is a callable, it should accept the corresponding :py:class:`pylatexenc.latexwalker.LatexMacroNode` as an argument. The callable will be inspected to see what other arguments it accepts. If it accepts an argument named `l2tobj`, the :py:class:`LatexNodes2Text` instance is provided to that argument. If it accepts an argument named `macroname`, the name of the macro is provided to that argument. .. py:attribute:: discard If set to `True`, then the macro call is discarded, i.e., it is converted to an empty string. .. versionadded:: 2.0 The class :py:class:`MacroTextSpec` was introduced in `pylatexenc 2.0` to succeed to the previously named `MacroDef` class. Nctt|||_|dn||_||_dSNT)superr__init__ macronamediscard simplify_repl)selfrrr __class__s r rzMacroTextSpec.__init__qsC mT""++---" 'ttg *r NN__name__ __module__ __qualname____doc__r __classcell__rs@r rrGsH((R++++++++++r rc$eZdZdZdfd ZxZS)EnvironmentTextSpeca A specification of how to obtain a textual representation of an environment. .. py:attribute:: environmentname The name of the environment .. py:attribute:: simplify_repl The replacement text of the environment. This is either a string or a callable: - If `simplify_repl` is a string, this string is used as the text representation of this environment node. The string may contain a single '%s' replacement placeholder, in which the (processed) environment body will be substituted. Alternatively, the `simplify_repl` string may contain '%()s' (where `` is an integer) to refer to the n-th argument after ``egin{environment}`` (starting at '%(1)s'). The body of the environment has to be referred to with `%(body)s`. You cannot mix the two %-formatting styles. - If `simplify_repl` is a callable, it should accept the corresponding :py:class:`pylatexenc.latexwalker.LatexEnvironmentNode` as an argument. The callable will be inspected to see what other arguments it accepts. If it accepts an argument named `l2tobj`, the :py:class:`LatexNodes2Text` instance is provided to that argument. If it accepts an argument named `environmentname`, the name of the environment is provided to that argument. .. py:attribute:: discard If set to `True`, then the full environment is discarded, i.e., it is converted to an empty string. .. versionadded:: 2.0 The class :py:class:`EnvironmentTextSpec` was introduced in `pylatexenc 2.0` to succeed to the previously named `EnvDef` class. NFctt|||_||_||_dSr)rr%renvironmentnamerr)rr'rrrs r rzEnvironmentTextSpec.__init__s; !4((11333.* r NFrr#s@r r%r%xsH--\r r%c$eZdZdZdfd ZxZS)SpecialsTextSpeca A specification of how to obtain a textual representation of latex specials. .. py:attribute:: specials_chars The sequence of special LaTeX characters .. py:attribute:: simplify_repl The replacement text for the given latex specials. This is either a string or a callable: - If `simplify_repl` is a string, this string is used as the text representation of this specials node. The string may contain a single '%s' replacement placeholder which will be replaced by the concatenated textual representation of all macro arguments. Alternatively, the string may contain '%()s' (where `` is an integer) to refer to the n-th argument (starting at '%(1)s'). You cannot mix the two %-formatting styles. - If `simplify_repl` is a callable, it should accept the corresponding :py:class:`pylatexenc.latexwalker.LatexSpecialsNode` as an argument. The callable will be inspected to see what other arguments it accepts. If it accepts an argument named `l2tobj`, the :py:class:`LatexNodes2Text` instance is provided to that argument. If it accepts an argument named `specials_chars`, the characters that were parsed this "latex specials" node are provided to that argument. .. versionadded:: 2.0 Latex specials were introduced in `pylatexenc 2.0`. Ncrtt|||_||_dSr)rr*rspecials_charsr)rr,rrs r rzSpecialsTextSpec.__init__s6 %%..000,*r rrr#s@r r*r*sH##H++++++++++r r*FcBt|||}|j|_|S)a? .. deprecated:: 2.0 Instantiate a :py:class:`EnvironmentTextSpec` instead. Since `pylatexenc 2.0`, `EnvDef` is a function which returns a :py:class:`~pylatexenc.macrospec.EnvironmentTextSpec` instance. In this way the earlier idiom ``EnvDef(...)`` still works in `pylatexenc 2`. )r'rr)r%r'envname)r.rres r EnvDefr0s. G=$+ - - -A!AI Hr cBt|||}|j|_|S)a7 .. deprecated:: 2.0 Instantiate a :py:class:`MacroTextSpec` instead. Since `pylatexenc 2.0`, `MacroDef` is a function which returns a :py:class:`~pylatexenc.macrospec.MacroTextSpec` instance. In this way the earlier idiom ``MacroDef(...)`` still works in `pylatexenc 2`. )rrr)rrmacname)r2rrms r MacroDefr4s& }gVVVA AI Hr c,||S)z Can be used as callback for display equation environments. .. versionadded:: 2.0 This function was introduced in `pylatexenc 2.0`. )math_node_to_text)envnodel2tobjs r fmt_equation_environmentr9s  # #G , ,,r c,||S)a- This function can be used as callback in :py:class:`MacroTextSpec` for ``\input`` or ``\include`` macros. The `macronode` must be a macro node with a single argument. If :py:meth:`set_tex_input_directory()` was called with a nonempty input directory in the :py:class:`LatexNodes2Text` object, then this method reads the contents of the file name in the macro argument according to the provided settings. Otherwise, returns an empty string. .. versionadded:: 2.0 This function was introduced in `pylatexenc 2.0`. )_input_node_simplify_repl) macronoder8s r fmt_input_macror=s  + +I 6 66r Tc|ffd S)a/ This function returns a callable that can be used in :py:class:`MacroTextSpec`, :py:class:`EnvironmentTextSpec`, or :py:class:`SpecialsTextSpec` for latex nodes that do not have a good textual representation, providing as text replacement the simple placeholder text ``'< P L A C E H O L D E R T E X T >'``. If `block=True` (the default), the placeholder text is typeset in an indented block on its own. Otherwise, it is typeset inline. .. versionadded:: 2.0 This function was introduced in `pylatexenc 2.0`. c(t||S)N)block)_do_fmt_placeholder_node)nr8phtr@s r z,placeholder_node_formatter..-s fE:::r r)placeholdertextr@s `r placeholder_node_formatterrFs&#2 ; ; ; ; ;;r czdd|zdz}|r||dSd|zdzS)Nz<  z > indent)join_fmt_indented_block)rEr8r@txts r rArA0sN /** *T 1C >))#f)=== 9s?r ctdD]$}t||rt||}n%d}t||S)a This function can be used as callable in :py:class:`MacroTextSpec`, :py:class:`EnvironmentTextSpec`, or :py:class:`SpecialsTextSpec` for latex nodes that do not have a good textual representation. The text replacement is the placeholder text ``'< N A M E O F T H E M A C R O O R E N V I R O N M E N T >'``. .. versionadded:: 2.0 This function was introduced in `pylatexenc 2.0`. )rr'r,z )hasattrgetattrrA)noder8attnames r fmt_placeholder_noderU8sVB 4   4%%D E  #D& 1 11r c2Gfdd}|}|jD]}|tjr |jdkr|A|tjr |jdkr|| ||td|j Dd fd|j D}d|zd zS) a This function can be used as a callable in :py:class:`EnvironmentTextSpec` for matrix-like environments like ``\begin{bmatrix}...\end{bmatrix}``. The contents is parsed by separating columns with ``&``'s and rows with ``\\``'s, and is rendered in the form ``[ a11 a12 ; a21 a22 ]``. .. versionadded:: 2.8 This function was introduced in `pylatexenc 2.8`. c,eZdZdZdZfdZdZdS).fmt_matrix_environment_node..StateTypec0g|_g|_g|_dSr) matrix_rowsbuffer_this_column buffer_nodesrs r rz7fmt_matrix_environment_node..StateType.__init__]s !D &(D # "D   r c:|j|dSr)r\appendrrRs r add_contentz:fmt_matrix_environment_node..StateType.add_contentbs   $ $T * * * * *r c|jrD|j|jg|_dSr)r\r[r_nodelist_to_textstrip)rr8s r new_columnz9fmt_matrix_environment_node..StateType.new_columnesY  '..++D,=>>EEGG!#D   r cz||j|jg|_dSr)rerZr_r[r]s r new_rowz6fmt_matrix_environment_node..StateType.new_rowls: OO      # #T%< > > >&(D # # #r N)rrr rrarerg)r8sr StateTyperX\s[ # # #  + + + # # # # # ) ) ) ) )r rh&\c3>K|]}|D]}t|VdSr)len).0rowxs r z.fmt_matrix_environment_node..s5PP3PPaCFFPPPPPPPr z; c3ZK|]%}dfd|DV&dS)rHc3DK|]}|dVdS)rHN)rjust)rmromax_char_widths r rpz8fmt_matrix_environment_node...sE   GGNC ( (      r NrL)rmrnrts r rpz.fmt_matrix_environment_node..sm""           """"""r z[ z ]) nodelist isNodeTyperLatexSpecialsNoder,reLatexMacroNoderrgramaxrZrL)rRr8rhstaterBmatrix_contentsrts ` @r fmt_matrix_environment_noder}OsW))))))))))* IKKE]   << 5 6 6 1;Ks;R;R        << 2 3 3  t8K8K MMOOO  ! MMOOOPPu/@PPPRRNii"""" $ """O / !D ((r )ii)i4iN)ihi)ii)ii)ii)i8iR)ili)ii)ii)ii")i<iV)ipi) bolditalicz bold-italicscriptz bold-scriptfraktur doublestruckz bold-fraktursansz sans-boldz sans-italiczsans-bold-italic monospacehi!Bi,!Ei0!Fi1!Hi !Ii!Li!Mi3!Ri!r/i/!gi !oi4!Ci-!i !i!i!Zi(!i!i !Ni!Pi!Qi!i!i$!)rrrrAazct|}t|i|d}||St|tt f\}}|tkr%|t krt||ztz S|t kr%|tkrt||zt z S|Sr) ord_fmt_math_style_exceptionsget_fmt_math_style_offsets_oA_oa_oZchr_oz)cstyleocr offset_up offset_los r _fmt_math_style_charrs QB"&&ub1155b$??A}266usCkJJIy SyyR3YY9r>C'((( SyyR3YY9r>C'((( Hr ic|Srr)rrs r rDrDsAr cFdfd|DS)a Return the text with letters replaced by unicode characters so that the style `style` is applied. (We use the unicode math alphanumeric symbols, see `https://unicode.org/charts/PDF/U1D400.pdf`_.) The `style` must be one of 'bold', 'italic', 'bold-italic', 'script', 'bold-script', 'fraktur', 'doublestruck', 'bold-fraktur', 'sans', 'sans-bold', 'sans-italic', 'sans-bold-italic', or 'monospace'. The character `c` is essentially expected to be an ascii letter, and any other character will be returned unchanged. (Possible exceptions might be implemented in the future, for instance to implement the double-struck one/identity operator ``\mathbbm{1}``.) c3:K|]}t|VdS))rN)r)rmrrs r rpz&fmt_math_text_style..s1HHa)!5999HHHHHHr ru)textrs `r fmt_math_text_stylers, 77HHHH4HHH J JJr ctj}ddlm}|D]0\}}|||d|d|d1|S)a Return a :py:class:`pylatexenc.macrospec.LatexContextDb` instance initialized with a collection of text replacements for known macros and environments. TODO: clean up and 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 environmentsspecialsrrr)rLatexContextDb _defaultspecsradd_context_category)dbrcatcatspecss r get_default_latex_context_dbrsz.  ! # #B$$$$$$?? X '/'9-5n-E)1*)=  ? ? ? ? Ir cptdtDS)Nc g|] }|j|f Sr)rrmr3s r z..s/###  a###r )dictriter_macro_specsrr r rDrDs>T##-//@@BB###r )generate_dict_fncptdtDS)Nc g|] }|j|f Sr)r'rs r rz..2s0###  A###r )rriter_environment_specsrr r rDrD2s>T##-//FFHH###r rbetween-macro-and-charsbetween-latex-constructs after-comment in-equationsbased-on-source)rrzexcept-in-equationsc^ddddd}||S|dur tdS|dur+td|DSt|tr|||St|t r|dkrt dS|dkrt dS|tvr"td||d krtj d d d }t|Std|)NFrrTcg|]}|dfSTr)rmks r rz3_parse_strict_latex_spaces_dict..{s1111aY111r onoffz0invalid value for strict_latex_spaces preset: {}defaultaThe value 'default' for `strict_latex_spaces=` in LatexNodes2Text() is deprecated. The actual default changed to 'macros', and for backwards compatibility the obsolete value 'default' still refers to the earlier default which is now called 'based-on-source'.) stacklevelrz+Invalid value for strict_latex_spaces: {!r}) _strict_latex_spaces_predefrkeys isinstanceupdate basestring_parse_strict_latex_spaces_dict ValueErrorformatrpylatexenc_deprecated_2)strict_latex_spacesds r rrnsu#($)   A "  % %*844  $ $11111222 ' . .7 $%%% ' 4 47 $ & &2488 8 % ' '2599 9 &A A AO$f%899;; ; ) + +  )M     #4 *+>??F &!45577 7r ceZdZdZdfd Z ddZdZdZdZd Z dd Z dd Z d Z dZ dZdZdZdZddZdZddZdZdZdZdZxZS) LatexNodes2Textu/ Simplistic Latex-To-Text Converter. This class parses a nodes structure generated by the :py:mod:`latexwalker` module, and creates a text representation of the structure. It is capable of parsing ``\input`` directives safely, see :py:meth:`set_tex_input_directory()` and :py:meth:`read_input_file()`. By default, ``\input`` and ``\include`` directives are ignored. Arguments to the constructor: - `latex_context_db` is a :py:class:`pylatexenc.macrospec.LatexContextDb` class storing a collection of rules for converting macros, environments, and other latex specials to text. The `LatexContextDb` should contain specifications via :py:class:`MacroTextSpec`, :py:class:`EnvironmentTextSpec`, and :py:class:`SpecialsTextSpec` objects. The default latex context database can be obtained using :py:func:`get_default_latex_context_db()`. Additional keyword arguments are flags which may influence the behavior: - `math_mode='text'|'with-delimiters'|'verbatim'|'remove'`: Specify how to treat chunks of LaTeX code that correspond to math modes. If 'text' (the default), then the math mode contents is incorporated as normal text. If 'with-delimiters', the content is incorporated as normal text but it is still included in the original math-mode delimiters, such as '$...$'. If 'verbatim', then the math mode chunk is kept verbatim, including the delimiters. The value 'remove' means to remove the math mode sections entirely and not to produce any replacement text. - `keep_comments=True|False`: If set to `True`, then LaTeX comments are kept (including the percent-sign); otherwise they are discarded. (By default this is `False`) - `fill_text`: If set to `True` or to a positive integer, then the whitespace of LaTeX char blocks is re-layed out to fill at the given number of characters or 80 by default. The fill is by far not perfect, but the resulting text might be slightly more readable. - `strict_latex_spaces=True|False`: If set to `True`, then we follow closely LaTeX's handling of whitespace. For instance, whitespace following a bare macro (i.e. without any delimiting characters like '{') is consumed/removed. If set to `False` (the default), then some liberties are taken with respect to whitespace [hopefully making the result slightly more aesthetic, but this behavior is mostly there for historical reasons]. You may also use one of the presets `strict_latex_spaces='based-on-source'|'macros'|'except-in-equations'`, which allow for finer control of how whitespace is handled: - The value 'based-on-source' is the option that is furthest from latex's behavior with spaces, and takes liberties in incuding spaces that are present in the source file in several situations where LaTeX would remove them, including after macros. This is meant to be hopefully slightly more aesthetic. However, this option might inadvertently break up words: For instance:: Sk\l odowska would be replaced by:: Skł odowska - The value 'macros' is the same as specifying `strict_latex_spaces=False`, and it is the default. It will make macros and other sequences of LaTeX constructions obey LaTeX space rules, but will keep indentations after comments and keep more liberal whitespace rules in equations for a hopefully more aesthetic result. - The 'except-in-equations' preset goes as you would expect, setting strict latex spacing only outside of equation contexts. Finally, the argument `strict_latex_spaces` may also be set to a dictionary with keys 'between-macro-and-chars', 'after-comment', 'between-latex-constructs', and 'in-equations', with individual values either `True` or `False`, dictating whitespace behavior in specific cases (`True` indicates strict latex behavior). The value for 'in-equations' may even be another dictionary with the same keys to override values in equations. A value of `False` for 'in-equation' has the same meaning as 'macros'. .. versionchanged:: 2.0 Since `pylatexenc 2.0`, the default value of `strict_latex_spaces` is 'macros', and no longer 'based-on-source'. .. deprecated:: 2.0 The value 'default' is also accepted, but it is no longer the default! It is an alias for 'based-on-source' .. versionchanged:: 2.6 In `pylatexenc` versions 2.0–2.5, contrary to the documentation, the default value of `strict_latex_spaces` was actually still 'based-on-source'. This bug was fixed in version 2.6, so that now, the default setting is actually 'macros'. - `keep_braced_groups=True|False`: If set to `True`, then braces delimiting a TeX group ``{Like this}`` will be kept in the output, with the contents of the group converted to text as usual. (By default this is `False`) - `keep_braced_groups_minlen=`: If `keep_braced_groups` is set to `True`, then we keep braced groups only if their contents length (after conversion to text) is longer than the given value. E.g., if `keep_braced_groups_minlen=2`, then ``{\'e}tonnant`` still goes to ``étonnant`` but ``{\'etonnant}`` becomes ``{étonnant}``. .. versionadded: 1.4 Added the `strict_latex_spaces`, `keep_braced_groups`, and `keep_braced_groups_minlen` flags .. versionadded: 2.0 Added the `math_mode=` flag to replace the poorly designed `keep_inline_math=` flag; Added the `fill_text=` flag. Additionally, the following arguments are accepted for backwards compatibility: - `keep_inline_math=True|False`: Obsolete since `pylatexenc 2`. If set to `True`, then this is the same as `math_mode='verbatim'`, and if set to `False`, this is the same as `math_mode='text'`. .. deprecated:: 2.0 The `keep_inline_math=` option is deprecated because it had a weird behavior and was poorly implemented, especially given that a similarly named option in :py:class:`LatexWalker` had a different effect. See issue :issue:`14`. - `text_replacements` this argument is ignored starting from `pylatexenc 2`. .. deprecated:: 2.0 Text replacements are no longer made at the end of the text conversion. This feature is replaced by the concept of LaTeX specials---see, e.g., :py:class:`pylatexenc.latexwalker.LatexSpecialsNode`. To keep existing code working, add a call to :py:meth:`apply_text_replacements()` immediately after :py:meth:`nodelist_to_text()` to achieve the same effect as in `pylatexenc 1.x`. See :py:meth:`apply_text_replacements()`. - `env_dict`, `macro_dict`: Obsolete since `pylatexenc 2`. If set, they are dictionaries of known environment and macro definitions. They default to :py:data:`default_env_dict` and :py:data:`default_macro_dict`, respectively. .. deprecated:: 2.0 You should now use the more powerful option `latex_context_db=`. You cannot specify both `macro_list` (or `env_list`) and `latex_context_db`. Nc tt||d|vsd|vrtjd|dg}|dg}t j}|d| | gnt}||_ d|_ d|_ d|vrFd|vrtd tjd |drd nd |_n|dd |_|jd vrt!d|dd|_|dd}t%||_|dd|_|dd|_|dd|_|jsd|_|jdurd|_d|vr|d=tjd|r3@@@@!= > > *#'    & &e##!8999  ),   ,1995G+H+HTZZfDNN"YY{F;;DN >!R R R455 5#YY>>#ii(=uEE#BCV#W#W "')),@%"H"H).3NPQ)R)R&;55~ "!DN >T ! !DN % ' ')*  )B     / NNO -- / / / / / / /r Tc8||_|r|ni|_||_dS)a[ Set where to look for input files when encountering the ``\input`` or ``\include`` macro. Alternatively, you may also override :py:meth:`read_input_file()` to implement a custom file lookup mechanism. The argument `tex_input_directory` is the directory relative to which to search for input files. If `strict_input` is set to `True`, then we always check that the referenced file lies within the subtree of `tex_input_directory`, prohibiting for instance hacks with '..' in filenames or using symbolic links to refer to files out of the directory tree. The argument `latex_walker_init_args` allows you to specify the parse flags passed to the constructor of :py:class:`pylatexenc.latexwalker.LatexWalker` when parsing the input file. N)rlatex_walker_init_argsr)rrrrs r set_tex_input_directoryz'LatexNodes2Text.set_tex_input_directorys.,$7 @V&^&<&<\^#(r c|jdStjtj|j|}|jrVtj|j}||std|dStj |s'tj |dzr|dz}tj |s'tj |dzr|dz}tj |std|dSt d| t|5}| cdddS#1swxYwYdS#t$r'}td||Yd}~dSd}~wwxYw) a This method may be overridden to implement a custom lookup mechanism when encountering ``\input`` or ``\include`` directives. The default implementation looks for a file of the given name relative to the directory set by :py:meth:`set_tex_input_directory()`. If `strict_input=True` was set, we ensure strictly that the file resides in a subtree of the reference input directory (after canonicalizing the paths and resolving all symlinks). If `set_tex_input_directory()` was not called, or if it was called with a value of `None`, then no file system access is attempted an an empty string is returned. You may override this method to obtain the input data in however way you see fit. In that case, a call to `set_tex_input_directory()` may not be needed as that function simply sets properties which are used by the default implementation of `read_input_file()`. This function accepts the referred filename as argument (the argument to the ``\input`` macro), and should return a string with the file contents (or generate a warning or raise an error). NrzPCan't access path '%s' leading outside of mandated directory [strict input mode]z.texz.latexzError, file doesn't exist: '%s'zReading input file %rzError, can't access '%s': %s)rospathrealpathrLr startswithrrexistsisfiledebugopenreadIOError)rfnfnfulldirfullfr/s r read_input_filezLatexNodes2Text.read_input_files2  # +2!!"',,t/G"L"LMM   g&&t'?@@G$$W-- * rw~~f%% %"'..&*I*I %f_Fw~~f%% '"'..(9J*K*K 'h&Fw~~f%%  NN=r B B B2 ,f555 f vvxx                      NN:B B B B22222 s< G F=0 G =GG GG G;G66G;ct|jdkr td|j|||jdg}|sdS|tj|fi|j  dS)Nrz5Expected exactly one argument for '\input' ! Got = %rrr) rlnodeargsrrr rcrdr LatexWalkerrget_latex_nodes)rrBinputtexs r r;z)LatexNodes2Text._input_node_simplify_repls qz??a   NNT: ' ' '''(=(=qz!}o(N(N(T(T(V(VWW 2$$  #H L L0K L L _  q "   r c ||tj|fi|dS)a  Parses the given `latex` code and returns its textual representation. This is equivalent to constructing a :py:class:`pylatexenc.latexwalker.LatexWalker` with the given `latex` string, calling its method :py:meth:`~pylatexenc.latexwalker.LatexWalker.get_latex_nodes()`, and providing the outcome to :py:meth:`nodelist_to_text()`. The `parse_flags` are keyword arguments to provide to the :py:class:`pylatexenc.latexwalker.LatexWalker` constructor. r)rcrrr)rlatex parse_flagss r latex_to_textzLatexNodes2Text.latex_to_textsC$$  #E 9 9[ 9 9 I I K KA N   r cfd}d}|D]}||r6|tjr|jds ||jz }|d}|dkrt||z dz }nt|}||||z }|}|S)a Extracts text from a node list. `nodelist` is a list of `latexwalker` nodes, typically returned by :py:meth:`pylatexenc.latexwalker.LatexWalker.get_latex_nodes()`. This function basically applies `node_to_text()` to each node and concatenates the results into one string. (This is not quite actually the case, since we take some care as to where we add whitespace according to the class options.) rNr rtextcol) _is_bare_macro_noderwrLatexCharsNodermacro_post_spacerfindrl node_to_text)rrvs prev_noderR last_nl_posrs r rcz LatexNodes2Text.nodelist_to_texts    D'' 22 4{9:: 4/0IJ433A''$--Kb  a&&,Q.a&& ""4"99 9AIIr rc |dS|tjr|||S|tjr||S|tjr||S|tjr| |S|tj r| |S|tj r| |S|tjr||St d|dS)a Return the textual representation of the given `node`. If `prev_node_hint` is specified, then the current node is formatted suitably as following the node given in `prev_node_hint`. This might affect how much space we keep/discard, etc. Nrrz0LatexNodes2Text.node_to_text(): Unknown node: %r)rwrrchars_node_to_textLatexCommentNodecomment_node_to_textLatexGroupNodegroup_node_to_textrymacro_node_to_textLatexEnvironmentNodeenvironment_node_to_textrxspecials_node_to_text LatexMathNoder6rr)rrRprev_node_hintrs r r zLatexNodes2Text.node_to_text*s_ <2 ??;5 6 6 B**4*AA A ??;7 8 8 3,,T22 2 ??;5 6 6 1**400 0 ??;5 6 6 1**400 0 ??;; < < 70066 6 ??;8 9 9 4--d33 3 ??;4 5 5 0))$// /I4PPPrr c|j}|jr|||}|jds't |dkrdS|S)z Return the textual representation of the given `node` representing a block of simple latex text with no special characters or macros. The `node` is :py:class:`~pylatexenc.latexwalker.LatexCharsNode`. rrrr)charsr do_fill_textrrlrd)rrRrcontents r r%z"LatexNodes2Text.chars_node_to_textRsd* > B'''AAG'(BC 7==??##q((2r c|jr;|jdrd}|jdkrd}d|jz|zSd|jz|jzS|jdrdS|jS)z Return the textual representation of the given `node` representing a latex comment. The `node` is :py:class:`~pylatexenc.latexwalker.LatexCommentNode`. rrr%)rrcomment_post_spacecomment)rrRnls r r'z$LatexNodes2Text.comment_node_to_textes   /'8 D*b00BT\)B..T\)D,CCC'8 /r ..r c||}|jr6t||jkr|jd|z|jdzS|S)z Return the textual representation of the given `node` representing a latex group. The `node` is :py:class:`~pylatexenc.latexwalker.LatexGroupNode`. rr)_groupnodecontents_to_textrrlr delimiters)rrRcontentss r r)z"LatexNodes2Text.group_node_to_textsY 22488  " Fs8}}8V'V'V?1%04?13EE Er c|j}j|}|tdd}fd}||||}|S)z Return the textual representation of the given `node` representing a latex macro invocation. The `node` is :py:class:`~pylatexenc.latexwalker.LatexMacroNode`. NrTrc|jr ||jd|zS|jrdSg}|jr|jjr |jj}dfd|DS)Nz macro '\%s'whatrc:g|]}|Srr:rmrBrs r rzRLatexNodes2Text.macro_node_to_text..get_macro_str_repl..'JJJ1D;;A>>JJJr rapply_simplify_replrnodeargdargnlistrL)rRrmacrrs r get_macro_str_replz>LatexNodes2Text.macro_node_to_text..get_macro_str_repls  Q//c6G5CY5O0QQQ{ rA} +!7 +M*77JJJJJJJKK Kr )rrget_macro_specr)rrRrrJrKmacrostrs` r r*z"LatexNodes2Text.macro_node_to_textsrN  // :: ;D111C L L L L L&%dIs;;r c|j}|j|}|tdd}|jr |||jd|zS|jrdS||jS)z Return the textual representation of the given `node` representing a full latex environment. The `node` is :py:class:`~pylatexenc.latexwalker.LatexEnvironmentNode`. NrFr>zenvironment '%s'r@) r'rget_environment_specr%rrGrrcrv)rrRr'envdefs r r,z(LatexNodes2Text.environment_node_to_texts.#88II >(U;;;F   W++D&2F1C_1U,WW W > 2$$T]333r cv|j}j|}||Sfd}||||}|S)z Return the textual representation of the given `node` representing special a latex character (or characters). The `node` is :py:class:`~pylatexenc.latexwalker.LatexSpecialsNode`. Nc|jr ||jd|zS|jrdS|jr|jjr |jj}dfd|DS)Nz specials '%s'r@rc:g|]}|SrrCrDs r rzXLatexNodes2Text.specials_node_to_text..get_specials_str_repl..rEr rF)rRr,specrrs r get_specials_str_replzDLatexNodes2Text.specials_node_to_text..get_specials_str_repls! W//d6H5Dn5U0WWW| r} +!7 +M*77JJJJJJJKK Kr )r,rget_specials_spec)rrRr,sspecrUr!s` r r-z%LatexNodes2Text.specials_node_to_textsg,"44^DD =! ! L L L L L " !$ > >r c|jdkrg|tjs |jdkr)||dS|S|jdkrdS|jdkrt|5||j  }dddn #1swxYwY|tj r|j }nd|j zd |j zf}|tjs |jdkr)|d ||dz|d zS|d |z|d zS|jd krt|5||j  }dddn #1swxYwY|tjs |jdkr||S|Std |j)a Return the textual representation of the given `node` representing a block of math mode latex. The `node` is either a :py:class:`~pylatexenc.latexwalker.LatexMathNode` or a :py:class:`~pylatexenc.latexwalker.LatexEnvironmentNode`. This method is responsible for honoring the `math_mode=...` option provided to the constructor. rdisplayrrJrrNz \begin{%s}z\end{%s}rrrzunknown math_mode={} !)rrwrr+ displaytyperMlatex_verbatim_PushEquationContextrcrvrdr.r;r' RuntimeErrorr)rrRr3delimss r r6z!LatexNodes2Text.math_node_to_texts >Z ' '{?@@ -"i////0C0C0E0Eb/QQQ**,,, ^x ' '2 ^0 0 0%d++ G G// >>DDFF G G G G G G G G G G G G G G G{899 ?')=>%t';<?{?@@ 7"i//ay4#;#;GB#;#O#OORXYZR[[[ay7*VAY66 ^v % %%d++ G G// >>DDFF G G G G G G G G G G G G G G G{?@@ "i////8887>>t~NNOO Os$-CCC-GGGc tjd|}d|vrdnd}tjd|}d|vrdnd}|}fd tjd|}d fdt |DD}|d kr|r|sd ndzd|z|r|sd ndz|zS) Nz^\s*z rz\s*$cd\}}|}|jdz kr dtj|jz|zS|tj|jd|z|dz|zS)N)rrrrX)initial_indent)rdrtextwrapfill)rorhead_wstrail_wsrs r fill_chunkz0LatexNodes2Text.do_fill_text..fill_chunks!' GX A$.***hmAt~>>>IIM!T^CKPPPQXQYQYZ[r z\n{2,}c@g|]\}}||Sr)rd)rmjthechunks r rz0LatexNodes2Text.do_fill_text.. s>   H~~     r c3JK|]\}}|||dkrndfVdS)rNr)rmrirorgrs r rpz/LatexNodes2Text.do_fill_text.."sX""1A!Q$$wwA>>@""""""r rrH)researchgrouprdcompilesplit enumeraterL) rrrrehead_parrf trail_par rawchunkschunksrgs ` ` @r r2zLatexNodes2Text.do_fill_textsQ)GT**0022$//66b9Wd++1133%11FF zz||     Jy))//55   """"" )) 4 4"""   '!))))33bQ KK    6Y 6SSB8:CD Dr ct|ri}t|d}d|vr|d<|tjrd|vr |j|d<|tjrd|vr |j|d<|tjrd|vr |j |d<||fi|}|r|SdSd|vrt|dkrpg}|j r|j j r |j j }tjd |}|tjr|r|jf} nt#d t%fd |DD} | |j nP|rt)fd |D} n2t#dt%fd|DD} || zS#t*t,f$r2t.d||cYSwxYw|S)z Utility to get the replacement text associated with a `node` for which we have a `simplify_repl` object (given by e.g. a MacroTextSpec or similar). The argument `what` is used in error messages. rr8r'rr,rr5rz(^|[^%])(%%)*%sc3DK|]\}}td|z|fVdSrNstrrmrivals r rpz6LatexNodes2Text.apply_simplify_repl..ZsE+11cQqS#r c3BK|]}|VdSrrCrmnnrs r rpz6LatexNodes2Text.apply_simplify_repl..[sB??DFD;;B????????r )bodyc:g|]}|SrrCr~s r rz7LatexNodes2Text.apply_simplify_repl..as7///! ::2>>///r c3DK|]\}}td|z|fVdSrxryr{s r rpz6LatexNodes2Text.apply_simplify_repl..dsE'-q#S1XXcNr c3BK|]}|VdSrrCr~s r rpz6LatexNodes2Text.apply_simplify_repl..esB;;@B77;;;;;;;;r z'( d--f--A 2 -  C $6$6!$;$; H} 2!7 2=1I&7GGM{?@@  H..t}==@AA5>????JR???66A HH$"7"7 "F"FHGGGG ////%-///001:;;;;FN;;;22  %$q((z* % % %RVD\\%$$$  % sH AI  I rIchd|z|dd|zzdz}|jrd|zdz}|S)Nr)replacer)rr<rKr@s r rMz#LatexNodes2Text._fmt_indented_blocktsEfx//d6kBBBTI > $JtOE r c|duo?|tjo |jduot |jdkSNr)rwrry nodeoptargrlrr`s r rz#LatexNodes2Text._is_bare_macro_node|sND ( :;;(4'(DM""a' )r c|dS|tjs||S||jS)Nr)rwrr(r rcrv)r groupnodes r r:z*LatexNodes2Text._groupnodecontents_to_textsQ  2##K$>?? 0$$Y// /$$Y%7888r cv|jr1|jjr%||jj|SdS)z Return the textual representation of the `k`\ -th argument of the given `node`. This might be useful for substitution lambdas in macro and environment specs. r)rHrIr:)rrRrs r node_arg_to_textz LatexNodes2Text.node_arg_to_texts? = NT]3 N224=3I!3LMM Mrr c|D]B\}}t|dr|||},|||}C|S)a Convenience function for code that used `text_replacements=` in `pylatexenc 1.x`. If you used custom `text_replacements=` in `pylatexenc 1.x` then you will have to change:: # pylatexenc 1.x with text_replacements text_replacements = ... l2t = LatexNodes2Text(..., text_replacements=text_replacements) text = l2t.nodelist_to_text(...) to:: # pylatexenc 2 text_replacements compatibility code text_replacements = ... l2t = LatexNodes2Text(...) temp = l2t.nodelist_to_text(...) text = l2t.apply_text_replacements(temp, text_replacements) as a quick fix. It is recommended however to treat text replacements instead as "latex specials". (Otherwise the brutal text replacements might act on text generated from macros and environments and give unwanted results.) See :py:class:`pylatexenc.macrospec.SpecialsSpec` and :py:class:`SpecialsTextSpec`. .. deprecated:: 2.0 The `apply_text_replacements()` method was introduced in `pylatexenc 2.0` as a deprecated method. You can use it as a quick fix to make existing code run as it did in `pylatexenc 1.x`. Its use is however not recommended for new code. You should use "latex specials" instead for characters that have special LaTeX meaning. sub)rPrr)rr!rpattern replacements r apply_text_replacementsz'LatexNodes2Text.apply_text_replacementssZJ%6 4 4 G[w&& 4KK Q//IIg{33r rrr)r)rI)rrr r!rrr r;rrcr r%r'r)r*r,r-r6r2rGrMrr:rrr"r#s@r rrs__@H/H/H/H/H/H/VSW-1))))8888v   (   $&&&P&&&&P&///:   6444*4-P-P-P`$D$D$D$DLEEEN))) 999+++++++r rceZdZfdZxZS)r\cd}|jdt|jd}tt||d|dS)Nrr)rrrr\r)rl2tnew_strict_latex_spacesrs r rz_PushEquationContext.__init__sn"&  "> 2 >&E'7'' # "D))2238M3J L L L L Lr )rrr rr"r#s@r r\r\sA L L L L L L L L Lr r\ctjddtj|||\}}}t |||S)z Heuristic conversion of LaTeX content `content` to unicode text. .. deprecated:: 1.0 Please use :py:class:`LatexNodes2Text` instead. 1.0zThe module-level function `pylatexenc.latex2text.latex2text()` is deprecated in favor of the `pylatexenc.latex2text.LatexNodes2Text` class.)rtolerant_parsingrr)rpylatexenc_deprecated_verrrlatexnodes2text)r3rrrrvtpostlens r latex2textrsl #  I )8))+++XtT 8,<)6 8 8 88r cttjddt|||S)z Extracts text from a node list. `nodelist` is a list of nodes as returned by :py:func:`pylatexenc.latexwalker.get_latex_nodes()`. .. deprecated:: 1.0 Please use :py:class:`LatexNodes2Text` instead. rzThe module-level function `pylatexenc.latex2text.latexnodes2text()` is deprecated in favor of the `pylatexenc.latex2text.LatexNodes2Text` class.r)rrrrc)rvrrs r rrsQ #  T )#   x  !r r(rr)FFF)FF)=r! __future__rrrrlloggingsysinspectrc version_infomajorr rzrr getargspecunichrr pylatexencrrrr getLoggerrrobjectrr%r*r0r4r9r=rFrArUr}rrrrrrrr maxunicoderrLazyDictdefault_macro_dictdefault_env_dictdefault_text_replacementsrrr_PushPropOverrider\rrrr r rs;4&87777777  Q&&&J+NN'N C  8 $ $.+.+.+.+.+F.+.+.+b33333&333l(+(+(+(+(+v(+(+(+X          2 - - - 7 7 7 ;;;;$222.;););)D  % %!&& #%*#& C##f++ C##f++ C##f++ C##f++ C##f++ C##f++ C##f++ C##f++ C##f++ C##f++ C##f++ C##f++  C##f++ C##f++ C##f++ C##f++ C##f++  C##f++ C##f++ C##f++ C##f++ C##f++ C##f++ C##f++1!!FSXXss3xxS33s88;S#s   >H--KKK,!!!L$U^ &"5> ( $)$) $($() $($() ,(7(7(7Ve e e e e fe e e V L L L L L;8 L L L.BG"88882!!!!!!r