U \>eD@sdZddlmZddlZddlmmZddlmZm Z ddl m Z ddl m Z erbddl mZd d d d d dZdddddZGddde 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_CHECKINGAny)util)inlinepatterns)Markdownrrzutil.Registry[Treeprocessor])mdkwargsreturncKsBt}|t|dd|t|dd|t|dd|S)z3 Build the default `treeprocessors` for Markdown. inlineZprettify unescaper)rZRegistryregisterInlineProcessorPrettifyTreeprocessorUnescapeTreeprocessor)r r Ztreeprocessorsr;/tmp/pip-unpacked-wheel-wj0og6ym/markdown/treeprocessors.pybuild_treeprocessors's robjectbool)sr cCst|tjst|tSdS)z_ Return `True` if object is a string but not an [`AtomicString`][markdown.util.AtomicString]. F) isinstancer AtomicStringstr)rrrrisString0s  rc@s eZdZdZdddddZdS) 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`. etree.Elementetree.Element | Nonerootr cCsdS)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)__name__ __module__ __qualname____doc__r$rrrrr7s rc@seZdZdZddddZdddd d Zdd d d ddZddddddZd3dd ddddZd4dddddddZ d5dddd d!d"d#Z d6d$dd d d%d&d'd(Z d)d*dd+d,d-Z d7dd/dd0d1d2Z d.S)8rzL A `Treeprocessor` that traverses a tree, applying inline patterns. r)r cCsJtj|_tj|_dt|jt|j|_tj|_||_ |j |_ g|_ dS)N) rZINLINE_PLACEHOLDER_PREFIX$_InlineProcessor__placeholder_prefixETXZ$_InlineProcessor__placeholder_suffixlenZ$_InlineProcessor__placeholder_lengthZINLINE_PLACEHOLDER_RE _InlineProcessor__placeholder_rer inlinePatterns ancestors)r#r rrr__init__Ps zInlineProcessor.__init__rztuple[str, str])typer cCs dt|j}tj|}||fS)z Generate a placeholder z%04d)r, stashed_nodesrZINLINE_PLACEHOLDER)r#r1idhashrrrZ__makePlaceholderZs z!InlineProcessor.__makePlaceholderintztuple[str | None, int])dataindexr cCs4|j||}|r$|d|fSd|dfSdS)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)r-searchgroupend)r#r6r7mrrrZ__findPlaceholder`s z!InlineProcessor.__findPlaceholderzetree.Element | str)noder1r cCs||\}}||j|<|S)z Add node to stash. )!_InlineProcessor__makePlaceholderr2)r#r<r1 placeholderr3rrrZ __stashNoders zInlineProcessor.__stashNoder)r6 patternIndexr cCsPt|tjsLd}t|j}||krL||j||||\}}}|s|d7}q|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)rrrr,r._InlineProcessor__applyPattern)r#r6r? startIndexcountmatchedrrrZ__handleInlinexs    zInlineProcessor.__handleInlineTrrNone)r<subnodeisTextr cCsv|r|j}d|_n |j}d|_||||}|sL||k rLt||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__processPlaceholderslistr7reverseinsert)r#r<rErFrGZ childResultposnewChildrrrZ__processElementTexts  z$InlineProcessor.__processElementText str | Nonez%list[tuple[etree.Element, list[str]]])r6parentrFr c sbdddfdd }gd}|r^||j|}|dkr,|||\}}||jkr|j|} |dkr|||} || t| ts| gt| D]>} | jr| j r| | | d| j r| j r| | | qn|| |}q |} | |j d d fn"|t|j} |||| | }q ||d } t|tjrPt| } || d }q S) 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. rOrDrGr cs|r|r>ddjr.ddj|7_q||dd_n>s`jrXj|7_q||_njrvj|7_n|_dS)Nr)rHrG)rGrFrPresultrrlinkTextsz7InlineProcessor.__processPlaceholders..linkTextrrRFN)findr*!_InlineProcessor__findPlaceholderr2getrrrJrHstrip$_InlineProcessor__processElementTextrGappendr/r,rr) r#r6rPrFrUZ strartIndexr7r3Z phEndIndexr<rGchildr:rrSrZ__processPlaceholderssL         z%InlineProcessor.__processPlaceholderszinlinepatterns.Patternztuple[str, bool, int])patternr6r?rAr cCst|tj}|jD] }||jkr|ddfSq|rd}|||D]>}|||\}} } | dksr| dkr|| d7}d}qLqqLn"| ||d}|d|} |s|ddfS|s||}| d} | d} |dkr|d| fSt|t s~t|j tjs~|gt|D]`} t|s| j rb|j| j|| j |d| _ |j| jr|| j|| _q|||} |rd|d| | || dddfSd| |d| |dddfSdS) 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{}{}{}{}rR)rrrZANCESTOR_EXCLUDESlowerr/ZgetCompiledRegExpfinditerZ handleMatchr:matchstartrrGrrrJrr\tag_InlineProcessor__handleInlinepoprH_InlineProcessor__stashNoder1formatr9groups)r#r^r6r?rAZ new_styleexcluderar<rbr:ZleftDatar]r>rrrZ__applyPatternsp              zInlineProcessor.__applyPatternr z list[str])rPparentsr cCsHg}|dk r2|dk r$||j|j|}q|||dS)zBuild the ancestor list.N)r\rcr_ parent_maprYrKextend)r#rPrjr/rrrZ__build_ancestorsMsz!InlineProcessor.__build_ancestorsNzlist[str] | None)treer/r cCsi|_|dkrgn |dd}dd|D|_||fg}|r|\}}||_|||jg}|D]0}|jrt|jtj s|j |j |j} d|_| || |} | D]} ||j| d<q|| 7}| || f|j|jrr||j} td} d|_| | | d}| jr.| j|_t||d}||D]$}||j|d<|||dqLt|rj||j|<| ||jddfqj|D]2\}} t| D]\}}|d}|||qqq<|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] }||q qSrr).0pcrrr os z'InlineProcessor.run..rdFr)r2iterrkrer/!_InlineProcessor__build_ancestorsrGrrrr\rcr_rIrdrHetreeElementrJr7rKrLr, enumerate)r#rmr/Z tree_parentsstackZ currElementrjZ insertQueuer]rGlstitemrHZdumbyZ tailResultrMrNelementiobjrrrr$Ws\        zInlineProcessor.run)r)T)T)r)N)r%r&r'r(r0r=rXrfrdr[rIr@rtr$rrrrrKs !VP rc@s0eZdZdZdddddZddddd Zd S) rz' Add line breaks to the html document. rrD)elemr cCsd}|j|jrn|jdkrn|jr,|jsLt|rL|j|djrL||_|D]}|j|jrP||qP|jr~|js||_dS)z8 Recursively add line breaks to `ElementTree` children.  )codeprerN)r Zis_block_levelrcrGrZr,_prettifyETreerH)r#r~r|errrrs z$PrettifyTreeprocessor._prettifyETreer!cCs|||d}|D](}|jr,|js4d|_qd|j|_q|d}|D]J}t|rP|djdkrP|d}t|sP|jdk rPt|j d|_qPdS)z7 Add line breaks to `Element` object and its children. brrz %srrrN) rrsrHrZr,rcrGrrrstrip)r#r"ZbrsrZpresrrrrrr$s   zPrettifyTreeprocessor.runN)r%r&r'r(rr$rrrrrsrc@sVeZdZdZedejej Z dddddZ dddd d Z d d d ddZ dS)rz Restore escaped chars z {}(\d+){}z re.Match[str]r)r;r cCstt|dS)Nr)chrr5r9)r#r;rrr _unescapeszUnescapeTreeprocessor._unescaperQcCs|j|j|S)N)REsubr)r#rGrrrrszUnescapeTreeprocessor.unescaperrDr!cCsh|D]Z}|jr*|jdks*||j|_|jr>||j|_|D]\}}||||qFqdS)z/ Loop over all elements and unescape all text. rN)rsrGrcrrHitemsset)r#r"r~keyvaluerrrr$s zUnescapeTreeprocessor.runN)r%r&r'r(recompilergrZSTXr+rrrr$rrrrrs r)r( __future__rrxml.etree.ElementTreeru ElementTreetypingrrrVrrZmarkdownrrrZ Processorrrrrrrrrs      V'