o gD@sdZddlmZddlZddlmmZddlmZm Z ddl m Z ddl m Z er1ddl mZdddZdddZGddde 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)Markdownmdrkwargsrreturnutil.Registry[Treeprocessor]cKsBt}|t|dd|t|dd|t|dd|S)z3 Build the default `treeprocessors` for Markdown. inlineprettify unescaper)rRegistryregisterInlineProcessorPrettifyTreeprocessorUnescapeTreeprocessor)r r treeprocessorsrW/var/www/html/bloggers_ems/venv/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@s~eZdZdZddZd/ddZd0d dZd1ddZd2d3ddZd4d5ddZ d4d6dd Z d2d7d%d&Z d'd(Z d8d9d-d.Z d)S):rzL 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__r tuple[str, str]cCs dt|j}tj|}||fS)z Generate a placeholder z%04d)r0 stashed_nodesrINLINE_PLACEHOLDER)r%typeidhashrrr__makePlaceholderZs z!InlineProcessor.__makePlaceholderdatarindexinttuple[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)r3searchgroupend)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)rrrr0r4_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[tuple[etree.Element, Any]]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__processElementTextrSappendr5r0rrr) r%r>r]rRrb strartIndexr?r; phEndIndexrHrSchildrDrr`r__processPlaceholderssN          *z%InlineProcessor.__processPlaceholderspatterninlinepatterns.PatternrMtuple[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_EXCLUDESlowerr5getCompiledRegExpfinditer handleMatchrDmatchstartr rSrrrVritag_InlineProcessor__handleInlinepoprT_InlineProcessor__stashNoder:formatrCgroups)r%rnr>rKrM new_styleexcludervrHrwrDleftDatarlrIrrr__applyPatternsj            zInlineProcessor.__applyPatterncCsNg}|dur|dur||j|j|}|dus|||dS)zBuild the ancestor list.N)rirxrr parent_maprfrWextend)r%r]parentsr5rrr__build_ancestorsMs z!InlineProcessor.__build_ancestorsNtreer5list[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 osz'InlineProcessor.run..rdFr)r8iterrrzr5!_InlineProcessor__build_ancestorsrSrrrrirxrrrUryrTetreeElementrVr?rWrXr0 enumerate)r%rr5 tree_parentsstack currElementr insertQueuerlrSlstitemrTdumby tailResultrZr[elementiobjrrrr&Ws^        *zInlineProcessor.run)r r7)r>rr?r@r rA)r r)r)r>rrKr@r r)T)rHr#rQr#rRr)r>rr]r#rRrr r^) rnror>rrKr@rMr@r rpN)rr#r5rr r#)r'r(r)r*r6rGrer{ryrhrUrLrr&rrrrrKs    ! V P 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_levelrxrSrgr0_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) rrrTrgr0rxrSrrrstrip)r%r"brsrpresrrrrrr&s   zPrettifyTreeprocessor.runN)r"r#r r)r'r(r)r*rr&rrrrrsrc@s@eZdZdZedejej Z ddZ d dd Z d d Z d S)rz Restore escaped chars z {}(\d+){}cCstt|dS)Nr)chrr@rC)r%rErrr _unescapeszUnescapeTreeprocessor._unescaperSrr cCs|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)rrSrxrrTitemsset)r%r"rkeyvaluerrrr&s zUnescapeTreeprocessor.runN)rSrr r)r'r(r)r*recompiler|rSTXr.rrrr&rrrrrs   r)r rr rr r )rrr r)r* __future__rrxml.etree.ElementTreer ElementTreetypingrrrcrrmarkdownrrr Processorr!rrrrrrrs"      V'