o i ebC@sdZddlmZddlZddlmmZddlmZm Z m Z ddl m Z ddl m Z er3ddlmZdddZdddZGddde jZGdddeZGdddeZGdddeZdS)z Tree processors manipulate the tree created by block processors. They can even create an entirely new `ElementTree` object. This is an excellent place for creating summaries, adding collected references, or last minute adjustments. ) annotationsN) TYPE_CHECKINGSequenceAny)util)inlinepatterns)Markdownmdr kwargsrreturn util.RegistrycKsBt}|t|dd|t|dd|t|dd|S)z3 Build the default `treeprocessors` for Markdown. inlineprettify unescaper)rRegistryregisterInlineProcessorPrettifyTreeprocessorUnescapeTreeprocessor)r r treeprocessorsrF/var/www/myenv/lib/python3.10/site-packages/markdown/treeprocessors.pybuild_treeprocessors's rsboolcCst|tjs t|tSdS)z_ Return `True` if object is a string but not an [`AtomicString`][markdown.util.AtomicString]. F) isinstancer AtomicStringstr)rrrrisString0s  r!c@seZdZdZd ddZdS) Treeprocessora  `Treeprocessor`s are run on the `ElementTree` object before serialization. Each `Treeprocessor` implements a `run` method that takes a pointer to an `Element` and modifies it as necessary. `Treeprocessors` must extend `markdown.Treeprocessor`. root etree.Elementr etree.Element | NonecCsdS)a Subclasses of `Treeprocessor` should implement a `run` method, which takes a root `Element`. This method can return another `Element` object, and the existing root `Element` will be replaced, or it can modify the current tree and return `None`. Nr)selfr#rrrrunAszTreeprocessor.runN)r#r$r r%)__name__ __module__ __qualname____doc__r'rrrrr"7s r"c@sveZdZdZddZddZd-d d ZddZd.d/ddZd0d1ddZ d0d2ddZ d.d3d#d$Z d%d&Z d4d5d+d,Z d'S)6rzL A `Treeprocessor` that traverses a tree, applying inline patterns. cCsJtj|_tj|_dt|jt|j|_tj|_||_ |j |_ g|_ dS)N) rINLINE_PLACEHOLDER_PREFIX$_InlineProcessor__placeholder_prefixETX$_InlineProcessor__placeholder_suffixlen$_InlineProcessor__placeholder_lengthINLINE_PLACEHOLDER_RE _InlineProcessor__placeholder_rer inlinePatterns ancestors)r&r rrr__init__Ps  zInlineProcessor.__init__cCs dt|j}tj|}||fS)z Generate a placeholder z%04d)r1 stashed_nodesrINLINE_PLACEHOLDER)r&typeidhashrrr__makePlaceholderZs z!InlineProcessor.__makePlaceholderdatar indexintr tuple[str | None, int]cCs0|j||}|r|d|fSd|dfS)a Extract id from data string, start from index. Arguments: data: String. index: Index, from which we start search. Returns: Placeholder id and string index, after the found placeholder. rN)r4searchgroupend)r&r>r?mrrr__findPlaceholder`s  z!InlineProcessor.__findPlaceholdercCs||\}}||j|<|S)z Add node to stash. )!_InlineProcessor__makePlaceholderr8)r&noder: placeholderr;rrr __stashNoders zInlineProcessor.__stashNoder patternIndexcCsVt|tjs)d}t|j}||kr)||j||||\}}}|s%|d7}||ks|S)a Process string with inline patterns and replace it with placeholders. Arguments: data: A line of Markdown text. patternIndex: The index of the `inlinePattern` to start with. Returns: String with placeholders. rr)rrrr1r5_InlineProcessor__applyPattern)r&r>rK startIndexcountmatchedrrr__handleInlinexs   zInlineProcessor.__handleInlineTrHr$subnodeisTextrcCsv|r |j}d|_n|j}d|_||||}|s&||ur&t||d}nd}||D] }|||dq.dS)a' Process placeholders in `Element.text` or `Element.tail` of Elements popped from `self.stashed_nodes`. Arguments: node: Parent node. subnode: Processing node. isText: Boolean variable, True - it's text, False - it's a tail. Nrr)texttail%_InlineProcessor__processPlaceholderslistr?reverseinsert)r&rHrQrRrS childResultposnewChildrrr__processElementTexts  z$InlineProcessor.__processElementTextparentlist[etree.ElementTree]c sRfdd}gd}|r||j|}|dkr|||\}}||jvr||j|} |dkr:|||} || t| sf| gt| D]} | jrV| jrV| | | d| j rd| j rd| | | qEn|| |}q |} | |j ddfn)|t |j} |||| | }n||d} t|tjrt| } || d}|sS)a Process string with placeholders and generate `ElementTree` tree. Arguments: data: String with placeholders instead of `ElementTree` elements. parent: Element, which contains processing inline data. isText: Boolean variable, True - it's text, False - it's a tail. Returns: List with `ElementTree` elements with applied inline patterns. cs|rEr!ddjrddj|7_dS|dd_dSs4jr/j|7_dS|_dSjr@j|7_dS|_dSdS)Nr)rTrS)rSrRr]resultrrlinkTexts  z7InlineProcessor.__processPlaceholders..linkTextrr_FN)findr.!_InlineProcessor__findPlaceholderr8getr!rVrTstrip$_InlineProcessor__processElementTextrSappendr6r1rrr) r&r>r]rRrb strartIndexr?r; phEndIndexrHrSchildrDrr`r__processPlaceholderssN           *z%InlineProcessor.__processPlaceholderspatternrMtuple[str, bool, int]cCst|tj}|jD]}||jvr|ddfSq |rEd}|||D]}|||\}} } | dus9| durC|| d7}d}q&n| ||d}|d|} |s]|ddfS|sn||}| d} | d} |durw|d| fSt |st|j tjs|gt|D],} t |s| j r|j| j|| j |d| _ |j| jr|| j|| _q|||} |rd|d| | || dddfSd| |d| |dddfS) a Check if the line fits the pattern, create the necessary elements, add it to `stashed_nodes`. Arguments: data: The text to be processed. pattern: The pattern to be checked. patternIndex: Index of current pattern. startIndex: String index, from which we start searching. Returns: String with placeholders instead of `ElementTree` elements. FrNTrz{}{}{}z{}{}{}{}r_)rrrANCESTOR_EXCLUDESlowerr6getCompiledRegExpfinditer handleMatchrDmatchstartr!rSrrrVritag_InlineProcessor__handleInlinepoprT_InlineProcessor__stashNoder:formatrCgroups)r&rnr>rKrM new_styleexcluderurHrvrDleftDatarlrIrrr__applyPatternsj            zInlineProcessor.__applyPatterncCsNg}|dur|dur||j|j|}|dus|||dS)zBuild the ancestor list.N)rirwrq parent_maprfrWextend)r&r]parentsr6rrr__build_ancestorsBs z!InlineProcessor.__build_ancestorsNtreer6Sequence[str] | NonecCsi|_|dur gn|dd}dd|D|_||fg}|r|\}}||_|||jg}|D]}|jrtt|jtj st|j |j |j} d|_| || |} | D] } ||j| d<qZ|| 7}| || f|j|jr||j} td} d|_| | | d}| jr| j|_t||d}||D]}||j|d<|||dqt|r||j|<| ||jddfq4|D]\}} t| D]\}}|d}|||qq|s |S)aApply inline patterns to a parsed Markdown tree. Iterate over `Element`, find elements with inline tag, apply inline patterns and append newly created Elements to tree. To avoid further processing of string with inline patterns, instead of normal string, use subclass [`AtomicString`][markdown.util.AtomicString]: node.text = markdown.util.AtomicString("This will not be processed.") Arguments: tree: `Element` object, representing Markdown tree. ancestors: List of parent tag names that precede the tree node (if needed). Returns: An element tree object with applied inline patterns. NcSsi|] }|D]}||qqSrr).0pcrrr dsz'InlineProcessor.run..rdFr)r8iterrryr6!_InlineProcessor__build_ancestorsrSrrrrirwrqrUrxrTetreeElementrVr?rWrXr1 enumerate)r&rr6 tree_parentsstack currElementr insertQueuerlrSlstitemrTdumby tailResultrZr[elementiobjrrrr'Ls^        *zInlineProcessor.run)r>r r?r@r rA)r)r>r rKr@r r )T)rHr$rQr$rRr)r>r r]r$rRrr r^) rnr r>r rKr@rMr@r roN)rr$r6rr r$)r(r)r*r+r7rGrerzrxrhrUrLrr'rrrrrKs     LJ rc@s"eZdZdZddZd dd Zd S) rz' Add line breaks to the html document. cCsd}|j|jr7|jdvr7|jr|js&t|r&|j|djr&||_|D]}|j|jr6||q(|jr?|jsD||_dSdS)z8 Recursively add line breaks to `ElementTree` children.  )codeprerN)r is_block_levelrwrSrgr1_prettifyETreerT)r&elemrerrrrs  z$PrettifyTreeprocessor._prettifyETreer#r$r NonecCs|||d}|D]}|jr|jsd|_q d|j|_q |d}|D]%}t|rM|djdkrM|d}t|sM|jdurMt|j d|_q(dS)z7 Add line breaks to `Element` object and its children. brrz %srrrN) rrrTrgr1rwrSrrrstrip)r&r#brsrpresrrrrrr's   zPrettifyTreeprocessor.runN)r#r$r r)r(r)r*r+rr'rrrrrsrc@s>eZdZdZedejej Z ddZ ddZ ddZ d S) rz Restore escaped chars z {}(\d+){}cCstt|dS)Nr)chrr@rC)r&rErrr _unescapeszUnescapeTreeprocessor._unescapecCs|j|j|Sr)REsubr)r&rSrrrrszUnescapeTreeprocessor.unescapecCsh|D]-}|jr|jdks||j|_|jr||j|_|D] \}}||||q#qdS)z/ Loop over all elements and unescape all text. rN)rrSrwrrTitemsset)r&r#rkeyvaluerrrr's zUnescapeTreeprocessor.runN)r(r)r*r+recompiler{rSTXr/rrrr'rrrrrs  r)r r r rr r )rrr r)r+ __future__rrxml.etree.ElementTreer ElementTreetypingrrrrcrrmarkdownr rr! Processorr"rrrrrrrs"      K'